Grid API reference.

Search shared sy-grid properties, methods, events, and ColumnDef. Select an API name for its full type contract.

Quick overview

Look up exact setting names, input types, and result formats when integrating a feature. Read the usage guide first, then search the relevant names.

Integration steps

Search by the intended action
For example, search rowData to change rows, getSelectedRowIds to read selection, or cellValueChanged to receive edit notifications.
Distinguish entry types
Property means a setting, Method a callable function, Event a Grid notification, and ColumnDef a single column's configuration.
Read types and entitlements
Click a name for its type description. Pass arrays, objects, and functions as properties and await method results. PRO indicates required entitlement.

Expected results

Find the correct API names and value shapes to connect features in your app.

The API table is a reference, not a list of action buttons. Clicking a name opens type information; run behavior through workspace controls or app code.

Useful terms

Property / Method: A setting / a function that executes an operation.
Event / ColumnDef: A Grid notification / one column's configuration.

sy-grid

Key properties

Attribute / Property	Type / Default	Description
rowData	`GridData[]`Default: undefined	Row data — each entry is a plain object keyed by `ColumnDef.field`. Mutable so managed row drag can reassign a reordered array; the host observes the new order via the `rowMoved` event.
columnDefs	`Array<ColumnDef \| GridColumnGroupDef>`Default: undefined	Column definitions in the standard shape. entries may also be nested groups (`{ headerName, children: [...] }`) — leaves drive every existing behaviour; groups add multi-level header rows.
defaultColDef	`Partial<ColumnDef>`Default: undefined	Defaults merged into every column def (right side wins).
	`GridTheme`Default: 'alpine'	Built-in theme name or custom token override object.
	`string \| number`Default: undefined	Outer height — number is treated as px, strings pass through (e.g. `"60vh"`).
	`GridLocale`Default: 'en'	Built-in locale name or custom message override object.
	`boolean`Default: false	Enable the wrapper-rendered pagination control bar.
pageSize	`number`Default: DEFAULT_PAGE_SIZE	Initial page size. Defaults to .
pageSizeOptions	`readonly number[]`Default: DEFAULT_PAGE_SIZE_OPTIONS	Page-size selector options. Defaults to .
rowHeight	`number`Default: 32	Uniform row height in px. `rowHeightFn` overrides this when supplied.
quickFilter	`boolean`Default: false	Mount the global quick filter toolbar above the grid header.
PRO columnMenu	`boolean`Default: false	Grid Pro header menu: sort, filter, pin, visibility and keyboard navigation.
rowSelection	`RowSelectionMode`Default: 'none'	Row selection mode.
getRowId	`(row: Readonly<GridData>) => GridRowId`Default: undefined	Optional domain-stable row id extractor for selection persistence.
selectionCheckbox	`boolean`Default: false	Render a selection checkbox column when multi-row selection is active.
resizableColumns	`boolean`Default: false	Enable draggable column resize handles.
reorderableColumns	`boolean`Default: false	Enable header drag column reordering.
columnHiding	`boolean`Default: false	Enable the runtime column visibility method surface.
multiSort	`boolean`Default: false	enable multi-column sort. When `true`, shift+click (or shift+Enter/Space on a focused header) appends the column to the ordered sort model / cycles it in place; plain click keeps the single-column cycle and collapses the model to one entry. When `false` (default), interaction behaviour is exactly the single sort. Programmatic `setSortModel` is honoured regardless of this flag. Initial multi-sort seeds from `columnDefs` `sort:` + `sortIndex`.
headerFilterRow	`boolean`Default: false	render an inline filter row under the column headers (AG Grid "floating filters"). Scalar columns get an input that edits the current condition's value in place; set/multi/range states show a summary that opens the full dropdown. Default `false`.
PRO groupBy	`string \| string[]`Default: undefined	group rows by this column. Rows fold into expandable groups rendered as group rows with a member count; the group stage runs after filter/sort and before pagination (pages count display rows, group rows included). Unknown fields are ignored with a warning.
PRO pivotMode	`boolean`Default: false	pivot mode. When on (and the three axis props below are non-empty), the grid cross-tabs the data instead of the normal client pipeline: `pivotRowGroupColumns` form the left rows, the distinct values of `pivotColumns` become auto-generated secondary columns, and each cell is `pivotAggFuncs[valueColumn]` over that row-group ∩ pivot value. Mutually exclusive with tree data / row grouping.
PRO pivotRowGroupColumns	`string[]`Default: undefined	left-axis grouping columns (outermost first).
PRO pivotColumns	`string[]`Default: undefined	columns whose distinct values become the top-axis pivot columns.
PRO pivotValueColumns	`string[]`Default: undefined	the value columns aggregated into each cell.
PRO pivotAggFuncs	`Record<string, string>`Default: undefined	aggregation per value column (built-in name or a registered custom name; default 'sum').
PRO rangeSelection	`boolean`Default: false	cell range selection (AG `enableRangeSelection` parity). Drag selects a rectangle, shift+click / shift+arrows extend the anchor, ctrl/meta+drag adds ranges, Escape clears. Coordinates are DISPLAY indexes: data transitions (sort/filter/pagination/ collapse) keep ranges but clamp them into the new shape. Sentinel rows (group/tree/detail) never anchor a range (a sweep may cross them - those rows simply don't paint). The viewport does NOT autoscroll while dragging past its edge (v1 - documented).
PRO statusBar	`boolean \| { panels?: ReadonlyArray<{ panel: string; align?: string }> }`Default: undefined	status bar below the grid body (columnDefs mode only). `true` (attribute `status-bar`) renders the default panel set (combined "Rows: filtered of total" count); the object form declares panels by NAME (serialisable — same policy as `aggFunc`): `{ panels: [{ panel: 'totalRows' \| 'filteredRows' \| 'totalAndFilteredRows', align?: 'left' \| 'center' \| 'right' }] }`. Unknown panel names warn once and are skipped. adds the selection/aggregation panels.

Other properties108

Attribute / Property	Type / Default	Description
	`unknown`Default: undefined	Application context propagated through typed callbacks and `getApi`.
	`GridComponentLocalDefinitions< GridData, unknown, unknown, unknown >`Default: undefined	Per-grid named lifecycle components. Direct column definitions win, followed by this map, grid-local registrations, then global registrations.
externalFilter	`\| GridExternalFilterCallbacks<GridData> \| GridExternalFilterInstance<GridData, unknown>`Default: undefined	Optional client-side external filter callbacks or lifecycle instance.
componentTimeoutMs	`number`Default: 5_000	Per-step timeout for optional renderer/editor/filter lifecycle work.
csvImport	`boolean`Default: false	show the "Import CSV" toolbar affordance + mapping wizard.
PRO pdfFontUrl	`string`Default: undefined	App-hosted TTF/OTF URL used automatically for PDF exports that contain Korean/Japanese/CJK or other text outside PDF Standard 14 WinAnsi.
PRO pdfAutoFont	`boolean`Default: true	Try to resolve an embedded PDF font automatically when `fontBytes` is not supplied. Uses `pdf-font-url` first, then browser local-font access when available. Default true.
PRO	`boolean`Default: false	Enable in-cell spreadsheet formulas. When `true`, a cell whose value is a string starting with `=` (e.g. `=SUM(A1:A3)`) is evaluated by the formula engine and the computed result is displayed. References are A1-style over `columnDefs` order (A = first column) × `rowData` order (row 1 = first row). Defaults to `false` — no behaviour change for grids that don't opt in.
PRO showFormulas	`boolean`Default: false	Show the formula text (`=…`) instead of the computed value in formula cells — the equivalent of Excel's "Show Formulas" (Ctrl+`). Useful for inspecting and verifying a sheet. Only meaningful when is `true`.
PRO formulaBar	`boolean`Default: false	show an Excel-style formula bar above the grid. It displays the active cell's raw content (the formula text for a formula cell) and edits it: Enter commits (and recalculates dependents), Escape reverts. Only meaningful with in the columnDefs API.
PRO workbookId	`string`Default: undefined	workbook identity used for cross-grid formula coordination. `workbook-id` and must be supplied together while is enabled. Workbook ids are case-sensitive.
PRO sheetName	`string`Default: undefined	case-insensitive sheet identity inside . Changing only this property renames the live registration without changing its numeric identity.
rowHeightFn	`(index: number, row: GridData) => number`Default: undefined	Optional per-row height function for variable-height virtualization.
virtualScroll	`boolean`Default: true	Enable wrapper-level row virtualization in columnDefs mode.
quickFilterText	`string`Default: ''	Initial quick filter value; later prop changes mirror into state.
quickFilterPlaceholder	`string`Default: undefined	Placeholder text for the quick filter input.
quickFilterMode	`'and' \| 'or'`Default: 'and'	Quick filter word mode.
quickFilterRegex	`boolean`Default: false	when true, the quick-filter text is a regular expression tested against each cell (a row matches when any cell matches). An invalid / half-typed pattern falls back to showing all rows.
quickFilterDebounce	`number`Default: 150	Debounce before quick filter re-runs the pipeline.
showEmptyState	`boolean`Default: true	Render the wrapper empty-state overlay.
emptyMessage	`string`Default: undefined	Message shown when source row data is empty.
noMatchesMessage	`string`Default: undefined	Message shown when filters hide every row.
clearFiltersLabel	`string`Default: undefined	Label for the no-matches clear-filters action.
	`boolean`Default: false	External loading flag for spinner, debounce, and interaction lock.
loadingMessage	`string`Default: undefined	Message rendered beside the loading spinner.
loadingMode	`LoadingMode`Default: 'manual'	Loading-mode switch for manual, auto, or host-owned loading UI.
minLoadingDuration	`number`Default: DEFAULT_MIN_LOADING_DURATION_MS	Minimum visible duration for the loading spinner in ms.
	`InfiniteRowDatasource`Default: undefined	infinite (lazy) row model datasource. When set, the grid ignores `rowData` and fetches rows in blocks from this datasource as the user scrolls (ag-grid `infiniteRowModel`). Unloaded rows render as loading placeholders until their block resolves.
cacheBlockSize	`number`Default: 100	rows per fetch block for the infinite row model.
maxBlocksInCache	`number`Default: undefined	max loaded blocks kept in memory (LRU); omit for unbounded.
PRO serverSideDatasource	`ServerSideDatasource<GridRow>`Default: undefined	server-side (SSRM) row model. When set, the server groups + paginates the data and the grid fetches one level at a time (`serverSideGroupCols` = the group columns, in order; empty = a flat server-side list). Reuses `cacheBlockSize` / `maxBlocksInCache` per node.
PRO serverSideGroupCols	`string[]`Default: undefined	the columns the server groups by, in order (empty = flat).
PRO serverSideTransactionWaitMs	`number`Default: undefined	wait window (ms) for `applyServerSideTransactionAsync` batching (the AG `asyncTransactionWaitMillis` shape under our naming). Read when the async queue is FIRST built; defaults to 50.
PRO viewportDatasource	`ViewportDatasource<GridRow>`Default: undefined	viewport (sliding-window) row model. When set, the grid ignores `rowData`: the datasource reports a KNOWN total count and streams only the rows for the currently-visible window (plus the virtualizer's overscan), discarding rows scrolled out of view. Ideal for huge, flat, frequently-changing datasets / live feeds (ag-grid `viewportRowModel`). Unlike the infinite model there is no block cache — scrolling re-requests the exact range.
rowDragManaged	`boolean`Default: false	managed row reorder. When true, a column with `rowDrag: true` shows a drag handle; dragging it reorders `rowData` (client mode only, and only while the display order equals the source order — no sort / filter / group / tree / pagination / infinite).
spanExportMode	`'origin-once' \| 'repeat'`Default: 'origin-once'	(PF-ROWLAYOUT-WIRING-01 batch A) — how a copied / exported range prints a spanned cell: `origin-once` (the value once, at the origin, and blanks under the cover — the spreadsheet convention) or `repeat` (the value in every covered coordinate). Only matters when a column declares `rowSpan` / `colSpan`.
rowDragMultiRow	`boolean`Default: false	(PF-ROWLAYOUT-WIRING-01 batch B, AG `rowDragMultiRow`) — when true, an UNMANAGED drag started on a selected row carries every selected row (the item's `rowKeys` / `rows`); otherwise one row travels.
rowDragText	`(params: { count: number; label: string }) => string`Default: undefined	(AG `rowDragText`) — the ghost label for an unmanaged drag; default `"<label>"` or `"<label> (+N)"` for a multi-row item.
cellChangeFlash	`boolean`Default: false	briefly highlight a cell when its value changes (inline edit, paste, `applyTransaction`) — ag-grid `enableCellChangeFlash`.
enableCellChangeFlash	`boolean`Default: false	Select a name to inspect its type contract.
PRO contextMenu	`boolean`Default: false	render a right-click context menu popup. The default menu is copy-cell / copy-row / export-csv; a host `contextMenuItemsCallback` customizes it.
PRO	`boolean`Default: false	Grid Pro find toolbar. Searches loaded rows and readable, visible columns.
PRO cellNotes	`boolean`Default: false	Standalone notes for uniquely identified, readable cells (Grid Pro).
PRO cellNotesAdapter	`GridCellNotesAdapter`Default: undefined	Atomic revision-aware persistence; no implicit local or collaboration storage.
PRO batchEditToolbar	`boolean`Default: false	Start / review / apply / cancel controls for client-side batch edits (Grid Pro).
PRO columnMenuItems	`(context: GridColumnMenuContext) => readonly GridColumnMenuItem[]`Default: undefined	Appends custom commands to the built-in column menu.
PRO contextMenuItemsCallback	`( ctx: ContextMenuContext<GridRow>, ) => ContextMenuItem<GridRow>[]`Default: undefined	host callback returning the menu items for a right-click. When set it REPLACES the default items (the host can call the built-in ids or supply items with a custom `action`).
keyboardNavigation	`boolean`Default: true	Enable keyboard navigation for the columnDefs grid body.
showSelectionCheckbox	`boolean`Default: false	Select a name to inspect its type contract.
shiftClickAdditive	`boolean`Default: false	Add shift-click ranges to the existing multi-selection instead of replacing it.
rowHover	`'css-only' \| 'stateful' \| 'off'`Default: 'css-only'	Row hover behaviour: CSS-only, stateful eventing, or disabled.
hideableColumns	`boolean`Default: false	Select a name to inspect its type contract.
autoSizeOnDoubleClick	`boolean`Default: true	Enable header double-click auto-size when column resizing is enabled.
enableMultiSort	`boolean`Default: false	Select a name to inspect its type contract.
PRO conditionBuilder	`boolean`Default: false	show the grid-level condition builder panel: an AND/OR tree of cross-column conditions ("name contains X AND (score > 50 OR …)") applied on top of the per-column filters. The programmatic surface (`setConditionFilter` / `getConditionFilter`) works regardless of this flag. Default `false`.
virtualizeColumns	`boolean`Default: undefined	window the scrolling middle columns: only the columns intersecting the viewport (plus overscan) render; leading / trailing spacers keep the scrollbar truthful. Pinned columns always render. Eligibility: every unpinned column needs a concrete pixel width (`width:` or a live resize) — any flex-sized middle column silently disables windowing (geometry is unknowable pre-layout).
PRO pivotSubtotals	`'off' \| 'top' \| 'bottom'`Default: 'off'	PF-GROUPPIVOT-WIRING-02 — per-level subtotal PLACEMENT for the client cross-tab. `off` (default) composes exactly the pre-ADR-023 list; `top` places each open node's subtotal straight after its marker, `bottom` closes the subtree . Collapsed nodes and innermost nodes get none; level filtering stays a core-only option.
PRO pivotGrandTotal	`'off' \| 'top' \| 'bottom'`Default: 'bottom'	PF-GROUPPIVOT-WIRING-02 — grand-total placement. `bottom` is the default AND the pre-ADR-023 behavior (the computed grand total has always closed the list); `top` opens with it; `off` hides it.
PRO pivotPanelShow	`'always' \| 'onlyWhenPivoting' \| 'never'`Default: 'never'	Canonical Pivot Panel visibility policy from the roadmap contract.
PRO pivotPanel	`boolean`Default: false	Compatibility alias: `true` is equivalent to `pivotPanelShow='always'`.
PRO groupPanel	`boolean`Default: false	show the row-group panel: a drop zone above the header. Drag a column header into it to group by that column (sets `groupBy`); the panel shows a chip for the grouped column, whose × clears the grouping.
PRO getDataPath	`(row: Record<string, unknown>) => readonly string[]`Default: undefined	tree data via materialized paths (AG `treeData` + `getDataPath` parity): every row names its position as a `string[]`. Function prop (property assignment, not attribute). The tree stage runs after filter/sort, before pagination. Mutually exclusive with `group-by` — tree data wins and warns once.
PRO treeIdField	`string`Default: undefined	declarative tree linkage for `{id, parentId}` tables : set BOTH `tree-id-field` and `tree-parent-field` to activate. `getDataPath` wins when both surfaces are set.
PRO treeParentField	`string`Default: undefined	parent-id column for declarative tree linkage.
PRO treeLabelField	`string`Default: undefined	label column for id-linked trees (defaults to the id).
PRO masterDetail	`boolean`Default: false	master-detail (single level, AG `masterDetail` parity): data rows gain an expand chevron in the first column; an expanded master is followed by a full-width detail row. Detail rows never count toward pagination (AG default). Expansion state keys off the canonical row id — provide `getRowId` for stability across filters (index-fallback ids shift, same caveat as selection). The detail panel renderer/slot lands ; until then the shell shows the master row's data.
PRO detailRowHeight	`number`Default: 160	pixel height of an expanded detail row (default 160).
PRO detailCellRenderer	`(params: { row: Record<string, unknown>; rowId: string \| number }) => CellRenderOutput`Default: undefined	detail panel renderer (function prop, AG `detailCellRenderer` parity). Returns the SAME discriminated output as cell renderers: `{kind:'text'}` (safe text), `{kind:'html'}` (trusted innerHTML — the host owns sanitisation, same contract as `cellRenderer`), or `{kind:'vnode'}`. Without it — or when it throws or returns an invalid shape (warned once) — the built-in field-list shell renders as the fallback.
PRO detailGridOptions	`DetailGridOptions`Default: undefined	declarative (nested) detail grid. When set alongside (and no , which wins), each expanded master's panel auto-mounts a child `<sy-grid>` configured by this object and fed `getDetailRowData(master)`. A config whose `masterDetail` + `detailGridOptions` are set nests grids further — the ergonomic path a plain-JS host cannot take via `detailCellRenderer` (it cannot build a child-grid vnode). Nesting is capped at levels (self-referential-config guard).
PRO getDetailRowData	`(params: { row: Record<string, unknown>; rowId: string \| number }) => unknown[] \| Promise<unknown[]>`Default: undefined	fetch the child rows for an expanded master (used with ). Returns the rows synchronously OR a `Promise` . Called ONCE per open (the result is cached per master id and released on collapse), so an async fetch fires exactly once.
PRO detailNestingLevel	`number`Default: 0	this grid's depth in a master-detail nesting chain (0 = the top grid). The parent sets it on each auto-mounted child; the renderer stops recursing at .
clipboardEscapeFormulae	`boolean`Default: true	Escape spreadsheet-formula prefixes in all outbound clipboard text.
PRO sideBar	`boolean \| string \| { panels?: ReadonlyArray<{ id: string } \| string>; defaultOpen?: string }`Default: undefined	tool-panel side bar right of the grid body (columnDefs mode only). `true` (attribute `side-bar`) docks both built-in panels closed; `'columns'` / `'filters'` docks that single panel OPENED (AG shorthand); the object form declares panels by name: `{ panels: [{ id: 'columns' \| 'filters' }], defaultOpen?: id }`. Unknown ids warn once and are skipped. ships the dock frame with read-only panel bodies; Days 246/247 make them interactive.
	`GridRow[]`Default: []	Select a name to inspect its type contract.
	`GridColumnDef[]`Default: []	Select a name to inspect its type contract.
maxRendered	`number`Default: 200	Select a name to inspect its type contract.
PRO OPTION	`GridEngineMode`Default: 'auto'	Select a name to inspect its type contract.
PRO OPTION proThreshold	`number`Default: 100_000	Select a name to inspect its type contract.
PRO OPTION	`GridUnavailableBehaviour`Default: 'fallback'	Behaviour when `engine="pro"` is requested but Pro is unavailable.
PRO OPTION brandLogo	`string`Default: undefined	The brand mark, right-aligned in a slim strip at the bottom of the grid (CONTRACTS §4.2; it never covers a cell or a control). Unset or empty: the Syidax mark. `'none'`: no mark. A `data:image/png\|jpeg\|webp;base64,…` URL (≤ 100 KB): that logo instead. Removal and a custom logo need a valid `grid.branding` license; without one the mark stays and the grid fires `licenseFeatureRefused`. SVG, external URLs and HTML are not accepted (the mark stays, with a console warning).
PRO collaborationRoom	`string`Default: undefined	Collaboration room id. When set (Pro build), the grid joins the room and cell edits sync across clients via the self-implemented CRDT. Community: no-op.
PRO realtimeUrl	`string`Default: undefined	Optional realtime sync URL (WebSocket). Omit for in-process/same-page demos.
PRO collabUserName	`string`Default: undefined	This client's display name / color for presence.
PRO collabUserColor	`string`Default: undefined	Select a name to inspect its type contract.
PRO collabPresence	`boolean`Default: true	Broadcast this client's cursor/selection presence (default true).
PRO collabConflictUi	`boolean`Default: true	Show the built-in conflict UI when this client loses a concurrent same-cell edit: a red flash on the cell + a transient notice naming the winning editor. The `collabConflictResolved` event fires regardless, so a host can turn this off and render its own.
auditLog	`boolean`Default: false	enable the audit trail: a bounded, append-only log of row/cell/ selection mutations and undo/redo transitions. Read it via getAuditLog and subscribe to auditLogChanged. Off by default (zero overhead).
auditLogMax	`number`Default: 1000	Cap on retained audit entries (oldest evict first).
canReadCell	`CanReadCellFn`Default: undefined	RBAC read policy. Return `false` from `canReadCell` to mask a cell's value: the grid shows `maskedCellValue` instead of the real value on the direct cell surfaces (body render, tree cells, tooltip, and a clipboard copy), while sort / filter / aggregation / formula keep reading the real value. Property-only; a policy that throws fails CLOSED (masks). Off by default (zero overhead). Export-pipeline masking lands on
maskedCellValue	`string`Default: '•••'	The placeholder shown for cells `canReadCell` denies.
canEditCell	`CanEditCellFn`Default: undefined	RBAC write policy. Return `false` from `canEditCell` to LOCK a cell: the grid refuses to open an editor on it and never writes a value back (blocking a keyboard/click edit, a formula-bar commit, AND a paste). The write-side twin of `canReadCell`; the two are independent (a cell can be readable-but-locked or masked-but-editable). Structural read-only rules (`editable` flag, computed columns, sentinel rows) still apply first — a policy only locks a cell that would otherwise be editable. Property-only; a policy that throws fails CLOSED (locks). Off by default (zero overhead).
conditionalFormats	`ConditionalFormatRule[]`Default: undefined	Conditional Formatting. A grid-level list of rules; each targets a column (or all), tests the cell value against a condition (equals / ranges / text / blank), and contributes a style (background / color / weight / …) when it matches. Rules merge in order (later wins) and honor Excel's `stopIfTrue`. Colors are sanitized. Property-only; empty/undefined = off (zero overhead). Evaluated on the DISPLAYED value, so an RBAC-masked cell is never styled by its hidden real value.
conditionalFormatUi	`boolean`Default: false	show the built-in Conditional Formatting rule builder (a toolbar button that opens an Excel-style rules panel: column / condition / value / colors). Editing the rules updates `conditionalFormats` live and fires `conditionalFormatsChanged`. Off by default.
validationRules	`ValidationRule[]`Default: undefined	Data validation. A grid-level list of per-column rules (required / number / integer / min / max / range / minLength / maxLength / pattern / oneOf / custom). A failing cell is MARKED invalid (a red state + the message as its title) — the edit is NOT blocked (the value lands, the cell flags it, spreadsheet-style by default). `invalid-edit-mode` can instead keep the editor open (`block`) or cancel/revert it (`revert`). A rejected or allowed-invalid edit fires `cellValidationFailed`. Blank passes every rule but `required`. Off by default (zero overhead).
invalidEditMode	`'allow' \| 'revert' \| 'block'`Default: 'allow'	Policy for an editor value that fails `validationRules`. `allow` preserves the existing spreadsheet-style mark-and-commit behavior.
maxSnapshots	`number`Default: 20	Cap on retained rowData snapshots (oldest evict first).
PRO collabPersistence	`'none' \| 'indexeddb'`Default: 'none'	Local op persistence: `'none'` (default) or `'indexeddb'` to survive a reload.
initialState	`SyGridState`Default: undefined	First-render unified state. Applied once in `componentWillLoad` before the initial pipeline; the scroll/focus phase waits for the first settled render like every other restore.
editType	`'cell' \| 'fullRow'`Default: 'cell'	PE-ROWEDIT-WIRING-01 — AG's `editType`. Under `'fullRow'` the ROW is the transaction: opening any editor on a data row opens the session, every editor commit STAGES its cell into it (no write, no per-cell event yet), and the row commits atomically — grid-level Enter on the session's row, editing a DIFFERENT row (blur-policy commit), or `stopRowEdit('commit')`. Grid-level Escape on the session's row cancels the whole row with zero writes. Editors paint one cell at a time (the row is the transaction, not a simultaneous paint — the recorded v1 scope).
PRO enableFillHandle	`boolean`Default: undefined	ADR-022 — paint the fill handle on the last canonical range's corner (AG `enableFillHandle`).
PRO fillHandleAxes	`'both' \| 'x' \| 'y'`Default: undefined	ADR-022 — axes the drag may extend along .
PRO fillHandleMode	`'copy' \| 'series'`Default: undefined	ADR-022 — the gesture's value mode (`fillRange`'s `mode`, default copy).
alignedGrids	`SyGridAlignedGridsInput \| string`Default: undefined	the alignment group: a group NAME (attribute-friendly; every grid naming the same group aligns), an array of peer `<sy-grid>` elements (sugar: this element mints a group from its own member id and configures every peer onto it), or `null` to leave.
isFullWidthRow	`(params: { row: GridRow; rowIndex: number; builtInKind: 'detail' \| 'group' \| 'group-footer' \| 'loading' \| 'custom' \| null }) => boolean`Default: undefined	marks a data row full-width (AG `isFullWidthRow`); grid-owned kinds win (`kind-conflict`).
fullWidthCellRenderer	`SyGridFullWidthRenderer<GridRow>`Default: undefined	the full-width renderer: `create` returns an element (or `{ gui }`); `refresh`/`destroy` follow the Phase C renderer law.
fullWidthRowHeight	`number \| ((row: GridRow, rowIndex: number) => number)`Default: undefined	the full-width row height (px, or a per-row function); the uniform row height otherwise.
pinnedTopRowData	`GridRow[]`Default: undefined	rows pinned above the viewport (AG `pinnedTopRowData`; ids via `getRowId`, else `__pinned-top-<i>`).
pinnedBottomRowData	`GridRow[]`Default: undefined	rows pinned below the viewport (AG `pinnedBottomRowData`).

Events93

Events	Detail type	Description
	`GridQueryResult & { tier: GridEngineTier }`	Select a name to inspect its type contract.
	`GridSortChangedDetail`	Fires when header sorting changes, including reset to unsorted.
	`GridFilterChangedDetail`	Fires when a column filter is applied, replaced, or cleared.
	`GridFilterModifiedDetail`	Fires when a lifecycle filter reports an unapplied UI modification.
PRO	`{ model: ConditionNode \| null }`	fires when the grid-level condition tree changes (builder Apply/Clear or `setConditionFilter`). `model: null` = cleared.
PRO	`{ presets: Array<{ name: string; json: string }> }`	fires when the named preset list changes (save/delete in the panel). Hosts persist the payload and feed it back on startup via `setConditionPresets`.
	`{ groupId: string; open: boolean }`	fires when a header group expands or collapses.
PRO	`{ key: string \| null; expanded: boolean }`	fires when a row group expands or collapses (`key: null` = blank bucket).
PRO	`{ path: readonly string[]; expanded: boolean }`	fires when a tree node expands or collapses.
PRO	`{ rowId: string \| number; expanded: boolean }`	fires when a master row's detail expands or collapses.
PRO	`{ rowId: string \| number; master: GridRow \| null }`	a master's detail was OPENED: its panel (and, with , the child grid) mounts on the next render. `master` is the master row when it is on the current filtered set, else `null`. Pairs with so a host can create / dispose per-detail resources (subscriptions, a child-grid ref, etc.).
PRO	`{ rowId: string \| number }`	a master's detail was CLOSED: its panel / child grid unmounts.
PRO	`{ ranges: CellRangeBounds[] }`	fires when the committed cell ranges change (normalized bounds).
PRO	`{ id: SideBarPanelId; open: boolean }`	fires when a side-bar tool panel opens or closes.
	`{ rowCount: number; columnCount: number }`	fires after a CSV import loads new columns + rows.
PRO	`{ text: string; ranges: CellRangeBounds[] }`	fires after a successful clipboard copy (TSV payload + source bounds).
PRO	`{ applied: number; skipped: number; top: number; left: number; changes: GridCellValueChangedDetail[]; }`	fires after every paste attempt (even `applied: 0` — the skipped counts are the host's only diagnostic). Arc review 239-242: `changes` carries the per-cell diffs (same shape as `cellValueChanged`, which also fires per changed cell) so hosts/audit never lose the diff.
	`GridPaginationChangedDetail`	Fires when active page or page size changes.
	`GridQuickFilterChangedDetail`	Fires when the quick filter commits a new search value.
	`GridEmptyStateActionDetail`	Fires when an empty-state overlay action is clicked.
	`GridActiveCellChangedDetail`	Fires when the active-cell pointer changes.
	`GridCellClickedDetail`	Fires when the user clicks a columnDefs body cell.
	`GridCellDoubleClickedDetail`	Fires when the same cell is clicked twice within the double-click threshold.
	`GridRowClickedDetail`	Fires when the user clicks (mouse up after a non-drag mouse down) on a body row.
	`GridCellEditingRequestedDetail`	Fires when editing is requested for an editable cell.
	`GridCellEditingCancelledDetail`	Fires when active edit mode is cancelled.
	`GridCellEditingCommittedDetail`	Fires when an active edit transaction commits.
PRO	`GridFormulaEvaluatedDetail`	Fires when a formula cell is committed (only when `formulas` is enabled).
PRO	`GridFormulaErrorDetail`	Fires alongside `formulaEvaluated` when the committed result is an error token.
PRO	`GridWorkbookBindingChangedDetail`	a workbook sheet registration connected, renamed, or disconnected.
PRO	`GridWorkbookBindingErrorDetail`	a rejected workbook/sheet input; the last valid binding is retained.
	`GridChunkLoadEventDetail`	Fires when an optional feature chunk starts a load attempt .
	`GridChunkLoadEventDetail`	Fires once when an optional feature chunk resolves and enters the cache.
	`GridChunkLoadEventDetail`	Fires when an optional feature chunk load finally fails, with a typed reason.
	`GridComponentErrorDetails`	Typed lifecycle lookup/create/refresh/model/focus/destroy failure.
	`GridRowDataChangedDetail`	Fires after `applyTransaction` resolves its row diff.
	`GridCellValueChangedDetail`	Fires once per changed cell on every `applyTransaction` update (AG Grid parity).
	`{ fromIndex: number; toIndex: number; row: unknown }`	fires after a managed row drag reorders the data.
PRO	`{ groupBy: string \| null }`	fires when the row-group column changes (via the group panel).
PRO	`PivotPanelChangeDetail`	Fires after the pivot panel changes an axis, order, or aggregation.
PRO	`PivotPanelChangeDetail`	Roadmap-compatible alias emitted with the same deterministic pivot config detail.
PRO	`{ pivotMode: boolean }`	Fires when the built-in pivot panel toggles delegated/client pivot mode.
PRO	`{ id: string; rowIndex: number; field?: string }`	fires when a context-menu item is chosen.
PRO	`GridRemoteEditAppliedDetail`	Fires after a remote collaboration edit is integrated (Phase 3.1.D).
PRO	`GridPresenceChangedDetail`	Fires when the set of remote collaborators (presence) changes (Phase 3.1.D).
PRO	`GridCollabConflict`	Fires when a concurrent same-cell edit is resolved by the CRDT (Phase 3.1.D).
PRO	`GridCollaboratorInfo`	Fires when a collaborator joins the room (Phase 3.1.D).
PRO	`{ id: string }`	Fires when a collaborator leaves the room (Phase 3.1.D).
PRO	`{ status: GridSyncStatus }`	Fires when the collaboration sync status changes (Phase 3.1.D).
PRO	`{ rowId: string; field: string; comments: GridCellComment[] }`	Fires when a cell's comment thread changes, local or remote .
PRO	`{ rowId: string; field: string; comment: GridCellComment }`	Fires when a newly-arrived comment
	`{ entry: AuditEntry }`	Fires per entry appended to the audit trail (when `audit-log` is on).
	`{ rules: ConditionalFormatRule[] }`	Fires when the built-in CF builder edits the rules.
	`{ rowIndex: number; field: string; value: unknown; message: string }`	Fires when a committed edit fails a validation rule.
	`{ id: string; name: string; rowCount: number }`	Fires when a rowData snapshot is captured.
	`{ id: string; name: string; rowCount: number }`	Fires when a rowData snapshot is restored.
	`GridXlsxImportedDetail`	Fires after `importDataFromXlsx` completes — payload carries the parsed snapshot.
	`GridHistoryChangedDetail`	Fires when the undo/redo stack mutates.
	`GridColumnResizedDetail`	Fires after a committed column resize.
	`GridColumnReorderedDetail`	Fires after a committed column reorder.
	`GridColumnVisibilityChangedDetail`	Fires after an effective column visibility change.
	`GridSelectionChangedDetail`	Fires when the row selection set changes.
	`GridRowHoverChangedDetail`	Fires when the hovered row changes in stateful hover mode.
	`GridThemeChangedDetail`	Fires after the active theme resolves.
	`GridLocaleChangedDetail`	Fires after the active locale resolves.
	`GridLiveObjectEvent<GridData>`	Phase B — one immutable event object is delivered here and to the originating live ref. `mutationId` gives a deterministic global order.
	`SyGridStateUpdatedDetail`	coalesced unified-state change notification.
	`SyGridPreDestroyedDetail`	final unified-state snapshot, exactly once on disconnect.
PRO	`SyGridBatchEditStartEventDetail`	one per sealed batch transaction: the ledger opening.
PRO	`SyGridBatchEditEndEventDetail`	the status-keyed batch transaction verdict (ledger close).
	`SyGridRowValueChangedEventDetail`	exactly once per COMMITTED row-edit stop .
	`SyGridRowEditStartEventDetail`	ADR-024 — a row session opened (interactive entry or the API).
	`SyGridRowEditStopEventDetail`	ADR-024 — the session resolved (committed / cancelled / rejected), once per stop.
PRO	`SyGridFillStartEventDetail`	one per fill transaction: the ledger opening .
PRO	`SyGridFillEndEventDetail`	the status-keyed fill transaction verdict (ledger close).
PRO	`SyGridPivotCombinationConflictDetail`	one conflict announcement per pivot combination the grid resolves against the caller's configuration (`PF-PIVOT-SILENT-01`). The detail carries the matrix vocabulary and the exact sentence the console also received; `getPivotCombinationReport` is the pull channel for the same information.
PRO	`SyGridPivotColumnsChangedDetail`	PF-GROUPPIVOT-WIRING-02 — the refresh identity, LIVE: emitted once per cross-tab recompute whose generated column set actually changed (`diffPivotColumns` — retained / added / removed / moved / axesChanged). The stateful model lives in the 'group-pivot' chunk and carries its OWN re-entrancy latch ; the element adds none. No diff, no event — a recompute that regenerates the same columns is silence, not noise.
PRO	`SyGridServerStoreUpdatedDetail`	the `storeUpdated` event at the element boundary.
	`SyGridRowDragEventDetail`	ADR-009 — typed accessor for the lazy 93 SSRM ops chunk ('ssrm-ops'). a drag session started (`kind: 'start'`), or entered a zone.
	`SyGridRowDragEventDetail`	the drop target moved.
	`SyGridRowDragEventDetail`	the pointer left every target (or the target went stale under a scroll).
	`SyGridRowDragEndDetail`	a drop completed: DELEGATED over this grid (nothing moved) or transferred to a zone.
	`SyGridRowDragCancelDetail`	the session ended without a drop (escape, blur, capture lost, disconnect, watchdog…).
	`SyGridRowsTransferredDetail`	a transfer into a registered zone was planned, committed and applied (or reverted).
	`SyGridSpanConflictEventDetail`	a `spanConflict` fires once per distinct conflict set a render pass resolves.
PRO	`SyGridTreeReparentedDetail`	Select a name to inspect its type contract.
	`SyGridPinnedRowsChangedDetail<GridRow>`	the pinned model changed (`setPinnedRows`, the two props, a state restore).
	`SyGridRowLayoutRefusedDetail`	a row-layout feature refused a request instead of silently no-oping.
PRO	`SyGridWorkbookPropagationDetail`	one event per affected SHEET per transaction: the generation/hash stamp riding the repaint. Fires from method, commit and enrollment contexts (never from render), so no parked-event flush is needed — the Phase F `componentDidRender` idiom applies to render-path emissions only.
PRO	`SyGridChartEvent`	the four outbound chart events, on ONE emitter each.
PRO	`SyGridChartEvent`	Select a name to inspect its type contract.
PRO	`SyGridChartEvent`	Select a name to inspect its type contract.
PRO	`SyGridChartEvent`	Select a name to inspect its type contract.

Methods203

Method / Arguments	Return type	Description
filter?: AuditLogFilter	`Promise<AuditEntry[]>`	The audit trail entries (optionally filtered). Empty when off.
	`Promise<void>`	Clear the audit trail (seq keeps advancing; never reused).
filter?: AuditLogFilter	`Promise<string>`	The audit trail as a CSV string (flat union columns, filterable).
filter?: AuditLogFilter, pretty?: boolean	`Promise<string>`	The audit trail as a JSON array string (structure preserved).
fileName?: string, filter?: AuditLogFilter	`Promise<void>`	Download the audit trail as a CSV file.
fileName?: string, filter?: AuditLogFilter	`Promise<void>`	Download the audit trail as a JSON file.
PRO rowId: string \| number, field: string	`Promise<void>`	Open the comment thread panel for a cell (also Shift+F2 on the active cell).
PRO	`Promise<void>`	Close the comment thread panel.
	`Promise<SyGridApi<TData, TContext, TValue, TFilterModel>>`	Canonical API: the returned object is the custom element itself.
columnId: string	`Promise<GridColumnRef<GridData, TValue, unknown> \| null>`	Select a name to inspect its type contract.
	`Promise<ReadonlyArray<GridColumnRef<GridData, unknown, unknown>>>`	Select a name to inspect its type contract.
groupId: string	`Promise<GridColumnGroupRef<GridData, unknown> \| null>`	Select a name to inspect its type contract.
	`Promise<ReadonlyArray<GridColumnGroupRef<GridData, unknown>>>`	Select a name to inspect its type contract.
rowId: GridRowId	`Promise<GridRowRef<GridData, unknown> \| null>`	Select a name to inspect its type contract.
index: number	`Promise<GridRowRef<GridData, unknown> \| null>`	Select a name to inspect its type contract.
callback: (row: GridRowRef<GridData, unknown>) => void	`Promise<void>`	Select a name to inspect its type contract.
callback: (row: GridRowRef<GridData, unknown>) => void	`Promise<void>`	Select a name to inspect its type contract.
PRO	`Promise<GridWorkbookBinding \| null>`	Current validated workbook/sheet registration, or null when opted out.
PRO	`Promise<GridWorkbookBinding \| null>`	Dispose and recreate the current registration using the public properties.
PRO	`Promise<boolean>`	Explicitly leave the current workbook without changing public properties.
column: string, direction?: GridSortDirection \| null	`Promise<void>`	Programmatic sort API (single-key semantics).
model: ReadonlyArray<{ field: string; direction: 'asc' \| 'desc' }>	`Promise<void>`	replace the whole ordered sort model (AG Grid `sortModel` semantics; array position = priority). Entries are validated: unknown or `sortable: false` columns and malformed entries are dropped, duplicate fields keep the first entry. Honoured regardless of `multi-sort` (the flag gates header interaction, not the programmatic surface). Emits `sortChanged` once with the applied model.
	`Promise<SortModelEntry[]>`	read the current ordered sort model (defensive copy).
query: string	`Promise<void>`	Select a name to inspect its type contract.
PRO OPTION	`Promise<GridEngineTier>`	Select a name to inspect its type contract.
PRO name: string, fn: (values: unknown[], rows: readonly unknown[]) => unknown	`Promise<void>`	register a named custom aggregation for `ColumnDef.aggFunc`. Registered names SHADOW built-ins (AG parity); re-registering a name replaces it. Invalid input warns and no-ops.
PRO name: string	`Promise<void>`	remove a registered aggregation (built-ins are unaffected).
PRO	`Promise<string[]>`	registered custom aggregation names (registration order).
PRO key: string \| null, expanded: boolean	`Promise<void>`	expand/collapse one row group. No-ops when the state already matches, grouping is inactive, or the key names no current group (arc review 222-226: unknown keys used to plant phantom collapse state + emit toggles for non-groups). Single-level: `key: null` = the blank bucket. Multi-level : `key` is a node's framed compound key (a `string`), validated against every node's key.
PRO	`Promise<void>`	expand every row group. Emits one `rowGroupToggled` per group that actually changes (AG fires rowGroupOpened per node on expand/collapse-all too — arc review 222-226). Multi-level keys are framed strings; single-level blank folds back to `null` in the event.
PRO	`Promise<void>`	collapse every row group (computed from the current data).
PRO path: readonly string[], expanded: boolean	`Promise<void>`	expand/collapse one tree node by its path. No-ops (with a warning) when tree data is inactive or the path names no collapsible node (leaves have nothing to collapse).
PRO	`Promise<void>`	expand every tree node (one `treeNodeToggled` per change).
PRO	`Promise<void>`	collapse every collapsible tree node.
PRO rowId: string \| number, expanded: boolean	`Promise<void>`	expand/collapse one master row's detail panel. Unknown ids warn + no-op (same validation discipline as row groups/tree nodes).
PRO	`Promise<void>`	expand every master's detail across the WHOLE filtered set (all pages — AG's forEachNodeAfterFilter convention; one `detailRowToggled` per change).
PRO	`Promise<void>`	collapse every open detail row.
groupId: string, open: boolean	`Promise<void>`	expand/collapse a header group by id (`groupId` or its declaration path). No-ops when the state already matches.
	`Promise< Array<{ rowIndex: number; rowId: unknown; field: string; value: unknown; message: string }> >`	every cell that currently fails a validation rule, in display order. Empty when there are no rules (zero overhead). A host uses this for an error summary / "jump to next error" / a save-guard.
name?: string	`Promise<string>`	capture the current `rowData` as a named snapshot (a deep copy, immune to later edits) and return its id. A version bookmark, distinct from undo/redo. The list is bounded by `maxSnapshots` (oldest evict first).
	`Promise<SnapshotMeta[]>`	the retained snapshots, newest last, without their row payloads.
id: string	`Promise<boolean>`	delete a snapshot by id; returns whether one was removed.
idA: string, idB?: string	`Promise<SnapshotDiff<GridRow>>`	diff snapshot `idA` → `idB` (added / removed / changed rows with per-field before/after). Omit `idB` to diff a snapshot against the CURRENT rowData. Rows match by `getRowId` (else `row.id`, else position). A missing id contributes an empty side.
id: string	`Promise<boolean>`	restore a snapshot: replace `rowData` with a fresh deep copy of the snapshot's rows (re-cloned so later edits don't taint the stored version) and emit `rowDataChanged` with the computed added / updated / removed (matched by getRowId) plus `snapshotRestored`. Returns false when the id is unknown. Undo/redo continues on top of the restored state.
PRO	`Promise<CellRangeBounds[]>`	committed cell ranges as normalized inclusive bounds.
PRO	`Promise<boolean>`	programmatic copy (same path as Ctrl/Cmd+C). Pro (grid.range-clipboard): the text is serialized and written only once entitled; the keyboard path does not route through this method.
PRO	`Promise<boolean>`	programmatic paste from the async clipboard API (the keyboard path uses the native `paste` event instead — arc review 239-242). Returns whether anything applied.
PRO	`Promise<void>`	clear every cell range (emits when something was cleared).
	`Promise<void>`	purge the cache (e.g. sort/filter changed) and refetch.
	`Promise<void>`	discard all measured auto-height row heights and remeasure on the next render (ag-grid `resetRowHeights` parity). Call after mutating content that changes wrapping (e.g. an external font/CSS swap) when the automatic data/column/viewport-width invalidation cannot see the change.
	`Promise<void>`	Scroll the column-defs viewport to the top.
ids: Array<string \| number>	`Promise<void>`	Replace the current row selection.
	`Promise<ReadonlyArray<string \| number>>`	Read the current selected row ids.
transaction: RowDataTransaction<GridRow>, label?: string, opts?: { source?: GridEditSource; origin?: unknown }	`Promise<ApplyRowTransactionResult<GridRow>>`	Apply a row-data transaction and emit its diff.
	`Promise<boolean>`	Undo the most recent recorded transaction.
	`Promise<boolean>`	Redo the most recently undone transaction.
	`Promise<void>`	Clear undo and redo history.
PRO opts?: { realtimeUrl?: string; userName?: string; userColor?: string; presence?: boolean; persistence?: 'none' \| 'indexeddb' }	`Promise<GridSyncStatus>`	Join the collaboration room (Pro, grid.collaboration). An existing session answers its status and a grid without a room answers 'offline' (nothing to join — no license read). Otherwise the request is refused (rejects with the license error) unless entitled; a build without the collab runtime rejects `module-missing` and a runtime or connection failure `load-failed` — never a silent 'offline'. Cell edits then sync across clients in the same `collaborationRoom`.
ids: GridChunkId[]	`Promise<void>`	Preload optional feature chunks ahead of first use . Explicit only — the grid never preloads on idle. A chunk of Grid Pro features (ledger entryPoints.chunks) serves each of them, so it is preloaded while ANY feature that loads it is entitled (the chunk-loader backstop's rule: a grouping-only grant preloads 'group-pivot'). The first chunk none of whose features is entitled rejects the whole call with the license error BEFORE any request. Load failures surface through `chunkLoadFailed`; this method rejects only on an entitlement refusal.
PRO	`Promise<void>`	Leave the collaboration room.
PRO	`Promise<GridSyncStatus>`	Current sync status — 'offline' in Community / when not connected.
PRO	`Promise<GridCollaboratorInfo[]>`	Connected collaborators .
PRO rowId: string \| number, field: string, text: string, parentId?: string	`Promise<string \| null>`	Add a comment to a cell's thread (Pro, requires an active collaboration session). Returns the comment id, or null when unavailable.
PRO rowId: string \| number, field: string	`Promise<GridCellComment[]>`	A cell's comment thread, ordered by creation time.
PRO rowId: string \| number, field: string, commentId: string, resolved: boolean	`Promise<boolean>`	Mark a comment resolved/unresolved. False when the comment is unknown.
PRO rowId: string \| number, field: string, commentId: string	`Promise<boolean>`	Delete a comment (CRDT tombstone — removed on every replica).
options?: Omit<CsvExportOptions<GridRow>, 'columns' \| 'rows'>	`Promise<CsvExportResult>`	Serialize the current rows + columns to CSV text.
options?: Omit<CsvDownloadOptions<GridRow>, 'columns' \| 'rows'>	`Promise<CsvExportResult>`	Download the current rows + columns as a CSV file.
PRO options?: { sheetName?: string; onlySelected?: boolean; columnKeys?: readonly string[]; skipHeaders?: boolean; }	`Promise<Uint8Array>`	serialize the current rows + visible columns to XLSX bytes.
PRO options?: { fileName?: string; sheetName?: string; onlySelected?: boolean; columnKeys?: readonly string[]; skipHeaders?: boolean; }	`Promise<void>`	build the XLSX workbook and trigger a browser download.
text: string, options?: { delimiter?: CsvDelimiter; hasHeader?: boolean }	`Promise<{ rowCount: number; columnCount: number }>`	parse CSV text and load it into the grid (replaces `columnDefs` + `rowData`). Returns the parsed shape; fires `csvImported`.
PRO options?: SyGridPdfExportOptions	`Promise<PdfExportResult>`	Serialize the current rows + columns to a PDF byte stream.
PRO options?: SyGridPdfDownloadOptions	`Promise<PdfExportResult>`	Build the PDF and trigger a browser download via Blob anchor click.
source: ArrayBuffer \| Uint8Array, options?: { sheetName?: string; snapshot?: SheetToRowDataOptions }	`Promise<XlsxImportResult>`	Parse an XLSX byte stream into `{ columnDefs, rowData }` and emit the `xlsxImported` event so a host can mirror the snapshot into its bound `rowData` / `columnDefs` props. Returns the parsed `XlsxImportResult` so callers can also inspect every sheet / shared strings / styles directly.
PRO target: { rowIndex: number; field?: string }	`Promise<ContextMenuItem[]>`	Build the default context-menu items for a cell.
rowIndex: number, field: string	`Promise<boolean>`	Copy a single cell's text representation to the system clipboard.
rowIndex: number	`Promise<boolean>`	Copy a single row as TSV (visible columns only).
target: { rowIndex: number; field: string; displayedText?: string; isOverflowing?: boolean }	`Promise<string>`	Resolve the tooltip text for a cell (overflow + tooltipField/tooltipValueGetter aware).
	`Promise<{ undo: number; redo: number }>`	Read the current undo and redo stack depths.
colId: string, width: number	`Promise<void>`	Set a column width, respecting min/max bounds.
colId: string	`Promise<void>`	Clear a live column-width override.
colId: string	`Promise<number \| null>`	Read the effective width for a column id.
field: string, side: ColumnPinSide \| null	`Promise<void>`	pin/unpin a column at runtime (`null` = unpin). Unknown fields are rejected with a warning. `'right'` becomes fully functional on ; the model accepts it already so column state snapshots round-trip.
field: string	`Promise<ColumnPinSide \| null>`	effective pin side of a column (override-aware).
orderedColIds: string[]	`Promise<void>`	Set the effective column order.
	`Promise<string[]>`	Read the effective column order.
colId: string	`Promise<void>`	Hide a single column.
colId: string	`Promise<void>`	Show a single column.
colId: string	`Promise<boolean>`	Toggle a column's hidden state and return the new state.
colIds: string[]	`Promise<void>`	Replace hidden-column state from a field list.
	`Promise<void>`	Clear all hidden-column state.
	`Promise<string[]>`	Read the current hidden-column ids.
colId: string	`Promise<number \| null>`	Auto-size a single column from visible content.
	`Promise<void>`	Auto-size every visible, resizable column.
	`Promise<ColumnStateEntry[]>`	Snapshot column width, order, visibility, (multi-)sort and pin state.
state: ColumnStateEntry[], opts?: ApplyColumnStateOptions	`Promise<void>`	Restore column state from a snapshot.
	`Promise<SyGridState>`	Immutable snapshot of the unified grid state .
state: SyGridState, options?: GridStateApplyOptions	`Promise<SyGridStateApplyReport>`	Controlled unified-state restore . Full apply covers every slice the state carries; `options.slices` selects a partial apply. Only slices in the returned `appliedSlices` are written; every restore problem is in the report, never swallowed.
	`Promise<SyGridFilterSlice>`	The complete global filter model (built-in, custom, quick, condition).
model: SyGridFilterSlice \| null	`Promise<FilterSliceApplyResult['report']>`	Replace the global filter model; `null` clears every filter family. Custom models flow through the Phase C facade and are awaited, so the returned report reflects async completion. Fail-closed: an invalid model returns its issues in `invalidBuiltIn` semantics with zero writes.
PRO	`Promise<SyGridCanonicalRange[]>`	the canonical range set (stable ids + anchor/focus).
PRO ranges: SyGridCellRangeInput[]	`Promise<SyGridCanonicalChange[]>`	replace the canonical selection through the transitions and mirror it into the legacy `rangeState`. Emits the existing `rangeSelectionChanged` (one selection event surface — no new event). Returns the typed change list (`removed` for every prior range, then one `added` per applied input, ids monotonic).
PRO options?: SyGridBatchStartOptions	`Promise<boolean>`	open a batch edit session . True when started or joined.
PRO	`Promise<boolean>`	whether a batch session is live.
PRO rowId: GridRowId, colId: string, value: unknown	`Promise<boolean>`	stage one identity-keyed cell into the live batch. Identity must resolve to a current row and a declared column; display coords ride along for the overlay seam only. Nothing is written to the model until `commitBatchEdit`.
PRO	`Promise<SyGridPendingBatchCell[]>`	the pending (staged, uncommitted) batch cells in first-staging order. The public pull surface for the visibility layer: the renderer overlay itself is deferred to Phase F (wiring the per-consumer pending policy into the shared cell text resolver would put a batch branch into every sealed render/copy/aggregation path — measured too regression-prone for this batch; recorded honestly in the daily note).
PRO	`Promise<number>`	cancel the live batch through the ledgered API cancel: one minted cancelled transaction (batchEditStart → batchEditEnd with `reason: 'api'`), zero writes, typed dropped count.
PRO options?: SyGridBatchCommitOptions	`Promise<SyGridBatchCommitReport>`	commit the live batch through the recovery-capable async core: one mint per flight, strongest-first fail-closed gates (RBAC → validation), partial-invalid policy ('reject-all' default — the session survives a refusal with pending intact; 'commit-valid' writes the valid subset and keeps invalid cells pending). Accepted writes apply through the single-authority `applyTransaction` route between the ledger's start and end events.
rowId: GridRowId	`Promise<boolean>`	open a full-row edit session for a DISPLAYED data row resolved by stable id. Editable columns = resolved column defs with `editable: true` (the grid's structural editability — the same gate every interactive edit path uses). Group markers, detail panels and unloaded placeholder rows carry no stable data id, so they cannot reach this API; the boundary table still guards them in-core.
reason?: 'commit' \| 'cancel'	`Promise<SyGridRowEditReport>`	stop the live row edit. `'commit'` (default) routes through the core's `'api'` commit row; `'cancel'` through the `'escape'` cancel row . A committed stop applies its writes through the single-authority route, then emits `rowValueChanged` exactly once AFTER the per-cell events . A rejected stop keeps the session open with pending intact (the recovery law).
colId: string, value: unknown	`Promise<boolean>`	ADR-024 — stage ONE cell value into the live row session (the public half PE-ROWEDIT-01 recorded missing: start/stop existed, nothing could put writes in). Refusals are the core's own (`no-row-edit`, `column-not-editable`) and stage NOTHING. The write itself lands at the row commit through the single-authority route — staging emits no event.
	`Promise<SyGridStateCaptureReport>`	QA-D Med-1 pull channel: the capture-side diagnostics of the unified-state builder, on demand (the push channel stays `preDestroyed.captureIssues`).
PRO options: SyGridFillRangeOptions	`Promise<SyGridFillRangeReport>`	5 — API-driven fill over the sealed 57 cores (`computeFillPlan` → `computeFillValues` → `planFillTransaction`), loaded on demand as the ADR-007 'fill' chunk. ONE mint from the grid-wide counter; the sealed ledger brackets the write batch (`fillStart` → the transaction route's per-cell stream → `fillEnd`) and the plan's own per-cell entries are NEVER re-emitted — accepted writes apply through the single-authority `applyTransaction` route, so `cellValueChanged`/undo/audit/collab ride the existing emission. Structural policy: opt-in editable columns; rows without a stable id (group markers, detail panels, unloaded placeholders) are excluded as 'protected' (the identity law — id-less rows are not writable). A committed fill applies the plan's `resultingRange` to the selection . A fail-closed value plan still opens and closes the ledger (`fillEnd` status 'cancelled', the error verbatim) with zero writes.
PRO index: number	`Promise<SyGridDisplayRowInfo \| null>`	the display-row taxonomy for ONE live display row.
PRO	`Promise<SyGridPivotCombinationReport>`	the combination decision over the features this grid actually has configured.
PRO	`Promise<SyGridPivotSecondaryColumns \| null>`	the identity model of the columns the grid GENERATED for the current cross-tab.
PRO options?: SyGridGroupCheckStatesOptions	`Promise<SyGridGroupCheckStatesReport>`	the group checkbox tri-state over the live hierarchy and the live selection.
input: SyGridRowDragStartInput	`Promise<SyGridRowDragStartResult>`	start an unmanaged drag from the API: a KEYBOARD grab of the row (arrows move it, `Enter` drops → `rowDragEnd` with `keyboard: true`, `Escape` cancels). A pointer session can only start from a real pointer-down on the handle — the gesture threshold and the pointer capture are what a pointer session IS, so the method says so rather than fake one.
	`Promise<SyGridRowDragSessionReport>`	the live (or last) drag session, the gesture, the residue and the zones.
input: SyGridDropZoneInput	`Promise<SyGridDropZoneRegistration>`	register a drop zone: `kind: 'grid'` with `grid` (a peer `<sy-grid>` element — its rows are read live and written on a transfer) or `kind: 'external'` with `element` (any element or selector; what lands there is delivered through `onDrop`).
zoneId: string	`Promise<boolean>`	remove a zone; a drag targeting it is cancelled. The grid's own zone cannot be removed.
	`Promise<SyGridDropZonesReport>`	the zone registry (own zone included), its generation and the active target.
	`Promise<SyGridDragSafetyReport>`	the drag-safety monitor: live/stuck drags, aborts by cause, the watchdog.
input: SyGridAlignedGridsInput	`Promise<SyGridAlignedGridsResult>`	join a group (name), configure peers (array sugar), or leave (`null`); the orchestration is chunk-side .
	`Promise<SyGridAlignedGridsReport>`	the group as this member sees it; an unconfigured grid answers without loading anything.
PRO request: SyGridReparentRequest	`Promise<SyGridReparentResult>`	reparent rows on the id-linkage tree: plan , apply (a NEW rowData; movers cloned with the parent field rewritten), emit `treeReparented`. Loads the `row-drag` chunk on first use; a non-id-linkage tree refuses without loading anything.
rowIndex?: number	`Promise<SyGridFullWidthRowInfo<GridRow> \| SyGridFullWidthLayoutReport \| null>`	what a display row is under the full-width layout (or the layout report when the index is omitted).
input: SyGridPinnedRowSetInput<GridRow>	`Promise<SyGridPinnedRowsResult<GridRow>>`	replace the pinned set atomically .
	`Promise<SyGridPinnedRowsReport<GridRow>>`	the pinned rows, the composed counts, the dangling / colliding ids and the policy matrix.
displayIndex: number	`Promise<SyGridPinnedRowInfo<GridRow> \| null>`	what a COMPOSED display index (`top ++ center ++ bottom`) holds.
colId: string	`Promise<SyGridRowSpanReport \| null>`	the full-list row-span layout of one column: what the paint uses, including every rejection (invalid answers, thrown callbacks, clamps at a section / list end / the facade cap) and the cache stats. `null` for an unknown column; `status` says why nothing spans.
rowIndex: number, colId: string	`Promise<SyGridCellSpanInfo \| null>`	the resolved rectangle at one coordinate: origin, spans, whether the coordinate is covered by another cell, the pixel rect, and the row / column rejections that touched it. Exact for any row, painted or not.
query?: SyGridSpanInteractionQuery	`Promise<SyGridSpanInteractionReport>`	the last painted frame's span grid (counts, conflicts, the widened render range) and, with a query, one access decision: where an edit / focus / copy at that coordinate is redirected to.
PRO	`Promise<SyGridServerSelectionState>`	PG-SEL-WIRING-01 — the server-side selection state: one predicate (`selectAll`) plus the exception ids, grid-wide, held without materialising a single row. Under a row-grouped topology the grid runs the hierarchical model instead and this answers `model-mismatch` naming `getServerGroupSelectionState`.
PRO	`Promise<SyGridServerSelectionState>`	PG-SEL-WIRING-01 — the hierarchical tri-state selection under a row-grouped SSRM topology.
PRO input: unknown	`Promise<SyGridServerSelectionSetResult>`	PG-SEL-WIRING-01 — replace the flat server selection state (`{ selectAll, toggledRowIds }`), typed refusals kept.
PRO input: unknown	`Promise<SyGridServerSelectionSetResult>`	PG-SEL-WIRING-01 — replace the hierarchical selection state (`{ selectAllChildren, toggledNodes }`).
PRO action?: 'select' \| 'clear'	`Promise<SyGridServerSelectAllResult>`	PG-SEL-WIRING-01 — select (default) or clear the WHOLE grid, unloaded rows included, in O(1).
PRO groupKeys: ReadonlyArray<string>, action?: 'select' \| 'deselect'	`Promise<SyGridServerGroupChildrenResult>`	PG-SEL-WIRING-01 — select or deselect ONE group subtree by its group-key path (group model).
PRO input?: SyGridServerRefreshInput	`Promise<SyGridServerRefreshResult>`	route-scoped SSRM refresh ` shape under our naming).
PRO transaction: SyGridServerTransactionInput	`Promise<SyGridServerTransactionResult>`	synchronous route-addressed server-side transaction . Order inside one transaction is pinned update → remove → add; `addIndex` addresses the post-remove sequence.
PRO transaction: SyGridServerTransactionInput, onSettle?: (settlement: SyGridServerTransactionSettlement) => void	`Promise<SyGridServerTransactionEnqueue>`	enqueue a server-side transaction into the async queue (the AG `applyServerSideTransactionAsync` shape under our naming). One wait window (`serverSideTransactionWaitMs`, default 50 ms) batches enqueues FIFO into one apply pass and ONE state commit; `onSettle` receives exactly one settlement, ever. State is read at FLUSH time , so a transaction enqueued before a refresh applies to the post-refresh store — or settles as a typed `store-loading` refusal.
PRO	`Promise<SyGridServerFlushReport>`	apply the pending async batch NOW (the AG `flushServerSideAsyncTransactions` shape). `empty` when nothing is pending — including when the queue was never built, which is why this method never loads the chunk to say so.
PRO	`Promise<SyGridServerStateReport \| null>`	the readonly snapshot over every live store: route/type/status/counts and per-block cache state, deep-frozen, plus the cross-tree diagnostics (`nodesWithoutStore` — the PG-SSRM-ORPHAN-01 class made visible) and the facade's landing-guard counter.
PRO	`Promise<SyGridServerPivotColumnsReport \| null>`	the identity model over the pivot result metadata the store retains (root-store-only publishing). Identity is the server's own naming under its group path, encoded by the one codec — the same label under two parents is two identities , and a duplicate colId refuses the whole model with the ids named.
PRO colIds: ReadonlyArray<string>	`Promise<SyGridServerPivotColumnAudit \| null>`	the PG-PIVOT-CONSUMER-01 usage gate: for the column ids a consumer is about to chart/export/restore against, answer `live` / `live-stale` / `unknown-column` from the CURRENT model, so after a metadata refresh no gated consumer uses a vanished column silently. `clean` is `true` iff every asked id resolved. `null` = SSRM is not active on this grid.
PRO	`Promise<SyGridWorkbookPropagationState>`	the enrollment report: identity, the generation clock, this sheet's hub-registered cross-sheet formula cells, every registration REFUSAL (a refused cell keeps painting its engine-local value and will NOT propagate — this report is the truth surface for that divergence), and the last publication stamp.
PRO	`Promise<SyGridWorkbookFlushReport>`	drain every scheduled workbook edit NOW . Commits auto-flush, so this usually answers `empty`; it exists for deterministic driving (tests, batch hosts). One generation per transaction .
PRO	`Promise<SyGridWorkbookSnapshotReport>`	the sheet's last-published universe: generation, snapshot hash and every published cell (display-projected, with the canonical hash-alphabet text beside it so a consumer can re-derive the hash independently). `unpublished` before the first transaction — the published universe is the cells the hub has routed, NOT every grid cell.
PRO	`Promise<SyGridWorkbookIntegrityReport>`	the cycle verdict over the live hub: whole-hub verdict counts, THIS sheet's non-acyclic cells, and the count of cells currently publishing `#CYCLE!` under the policy. Note the honest paint divergence: a cycle-member cell's own PAINT is the engine-local value while its PUBLICATION is `#CYCLE!` (PH-CYCLE-PAINT-01) — importing grids paint the published `#CYCLE!`.
PRO input: SyGridSpillApplyInput	`Promise<SyGridSpillApplyResult>`	land a dynamic-array formula under the collision policy: a spill lands WHOLE or not at all. The anchor text is written through `applyTransaction` (the grid's single write authority, so undo/audit/cellValueChanged all ride it) with a facade-minted grid-wide mutation id (PH-UNDO-01); the engine half lands through the model. Coordinates are SHEET coordinates (definition/data order — formulas are display-independent). `landed-blocked` = occupied-only collisions: the anchor paints `#SPILL!` through the existing formula error path until the occupant leaves. Covered cells beyond the data rectangle compute but do not paint (PH-SPILL-COVER-01, reported in `unpaintedCells`). Refused on the dual (WASM-serving) engine lane — PH-SPILL-01, `engine-lane-unsupported`.
PRO target: SyGridSpillTarget	`Promise<SyGridSpillClearResult>`	retire a landed spill anchor: the anchor data cell clears through the single write authority (minting its own mutation id) and the whole coverage heals through the model.
PRO mutationId: GridMutationId	`Promise<SyGridSpillUndoResult>`	undo one spill transaction by its mutation id: the anchor's previous data content restores through the single write authority and the engine half retires/re-lands deterministically. An entry is consumed by its undo; grid-level `undo` reaches the same data half through the transaction it recorded.
PRO	`Promise<SyGridSpillReport>`	the spill-state report over the live engine: every anchor's range (dims, status, per-range hash, engine-truth covered values), the loud overlap report, and the whole-model state hash. The refresh that answers it also HEALS coverage deltas . Refused on the dual lane (PH-SPILL-01).
PRO params: SyGridChartCreateParams	`Promise<SyGridChartCreateResult>`	create a linked chart from the current canonical range (or from explicit params) and mount a real `<sy-chart>` into a grid-owned panel or the caller's container.
PRO chartId: string, patch: SyGridChartUpdatePatch	`Promise<SyGridChartUpdateResult>`	change a live chart's type, source window or properties.
PRO chartId: string	`Promise<SyGridChartDestroyResult>`	destroy one chart and free every resource it holds.
PRO	`Promise<SyGridChartReport[]>`	the live chart refs (never a lie about liveness).
PRO mutation?: SyGridChartSyncMutation	`Promise<SyGridChartSyncReport>`	re-derive every linked chart against the CURRENT view. The generation advances first, so a re-presented view is a no-op at tolerance zero rather than a re-render.
PRO permissions?: SyGridChartPermissions	`Promise<SyGridChartMenuReport>`	the menu/wizard MODEL: what this selection may be charted as.
PRO permissions?: SyGridChartPermissions	`Promise<SyGridChartPanelReport>`	open the rendered tool panel: a `role="dialog"` with a `role="menu"` of every concrete type, roving tabindex, 44px touch targets and RTL-aware arrow keys.
PRO	`Promise<SyGridChartPanelReport>`	close the tool panel and release its wizard.
PRO	`Promise<SyGridChartPanelReport>`	the panel's current focus/touch/RTL truth, measured.
PRO	`Promise<SyGridChartCreateResult>`	activate the panel's focused menu item (Enter/Space).
PRO	`Promise<SyGridChartCaptureResult>`	capture every live chart into the versioned model envelope.
PRO envelope: unknown	`Promise<SyGridChartRestoreResult>`	restore charts from a persisted envelope against THIS grid.
PRO chartId: string, request: SyGridChartExportRequest	`Promise<SyGridChartExportResult>`	resolve an export and ask the ELEMENT for the pixels.
PRO chartId: string, colId: string, action: SyGridChartCrossFilterAction, categories: unknown[]	`Promise<SyGridChartCrossFilterResult>`	a chart gesture becomes a real grid filter model.
PRO	`Promise<SyGridChartCrossFilterResult>`	drop every chart-owned filter; external filters are untouched.
PRO chartId: string	`Promise<SyGridChartAccessibleReport \| null>`	the accessible summary: the ELEMENT's own data table fed the grid's projection, plus the focus stops the RENDERED panel exposes and the violations the predicate finds in them.
PRO	`Promise<SyGridChartFleetReport>`	the fleet/teardown ledger: live charts, open handles, leaks.
rowId: string \| number \| null	`Promise<void>`	Set or clear the hovered row id.
	`Promise<string \| number \| null>`	Read the currently hovered row id.
	`Promise<EditTransaction \| null>`	Read the active edit transaction.
	`Promise<boolean>`	Commit the active edit transaction.
	`Promise<boolean>`	Cancel the active edit transaction.
name: string, renderer: CellRenderer	`Promise<boolean>`	Register a custom cell renderer by name.
	`Promise<ReadonlyArray<string>>`	List registered cell-renderer names.
name: string	`Promise<boolean>`	Unregister a host-registered renderer by name.
scope: GridComponentRegistrationScope, kind: TKind, name: string, definition: GridComponentDefinitionFor< TKind, GridData, unknown, unknown, unknown >	`Promise<void>`	Register a named lifecycle component in this grid or application scope.
scope: GridComponentRegistrationScope, kind: TKind, name: string, definition: GridComponentDefinitionFor< TKind, GridData, unknown, unknown, unknown >	`Promise<void>`	Atomically replace a named lifecycle component definition.
scope: GridComponentRegistrationScope, kind: GridComponentKind, name: string	`Promise<boolean>`	Remove one named lifecycle component.
scope: GridComponentRegistrationScope, kind: GridComponentKind	`Promise<ReadonlyArray<string>>`	List lifecycle component names in deterministic registration order.
rowId: GridRowId, colId: string	`Promise<GridRendererDiscovery<GridData, unknown, unknown>>`	Return the currently mounted lifecycle renderer for one logical cell.
rowId: GridRowId, colId: string	`Promise<boolean>`	Destroy one mounted lifecycle renderer without affecting pure renderers.
rowId: GridRowId, colId: string, direction: 'in' \| 'out'	`Promise<boolean>`	Invoke the optional focus hook on one mounted lifecycle renderer.
	`Promise< GridMountedComponentLookup< GridEditorInstance<GridData, unknown, unknown>, GridEditorParams<GridData, unknown, unknown>, HTMLElement > \| null >`	Return the active lifecycle editor lookup, including its generation.
columnId: string	`Promise< GridFilterInstance<GridData, TColumnValue, TModel, unknown> \| null >`	Return the mounted lifecycle filter instance for one column.
columnId: string	`Promise<TModel \| null>`	Read the canonical lifecycle-filter model owned by the grid facade.
columnId: string, model: TModel \| null	`Promise<boolean>`	Set one lifecycle-filter model and await floating/peer synchronization.
	`Promise<void>`	Synchronize models after an advanced caller mutates a raw filter instance. Prefer setColumnFilterModel for normal application code.
	`Promise<boolean>`	Re-run a same-identity external filter's async refresh contract.
columnId: string	`Promise<boolean>`	Destroy a lifecycle filter and schedule deterministic lazy recreation.
columnId: string, options?: { preserveModel?: boolean }	`Promise<boolean>`	Recreate a mounted lifecycle filter, optionally retaining its model.
PRO columns: string[]	`Promise<boolean>`	Replace the pivot columns through the same validated transition path as the Pivot Panel.
PRO columns: string[]	`Promise<boolean>`	Replace the value columns; duplicates are removed and arrays are detached from the caller.
PRO model: ConditionNode \| null	`Promise<void>`	apply/replace the grid-level condition tree programmatically (`null` clears it). The model is validated (`validateConditionNode`) and deep-copied; invalid models are rejected with a console warning and no state change. The builder panel reflects every scalar condition; set leaves still filter but are not editable in the initial panel (see `treeToBuilderDraft`).
PRO	`Promise<ConditionNode \| null>`	read the applied condition tree (deep copy, `null` = none).
PRO presets: ReadonlyArray<{ name: string; json: string }>	`Promise<void>`	replace the named preset list (host persistence hook: read with , persist wherever you like, and feed back on startup). Malformed entries are dropped; JSON payloads are validated with the tree parser.
PRO	`Promise<Array<{ name: string; json: string }>>`	read the named preset list (defensive copy).
PRO id: string	`Promise<boolean>`	open a side-bar tool panel; false = unknown/undeclared id.
PRO	`Promise<void>`	close the open tool panel (no-op when already closed).
PRO	`Promise<string \| null>`	the open tool panel id, or null.

ColumnDef53

ColumnDef	Type / Required	Description
	`GridFieldPath<TData>`Required	Key on the row object — used to read the cell value when no `valueGetter`.
	`string`Optional	Stable public id. Falls back to `field`.
	`string`Optional	Header text. Falls back to `field` when omitted.
	`string`Optional	tooltip shown on header hover/focus. When omitted, a truncated (overflowing) header still shows its full text as a tooltip.
	`boolean`Optional	Whether the column is sortable (header click toggles direction).
	`'asc' \| 'desc' \| null`Optional	Initial sort direction; `null` means unsorted.
	`number`Optional	initial multi-sort priority when several columns declare `sort:` and the grid runs with `multi-sort`. Lower values sort first; omissions and ties fall back to `columnDefs` order. Ignored in single-sort mode . Mirrors AG Grid's `initialSortIndex`.
PRO OPTION	`\| ColumnFilterDecl \| string \| GridFilterDefinition<TData, TValue, unknown, TContext>`Optional	Filter type. `true` enables the built-in text filter; `false` disables it. an ordered array stacks several kinds on this column in one dropdown, AND-combined — see .
	`GridCallback<[ValueGetterParams<TData, TValue, TContext>], TValue> \| string`Optional	Computed value hook. Function callbacks receive value-getter params; string expressions are evaluated by the grid expression parser.
PRO	`string`Optional	calculated column: a row-template formula (`'=B*C'`) evaluated by the formula engine for EVERY row. Bare column letters anchor to the row (`B` → `B3` on row 3); whole-column ranges (`SUM(D:D)`) and function names pass through. Requires the grid's `formulas` prop; the column is read-only (like a `valueGetter` column) and sorts/filters by its computed values.
	`GridCallback<[ValueFormatterParams<TData, TValue, TContext>], string> \| string`Optional	Converts a resolved cell value into display text. Accepts a function or a template string such as `{{value \| round:2}}`.
	`GridFieldPath<TData>`Optional	Row field used as tooltip text before overflow fallback.
	`GridCallback<[ValueGetterParams<TData, TValue, TContext>], unknown> \| string`Optional	Computed tooltip text. Wins over `tooltipField`.
	`\| string \| CellRenderer<TData, TValue> \| GridRendererDefinition<TData, TValue, TContext>`Optional	Custom renderer name or inline renderer. Omitted columns render as text.
	`Record<string, unknown>`Optional	Opaque options passed to the cell renderer.
PRO OPTION	`GridCellEditorDeclaration<TData, TValue, TContext>`Optional	Named or direct lifecycle editor. Built-in editors continue to use `editor`.
	`\| string \| GridFloatingFilterDefinition<unknown, TContext>`Optional	Optional lifecycle floating filter rendered in the header filter row.
	`\| string \| string[] \| GridCallback<[CellCallbackParams<TData, TValue, TContext>], string>`Optional	Always-applied cell class. Accepts a class string, class array, or callback returning classes.
	`Record< string, GridCallback<[CellCallbackParams<TData, TValue, TContext>], boolean> \| string >`Optional	Conditional classes keyed by class name. Values are predicates or expressions.
	`\| Record<string, string \| number> \| GridCallback< [CellCallbackParams<TData, TValue, TContext>], Record<string, string \| number> \| null \| undefined > \| ReadonlyArray< \| Record<string, string \| number> \| GridCallback< [CellCallbackParams<TData, TValue, TContext>], Record<string, string \| number> \| null \| undefined > >`Optional	Inline cell style object, callback, or merged array of either form.
	`number`Optional	Fixed column width in pixels.
	`number`Optional	Lower bound for column width in pixels.
	`number`Optional	Upper bound for column width in pixels.
	`number`Optional	Flex factor — distributes leftover horizontal space (CSS-flex semantics).
	`boolean`Optional	Per-column override for wrapper-level column resizing.
	`boolean`Optional	Per-column override for wrapper-level column reordering.
	`'left' \| 'right' \| null`Optional	pin this column to an edge: pinned columns render before (left) / after (right) the scrolling middle block and stick while it scrolls horizontally. Pinned columns need a concrete pixel width (`width` or a live resize); flex-sized pinned columns fall back to a 150px default. Runtime `setColumnPinned` overrides this declaration.
	`'open' \| 'closed'`Optional	visibility rule relative to the parent header group's open/closed state (AG `columnGroupShow`): `'open'` shows only while the group is expanded, `'closed'` only while collapsed, omitted always. Any child declaring this gives the group its expand/collapse toggle.
PRO	`'sum' \| 'avg' \| 'min' \| 'max' \| 'count' \| string`Optional	aggregate this column over each row group (`group-by` active): the value renders in the group footer row. Built-ins: `'sum' \| 'avg' \| 'min' \| 'max' \| 'count'`; any other name resolves through `registerAggFunc` (registered names may shadow built-ins — AG `aggFuncs` parity), unknown names warn once and skip the column. Names only (no inline functions) — the declarative surface stays serialisable; functions live in the instance registry.
	`boolean`Optional	Initial hidden state; runtime visibility state owns later changes.
	`boolean`Optional	AG Grid compatibility alias for ; `hidden` wins when both are set.
	`boolean`Optional	Whether cells in this column can be edited.
PRO OPTION	`'text' \| 'number' \| 'date' \| 'select' \| 'checkbox' \| 'textarea' \| 'autocomplete' \| 'largeText'`Optional	Built-in editor type.
	`GridCallback<[ValueParserParams<TData, TValue, TContext>], TValue>`Optional	Arc review 239-242 — parse a clipboard-pasted display string into THIS column's cell value (AG `valueParser` parity). When present it fully replaces the built-in auto-detection (`detectPastedValue`); a throw falls back to the raw string. `editor: 'text'` columns skip auto-detection even without a parser (identifiers stay strings).
	`GridCallback< [ValueSetterParams<TData, TValue, TContext>], boolean \| void >`Optional	Optional host-owned write path. Return false to reject the edit. A true or void result accepts the mutation; the callback must apply `newValue` synchronously so transaction/event/audit/undo surfaces observe one value.
	`GridCallback<[TValue, TValue, Readonly<TData>, Readonly<TData>], number>`Optional	Select a name to inspect its type contract.
	`ReadonlyArray<{ value: unknown; label: string; disabled?: boolean }>`Optional	Option list for `editor: 'select'`.
	`number \| Date \| string`Optional	Inclusive lower bound for number/date editors.
	`number \| Date \| string`Optional	Inclusive upper bound for number/date editors.
	`number`Optional	Multiple-of-step constraint for number editors.
	`number`Optional	Display formatting hint for number editors.
	`boolean`Optional	When true, an empty number/date editor commits as `null`.
	`boolean`Optional	Select a name to inspect its type contract.
	`'date' \| 'iso'`Optional	Commit shape for date editors.
	`number`Optional	Initial visible rows for textarea editors.
	`number`Optional	Auto-grow cap for textarea editors.
	`number`Optional	Visible columns (character width) for the large-text popup editor.
	`number`Optional	Max character length for the large-text popup editor. New input is capped here (ag-grid `agLargeTextCellEditor` parity, default 200); a seed value already longer is NOT truncated (no silent data loss) but warns once. Set explicitly to `0` for no limit.
	`boolean`Optional	show a row-drag handle in this column's cells. Combined with the grid's `row-drag-managed` prop, dragging the handle reorders `rowData`.
	`boolean`Optional	let this column's cell text wrap onto multiple lines instead of truncating with an ellipsis (ag-grid `wrapText`). On its own the cell wraps within the fixed row height (overflow clipped); pair with to grow the row to fit.
	`boolean`Optional	size the row to fit this column's (wrapped) content instead of the uniform `row-height` (ag-grid `autoHeight`). When any visible column sets this, the grid measures each rendered row after paint and virtualizes with the measured heights (see ). The tallest auto-height cell in a row wins.
	`(params: SyGridRowSpanParams<TData>) => number`Optional	(PF-ROWLAYOUT-WIRING-01 batch A, AG `rowSpan`) — how many rows this column's cell spans, starting at the row the callback is asked about. `1` (or a non-integer / non-positive answer) spans nothing; the span never crosses a group / footer / tree / detail / loading / pivot row and is capped at 100 rows. Client-side row model only; refused (and painted 1×1) under auto-height rows — `getRowSpan(colId)` says why.
	`(params: SyGridColSpanParams<TData>) => number`Optional	(PF-ROWLAYOUT-WIRING-01 batch A, AG `colSpan`) — how many columns this cell spans, to the right, inside its pin container (a span declared across a pin seam is clamped and reported). Origin cells take the summed width of the columns they cover; covered coordinates paint no cell. `getCellSpan(rowIndex, colId)` reports the resolved rectangle.