@kanunilabs/datagrid-react 1.8.8 → 1.8.10

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 import * as react from 'react';
-import { ReactNode, RefObject } from 'react';
-import { GridRowData, DataGridController, GridDataType, RowKey, LookupItem, GridDictionary, StateStoringConfig, RowNode, GridColumnDef, DataGridCoreConfig, FilterRenderContextBase, FilterNode, InferColumnsOptions, GridThemeName, GridPaletteName, DescribeFilterOptions, GridDensity, ToolbarOptions, PortalContainer, CardViewOptions, EditMode, RowChange, RowStatusSource, ColumnRuntime, ColumnLayout, SortDescriptor, ColumnModel, RowSaveStatus, DataRowNode, ColSpanPlan, SummaryDef, RemoteDistinctList, PortalKind, ToolbarSearchOptions, ToolbarIconName, ColumnState, BusyPhase, VirtualWindow, ChartBoxSpec, ChartBoxModel, ChartSpec, ChartModel, ChartXYSpec, ChartXYModel, CellRange, RangeSelectionEngine, ColumnSelectMode, EditingEngine, ValidationRule, CrudHandlers, EditingPermissions, NewRowPosition, RowEditSession, LookupMatchMode } from '@kanunilabs/datagrid-core';
-export { BusyChangedEvent, BusyPhase, ClientRowModel, ColumnLayout, ColumnLookup, ColumnModel, ColumnPin, ColumnRuntime, ColumnState, ColumnStateChangedEvent, ContentReadyEvent, CustomFilterOperator, CustomFilterOperatorId, DEFAULT_ROW_HEIGHT, DENSITY_ROW_HEIGHT, DataGridController, DataGridCoreConfig, DataRowNode, DataSource, FilterChangedEvent, FilterCondition, FilterGroupNode, FilterNode, FilterOperator, FocusedRowChangedEvent, GRID_COLOR_SCHEMES, GRID_PALETTES, GRID_THEMES, GridColorScheme, GridColumnDef, GridDataType, GridDensity, GridEventMap, GridPalette, GridPaletteName, GridRowData, GridStateStore, GridTheme, GridThemeName, GridViewState, GroupRowNode, GroupingConfig, HeaderBandCell, InferColumnsOptions, LoadOptions, LoadResult, LookupItem, NewRowPosition, PortalContainer, RowDropPosition, RowKey, RowNode, SUMMARY_TYPE_LABEL, ScrollingConfig, SelectionDescriptor, SortChangedEvent, SortDescriptor, SortDirection, StateStoringConfig, SummaryDef, SummaryType, THEME_ROW_HEIGHT, ToolbarOptions, ToolbarSearchOptions, ViewportChangedEvent, VirtualWindow, VirtualWindowEngine, allowedSummaryTypes, andFilters, attachStateStoring, bandDepth, bandPath, computeColumnLayout, computeHeaderBands, createRestDataSource, describeFilter, downloadBlob, fillText, filterInputFromNode, formatSummaryValue, humanizeField, importCsv, inferColumns, isDataRow, isDataSource, isFilterGroup, isGroupRow, isPackagedTheme, lookupLabel, moveRowInArray, parseCsv, parseFilterInput, sniffDelimiter, summaryKey, summaryLabel, summaryTypeLabels, themeClassName } from '@kanunilabs/datagrid-core';
+import { RefObject, ReactNode, FocusEvent, MouseEvent } from 'react';
+import { GridRowData, DataGridController, GridDataType, RowKey, LookupItem, GridDictionary, StateStoringConfig, RowNode, DataRowNode, CardField, RowSaveStatus, GridColumnDef, DataGridCoreConfig, FilterRenderContextBase, FilterNode, InferColumnsOptions, GridThemeName, GridPaletteName, DescribeFilterOptions, GridDensity, ToolbarOptions, PortalContainer, CardViewOptions, EditMode, RowChange, RowStatusSource, ColumnRuntime, ColumnLayout, SortDescriptor, ColumnLookup, ColumnModel, ColSpanPlan, SummaryDef, RemoteDistinctList, PortalKind, ToolbarSearchOptions, ToolbarIconName, ColumnState, BusyPhase, VirtualWindow, ChartBoxSpec, ChartBoxModel, ChartSpec, ChartModel, ChartXYSpec, ChartXYModel, CellRange, RangeSelectionEngine, ColumnSelectMode, EditingEngine, EditingApi, NewRowPosition, ValidationRule, CrudHandlers, EditingPermissions, CommitOn, RowEditSession, ColumnNumberFormat, LookupMatchMode, LookupMatchFold } from '@kanunilabs/datagrid-core';
+export { BusyChangedEvent, BusyPhase, ChangesChangedEvent, ClientRowModel, ColumnLayout, ColumnLookup, ColumnModel, ColumnPin, ColumnRuntime, ColumnState, ColumnStateChangedEvent, CommitOn, ContentReadyEvent, CustomFilterOperator, CustomFilterOperatorId, DEFAULT_ROW_HEIGHT, DENSITY_ROW_HEIGHT, DataGridController, DataGridCoreConfig, DataRowNode, DataSource, EditingApi, FilterChangedEvent, FilterCondition, FilterGroupNode, FilterNode, FilterOperator, FocusedRowChangedEvent, GRID_COLOR_SCHEMES, GRID_PALETTES, GRID_THEMES, GridColorScheme, GridColumnDef, GridDataType, GridDensity, GridEventMap, GridPalette, GridPaletteName, GridRowData, GridStateStore, GridTheme, GridThemeName, GridViewState, GroupRowNode, GroupingConfig, HeaderBandCell, InferColumnsOptions, LoadOptions, LoadResult, LookupItem, NewRowPosition, PortalContainer, RowDropPosition, RowKey, RowNode, SUMMARY_TYPE_LABEL, SaveRejected, SaveRowError, ScrollingConfig, SelectionDescriptor, SortChangedEvent, SortDescriptor, SortDirection, StateStoringConfig, SummaryDef, SummaryType, THEME_ROW_HEIGHT, ToolbarOptions, ToolbarSearchOptions, ViewportChangedEvent, VirtualWindow, VirtualWindowEngine, allowedSummaryTypes, andFilters, attachStateStoring, bandDepth, bandPath, computeColumnLayout, computeHeaderBands, createRestDataSource, describeFilter, downloadBlob, fillText, filterInputFromNode, formatSummaryValue, humanizeField, importCsv, inferColumns, isDataRow, isDataSource, isFilterGroup, isGroupRow, isPackagedTheme, isSaveRejected, lookupLabel, moveRowInArray, parseCsv, parseFilterInput, sniffDelimiter, summaryKey, summaryLabel, summaryTypeLabels, themeClassName } from '@kanunilabs/datagrid-core';
 
 /** Formats an export menu can offer. */
 type ExportKind = 'csv' | 'excel' | 'excel-selected' | 'pdf';
@@ -82,6 +82,11 @@ interface GridEditFormProps<TRow = GridRowData> {
     onNaturalHeight?: (px: number) => void;
     labels?: Partial<EditFormLabels>;
     onChange: (columnId: string, value: unknown) => void;
+    /**
+     * Several fields of the open row in one step — a custom editor's
+     * `ctx.api.setRowValues` (P-4.3). Absent: it answers false.
+     */
+    setRowValues?: (values: Readonly<Record<string, unknown>>) => boolean;
     onSave: () => void;
     onCancel: () => void;
 }
@@ -98,7 +103,141 @@ interface EditFormLabels {
 declare function editFormLabels(t: GridDictionary): EditFormLabels;
 /** English, kept as the constant this package already exported. */
 declare const DEFAULT_EDIT_FORM_LABELS: EditFormLabels;
-declare function GridEditForm<TRow = GridRowData>({ rowKey, fields, getValue, errors, lookups, customEditors, row, saving, saveError, isNew, dark, popup, inline, onNaturalHeight, labels: labelOverrides, onChange, onSave, onCancel, }: GridEditFormProps<TRow>): react.JSX.Element;
+declare function GridEditForm<TRow = GridRowData>({ rowKey, fields, getValue, errors, lookups, customEditors, row, saving, saveError, isNew, dark, popup, inline, onNaturalHeight, labels: labelOverrides, onChange, setRowValues, onSave, onCancel, }: GridEditFormProps<TRow>): react.JSX.Element;
+
+/**
+ * Which gestures open a cell's editor (P-7.1). Every field defaults to
+ * today's behaviour: `f2: true, enter: false, typing: true, doubleClick: true`.
+ */
+interface EditKeys {
+    /**
+     * F2 opens the focused cell's editor. Default true. `false`: the grid does
+     * not handle F2 at all and does not `preventDefault()` it — the key reaches
+     * the page (an app whose F2 means Save).
+     */
+    f2?: boolean;
+    /**
+     * Enter opens the focused cell's editor, and Enter (or Shift+Enter) in an
+     * open editor commits and STAYS on the cell instead of moving down. Enter
+     * never adds a row. On a cell that cannot be edited Enter stays
+     * `onRowActivate`. Default false: Enter is `onRowActivate`, and in an open
+     * editor commits and moves down.
+     */
+    enter?: boolean;
+    /**
+     * Typing a printable character on a focused cell opens its editor with that
+     * character. Default true. Same as `editOnKeyPress`; this one wins when both
+     * are given.
+     */
+    typing?: boolean;
+    /**
+     * Space on a focused lookup cell opens its editor (and, with
+     * `lookup.openOnEdit`, its list) instead of doing nothing; the space is not
+     * typed into the box. While an editor is open Space types a space as usual.
+     * Default false (P-11).
+     */
+    space?: boolean;
+    /**
+     * A double-click (a double-tap on a touch screen) opens the cell's editor.
+     * Default true.
+     */
+    doubleClick?: boolean;
+}
+/** The cell the key is about: the open editor's, else the focused one. */
+interface GridKeyCell {
+    rowKey: RowKey;
+    columnId: string;
+}
+/**
+ * What the app's `onKeyDown` hook is told about the grid (P-7.2).
+ */
+interface GridKeyContext {
+    /** A cell editor (or, in a row mode, a row) is open. */
+    editing: boolean;
+    /** The open editor's cell, else the focused cell; null when neither. */
+    cell: GridKeyCell | null;
+    /** `cell`'s row was added and is not saved yet. */
+    isNewRow: boolean;
+    /**
+     * Commit the open cell editor — the value being typed becomes the cell's
+     * (pending) value. True when nothing was open or the value was taken; false
+     * when a rule refused it (the editor stays open) or a whole row is open in a
+     * row mode (save that with `api.saveChanges()`).
+     */
+    commit(): boolean;
+    /** Close the open editor without keeping its value. */
+    cancel(): void;
+}
+/**
+ * `onKeyDown` on the grid: called for EVERY key pressed inside the grid, in the
+ * capture phase at the grid's root — before the grid's own handling and before
+ * an open editor sees the key. Return `'handled'` and the grid does nothing with
+ * that key (the browser's own default is not prevented; call
+ * `event.preventDefault()` for that).
+ */
+type GridKeyHook = (event: KeyboardEvent, ctx: GridKeyContext) => 'handled' | void;
+type AnyKeyEvent = KeyboardEvent | {
+    nativeEvent: KeyboardEvent;
+};
+/** Remember that the app's hook took this key; every grid handler then skips it. */
+declare function markKeyHandledByApp(event: AnyKeyEvent): void;
+/**
+ * A character typed with AltGr (Alt+Ctrl on Windows). It is typing, not an Alt
+ * shortcut: it opens the editor like any other character.
+ */
+declare function isAltGraphChar(event: AnyKeyEvent): boolean;
+/**
+ * True when the grid must leave this key alone: the page already claimed it
+ * (`defaultPrevented`, read from the NATIVE event — React's copy is fixed when
+ * the event is created, and a capture listener on `window` runs first), the
+ * app's `onKeyDown` answered 'handled', or it is an Alt combination other than
+ * AltGr typing.
+ */
+declare function gridIgnoresKey(event: AnyKeyEvent): boolean;
+/**
+ * The page or the app's hook already took this key: an editor leaves it
+ * alone (no commit, no move, no `stopPropagation`).
+ */
+declare function keyClaimed(event: AnyKeyEvent): boolean;
+/**
+ * True when an open editor uses this key, so it must not reach the grid's (or
+ * the page's) shortcuts. F1-F12 and Ctrl/Cmd/Alt combinations a text box has no
+ * use for are NOT the editor's: they go on to the page (P-7.2), which is how an
+ * app's F2 "Save" or Ctrl+P still works while a cell is being typed in. Keys the
+ * page or the app's hook already took are not the editor's either.
+ */
+declare function editorOwnsKey(event: AnyKeyEvent): boolean;
+/**
+ * Elements that are part of an open editor (P-4). The grid puts it on the box
+ * it draws a column's `renderEditor` in; an app may put it on an editor's own
+ * popup or dialog. Focus moving into one is not "leaving the cell" (the P-10
+ * row send, `ctx.commitOnBlur`). Inside the grid, keys whose target is in one
+ * are the EDITOR's: the grid's own key handling (navigation, F2, Escape,
+ * typing-to-edit) leaves them alone; the app's `onKeyDown` hook still sees
+ * them. A key whose target is OUTSIDE the grid's DOM — an app dialog portaled
+ * to `<body>`, marked or not — is never the grid's (`eventFromOwnDom`).
+ */
+declare const EDITOR_OWNED_SELECTOR = "[data-kanuni-editor]";
+/** The grid's own popups (lookup list, calendar, menus, dialogs). */
+declare const GRID_PORTAL_SELECTOR = ".kanuni-datagrid-portal, [data-kanuni-portal]";
+/**
+ * Did this event start inside `currentTarget`'s DOM? React routes events from a
+ * portal through the COMPONENT tree: a dialog an app's custom editor opens
+ * (portaled to `<body>`) still bubbles through the cell, the row, the
+ * scroller and the grid root (P-4.7). Every grid handler asks this first and
+ * ignores events from outside its own subtree. `ownPortals`: also count the
+ * grid's own popups (they are portaled too, and are the grid's).
+ */
+declare function eventFromOwnDom(event: {
+    currentTarget: EventTarget | null;
+    target: EventTarget | null;
+}, ownPortals?: boolean): boolean;
+/**
+ * Where focus may go and still be "in" the grid: the grid itself, one of its
+ * detached popups (date calendar, lookup list, dialogs) or an element the app
+ * marks as belonging to the open editor.
+ */
+declare function focusStaysWithGrid(gridSelector: string, next: Element | null): boolean;
 
 declare function useStateStoring<TRow = GridRowData>(controller: DataGridController<TRow>, config: StateStoringConfig | undefined): void;
 
@@ -129,6 +268,13 @@ interface PrintLayoutOptions {
         rows: number;
         maxRows: number;
     }) => void;
+    /**
+     * Print the column headers (band rows, header, filter row) at the top of
+     * EVERY page, not only the first (default true; Tekax P-15). A row is never
+     * split across two pages, whichever way this is set. The summary row prints
+     * once, after the last row.
+     */
+    repeatHeader?: boolean;
 }
 /** Default row cap. Report-sized results print; result sets do not. */
 declare const PRINT_MAX_ROWS = 5000;
@@ -148,7 +294,9 @@ interface PrintLayoutState {
  * — an ordinary `setState` would land after that and print the old, clipped
  * view. This is the case the API exists for.
  */
-declare function usePrintLayout<TRow = GridRowData>(controller: DataGridController<TRow>, options: boolean | PrintLayoutOptions | undefined): PrintLayoutState;
+declare function usePrintLayout<TRow = GridRowData>(controller: DataGridController<TRow>, options: boolean | PrintLayoutOptions | undefined, 
+/** The grid's root element, for the repeating header's printable copy. */
+rootRef?: RefObject<HTMLElement | null>): PrintLayoutState;
 
 /** MIME type carrying the payload. Custom so nothing else claims it. */
 declare const ROW_DRAG_MIME = "application/x-kanuni-row";
@@ -237,10 +385,70 @@ interface CellRenderContext<TRow = GridRowData> {
 interface HeaderRenderContext<TRow = GridRowData> {
     column: GridColumnDef<TRow>;
 }
+/**
+ * Where focus goes after a custom editor commits (P-4.2):
+ * `'down'` — the cell below (what Enter does in the built-in editor);
+ * `'next'` / `'previous'` — the next / previous editable cell (Tab /
+ * Shift+Tab, wrapping to the next row like the built-in editor);
+ * `'none'` — stay on the cell (today's `commit()`).
+ * An explicit `move` wins over `editing.editKeys.enter`.
+ */
+type EditorCommitMove = 'down' | 'next' | 'previous' | 'none';
+interface EditorCommitOptions {
+    /** Default `'none'`. */
+    move?: EditorCommitMove;
+}
+/** Writes a custom editor may make to ITS row (P-4.3). */
+interface EditorRowApi {
+    /**
+     * Write several fields of the editor's row in ONE step — a picker writing
+     * code, name and id together: one undo step, one validation pass, one save
+     * in `cell` mode, pending in `batch`. All or nothing: `editable: false`
+     * columns ARE written (that flag only stops the user typing), a row lock
+     * (`allowUpdating` refusing the row/column) or a failing rule writes none
+     * and answers false. The editor stays open; if its own column is among the
+     * fields it shows the new value. Same as `EditingApi.setRowValues(rowKey, …)`.
+     */
+    setRowValues(values: Readonly<Record<string, unknown>>): boolean;
+}
 /**
  * What a custom editor is handed. `commit`/`cancel` are the SAME handles the
  * built-in editor uses, so a replacement participates in Tab-walking, batch
  * changes and undo rather than living beside them.
+ *
+ * **The custom editor contract (P-4)** — what the grid does around a
+ * `renderEditor`:
+ *
+ * - The editor is drawn inside a box the grid owns, marked
+ *   `data-kanuni-editor` (`display: contents`, so it does not change the
+ *   layout). Keys whose target is inside it are the editor's: the grid does
+ *   not navigate, open, or type-to-edit on them. Two exceptions, both only
+ *   when the editor's own handler did not call `event.preventDefault()`:
+ *   **Escape** cancels the editor (`cancel()`), and **Tab / Shift+Tab** walk
+ *   the focusable elements INSIDE the box (text box → "…" button) and only
+ *   past the last (first) one commit and move to the next (previous) cell —
+ *   `commit({ move: 'next' })`. Enter is left to the editor: call
+ *   `commit({ move: 'down' })` from it for the built-in behaviour. The
+ *   editor's own shortcuts (F4, Alt+ArrowDown for its "…" button) are never
+ *   taken by the grid.
+ * - Events from OUTSIDE the grid's DOM — a dialog the editor opens in a
+ *   portal (Radix `Dialog`, a `<dialog>` under `<body>`) — never reach the
+ *   grid's handlers, although React routes them through the editor's
+ *   component tree: Enter, arrows, PageUp/PageDown, Space, Escape, Tab, F2,
+ *   Insert, Ctrl+Delete, Ctrl+Z, clicks and double-clicks in that dialog
+ *   change nothing in the grid or the editor session — also when the dialog
+ *   holds another KanuniLabs grid. Escape in the dialog closes the dialog (its
+ *   own business); a second Escape, back in the editor, cancels the editor.
+ * - Blur: the grid does not commit a custom editor on blur by itself. Put
+ *   `onBlur={ctx.commitOnBlur}` on the editor's root element to commit when
+ *   focus leaves it the way the built-in editors do. While a dialog of the
+ *   editor is open call `suspendBlurCommit(true)` (before it takes focus) and
+ *   `suspendBlurCommit(false)` when it closes: in between, neither
+ *   `commitOnBlur` nor `commitOn: 'row'`'s "focus left the grid" send runs.
+ * - Focus: after `commit()` / `cancel()` focus goes to the grid's scroller
+ *   (the keyboard keeps working); after `suspendBlurCommit(false)` focus that
+ *   fell to `<body>` (the dialog's opener is gone) goes back to the editor, or
+ *   to the scroller when the editor has closed.
  */
 interface EditorRenderContext<TRow = GridRowData> {
     /** Current (uncommitted) editor value. */
@@ -248,11 +456,45 @@ interface EditorRenderContext<TRow = GridRowData> {
     /** The row with pending edits applied — what a cascading list should read. */
     row: TRow;
     columnId: string;
+    /** Key of the edited row. */
+    rowKey: RowKey;
     /** Validation message for `value`, or null. */
     error: string | null;
+    /** True while `error` is set — for `aria-invalid`. */
+    invalid: boolean;
+    /**
+     * Id of an element holding `error` while there is one (screen-reader text
+     * the grid draws next to the editor) — for `aria-errormessage` /
+     * `aria-describedby`. Draw the message visibly yourself. Undefined when
+     * there is no error.
+     */
+    errorId: string | undefined;
+    /** The column's header text — for the editor's `aria-label`. */
+    ariaLabel: string;
     setValue: (value: unknown) => void;
-    commit: () => void;
+    /**
+     * Commit the value. False when a rule refused it (the editor stays open).
+     * Without options it stays on the cell, as always.
+     */
+    commit: (options?: EditorCommitOptions) => boolean;
     cancel: () => void;
+    /**
+     * While on, losing focus is not leaving the editor: `commitOnBlur` and the
+     * `commitOn: 'row'` send on "focus left the grid" wait. Turn it on before a
+     * dialog of the editor takes focus, off when the dialog closes. Ends by
+     * itself when the editor closes. No-op in the row form.
+     */
+    suspendBlurCommit: (on: boolean) => void;
+    /**
+     * A `focusout` handler for the editor's root element: commits (staying on
+     * the cell, focus left where the user put it) once focus has gone somewhere
+     * that is not part of the editor — not inside its box, not one of the
+     * grid's popups, not an element marked `data-kanuni-editor` — unless
+     * `suspendBlurCommit(true)` is on. Optional to use.
+     */
+    commitOnBlur: (event: FocusEvent) => void;
+    /** Writes to this row (`setRowValues`). */
+    api: EditorRowApi;
 }
 /**
  * What a column's own filter UI is handed (`renderFilter`). `value` is the
@@ -479,6 +721,61 @@ interface RowTemplateContext<TRow = GridRowData> {
     /** True when this is the focused row (`focusedRow` is on). */
     focused: boolean;
 }
+/** What `cardView.renderCard` draws one card from (P-9). */
+interface CardRenderContext<TRow = GridRowData> {
+    /** The row as the user sees it — pending (unsaved) values included. */
+    row: TRow;
+    node: DataRowNode<TRow>;
+    /**
+     * The default card's fields, in order (the first is the title): each
+     * column's header and the TEXT its closed cell shows — formatter, number
+     * format and lookup label included (a function list's label too; empty
+     * while that list is still loading).
+     */
+    fields: CardField[];
+    selected: boolean;
+    /** The row's save status (`rowStatus`), or null. The grid draws its marker either way. */
+    status: RowSaveStatus | null;
+}
+/**
+ * `cardView` options of the React grids (P-9): the shared ones
+ * ({@link CardViewOptions}: `breakpoint`, `columns`) plus the card as a tap
+ * target.
+ */
+interface DataGridCardViewOptions<TRow = GridRowData> extends CardViewOptions {
+    /**
+     * A card was pressed — tapped, or clicked with a mouse. A touch that moves
+     * more than 10 px (a scroll, a swipe) is not a press. Called after the grid
+     * has made the row the focused one (so `onFocusedRowChanged` has already
+     * fired for it) and before `edit: 'popup'` opens it. `event.preventDefault()`
+     * keeps the popup closed.
+     */
+    onCardPress?: (rowKey: RowKey, node: DataRowNode<TRow>, event: MouseEvent<HTMLElement>) => void;
+    /**
+     * Draw a card's content yourself. The grid keeps the card's box — its
+     * height, the press, selection, the `rowStatus` marker and `rowClassName`
+     * on the row element — and puts what this returns inside it. Cards are
+     * virtualised like rows, so every card is `height` pixels tall: give
+     * `height` when your card is not the default card's height.
+     */
+    renderCard?: (ctx: CardRenderContext<TRow>) => ReactNode;
+    /**
+     * Height of every card in pixels. Default: the default card's height for
+     * its field count (title 22 px, 20 px a line, 21 px of padding; at least 44
+     * — a touch target).
+     */
+    height?: number;
+    /**
+     * `'popup'`: pressing a card on an editing grid opens its row in the edit
+     * dialog (the `editing.mode: 'popup'` form), whatever `editing.mode` is.
+     * Save follows the mode: `batch` keeps the values pending for the batch
+     * Save, `cell` writes them into the row and sends the row once (also under
+     * `commitOn: 'row'` — closing the form is leaving the row), a row mode saves
+     * the row. Cancel puts the row back as it was when the dialog opened.
+     * The dialog stays open when the grid widens back into a table.
+     */
+    edit?: 'popup';
+}
 /** What a header menu is opened against. */
 interface HeaderMenuContext {
     columnId: string;
@@ -535,11 +832,28 @@ interface DataGridEditingOptions<TRow = GridRowData> {
     formHeight?: number;
     /** Typing a printable character on a focused cell opens its editor. Default true. */
     editOnKeyPress?: boolean;
+    /**
+     * Which gestures open an editor (P-7.1): `{ f2, enter, typing, doubleClick }`.
+     * Each one left out keeps today's behaviour (`f2: true, enter: false,
+     * typing: true, doubleClick: true`). See `EditKeys`.
+     */
+    editKeys?: EditKeys;
     /** Tab moves between cells inside the grid instead of leaving it. Default true. */
     focusCellOnTab?: boolean;
     /** Tab past the last editable cell of a row wraps to the next row. Default true. */
     focusCellOnCycle?: boolean;
 }
+/** What `rowClassName` is told about a row (P-8). */
+interface RowClassNameContext<TRow = GridRowData> {
+    /** The row as it shows: with an editing grid's pending (unsaved) values. */
+    row: TRow;
+    node: DataRowNode<TRow>;
+    rowKey: RowKey;
+    /** Its save state (`new`, `changed`, `removed`, `saving`, `saved`, `error`), or null. */
+    status: RowSaveStatus | null;
+    /** 0-based position in the displayed rows (pinned rows: in their own block). */
+    index: number;
+}
 interface DataGridProps<TRow = GridRowData> extends Omit<DataGridCoreConfig<TRow>, 'columns'> {
     /**
      * Optional: with an ARRAY data source and no columns, one column per field
@@ -681,6 +995,21 @@ interface DataGridProps<TRow = GridRowData> extends Omit<DataGridCoreConfig<TRow
     loadingOverlay?: boolean | number;
     /** Fired on Enter / double-click over the focused row. */
     onRowActivate?: (node: RowNode<TRow>) => void;
+    /**
+     * Called for EVERY key pressed inside the grid (P-7.2), in the capture phase
+     * at the grid's root: before the grid's own handling and before an open
+     * cell editor sees the key — so it also gets F2 while a cell is being typed
+     * in. `ctx` says whether an editor is open, which cell the key is about,
+     * whether that row is new, and can `commit()` the value being typed or
+     * `cancel()` it. Return `'handled'` and the grid does nothing with the key
+     * (the browser's own default is not prevented; call `event.preventDefault()`
+     * for that).
+     *
+     * The grid also leaves alone any key whose `defaultPrevented` is already
+     * true when it arrives (a page listener on `window` took it) and every Alt
+     * combination except AltGr typing. Default: not called.
+     */
+    onKeyDown?: GridKeyHook;
     /** Announcements for screen readers (sort/filter/selection). Defaults on. */
     announcements?: boolean;
     /** Drop area above the grid for grouping by a column. */
@@ -826,8 +1155,12 @@ interface DataGridProps<TRow = GridRowData> extends Omit<DataGridCoreConfig<TRow
      *
      * `columns` picks the fields and their order (the first is the title);
      * default: the visible columns.
+     *
+     * A card is a tap target (P-9): `onCardPress` hears it, `renderCard` draws
+     * the card's content yourself, and on an editing grid `edit: 'popup'` opens
+     * the row in the edit dialog. See {@link DataGridCardViewOptions}.
      */
-    cardView?: boolean | CardViewOptions;
+    cardView?: boolean | DataGridCardViewOptions<TRow>;
     /**
      * The grid switched between cards and the table (`cardView`), as its width
      * crossed the breakpoint. `true` while cards are shown.
@@ -978,6 +1311,19 @@ interface DataGridProps<TRow = GridRowData> extends Omit<DataGridCoreConfig<TRow
      * range selection, fill and paste are `EnterpriseDataGrid`.
      */
     editing?: DataGridEditingOptions<TRow>;
+    /**
+     * A class name for a whole data row (P-8), from the row itself: one rule
+     * for every column instead of a `cellClassName` per column ("a return line
+     * reads red"). Added to the row element beside the grid's own classes
+     * (`rowStatus`, selection, odd/even); return `undefined` or `''` for none.
+     *
+     * Asked for every rendered row on every render, so it follows edits (with
+     * pending values — `row` is what the row shows), `refreshCells()` and
+     * scrolling without being told. Keep it cheap. Data rows only: group,
+     * detail and message rows are not asked. Card view: the class lands on the
+     * card's row element too.
+     */
+    rowClassName?: (ctx: RowClassNameContext<TRow>) => string | undefined;
     /** Replace a cell's content (e.g. with an editor). Return undefined for default. */
     renderCellContent?: (ctx: CellSlotContext<TRow>) => ReactNode | undefined;
     /** Extra class names per cell (dirty marker, range highlight, invalid). */
@@ -1039,6 +1385,12 @@ interface DataGridProps<TRow = GridRowData> extends Omit<DataGridCoreConfig<TRow
      * position and height come from `controller.setEditFormRow`.
      */
     renderEditForm?: (rowKey: RowKey, row: TRow | undefined) => ReactNode;
+    /**
+     * Open a row in the edit dialog from a card (`cardView.edit: 'popup'`, P-9).
+     * Set by `EnterpriseDataGrid`, which owns its editing layer; the free grid
+     * uses its own `editing` when this is left empty. False when nothing opened.
+     */
+    openCardEditor?: (rowKey: RowKey) => boolean;
 }
 interface CellSlotContext<TRow = GridRowData> {
     node: RowNode<TRow>;
@@ -1168,6 +1520,41 @@ interface GridHeaderBandsProps<TRow = GridRowData> {
 declare function GridHeaderBandsImpl<TRow = GridRowData>({ layout, centerColumns, leadingSpacer, trailingSpacer, depth, checkboxColumn, detailColumn, statusColumn, rowNumberColumn, rowHeight, bandFold, }: GridHeaderBandsProps<TRow>): react.JSX.Element | null;
 declare const GridHeaderBands: typeof GridHeaderBandsImpl;
 
+/** What `label()` answers while the list is still being fetched. */
+declare const LOOKUP_PENDING: unique symbol;
+declare class LookupLabels<TRow = GridRowData> {
+    private readonly controller;
+    /** Lists per lookup definition, by row + `dependsOn` values. */
+    private readonly lists;
+    /** The label each cell last showed, by row + column: the no-flicker fallback. */
+    private readonly shown;
+    private repaintQueued;
+    /**
+     * The row WITH pending edits (batch mode keeps them out of the data), so a
+     * child list follows a parent the user changed but has not saved. Set by
+     * the grid on every render.
+     */
+    effectiveRow: ((rowKey: RowKey) => unknown) | null;
+    constructor(controller: DataGridController<TRow>);
+    private key;
+    private repaint;
+    /**
+     * The list for this row: an array when known, the promise while it is not.
+     * Called through the cache — the same row and `dependsOn` values never call
+     * `items` twice — except with `fresh` (a list without `dependsOn`, opened in
+     * the editor: it may read anything, so it is asked again, as before).
+     */
+    items(lookup: ColumnLookup<TRow>, row: TRow, rowKey: RowKey, fresh?: boolean): readonly LookupItem[] | Promise<readonly LookupItem[]>;
+    /**
+     * A FUNCTION lookup's label for a cell: the label, `LOOKUP_PENDING` while
+     * the list is in flight, or null when the column is not a function lookup
+     * or the value is not in the list (the caller falls through to the value).
+     */
+    label(def: GridColumnDef<TRow> | undefined, columnId: string, value: unknown, storedRow: TRow, rowKey: RowKey): string | null | typeof LOOKUP_PENDING;
+}
+/** The one label cache of this grid. */
+declare function lookupLabelsFor<TRow>(controller: DataGridController<TRow>): LookupLabels<TRow>;
+
 interface GridRowProps<TRow = GridRowData> {
     /** Used to build stable cell ids for aria-activedescendant. */
     gridId: string;
@@ -1254,6 +1641,10 @@ interface GridRowProps<TRow = GridRowData> {
     rowStatusText?: string;
     /** `rowStatus.tint`: wash the whole row, not only the marker. */
     rowStatusTint?: boolean;
+    /** `rowStatus.strike`: strike through a `'removed'` row's text (P-2). */
+    rowStatusStrike?: boolean;
+    /** The app's `rowClassName` for this row (P-8), already resolved: a primitive, so memo holds. */
+    rowClass?: string;
     /** Renders the leading checkbox cell. */
     checkboxColumn: boolean;
     /** Renders the leading row-number cell (gap analysis P3.5). */
@@ -1348,6 +1739,12 @@ interface GridRowProps<TRow = GridRowData> {
      * when it does not, they do not.
      */
     searchNeedle?: string;
+    /**
+     * The grid's cache of FUNCTION lookup lists (P-5.1): a closed cell shows the
+     * label, not the raw code. One stable object per grid; when a list arrives
+     * it calls `refreshCells()`, which moves `revision`.
+     */
+    lookupLabels?: LookupLabels<TRow>;
     /** Aggregate definitions rendered inside group headers (Enterprise). */
     summaryDefs?: readonly SummaryDef<TRow>[];
     /** Render a leading expander cell for master-detail (Enterprise). */
@@ -1381,7 +1778,7 @@ interface GridRowProps<TRow = GridRowData> {
     onCellPointerEnter?: (ctx: CellSlotContext<TRow>, event: React.MouseEvent) => void;
     onCellDoubleClick?: (ctx: CellSlotContext<TRow>) => void;
 }
-declare function GridRowImpl<TRow = GridRowData>({ gridId, node, index, layout, columnModel, centerColumns, centerIndices, stickyInsets, leadingSpacer, trailingSpacer, striped, selected, ariaSelectable, selectable, groupSelection, onToggleGroupSelect, groupDisplay, focusedColumnId, rowFocused, renderRow, checkboxColumn, statusColumn, rowNumberColumn, rowNumber, getNote, getSpan, resolveColSpans, findKind, headerRowCount, onRowClick, onRowMouseDown, onRowDoubleClick, onToggleSelect, onCellMouseDown, onRowContextMenu, searchNeedle, onToggleGroup, summaryDefs, detailColumn, detailExpanded, onToggleDetail, onToggleTreeRow, renderDetail, renderEditForm, renderRowMessage, renderCellContent, getCellClassName, onCellPointerDown, onCellPointerEnter, onCellDoubleClick, rowDrag, dropSide, rowStatus, rowStatusText, rowStatusTint, height, }: GridRowProps<TRow>): react.JSX.Element | null;
+declare function GridRowImpl<TRow = GridRowData>({ gridId, node, index, layout, columnModel, centerColumns, centerIndices, stickyInsets, leadingSpacer, trailingSpacer, striped, selected, ariaSelectable, selectable, groupSelection, onToggleGroupSelect, groupDisplay, focusedColumnId, rowFocused, renderRow, checkboxColumn, statusColumn, rowNumberColumn, rowNumber, getNote, getSpan, resolveColSpans, findKind, headerRowCount, onRowClick, onRowMouseDown, onRowDoubleClick, onToggleSelect, onCellMouseDown, onRowContextMenu, searchNeedle, lookupLabels, onToggleGroup, summaryDefs, detailColumn, detailExpanded, onToggleDetail, onToggleTreeRow, renderDetail, renderEditForm, renderRowMessage, renderCellContent, getCellClassName, onCellPointerDown, onCellPointerEnter, onCellDoubleClick, rowDrag, dropSide, rowStatus, rowStatusText, rowStatusTint, rowStatusStrike, rowClass, height, }: GridRowProps<TRow>): react.JSX.Element | null;
 declare const GridRow: typeof GridRowImpl;
 
 interface GridFilterRowProps<TRow = GridRowData> {
@@ -2010,8 +2407,10 @@ interface GridPinnedRowsProps<TRow = GridRowData> {
      * rows have to move down to make room. `DataGrid` does both from one count.
      */
     ariaRowBase: number;
+    /** The app's `rowClassName` (P-8), resolved by `DataGrid`; `userKey` is the data row's key for a user-pinned row. */
+    rowClassFor?: (node: DataRowNode<TRow>, index: number, userKey: RowKey | null) => string | undefined;
 }
-declare function GridPinnedRowsImpl<TRow = GridRowData>({ gridId, side, rows, rowKeys, onUserRowContextMenu, layout, columnModel, centerColumns, centerIndices, stickyInsets, leadingSpacer, trailingSpacer, checkboxColumn, detailColumn, statusColumn, rowNumberColumn, rowHeight, bandOffset, headerRowsBetween, ariaRowBase, }: GridPinnedRowsProps<TRow>): react.JSX.Element | null;
+declare function GridPinnedRowsImpl<TRow = GridRowData>({ gridId, side, rows, rowKeys, onUserRowContextMenu, layout, columnModel, centerColumns, centerIndices, stickyInsets, leadingSpacer, trailingSpacer, checkboxColumn, detailColumn, statusColumn, rowNumberColumn, rowHeight, bandOffset, headerRowsBetween, ariaRowBase, rowClassFor, }: GridPinnedRowsProps<TRow>): react.JSX.Element | null;
 declare const GridPinnedRows: typeof GridPinnedRowsImpl;
 
 type UseDataGridOptions<TRow = GridRowData> = DataGridCoreConfig<TRow>;
@@ -2111,6 +2510,14 @@ declare function GridTextProvider({ locale, messages, children }: GridTextProvid
 /** The resolved dictionary. Stable between language changes. */
 declare function useGridText(): GridDictionary;
 
+/**
+ * Text an editor opens with when the typed character is not a value yet
+ * (P-3.6): `-` or `,` on a number cell, a digit on a date cell. Keyed by the
+ * engine's edit SESSION object, so it belongs to that one opening; the session
+ * itself keeps the cell's value until the editor reports a complete one, which
+ * is what makes "-" followed by Enter change nothing.
+ */
+declare const editorSeedText: WeakMap<object, string>;
 interface UseGridEditingOptions<TRow = GridRowData> {
     controller: DataGridController<TRow> | null;
     mode?: EditMode;
@@ -2128,13 +2535,42 @@ interface UseGridEditingOptions<TRow = GridRowData> {
     /** Typing a printable key on a focused cell starts editing. Default true. */
     editOnKeyPress?: boolean;
     /**
-     * `Insert` opens a blank row ABOVE the focused one. Default false.
+     * `Insert` opens a blank row next to the focused one: `true` or `'above'`
+     * above it, `'below'` under it. Default false (off).
      *
      * Off by default because Insert is not a neutral key: some users have it
      * bound elsewhere, and a grid that starts creating records on a keypress
-     * nobody asked for is a surprise.
+     * nobody asked for is a surprise. When on, the key is the grid's whenever a
+     * cell has focus: it is `preventDefault()`ed even when no row can be added,
+     * so a page-level Insert shortcut does not fire for it (P-7.5).
+     */
+    insertKey?: boolean | 'above' | 'below';
+    /**
+     * Which gestures open an editor (P-7.1): `f2`, `enter`, `typing`,
+     * `doubleClick`. Each left out keeps today's behaviour.
+     */
+    editKeys?: EditKeys;
+    /**
+     * Tab on the last editable cell of the last row adds a blank row and moves
+     * to its first editable cell (P-7.8). Shift+Tab never adds one and stays on
+     * the first cell. Needs `allowAdding`. Default false.
+     */
+    appendOnTab?: boolean;
+    /**
+     * Ctrl+Delete (Cmd+Delete) deletes the focused row (P-7.5): `allowDeleting`,
+     * then the `confirmDelete` FUNCTION is asked; without a function nothing is
+     * deleted. On a row already marked removed (`batch`) it restores it. Not
+     * while an editor is open (the key is the text box's). Default false.
+     */
+    deleteKey?: boolean;
+    /** Ctrl+D / Ctrl+R fill down / right over the selection. Default true. */
+    fillKeys?: boolean;
+    /**
+     * Ctrl+V over several selected cells spreads a copied table over them.
+     * Default true. `false`: the paste goes to the focused cell only and the
+     * clipboard text is ONE value (tabs and line breaks do not split it).
      */
-    insertKey?: boolean;
+    rangePaste?: boolean;
     /**
      * Arrow-down on the LAST row appends a blank one. Default false.
      *
@@ -2186,6 +2622,26 @@ interface UseGridEditingOptions<TRow = GridRowData> {
      * columns read-only — those editors are Enterprise.
      */
     canEditColumn?: (columnId: string) => boolean;
+    /**
+     * Called ONCE when the grid's editing is ready, with the `EditingApi` (P-1)
+     * — the same object `controller.editing` returns while the grid is mounted.
+     * Not called again for a React StrictMode remount or a re-render; the object
+     * stays valid across both and turns into a harmless no-op after unmount.
+     */
+    onReady?: (api: EditingApi<TRow>) => void;
+    /**
+     * `cell` mode: save each committed cell at once (`'cell'`, default) or the
+     * whole row once the user leaves it (`'row'`, P-10) — to another row by any
+     * key or click, or out of the grid. A new row left empty is dropped, never
+     * sent. Ignored by the other modes.
+     */
+    commitOn?: CommitOn;
+    /**
+     * The grid shows a refused save's reason under the row (`rowStatus.messages`).
+     * With `commitOn: 'row'` a row refused on leave is then reported there only,
+     * not also in the "cannot save" dialog. Default false.
+     */
+    rowMessages?: boolean;
 }
 /**
  * What the footer strip shows for the current range.
@@ -2240,13 +2696,21 @@ interface UseGridEditingResult<TRow = GridRowData> {
     range: RangeApi;
     /** Bumped on every engine change; consumers read through it. */
     version: number;
+    /**
+     * The app-facing editing API (P-1): one object for the life of this hook,
+     * forwarding to the current engine — see `EditingApi`.
+     */
+    api: EditingApi<TRow>;
     beginEdit: (rowKey: RowKey, columnId: string) => void;
     /**
      * Open a whole ROW (row / form / popup modes). False when the mode does not
      * support it, or another row is already open — the caller decides what to
      * do with the first one rather than having it saved or discarded silently.
+     * `standalone`: in any mode — a card's popup (P-9; see the engine).
      */
-    beginRowEdit: (rowKey: RowKey) => boolean;
+    beginRowEdit: (rowKey: RowKey, options?: {
+        standalone?: boolean;
+    }) => boolean;
     /** Validate and persist the open row. Resolves false and stays open on failure. */
     saveRowEdit: () => Promise<boolean>;
     /** Discard the open row's edits. Other rows keep theirs. */
@@ -2259,7 +2723,44 @@ interface UseGridEditingResult<TRow = GridRowData> {
      * `beforeKey` puts it directly above that row instead of at the end — what
      * the Insert key needs.
      */
-    addRow: (values?: Record<string, unknown>, beforeKey?: RowKey) => RowKey | null;
+    addRow: (values?: Record<string, unknown>, beforeKey?: RowKey, options?: {
+        open?: boolean;
+        position?: NewRowPosition;
+    }) => RowKey | null;
+    /**
+     * The built-in cell editor's commit (Enter, blur, a picked item), shared by
+     * both renderers. `'down'` moves to the cell below afterwards — unless
+     * `editKeys.enter` is on, where Enter stays on the cell (P-7.1). `'blur'`:
+     * focus has already gone where the user put it, so it is not pulled back to
+     * the grid (P-10: a click on a field outside the grid must keep that field).
+     */
+    commitCellEditor: (move: 'down' | 'none' | 'blur') => void;
+    /**
+     * A custom editor's commit (`renderEditor`'s `ctx.commit`, P-4.2): `'none'`
+     * stays on the cell, `'down'` moves down (whatever `editKeys.enter` says —
+     * the editor asked), `'next'` / `'previous'` walk to the adjacent editable
+     * cell like Tab, `'blur'` leaves focus where it is. False when a rule
+     * refused the value.
+     */
+    commitCustomEditor: (move: 'down' | 'next' | 'previous' | 'none' | 'blur') => boolean;
+    /**
+     * `ctx.suspendBlurCommit` (P-4.1): while on, blur is not leaving the editor
+     * (`ctx.commitOnBlur`, the `commitOn: 'row'` send). Turning it off puts focus
+     * that fell to `<body>` back on the editor (`restoreTo`), else the scroller.
+     */
+    suspendBlurCommit: (on: boolean, restoreTo?: () => HTMLElement | null) => void;
+    /** True while a custom editor's dialog holds `suspendBlurCommit(true)`. */
+    blurCommitSuspended: () => boolean;
+    /** What the app's `onKeyDown` hook is told (P-7.2). */
+    keyContext: () => GridKeyContext;
+    /** `editKeys.doubleClick` — a double-click / double-tap opens an editor. */
+    doubleClickEdits: boolean;
+    /**
+     * Close the open cell editor without keeping its value and give focus back
+     * to the grid (the editors' Escape). Under `commitOn: 'row'` a new row left
+     * empty by it is dropped, never sent (P-10).
+     */
+    cancelCellEdit: () => void;
     /**
      * Commit and move to the next (1) or previous (-1) editable cell. By default
      * the destination is only FOCUSED; pass `open: true` to carry the editor
@@ -2355,6 +2856,12 @@ interface UseEditModesOptions<TRow = GridRowData> {
      * default batch mode saves from the command column) and passes that here.
      */
     batchBar?: boolean;
+    /**
+     * Cards are shown with `cardView.edit: 'popup'` (P-9): an open row session
+     * of a row mode — opened in the table before the grid narrowed — is drawn
+     * as the popup, the one editor a card view has.
+     */
+    cardPopup?: boolean;
 }
 interface EditModes<TRow = GridRowData> {
     /** A row mode (row / form / popup) is in force and drawn. */
@@ -2381,6 +2888,11 @@ interface EditModes<TRow = GridRowData> {
     editRowMenuItem: <TContext>(rowKey: RowKey) => GridMenuItem<TContext> | null;
     /** Open a row (double-click in a row mode). False when not a row mode. */
     openRow: (rowKey: RowKey) => boolean;
+    /**
+     * Open a row in the popup from a card (`cardView.edit: 'popup'`, P-9), in
+     * any mode. False when it cannot be opened (locked, removed, another row open).
+     */
+    openCardEditor: (rowKey: RowKey) => boolean;
 }
 /**
  * The columns a record's form offers, in the grid's own order.
@@ -2394,7 +2906,7 @@ interface EditModes<TRow = GridRowData> {
  * them out).
  */
 declare function editFormColumnIds<TRow>(controller: DataGridController<TRow> | null, isFormColumn?: (columnId: string) => boolean): string[];
-declare function useEditModes<TRow = GridRowData>({ controller, editing, mode, active, rootRef, rowHeight, formLabels, formHeight: formHeightOption, dark, rowLookups, customEditors, isFormColumn, batchBar, }: UseEditModesOptions<TRow>): EditModes<TRow>;
+declare function useEditModes<TRow = GridRowData>({ controller, editing, mode, active, rootRef, rowHeight, formLabels, formHeight: formHeightOption, dark, rowLookups, customEditors, isFormColumn, batchBar, cardPopup, }: UseEditModesOptions<TRow>): EditModes<TRow>;
 
 interface GridRowEditorProps<TRow = GridRowData> {
     controller: DataGridController<TRow>;
@@ -2414,6 +2926,122 @@ interface GridRowEditorProps<TRow = GridRowData> {
 }
 declare function GridRowEditor<TRow = GridRowData>({ controller, engine, columnId, message, saving, lookupOptions, onSave, onCancel, }: GridRowEditorProps<TRow>): react.JSX.Element;
 
+type ResolvedNumberFormat = ColumnNumberFormat & {
+    locale: string;
+};
+/**
+ * The column's `numberFormat` when its editor is the number TEXT box — not
+ * for a lookup, a custom editor or a formula column, which own their value.
+ */
+declare function numberTextFormat(def: {
+    numberFormat?: ColumnNumberFormat;
+    lookup?: unknown;
+    renderEditor?: unknown;
+    allowFormulas?: boolean;
+} | undefined): ResolvedNumberFormat | undefined;
+
+interface GridLookupEditorProps {
+    options: readonly LookupItem[];
+    value: unknown;
+    /** Prefix (default) or substring — for the label (the name of a `linked` list). */
+    matchMode?: LookupMatchMode;
+    /** How typed text matches a `linked` list's code (`value`). Default `'startsWith'`. */
+    codeMatchMode?: LookupMatchMode;
+    /**
+     * A code + name list (`lookup.linkedColumns`, P-5.2): each item shows its
+     * code (`value`) and name (`label`), typing matches either, and the box
+     * shows the code.
+     */
+    linked?: boolean;
+    /**
+     * How typed text and item text are folded before they are compared
+     * (`lookup.matchFold`, P-13). Default `'case'` — the editor's old behaviour.
+     */
+    matchFold?: LookupMatchFold;
+    /** Let text that matches nothing become the value. Default false. */
+    allowCustom?: boolean;
+    /**
+     * Open the list as soon as the editor mounts (`lookup.openOnEdit`, P-11).
+     * Only for an editor that takes focus (`autoFocus`) — in a row or form every
+     * field would open its list at once.
+     */
+    openOnEdit?: boolean;
+    /**
+     * The editor was opened by TYPING and `value` is that one character: the
+     * box starts with it as the typed text (list filtered by it, caret after
+     * it). Acts only together with `openOnEdit`.
+     */
+    seeded?: boolean;
+    /**
+     * Refuse typing that matches no item (`lookup.restrictInput`, P-12).
+     * Deleting is always free; ignored with `allowCustom`.
+     */
+    restrictInput?: boolean;
+    /**
+     * Complete typed text to the one item left / an exact label on leaving.
+     * Default true. False: the "pick from the list" rule (K-3, see the top).
+     */
+    autoCompleteSingle?: boolean;
+    /**
+     * Typed text that picks nothing (closed list): Enter keeps the editor open
+     * and announces it either way; Tab stays (`'keep-open'`, default) or drops
+     * the text and moves on (`'revert'`).
+     */
+    onNoMatch?: 'revert' | 'keep-open';
+    /**
+     * Picking an item writes it: answer true when written. Left out, a pick is
+     * `onChange(item.value)`. A code + name pick writes several columns in one
+     * step through this (P-5.2); false (a locked row) keeps the editor open.
+     */
+    onPick?: (item: LookupItem) => boolean;
+    invalid?: boolean;
+    /**
+     * Take focus on mount. True for a cell editor — it opened BECAUSE the user
+     * asked to edit that one cell. False in `row` mode, where every editable cell
+     * mounts an editor at once and each would grab focus in turn, landing the
+     * caret on whichever lookup happened to render last.
+     */
+    autoFocus?: boolean;
+    testId?: string;
+    /** Stamped as `data-column-id`, so callers can find one field of a row. */
+    columnId?: string;
+    ariaLabel?: string;
+    onChange: (value: unknown) => void;
+    /** Commit (Enter / picking an item), handed back to the engine. */
+    onCommit: () => void;
+    /**
+     * Whether picking an item counts as committing. True for a cell editor —
+     * the pick IS the edit. False in `row`/`form` mode, where picking fills one
+     * field of a record the user is still filling in and only Save ends it.
+     */
+    commitOnPick?: boolean;
+    onCancel: () => void;
+    /** Tab moves to the adjacent cell; the engine owns that. */
+    onTab?: (shiftKey: boolean) => void;
+    /**
+     * Focus left the box for somewhere that is not its list: commit (the cell
+     * editor's click-away, P-10). Left out (row mode, the form), a blur only
+     * settles the typed text, as before.
+     */
+    onBlurCommit?: () => void;
+}
+/**
+ * The same match, as items. Kept for callers and tests that want the simple
+ * shape; the component itself works in indices to avoid the copy.
+ */
+declare function matchOptions(options: readonly LookupItem[], query: string, mode: LookupMatchMode): readonly LookupItem[];
+/** The editor's settings that come straight from a column's `lookup`. */
+type LookupEditorSettings = Pick<GridLookupEditorProps, 'matchMode' | 'codeMatchMode' | 'linked' | 'allowCustom' | 'autoCompleteSingle' | 'onNoMatch' | 'matchFold' | 'openOnEdit' | 'restrictInput'>;
+/** `lookup` → the editor's props, one reading for the cell, row and form editors. */
+declare function lookupEditorSettings(lookup: ColumnLookup<never> | undefined): LookupEditorSettings;
+/**
+ * What one pick writes to the row (P-5.2 / P-5.3): the column's own value,
+ * `linkedColumns`' code / name / id, then `map`. Null when the column has
+ * neither — a plain pick, one cell, as before.
+ */
+declare function lookupPickValues(lookup: ColumnLookup<never> | undefined, columnId: string, item: LookupItem): Record<string, unknown> | null;
+declare function GridLookupEditor({ options, value, matchMode, codeMatchMode, matchFold, linked, allowCustom, openOnEdit, seeded, restrictInput, autoCompleteSingle, onNoMatch, onPick, invalid, autoFocus, testId, columnId, ariaLabel, onChange, onCommit, commitOnPick, onCancel, onTab, onBlurCommit, }: GridLookupEditorProps): react.JSX.Element;
+
 interface GridCellEditorProps {
     value: unknown;
     dataType: GridDataType | undefined;
@@ -2427,6 +3055,13 @@ interface GridCellEditorProps {
     allowCustom?: boolean;
     /** How typed text narrows the lookup list. Default `'startsWith'`. */
     matchMode?: LookupMatchMode;
+    /**
+     * The rest of the column's `lookup` as the combo box reads it (P-5 / P-6):
+     * code + name, K-3, `onNoMatch`. Wins over `allowCustom` / `matchMode`.
+     */
+    lookupSettings?: LookupEditorSettings;
+    /** A pick that writes more than this cell (code + name, `map`): true when written. */
+    onPick?: (item: LookupItem) => boolean;
     /** Accessible name for the editor, used by the lookup combo box. */
     ariaLabel?: string;
     /** Format for a `date` column — governs both the mask and the display. */
@@ -2439,13 +3074,31 @@ interface GridCellEditorProps {
      * make the second keystroke erase the first.
      */
     seeded?: boolean;
+    /**
+     * The editor was opened by typing a character that is not a value yet
+     * (P-3.6): `-` or `,` on a number cell, a digit on a date cell. The box
+     * starts with it, caret after it; `value` stays the cell's own until a
+     * complete value is typed.
+     */
+    seedText?: string;
+    /**
+     * The column's `numberFormat` (locale resolved): the editor is then a text
+     * box in that locale (P-3) whose value is the TEXT; the engine reads it.
+     */
+    numberFormat?: ResolvedNumberFormat;
+    /**
+     * The grid's number locale (`'tr-TR'`), for reading a number box opened by
+     * typing `-` or `,` on a column without `numberFormat`. Default `'en-US'`.
+     */
+    numberLocale?: string;
     onChange: (value: unknown) => void;
-    onCommit: (move: 'down' | 'none') => void;
+    /** `'blur'`: focus left the editor — commit, but do not take focus back. */
+    onCommit: (move: 'down' | 'none' | 'blur') => void;
     /** Tab / Shift+Tab: commit here and keep editing in the adjacent cell. */
     onTab: (direction: 1 | -1) => void;
     onCancel: () => void;
 }
-declare function GridCellEditor({ value, dataType, error, seeded, options, allowCustom, matchMode, ariaLabel, dateFormat, onChange, onCommit, onTab, onCancel, }: GridCellEditorProps): react.JSX.Element;
+declare function GridCellEditor({ value, dataType, error, seeded, seedText, options, allowCustom, matchMode, lookupSettings, onPick, ariaLabel, dateFormat, numberFormat, numberLocale, onChange, onCommit, onTab, onCancel, }: GridCellEditorProps): react.JSX.Element;
 
 interface GridDateEditorProps {
     value: unknown;
@@ -2470,47 +3123,19 @@ interface GridDateEditorProps {
     onCommit: () => void;
     onCancel: () => void;
     onTab?: (shiftKey: boolean) => void;
-}
-declare function GridDateEditor({ value, format, invalid, disabled, autoFocus, testId, columnId, ariaLabel, onChange, onCommit, onCancel, onTab, }: GridDateEditorProps): react.JSX.Element;
-
-interface GridLookupEditorProps {
-    options: readonly LookupItem[];
-    value: unknown;
-    /** Prefix (default) or substring. */
-    matchMode?: LookupMatchMode;
-    /** Let text that matches nothing become the value. Default false. */
-    allowCustom?: boolean;
-    invalid?: boolean;
     /**
-     * Take focus on mount. True for a cell editor — it opened BECAUSE the user
-     * asked to edit that one cell. False in `row` mode, where every editable cell
-     * mounts an editor at once and each would grab focus in turn, landing the
-     * caret on whichever lookup happened to render last.
+     * Focus left the box for somewhere that is not its calendar: commit (the
+     * cell editor's click-away, P-10). Left out (row mode, the form), a blur
+     * only settles the typed text, as before.
      */
-    autoFocus?: boolean;
-    testId?: string;
-    /** Stamped as `data-column-id`, so callers can find one field of a row. */
-    columnId?: string;
-    ariaLabel?: string;
-    onChange: (value: unknown) => void;
-    /** Commit (Enter / picking an item), handed back to the engine. */
-    onCommit: () => void;
+    onBlurCommit?: () => void;
     /**
-     * Whether picking an item counts as committing. True for a cell editor —
-     * the pick IS the edit. False in `row`/`form` mode, where picking fills one
-     * field of a record the user is still filling in and only Save ends it.
+     * Digits the box starts with — the editor was opened by typing one on the
+     * cell (P-3.6). The caret goes after them instead of selecting.
      */
-    commitOnPick?: boolean;
-    onCancel: () => void;
-    /** Tab moves to the adjacent cell; the engine owns that. */
-    onTab?: (shiftKey: boolean) => void;
+    seedDigits?: string;
 }
-/**
- * The same match, as items. Kept for callers and tests that want the simple
- * shape; the component itself works in indices to avoid the copy.
- */
-declare function matchOptions(options: readonly LookupItem[], query: string, mode: LookupMatchMode): readonly LookupItem[];
-declare function GridLookupEditor({ options, value, matchMode, allowCustom, invalid, autoFocus, testId, columnId, ariaLabel, onChange, onCommit, commitOnPick, onCancel, onTab, }: GridLookupEditorProps): react.JSX.Element;
+declare function GridDateEditor({ value, format, invalid, disabled, autoFocus, testId, columnId, ariaLabel, onChange, onCommit, onCancel, onTab, onBlurCommit, seedDigits, }: GridDateEditorProps): react.JSX.Element;
 
 interface GridDialogProps {
     open: boolean;
@@ -2527,4 +3152,4 @@ interface GridDialogProps {
 }
 declare function GridDialog({ open, title, message, cancelLabel, confirmLabel, danger, dark, onConfirm, onCancel, }: GridDialogProps): react.ReactPortal | null;
 
-export { type AlignedGridsApi, BAND_ROW_HEIGHT, type BatchSaveError, type CellMenuOptions, type CellRenderContext, type CellSlotContext, type CellTooltipOptions, DEFAULT_EDIT_FORM_LABELS, DEFAULT_HEADER_MENU_LABELS, DataGrid, type DataGridProps, type DistinctEntry, type EditFormField, type EditFormLabels, type EditModes, type EditorRenderContext, type ExportOutcome, type FilterRenderContext, GridCellEditor, type GridCellEditorProps, GridColumnChooser, type GridColumnChooserProps, GridContextMenu, type GridContextMenuProps, GridDateEditor, type GridDateEditorProps, GridDialog, type GridDialogProps, GridEditForm, type GridEditFormProps, GridFilterPanel, type GridFilterPanelProps, GridFilterRow, type GridFilterRowProps, GridFooterRow, type GridFooterRowProps, GridGroupPanel, type GridGroupPanelProps, GridHeader, GridHeaderBands, type GridHeaderBandsProps, GridHeaderFilterPopup, type GridHeaderFilterPopupProps, type GridHeaderProps, GridLoadingOverlay, type GridLoadingOverlayProps, GridLookupEditor, type GridLookupEditorProps, type GridMenuItem, GridNoteEditor, type GridNotesConfig, GridPager, type GridPagerProps, GridPinnedRows, type GridPinnedRowsProps, GridPopupPanel, type GridPopupPanelProps, GridPortal, type GridPortalProps, GridRow, GridRowEditor, type GridRowEditorProps, type GridRowProps, GridSummaryBar, type GridSummaryBarProps, GridSurfaceProvider, type GridSurfaceProviderProps, GridTextProvider, type GridTextProviderProps, GridToolbar, GridToolbarButton, type GridToolbarButtonProps, type GridToolbarProps, GridTooltip, type GridTooltipConfig, type GridTooltipProps, type HeaderMenuContext, type HeaderMenuDeps, type HeaderMenuLabels, type HeaderRenderContext, type NoteCellContext, PRINT_MAX_ROWS, type PendingDelete, type PrintLayoutOptions, type PrintLayoutState, ROW_DRAG_MIME, type RangeApi, type ReactColumnRuntime, type ReactGridColumnDef, type RowDragConfig, type RowDragHandlers, type RowDragPayload, type RowDropEvent, type RowLookupMap, type RowMenuContext, type RowReorderEvent, type RowTemplateContext, SHORTCUT_COPY, SHORTCUT_CUT, SHORTCUT_PASTE, type SelectionStats, ToolbarIcon, type TooltipState, type UseDataGridOptions, type UseDataGridResult, type UseEditModesOptions, type UseGridEditingOptions, type UseGridEditingResult, buildCellMenuItems, buildHeaderMenu, copyToClipboard, editFormColumnIds, editFormLabels, headerMenuLabels, matchOptions, measureBestFitWidth, reconcileFilterInputs, runGridExport, useAlignedGrids, useAnchoredPopup, useCellTooltip, useDataGrid, useEditModes, useGridChartBoxData, useGridChartData, useGridChartXYData, useGridEditing, useGridPortalTarget, useGridSurfaceClass, useGridText, usePrintLayout, useRowDrag, useStateStoring, writeClipboardText };
+export { type AlignedGridsApi, BAND_ROW_HEIGHT, type BatchSaveError, type CardRenderContext, type CellMenuOptions, type CellRenderContext, type CellSlotContext, type CellTooltipOptions, DEFAULT_EDIT_FORM_LABELS, DEFAULT_HEADER_MENU_LABELS, DataGrid, type DataGridCardViewOptions, type DataGridProps, type DistinctEntry, EDITOR_OWNED_SELECTOR, type EditFormField, type EditFormLabels, type EditKeys, type EditModes, type EditorCommitMove, type EditorCommitOptions, type EditorRenderContext, type EditorRowApi, type ExportOutcome, type FilterRenderContext, GRID_PORTAL_SELECTOR, GridCellEditor, type GridCellEditorProps, GridColumnChooser, type GridColumnChooserProps, GridContextMenu, type GridContextMenuProps, GridDateEditor, type GridDateEditorProps, GridDialog, type GridDialogProps, GridEditForm, type GridEditFormProps, GridFilterPanel, type GridFilterPanelProps, GridFilterRow, type GridFilterRowProps, GridFooterRow, type GridFooterRowProps, GridGroupPanel, type GridGroupPanelProps, GridHeader, GridHeaderBands, type GridHeaderBandsProps, GridHeaderFilterPopup, type GridHeaderFilterPopupProps, type GridHeaderProps, type GridKeyCell, type GridKeyContext, type GridKeyHook, GridLoadingOverlay, type GridLoadingOverlayProps, GridLookupEditor, type GridLookupEditorProps, type GridMenuItem, GridNoteEditor, type GridNotesConfig, GridPager, type GridPagerProps, GridPinnedRows, type GridPinnedRowsProps, GridPopupPanel, type GridPopupPanelProps, GridPortal, type GridPortalProps, GridRow, GridRowEditor, type GridRowEditorProps, type GridRowProps, GridSummaryBar, type GridSummaryBarProps, GridSurfaceProvider, type GridSurfaceProviderProps, GridTextProvider, type GridTextProviderProps, GridToolbar, GridToolbarButton, type GridToolbarButtonProps, type GridToolbarProps, GridTooltip, type GridTooltipConfig, type GridTooltipProps, type HeaderMenuContext, type HeaderMenuDeps, type HeaderMenuLabels, type HeaderRenderContext, LOOKUP_PENDING, type LookupEditorSettings, LookupLabels, type NoteCellContext, PRINT_MAX_ROWS, type PendingDelete, type PrintLayoutOptions, type PrintLayoutState, ROW_DRAG_MIME, type RangeApi, type ReactColumnRuntime, type ReactGridColumnDef, type ResolvedNumberFormat, type RowClassNameContext, type RowDragConfig, type RowDragHandlers, type RowDragPayload, type RowDropEvent, type RowLookupMap, type RowMenuContext, type RowReorderEvent, type RowTemplateContext, SHORTCUT_COPY, SHORTCUT_CUT, SHORTCUT_PASTE, type SelectionStats, ToolbarIcon, type TooltipState, type UseDataGridOptions, type UseDataGridResult, type UseEditModesOptions, type UseGridEditingOptions, type UseGridEditingResult, buildCellMenuItems, buildHeaderMenu, copyToClipboard, editFormColumnIds, editFormLabels, editorOwnsKey, editorSeedText, eventFromOwnDom, focusStaysWithGrid, gridIgnoresKey, headerMenuLabels, isAltGraphChar, keyClaimed, lookupEditorSettings, lookupLabelsFor, lookupPickValues, markKeyHandledByApp, matchOptions, measureBestFitWidth, numberTextFormat, reconcileFilterInputs, runGridExport, useAlignedGrids, useAnchoredPopup, useCellTooltip, useDataGrid, useEditModes, useGridChartBoxData, useGridChartData, useGridChartXYData, useGridEditing, useGridPortalTarget, useGridSurfaceClass, useGridText, usePrintLayout, useRowDrag, useStateStoring, writeClipboardText };