apex-grid 3.2.0 → 3.3.0

package/components/grid.d.ts

@@ -2,10 +2,15 @@ import { ContextProvider } from '@lit/context';
 import { nothing } from 'lit';
 import { DataOperationsController } from '../controllers/data-operation.js';
 import { GridDOMController } from '../controllers/dom.js';
+import type { RowPinPosition } from '../controllers/row-pin.js';
+import type { RowDropPosition } from '../controllers/row-reorder.js';
 import { StateController } from '../controllers/state.js';
+import { type GridLocaleKey, type GridLocaleText, type LocaleParams } from '../i18n/index.js';
 import { type CSVExportOptions, type ExportFormat, type ExportOptions } from '../internal/export.js';
 import { EventEmitterBase } from '../internal/mixins/event-emitter.js';
-import type { ColumnConfiguration, DataPipelineConfiguration, GridEditingConfiguration, GridExpansionConfiguration, GridSelectionConfiguration, GridSortConfiguration, GridTreeConfiguration, Keys, PaginationConfiguration, PaginationState, PinPosition } from '../internal/types.js';
+import { type GridSchema } from '../internal/state-schema.js';
+import { type GetStateOptions, type GridState, type SetStateOptions, type SetStateResult } from '../internal/state-snapshot.js';
+import type { ColumnConfiguration, ColumnGroupConfiguration, DataPipelineConfiguration, GridEditingConfiguration, GridExpansionConfiguration, GridRowPinningConfiguration, GridRowReorderingConfiguration, GridSelectionConfiguration, GridSortConfiguration, GridTreeConfiguration, Keys, PaginationConfiguration, PaginationState, PinPosition, ToolbarAction } from '../internal/types.js';
 import type { FilterExpression } from '../operations/filter/types.js';
 import type { SortExpression } from '../operations/sort/types.js';
 import ApexFilterRow from './filter-row.js';
@@ -150,6 +155,73 @@ export interface ApexCellValueChangedEvent<T extends object> {
      */
     value: unknown;
 }
+/**
+ * Event payload for the `cellValidationFailed` event.
+ */
+export interface ApexCellValidationFailedEvent<T extends object> {
+    /**
+     * The column key of the rejected cell.
+     */
+    key: Keys<T>;
+    /**
+     * The view-relative row index of the rejected cell.
+     */
+    rowIndex: number;
+    /**
+     * The data record being edited (a live reference to the row in
+     * {@link ApexGrid.data}).
+     */
+    data: T;
+    /**
+     * The candidate value that failed validation.
+     */
+    value: unknown;
+    /**
+     * The collected validator error messages.
+     */
+    errors: readonly string[];
+}
+/**
+ * Event payload for the cancellable `rowPinning` event and the follow-up
+ * `rowPinned` event.
+ */
+export interface ApexRowPinningEvent<T extends object> {
+    /** The row being pinned or unpinned (a live reference into {@link ApexGrid.data}). */
+    row: T;
+    /**
+     * The target band: `'top'` / `'bottom'` when pinning, or `null` when
+     * unpinning.
+     */
+    position: RowPinPosition | null;
+}
+/**
+ * Event payload for the cancellable `rowMoving` event and the follow-up
+ * `rowMoved` event.
+ */
+export interface ApexRowMovingEvent<T extends object> {
+    /** The moving row's view index before the move. */
+    from: number;
+    /** The target row's view index. */
+    to: number;
+    /** The row being moved (a live reference into {@link ApexGrid.data}). */
+    data: T;
+}
+/**
+ * Event payload for the `historyChanged` event.
+ */
+export interface ApexHistoryChangedEvent {
+    /** Whether there is at least one command to undo. */
+    canUndo: boolean;
+    /** Whether there is at least one command to redo. */
+    canRedo: boolean;
+}
+/**
+ * Event payload for the `stateChanged` event.
+ */
+export interface ApexStateChangedEvent {
+    /** The grid's restorable state after the change, as captured by `getState`. */
+    state: GridState;
+}
 /**
  * Event payload for the `rowEditStarted` event.
  */
@@ -450,6 +522,68 @@ export interface ApexGridEventMap<T extends object> {
      * @event
      */
     cellValueChanged: CustomEvent<ApexCellValueChangedEvent<T>>;
+    /**
+     * Emitted when a candidate cell value is rejected by one or more of the
+     * column's {@link BaseColumnConfiguration.validators}. The value is not
+     * written; in inline edit mode the editor stays open. Fires for single,
+     * row-mode, and bulk (paste / fill) edits.
+     *
+     * @event
+     */
+    cellValidationFailed: CustomEvent<ApexCellValidationFailedEvent<T>>;
+    /**
+     * Emitted after the undo / redo stacks change (a recorded edit, an undo, a
+     * redo, or a clear). Carries the current `canUndo` / `canRedo` so a toolbar
+     * can enable or disable its buttons.
+     *
+     * @event
+     */
+    historyChanged: CustomEvent<ApexHistoryChangedEvent>;
+    /**
+     * Emitted (debounced, after the render pipeline settles) whenever the grid's
+     * restorable state changes, carrying the new {@link ApexGrid.getState}
+     * snapshot. The single signal for persistence (save the snapshot) or for
+     * re-prompting an AI layer. The payload is only computed while at least one
+     * `stateChanged` listener is attached, so it is zero-cost otherwise.
+     *
+     * @remarks
+     * Fires for programmatic changes (including `setState`) as well as user
+     * interaction. To avoid a save loop, compare the snapshot to your last-saved
+     * one before persisting (identical snapshots never fire a second time).
+     *
+     * @event
+     */
+    stateChanged: CustomEvent<ApexStateChangedEvent>;
+    /**
+     * Emitted before a row is pinned, moved between bands, or unpinned.
+     *
+     * @remarks
+     * Cancellable — `preventDefault()` aborts the change.
+     *
+     * @event
+     */
+    rowPinning: CustomEvent<ApexRowPinningEvent<T>>;
+    /**
+     * Emitted after a row's pin state has changed.
+     *
+     * @event
+     */
+    rowPinned: CustomEvent<ApexRowPinningEvent<T>>;
+    /**
+     * Emitted before a row is moved via drag, keyboard, or {@link ApexGrid.moveRow}.
+     *
+     * @remarks
+     * Cancellable — `preventDefault()` aborts the move.
+     *
+     * @event
+     */
+    rowMoving: CustomEvent<ApexRowMovingEvent<T>>;
+    /**
+     * Emitted after a row has been moved.
+     *
+     * @event
+     */
+    rowMoved: CustomEvent<ApexRowMovingEvent<T>>;
     /**
      * Emitted when a row enters edit mode (row edit mode only).
      *
@@ -515,81 +649,8 @@ export interface ApexGridEventMap<T extends object> {
      */
     rowSelected: CustomEvent<ApexRowSelectedEvent<T>>;
 }
-/**
- * Apex grid is a web component for displaying data in a tabular format quick and easy.
- *
- * Out of the box it provides row virtualization, sort and filter operations (client and server side),
- * the ability to template cells and headers and column hiding.
- *
- * @remarks
- * A working, styled grid requires three things:
- *  1. Register the element: `import 'apex-grid/define'` (or `ApexGrid.register()`).
- *  2. Give the host element a bounded height, e.g. `apex-grid { height: 480px }` —
- *     the virtualizer collapses without one.
- *  3. Do NOT set `display` on the host — the component declares `:host { display: grid }`
- *     internally and any override breaks the track layout.
- *
- * The grid is styled out of the box through `--ag-*` CSS custom properties —
- * there is no theme to import and no `configureTheme()` call. Override `--ag-*`
- * tokens on the host (or any ancestor) to rebrand; when `igniteui-webcomponents`
- * is present, the brand tokens auto-tint from its palette. For dark mode, set
- * the `theme="dark"` attribute on the host for the built-in slate dark palette
- * (further `--ag-*` overrides still compose on top). Add `tinted` (e.g.
- * `theme="tinted"` or `theme="dark tinted"`) to mix the brand into the chrome
- * so the grid wears its brand even at rest. See the README "Getting Started"
- * and "Theming" sections for the full example and token list.
- *
- * @element apex-grid
- *
- * @attr {string} theme - Space-separated theme flags. `dark` opts into the built-in dark palette; `tinted` mixes `--ag-brand` into the chrome surfaces. Combine as `theme="dark tinted"`.
- *
- * @fires sorting - Emitted when sorting is initiated through the UI.
- * @fires sorted - Emitted when a sort operation initiated through the UI has completed.
- * @fires filtering - Emitted when filtering is initiated through the UI.
- * @fires filtered - Emitted when a filter operation initiated through the UI has completed.
- * @fires pageChanging - Cancellable. Emitted before page/page-size changes are applied.
- * @fires pageChanged - Emitted after a page/page-size change has been applied.
- * @fires quickFilterChanging - Cancellable. Emitted before a quick-filter value is applied.
- * @fires quickFilterChanged - Emitted after a quick-filter change has been applied.
- * @fires columnPinning - Cancellable. Emitted before a column's pin position changes.
- * @fires columnPinned - Emitted after a column's pin position has changed.
- * @fires columnMoving - Cancellable. Emitted before a column is moved.
- * @fires columnMoved - Emitted after a column has been moved.
- * @fires cellValueChanging - Cancellable. Emitted before a cell value is committed.
- * @fires cellValueChanged - Emitted after a cell value has been committed.
- * @fires rowEditStarted - Emitted when a row enters edit mode (row mode only).
- * @fires rowEditEnded - Emitted when a row leaves edit mode (row mode only).
- * @fires rowSelecting - Cancellable. Emitted before a selection-set change is applied.
- * @fires rowSelected - Emitted after a selection-set change has been applied.
- * @fires rowExpanding - Cancellable. Emitted before the row-expansion set changes (master-detail).
- * @fires rowExpanded - Emitted after a row-expansion change has been applied.
- * @fires treeRowExpanding - Cancellable. Emitted before a tree-row expansion change (tree mode).
- * @fires treeRowExpanded - Emitted after a tree-row expansion change has been applied.
- *
- * @csspart live-region - Visually-hidden ARIA live region used for screen-reader announcements.
- *
- * @cssprop [--ag-brand] - Brand color for selection, focus rings, and accents. Auto-tints from `--ig-primary-500` when igniteui is present.
- * @cssprop [--ag-brand-strong] - Brand color for hover / pressed states.
- * @cssprop [--ag-grid-shadow] - Grid edge/shadow override. Default is a flat 1px hairline edge; set to `var(--ag-shadow-card)` for the elevated card look, or `none` to remove it.
- * @cssprop [--ag-grid-bg] - Host card background. Defaults to a subtle light gradient; override with a flat color (or use `theme="dark"`) for dark themes.
- * @cssprop [--ag-surface] - Grid card background (must be opaque).
- * @cssprop [--ag-surface-alt] - Alternating row tint.
- * @cssprop [--ag-surface-elevated] - Header background.
- * @cssprop [--ag-hairline] - Header / structural gridline color.
- * @cssprop [--ag-border] - Row separator color.
- * @cssprop [--ag-text] - Primary text color.
- * @cssprop [--ag-text-body] - Row text color.
- * @cssprop [--ag-text-muted] - Muted text (roles, labels).
- * @cssprop [--ag-row-hover] - Row hover wash.
- * @cssprop [--ag-row-h] - Row height.
- * @cssprop [--ag-header-h] - Header height.
- * @cssprop [--ag-radius] - Outer card corner radius.
- * @cssprop [--ag-font] - Grid font family.
- * @cssprop [--ag-fs-cell] - Cell font size.
- *
- * @see {@link https://github.com/apexcharts/apex-grid/blob/main/packages/core/src/styles/_tokens.scss | _tokens.scss} for the complete `--ag-*` token list.
- */
 export declare class ApexGrid<T extends object> extends EventEmitterBase<ApexGridEventMap<T>> {
+    #private;
     static get tagName(): string;
     static styles: import("lit").CSSResult;
     /**
@@ -628,6 +689,17 @@ export declare class ApexGrid<T extends object> extends EventEmitterBase<ApexGri
     columns: Array<ColumnConfiguration<T>>;
     /** The data source for the grid. */
     data: Array<T>;
+    /**
+     * Optional stable row-identity resolver.
+     *
+     * @remarks
+     * When provided, {@link ApexGrid.getState} captures selection / expansion /
+     * tree rows by the returned id, so they survive a wholesale {@link ApexGrid.data}
+     * reload. Without it those rows are captured by positional index into
+     * {@link ApexGrid.data}, which round-trips within a session but not across a
+     * data swap. The id must be unique per row and stable across reloads.
+     */
+    rowId?: (row: T) => string | number;
     /**
      * Whether the grid will try to "resolve" its column configuration based on the passed
      * data source.
@@ -712,6 +784,39 @@ export declare class ApexGrid<T extends object> extends EventEmitterBase<ApexGri
      * @attr show-export
      */
     showExport: boolean;
+    /**
+     * Localization overrides for the grid's built-in UI text (pagination, filter
+     * operators and controls, row/selection labels, the toolbar, and so on).
+     *
+     * @remarks
+     * A (possibly partial) map of locale keys to translated strings. Any key you
+     * omit falls back to the built-in English default, so partial maps are valid.
+     * A ready-made Spanish dictionary ships as `esLocale`; community translations
+     * are just plain objects of the same shape.
+     *
+     * @example
+     * ```ts
+     * import { esLocale } from '@apexcharts/grid';
+     *
+     * // Whole-UI translation:
+     * grid.localeText = esLocale;
+     *
+     * // Or override a handful of strings:
+     * grid.localeText = { 'toolbar.searchPlaceholder': 'Buscar productos…' };
+     * ```
+     */
+    localeText?: GridLocaleText;
+    /**
+     * Resolves a built-in locale key to its display string, applying any
+     * {@link ApexGrid.localeText} override over the English default and
+     * interpolating `{placeholder}` tokens from `params`.
+     *
+     * @remarks
+     * Used internally by the grid's components. `fallback` is returned when the
+     * key is not part of the built-in set (for example a custom filter operand's
+     * own label).
+     */
+    localize(key: GridLocaleKey, params?: LocaleParams, fallback?: string): string;
     /**
      * Enables drag-and-drop column reordering on the column headers.
      *
@@ -724,6 +829,26 @@ export declare class ApexGrid<T extends object> extends EventEmitterBase<ApexGri
      * @attr column-reordering
      */
     columnReordering: boolean;
+    /**
+     * Shows a persistent vertical divider on the trailing edge of every column
+     * header, rather than only the frozen-column pin edges.
+     *
+     * @remarks
+     * On by default. On columns that opt into resizing (via
+     * {@link BaseColumnConfiguration.resizable}) the divider doubles as the
+     * resize handle: it takes the `col-resize` cursor and can be dragged to
+     * resize, so the always-visible line is also the grab target. On
+     * non-resizable columns it is purely decorative.
+     *
+     * Because the default is `true`, hide the dividers by setting the property to
+     * `false` (`grid.columnSeparator = false`); the reflected `column-separator`
+     * attribute is then removed. The line's color and vertical inset are themeable
+     * through the `--ag-header-separator` / `--header-separator-color` custom
+     * properties and `--apex-header-separator-inset`.
+     *
+     * @attr column-separator
+     */
+    columnSeparator: boolean;
     /**
      * Inline editing configuration for the grid.
      *
@@ -809,6 +934,76 @@ export declare class ApexGrid<T extends object> extends EventEmitterBase<ApexGri
      * ```
      */
     expansion?: GridExpansionConfiguration<T>;
+    /**
+     * Row-pinning configuration.
+     *
+     * @remarks
+     * Disabled by default. Set `enabled: true` to allow pinning rows to a sticky
+     * top / bottom band via {@link ApexGrid.pinRow}.
+     *
+     * @example
+     * ```ts
+     * grid.rowPinning = { enabled: true };
+     * grid.pinRow(grid.data[0], 'top');
+     * ```
+     */
+    rowPinning?: GridRowPinningConfiguration;
+    /**
+     * Row-reordering configuration.
+     *
+     * @remarks
+     * Disabled by default. Set `enabled: true` to allow drag / keyboard reorder
+     * and {@link ApexGrid.moveRow}. A manual order is mutually exclusive with
+     * column sorting (applying a sort clears it). Set `applyToData: true` to also
+     * splice {@link ApexGrid.data} in place.
+     *
+     * @example
+     * ```ts
+     * grid.rowReordering = { enabled: true };
+     * ```
+     */
+    rowReordering?: GridRowReorderingConfiguration;
+    /**
+     * Transient spreadsheet coordinate hints: when `true`, a leading row-number
+     * gutter (1, 2, 3, ...) and A / B / C column letters are revealed so cell
+     * references are discoverable. Enterprise toggles this while a formula cell is
+     * being edited; it can also be set directly for a persistent spreadsheet look.
+     * Reflected so styling / tests can observe it on the host.
+     */
+    coordinateHints: boolean;
+    /**
+     * Whether column headers show the column-menu (kebab) button. On by default,
+     * and the button is always visible (not hover-only). Set to `false` to hide it
+     * entirely; a feature module's menu (e.g. the enterprise context menu) stays
+     * reachable by right-click. This is a JS property (no attribute) so it can
+     * stay `true` by default.
+     */
+    columnMenu: boolean;
+    /**
+     * Column groups rendered as spanning headers above the column header row.
+     *
+     * @remarks
+     * A column joins a group via its {@link BaseColumnConfiguration.group} id.
+     * Members must be contiguous within one pin region. `columns` stays flat — all
+     * width / pin / resize / reorder machinery is unchanged; grouping is a
+     * presentational header layer. v1 ships static spanning headers (no collapse).
+     *
+     * @example
+     * ```ts
+     * grid.columnGroups = [{ id: 'name', headerText: 'Name' }];
+     * grid.columns = [{ key: 'first', group: 'name' }, { key: 'last', group: 'name' }];
+     * ```
+     */
+    columnGroups?: ColumnGroupConfiguration[];
+    /**
+     * Whether a group header row should render: at least one configured group has
+     * a visible member column.
+     */
+    get hasColumnGroups(): boolean;
+    /**
+     * Number of group header rows above the column header (0 or 1 in v1).
+     */
+    get columnGroupDepth(): number;
     /**
      * The currently expanded rows, in insertion order.
      *
@@ -851,8 +1046,8 @@ export declare class ApexGrid<T extends object> extends EventEmitterBase<ApexGri
      *
      * @remarks
      * Tree mode keeps {@link ApexGrid.data} flat; the grid derives the
-     * hierarchy from a user-supplied `getDataPath(row)` callback (AG Grid's
-     * "tree data" pattern). When enabled, the first visible data column (or
+     * hierarchy from a user-supplied `getDataPath(row)` callback (the
+     * flat-array "tree data" pattern). When enabled, the first visible data column (or
      * the column referenced by `groupColumnKey`) renders a chevron toggle
      * and depth-based indentation.
      *
@@ -962,6 +1157,8 @@ export declare class ApexGrid<T extends object> extends EventEmitterBase<ApexGri
     protected paginationChanged(): void;
     protected quickFilterChanged(): void;
     protected updated(): void;
+    addEventListener<K extends keyof M, M extends ApexGridEventMap<T> & HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: M[K]) => unknown, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof M, M extends ApexGridEventMap<T> & HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: M[K]) => unknown, options?: boolean | EventListenerOptions): void;
     protected firstUpdated(): void;
     /**
      * Performs a filter operation in the grid based on the passed expression(s).
@@ -971,6 +1168,59 @@ export declare class ApexGrid<T extends object> extends EventEmitterBase<ApexGri
      * Performs a sort operation in the grid based on the passed expression(s).
      */
     sort(expressions: SortExpression<T> | SortExpression<T>[]): void;
+    /**
+     * Returns a serializable, JSON-safe snapshot of the grid's restorable state:
+     * column layout, sort, filter, quick-filter, pagination, selection, expansion,
+     * tree expansion, and any feature-module state. Functions and templates are
+     * omitted (see {@link GridState}).
+     *
+     * @remarks
+     * Pair with {@link ApexGrid.setState} to persist/restore views, drive an AI
+     * assistant, or implement save/restore. Set {@link ApexGrid.rowId} for
+     * selection/expansion to survive a wholesale data reload.
+     *
+     * @example
+     * ```ts
+     * const snapshot = grid.getState();
+     * localStorage.setItem('grid', JSON.stringify(snapshot));
+     * // later …
+     * grid.setState(JSON.parse(localStorage.getItem('grid')!));
+     * ```
+     */
+    getState(options?: GetStateOptions<T>): GridState;
+    /**
+     * A machine-readable description of the grid: its columns and data types, the
+     * operations available per column (sort directions, filter operands), the
+     * grid-level capabilities, and the current {@link ApexGrid.getState} snapshot.
+     *
+     * @remarks
+     * This is the contract an AI layer hands to an LLM (to constrain its output)
+     * and validates a returned patch against before {@link ApexGrid.setState}, but
+     * it is AI-agnostic: it equally drives a view-editor UI or documentation. It is
+     * a descriptor, not a JSON-Schema document. The enterprise grid extends it with
+     * grouping / pivot / aggregation availability.
+     */
+    getSchema(): GridSchema;
+    /**
+     * Applies a (partial) state snapshot produced by {@link ApexGrid.getState}.
+     *
+     * @remarks
+     * Only the slices present on `state` are applied — omit a slice to leave it
+     * untouched (e.g. pass `{ sort }` to change only sorting). A present-but-empty
+     * `sort`/`filter` array clears that operation. Slices are applied in dependency
+     * order (columns → sort → filter → quick-filter → module structure → row order
+     * → tree → expansion → row pinning → selection → pagination) so row-referencing
+     * state resolves against the transformed view. `rowOrder` is mutually exclusive
+     * with an active `sort`: a snapshot carrying both keeps the sort and drops
+     * `rowOrder`.
+     *
+     * **Defensive by design.** `setState` is written into by persisted blobs and
+     * LLM output, so it never throws on malformed input (unless
+     * {@link SetStateOptions.strict}): unknown columns / operands, out-of-range
+     * pages, unresolvable rows, and wrong-typed slices are dropped, clamped, or
+     * skipped, each recorded in the returned {@link SetStateResult}.
+     */
+    setState(state: Partial<GridState>, options?: SetStateOptions<T>): SetStateResult;
     /**
      * Resets the current sort state of the control.
      */
@@ -1119,6 +1369,72 @@ export declare class ApexGrid<T extends object> extends EventEmitterBase<ApexGri
      * Discards the current edit without writing back to {@link ApexGrid.data}.
      */
     cancelEdit(): void;
+    /**
+     * Whether there is a recorded edit to undo.
+     *
+     * @remarks
+     * Always `false` unless `editing.history.enabled` is set.
+     */
+    get canUndo(): boolean;
+    /**
+     * Whether there is a previously-undone edit to redo.
+     */
+    get canRedo(): boolean;
+    /**
+     * Reverts the most recent cell-data edit (single, row-mode, or bulk paste /
+     * fill commits each as one step). No-op when there is nothing to undo or
+     * history is disabled.
+     */
+    undo(): void;
+    /**
+     * Re-applies the most recently undone edit. No-op when there is nothing to
+     * redo or history is disabled.
+     */
+    redo(): void;
+    /**
+     * Clears the undo / redo stacks.
+     */
+    clearHistory(): void;
+    /**
+     * Pins `row` to a sticky top or bottom band, lifting it out of the scrolling
+     * body. Moves it between bands when already pinned elsewhere.
+     *
+     * @remarks
+     * Requires `rowPinning.enabled`. Goes through the cancellable `rowPinning`
+     * event and emits `rowPinned` on success. Identity is by reference, so pass
+     * the same object held in {@link ApexGrid.data}.
+     *
+     * @returns `true` when applied, `false` when disabled or cancelled.
+     */
+    pinRow(row: T, position?: RowPinPosition): boolean;
+    /**
+     * Unpins `row` from whichever band holds it, returning it to the scrolling
+     * body.
+     *
+     * @returns `true` when applied (or already unpinned), `false` when cancelled.
+     */
+    unpinRow(row: T): boolean;
+    /**
+     * The currently pinned rows per band, in the order they were pinned.
+     */
+    get pinnedRows(): {
+        top: T[];
+        bottom: T[];
+    };
+    /**
+     * Moves the row at view index `from` to land `position` (`'before'` /
+     * `'after'`) the row at view index `to`. Indices are into
+     * {@link ApexGrid.pageItems}.
+     *
+     * @remarks
+     * Requires `rowReordering.enabled`. Establishes a manual order (mutually
+     * exclusive with column sorting), goes through the cancellable `rowMoving`
+     * event, emits `rowMoved`, and animates the affected rows.
+     *
+     * @returns `true` when applied, `false` when disabled, out of range, or
+     * cancelled.
+     */
+    moveRow(from: number, to: number, position?: RowDropPosition): boolean;
     /**
      * Exports the current grid contents as a CSV string and (in a browser
      * context) triggers a download.
@@ -1150,6 +1466,17 @@ export declare class ApexGrid<T extends object> extends EventEmitterBase<ApexGri
      * chosen id to {@link ApexGrid.exportAs}.
      */
     get exportFormats(): ReadonlyArray<ExportFormat>;
+    /**
+     * Custom action buttons rendered in the toolbar's trailing actions area, in
+     * order.
+     *
+     * @remarks
+     * The community grid contributes none. This is the seam derived grids use to
+     * add toolbar buttons (mirroring {@link ApexGrid.exportFormats}):
+     * `@apexcharts/grid-enterprise` overrides it to add a "Create chart" action.
+     * The toolbar renders one button per entry and calls its `run()` on click.
+     */
+    get toolbarActions(): ReadonlyArray<ToolbarAction>;
     /**
      * Exports the grid in the given format (one of {@link ApexGrid.exportFormats}).
      * Called by the toolbar's export menu. The community grid handles `'csv'`;
@@ -1187,8 +1514,13 @@ export declare class ApexGrid<T extends object> extends EventEmitterBase<ApexGri
      * builds on.
      */
     protected bodyPointerHandler(event: PointerEvent): void;
+    protected renderGroupHeaderRow(): import("lit-html").TemplateResult<1> | typeof nothing;
     protected renderHeaderRow(): import("lit-html").TemplateResult<1>;
     protected renderBody(): import("lit-html").TemplateResult<1>;
+    /** Number of chrome rows above the body (group header + header + optional filter). */
+    protected get headerRowCount(): number;
+    protected renderPinnedTop(): import("lit-html").TemplateResult<1> | typeof nothing;
+    protected renderPinnedBottom(): import("lit-html").TemplateResult<1> | typeof nothing;
     protected renderFilterRow(): import("lit-html").TemplateResult<1> | typeof nothing;
     protected renderToolbar(): import("lit-html").TemplateResult<1> | typeof nothing;
     protected renderPaginator(): import("lit-html").TemplateResult<1> | typeof nothing;
@@ -1199,6 +1531,13 @@ export declare class ApexGrid<T extends object> extends EventEmitterBase<ApexGri
      * don't have to coordinate consumer DOM placement.
      */
     protected renderLiveRegion(): import("lit-html").TemplateResult<1>;
+    /**
+     * Floating "ghost" of the row being pointer-dragged for reorder. Rendered at
+     * the top of the shadow tree (outside the virtualizer) so its `position: fixed`
+     * tracks the viewport, and painted from the cell snapshot captured at grab
+     * time so it mirrors the row's visible content and column widths.
+     */
+    protected renderRowDragGhost(): import("lit-html").TemplateResult<1> | typeof nothing;
     protected render(): import("lit-html").TemplateResult<1>;
     /**
      * Sets the live region's announcement text. Screen readers configured to