@globalpayments/vega 2.56.0 → 2.57.0

package/dist/types/components/vega-table/slimmers/controllers/dto/column-render-input-model.d.ts

@@ -0,0 +1,138 @@
+import { Nullable } from '../../../../../types/general';
+import { VegaTablePinnedType } from '../../../interface';
+import { ColumnStructureModel } from './column-structure-model';
+declare type IteratorMode = 'dfs' | 'bfs';
+/**
+ * ColumnRenderInputModel
+ *
+ * Render-time representation of a column or group node used by header/body renderers.
+ * Built from a ColumnStructureModel tree, it carries computed layout metadata required
+ * for rendering and pinned/sticky calculations (colSpan, rowSpan, pinned boundaries, etc).
+ *
+ * Instances form a forest (root-level nodes in an array) that mirrors the structure model
+ * but contains additional render-specific properties and parent/child links for renderers.
+ */
+export declare class ColumnRenderInputModel {
+  readonly key: string;
+  readonly label: string;
+  readonly pinned: VegaTablePinnedType;
+  readonly colSpan: Nullable<number>;
+  readonly rowSpan: Nullable<number>;
+  readonly isViewStart: boolean;
+  readonly isViewEnd: boolean;
+  readonly isLeftEndPinned: boolean;
+  readonly isRightStartPinned: boolean;
+  readonly isNoPinnedEnd: boolean;
+  readonly headHasGroupColumn: boolean;
+  readonly headHasPinnedColumn: boolean;
+  readonly headMaxDepth: number;
+  readonly level: number;
+  readonly columnIndex: number;
+  readonly parent: Nullable<ColumnRenderInputModel>;
+  readonly children: ColumnRenderInputModel[];
+  private iteratorCacheMap;
+  private leaves;
+  /**
+   * Create a new render input node.
+   *
+   * @param {string} key - Unique key (matches ColumnStructureModel.key).
+   * @param {string} label - Optional display label (from structure model).
+   * @param {VegaTablePinnedType} pinned - Pinned type for this node ('left' | 'right' | null).
+   * @param {Nullable<number>} colSpan - Number of visual columns spanned by this node's subtree.
+   * @param {Nullable<number>} rowSpan - Number of header rows this node should span.
+   * @param {boolean} isViewStart - True when this node is the start of a visible view range.
+   * @param {boolean} isViewEnd - True when this node is the end of a visible view range.
+   * @param {boolean} isLeftEndPinned - True when node is last left-pinned sibling.
+   * @param {boolean} isRightStartPinned - True when node is first right-pinned sibling.
+   * @param {boolean} isNoPinnedEnd - True when node is last non-pinned sibling.
+   * @param {boolean} headHasGroupColumn - Header contains group columns (affects rowSpan).
+   * @param {boolean} headHasPinnedColumn - Header contains pinned columns.
+   * @param {number} headMaxDepth - Maximum header depth (number of header rows).
+   * @param {number} level - Level/index of this node within header rows (0-based).
+   * @param {number} columnIndex - Sequential leaf index (used for ordering).
+   * @param {Nullable<ColumnRenderInputModel>} parent - Parent render input node (null for root-level).
+   * @param {ColumnRenderInputModel[]} children - Child render input nodes.
+   */
+  constructor(key: string, label: string, pinned: VegaTablePinnedType, colSpan: Nullable<number>, rowSpan: Nullable<number>, isViewStart: boolean, isViewEnd: boolean, isLeftEndPinned: boolean, isRightStartPinned: boolean, isNoPinnedEnd: boolean, headHasGroupColumn: boolean, headHasPinnedColumn: boolean, headMaxDepth: number, level: number, columnIndex: number, parent: Nullable<ColumnRenderInputModel>, children?: ColumnRenderInputModel[]);
+  /**
+   * Build a forest of ColumnRenderInputModel nodes from a ColumnStructureModel root.
+   *
+   * @param {ColumnStructureModel} rootModel - Root ColumnStructureModel that supplies tree and level data.
+   * @returns {ColumnRenderInputModel[]} Array of root-level ColumnRenderInputModel nodes (the render forest).
+   */
+  static from(rootModel: ColumnStructureModel): ColumnRenderInputModel[];
+  /**
+   * True when the provided structure model is the last left-pinned sibling in its parent's children.
+   * Used to mark boundary nodes for left-pinned groups.
+   *
+   * @param {ColumnStructureModel} model - Structure model to check.
+   * @returns {boolean} True when model is the last left-pinned sibling.
+   */
+  private static isLeftEndPinned;
+  /**
+   * True when the provided structure model is the first right-pinned sibling in its parent's children.
+   * Used to mark boundary nodes for right-pinned groups.
+   *
+   * @param {ColumnStructureModel} model - Structure model to check.
+   * @returns {boolean} True when model is the first right-pinned sibling.
+   */
+  private static isRightStartPinned;
+  /**
+   * True when the provided structure model is the last non-pinned sibling in its parent's children.
+   * Useful to handle the 'no-pinned-end' condition.
+   *
+   * @param {ColumnStructureModel} model - Structure model to check.
+   * @returns {boolean} True when model is the last non-pinned sibling.
+   */
+  private static isNoPinnedEnd;
+  /**
+   * True when the provided model is the first child of its parent.
+   *
+   * @param {ColumnStructureModel} model - Structure model to check.
+   * @returns {boolean} True when model is the first child.
+   */
+  private static isParentStart;
+  /**
+   * True when the provided model is the last child of its parent.
+   *
+   * @param {ColumnStructureModel} model - Structure model to check.
+   * @returns {boolean} True when model is the last child.
+   */
+  private static isParentEnd;
+  /**
+   * Compute a node's colSpan by iterating its subtree and counting the maximum number
+   * of nodes present at any single level (visual column span).
+   *
+   * @param {ColumnStructureModel} mode - ColumnStructureModel node to examine.
+   * @returns {number} Number of visual columns spanned by the node.
+   */
+  private static getColSpan;
+  /**
+   * Return cached leaf render nodes for this subtree.
+   * Caches the result on first call and returns cached array on subsequent calls.
+   *
+   * @returns {ColumnRenderInputModel[]} Array of leaf render input nodes.
+   */
+  getLeaves(): ColumnRenderInputModel[];
+  /**
+   * Generic iterator that supports traversal modes ('dfs' currently implemented).
+   *
+   * @param {IteratorMode} [mode='dfs'] - Iterator mode ('dfs' | 'bfs').
+   * @returns {ColumnRenderInputModel[]} Traversal-ordered array of nodes.
+   */
+  iterator(mode?: IteratorMode): ColumnRenderInputModel[];
+  /**
+   * Depth-first pre-order traversal of this node and its descendants.
+   * Caches the result for the 'dfs' mode to avoid repeated recursion.
+   *
+   * @returns {ColumnRenderInputModel[]} Array of nodes in DFS order (includes this node).
+   */
+  private dfsIterator;
+  /**
+   * True when this render node has no children (visual leaf).
+   *
+   * @returns {boolean} True when node is a leaf.
+   */
+  private isLeaf;
+}
+export {};

package/dist/types/components/vega-table/slimmers/controllers/dto/column-structure-model.d.ts

@@ -0,0 +1,140 @@
+import { Nullable } from '../../../../../types/general';
+import { VegaTableColumnConfig, VegaTableGroupColumnConfig, VegaTablePinnedType } from '../../../interface';
+declare type IteratorMode = 'dfs' | 'bfs';
+/**
+ * Represents the hierarchical structure of table columns (including group columns).
+ *
+ * Responsibilities:
+ * - Build the tree from flat or grouped column configs (.from / .fromGroupColumns)
+ * - Provide traversal helpers (iterator / dfs) with caching
+ * - Provide utility checks (isLeaf, hasGroupColumn, hasPinnedColumn)
+ * - Produce leaf column configs for rendering (generateColumnConfigByLeaves)
+ * - Order root children by pinned type for rendering (orderChildrenByPinned)
+ */
+export declare class ColumnStructureModel {
+  readonly key: string;
+  readonly level: number;
+  readonly parent?: ColumnStructureModel;
+  readonly label?: Nullable<string>;
+  readonly pinned?: VegaTablePinnedType;
+  private static readonly ROOT_LEVEL;
+  private static readonly ROOT_KEY;
+  children: ColumnStructureModel[];
+  private leaves;
+  private orderedChildren;
+  private iteratorCacheMap;
+  /**
+   * Constructor for ColumnStructureModel.
+   *
+   * @param {string} key - Unique key for the column.
+   * @param {number} level - Row level of this column (root uses ROOT_LEVEL).
+   * @param {ColumnStructureModel} [parent] - Optional parent node.
+   * @param {string} [label] - Optional display label for the column.
+   * @param {VegaTablePinnedType} [pinned] - Optional pinned metadata ('left'|'right'|null).
+   */
+  constructor(key: string, level: number, parent?: ColumnStructureModel, label?: Nullable<string>, pinned?: VegaTablePinnedType);
+  /**
+   * Creates the root ColumnStructureModel from column configs.
+   *
+   * @param {VegaTableColumnConfig[]} columnsConfig - Array of column configs.
+   * @param {Nullable<VegaTableGroupColumnConfig[]>} groupColumnConfig - Optional grouping configuration.
+   * @returns {ColumnStructureModel} Root column structure model.
+   */
+  static from(columnsConfig: VegaTableColumnConfig[], groupColumnConfig: Nullable<VegaTableGroupColumnConfig[]>): ColumnStructureModel;
+  /**
+   * Recursively creates ColumnStructureModel children from group column configs.
+   *
+   * @param {ColumnStructureModel} parent - Parent node for the created children.
+   * @param {VegaTableGroupColumnConfig[]} groupColumns - Array of group column configs.
+   * @param {number} level - Current row level.
+   * @returns {ColumnStructureModel[]} Array of child column structure models.
+   */
+  private static fromGroupColumns;
+  /**
+   * Generates an array of VegaTableColumnConfig for all leaf columns.
+   *
+   * @param {VegaTableColumnConfig[]} columns - Array of all column configs.
+   * @returns {VegaTableColumnConfig[]} Array of configs for leaf columns.
+   */
+  generateColumnConfigByLeaves(columns: VegaTableColumnConfig[]): VegaTableColumnConfig[];
+  /**
+   * Compute the maximum depth (highest level value) under this node.
+   * This is useful to determine the number of header rows required for rendering.
+   *
+   * @returns {number} Maximum level found in the subtree (or 0 when empty).
+   */
+  getMaxDepth(): number;
+  /**
+   * Checks if this subtree contains any group (non-leaf) columns.
+   *
+   * @returns {boolean} True if any descendant is a group column.
+   */
+  hasGroupColumn(): boolean;
+  /**
+   * Checks if this subtree contains any left pinned children.
+   *
+   * @returns {boolean} True if any immediate child has a pinned value.
+   */
+  hasLeftPinnedColumn(): boolean;
+  /**
+   * Checks if this subtree contains any right pinned children.
+   *
+   * @returns {boolean} True if any immediate child has a pinned value.
+   */
+  hasRightPinnedColumn(): boolean;
+  /**
+   * Checks if this node is a leaf (no children).
+   *
+   * @returns {boolean} True when this node has no children.
+   */
+  isLeaf(): boolean;
+  /**
+   * Return an array of nodes for this subtree using the specified traversal mode.
+   *
+   * Currently only depth-first search ('dfs') is supported. The returned array is
+   * cached per-mode to avoid repeated traversal costs.
+   *
+   * @param {IteratorMode} mode - Traversal mode to use. Defaults to 'dfs'.
+   * @returns {ColumnStructureModel[]} Array of ColumnStructureModel nodes in traversal order.
+   */
+  iterator(mode?: IteratorMode): ColumnStructureModel[];
+  /**
+   * Gets all leaf nodes in the subtree, with caching.
+   *
+   * Subsequent calls return the cached array until the underlying model is rebuilt.
+   *
+   * @returns {ColumnStructureModel[]} Array of leaf column models.
+   */
+  getLeaves(): ColumnStructureModel[];
+  /**
+   * For root nodes, returns children ordered by pinned type (left, none, right).
+   * For non-root nodes, returns children in their natural order.
+   *
+   * @returns {ColumnStructureModel[]} Array of child column models.
+   */
+  getOrderedChildren(): ColumnStructureModel[];
+  /**
+   * Orders root children by pinned type (left, none, right) and caches the result.
+   *
+   * For non-root nodes this method returns children in their natural order.
+   *
+   * @returns {ColumnStructureModel[]} Array of ordered child column models.
+   */
+  private orderChildrenByPinned;
+  /**
+   * Checks if this node is the root node.
+   *
+   * @returns {boolean} True if root node, false otherwise.
+   */
+  private isRoot;
+  /**
+   * Performs a depth-first traversal of the column structure.
+   *
+   * The traversal respects root-child pinned ordering (left/no/right) for the root node.
+   * Results are cached per-node to avoid repeated recursion costs.
+   *
+   * @returns {ColumnStructureModel[]} Array of all nodes in DFS order.
+   */
+  private dfsIterator;
+}
+export {};

package/dist/types/components/vega-table/slimmers/controllers/dto/test/column-render-input-model.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/components/vega-table/slimmers/controllers/dto/test/column-structure-model.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/components/vega-table/slimmers/controllers/vega-table-column-structure-model-controller.d.ts

@@ -0,0 +1,35 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaTable } from '../../vega-table';
+/**
+ * Controller responsible for building and keeping the ColumnStructureModel in sync
+ * with the component's `columns` and `groupColumns` properties.
+ *
+ * This slimmer maps relevant component fields and lifecycle/watch hooks to
+ * automatically rebuild the column structure when inputs change.
+ */
+export declare class VegaTableColumnStructureModelController extends VegaSlimmer {
+  host: VegaTable['host'];
+  columns: VegaTable['columns'];
+  groupColumns: VegaTable['groupColumns'];
+  columnStructureModel: VegaTable['columnStructureModel'];
+  /**
+   * Component lifecycle hook mapped to the host's componentWillLoad.
+   * Initializes the ColumnStructureModel prior to initial render.
+   */
+  componentWillLoad(): void;
+  /**
+   * Watch handler mapped to the host's watchColumns.
+   * Rebuilds the ColumnStructureModel when `columns` changes.
+   */
+  watchColumns(): void;
+  /**
+   * Watch handler mapped to the host's watchGroupColumns.
+   * Rebuilds the ColumnStructureModel when `groupColumns` changes.
+   */
+  watchGroupColumns(): void;
+  /**
+   * Build and assign the ColumnStructureModel from current `columns` and `groupColumns`.
+   * Uses `ColumnStructureModel.from` which returns a root model representing the column tree.
+   */
+  private setColumnStructureModel;
+}

package/dist/types/components/vega-table/slimmers/controllers/vega-table-render-input-controller.d.ts

@@ -0,0 +1,103 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaTable } from '../../vega-table';
+import { ColumnRenderInputModel } from './dto/column-render-input-model';
+/**
+ * VegaTableRenderInputController
+ *
+ * Central controller that computes and provides render input data for table header rows,
+ * header cells and body cells. Responsibilities:
+ * - Build and cache shared header layout context (depth, width, pinned indices).
+ * - Generate per-head-row and per-body-row render inputs used by head/row renderers.
+ * - Expose render inputs to shadow DOM cells via Remote Invocation Call (RIC) registry.
+ */
+export declare class VegaTableRenderInputController extends VegaSlimmer {
+  host: VegaTable['host'];
+  columnStructureModel: VegaTable['columnStructureModel'];
+  vegaTableColGroupRenderer: VegaTable['vegaTableColGroupRenderer'];
+  private columnRenderInputModels;
+  private leavesRenderInputModels;
+  private headRowRenderInputMap;
+  private headCellRenderInputMap;
+  private pinnedColumnBodyCellRenderInputMap;
+  /**
+   * Register remote invocation observers when controller is connected.
+   * Called via component lifecycle mapping.
+   */
+  connectedCallback(): void;
+  /**
+   * Unregister remote invocation observers when controller is disconnected.
+   * Called via component lifecycle mapping.
+   */
+  disconnectedCallback(): void;
+  /**
+   * Initialize head context before component load.
+   * Called via component lifecycle mapping.
+   */
+  componentWillLoad(): void;
+  /**
+   * Recompute head context when the column structure model changes.
+   * Called via watch mapping.
+   */
+  watchColumnStructureModel(): void;
+  /**
+   * Return render input models for table body (flattened leaves).
+   *
+   * @returns {ColumnRenderInputModel[]} Flattened array of leaf render input models.
+   */
+  getLeafRenderInputs(): ColumnRenderInputModel[];
+  /**
+   * Return render input models for table head (root-level forest).
+   *
+   * @returns {ColumnRenderInputModel[]} Root-level column render input models.
+   */
+  getHeadRenderInputs(): ColumnRenderInputModel[];
+  /**
+   * Store head row render input mapping for remote invocation.
+   *
+   * @param {HTMLElement} headRow - The head row element.
+   * @param {ColumnRenderInputModel[]} renderInputs - Associated render input models.
+   */
+  addHeadRowRenderInputMap(headRow: HTMLVegaTableHeadRowElement, renderInputs: ColumnRenderInputModel[]): void;
+  /**
+   * Store head cell render input mapping for remote invocation.
+   *
+   * @param {HTMLElement} headCell - The head cell element.
+   * @param {ColumnRenderInputModel} renderInput - Associated render input model.
+   */
+  addHeadCellRenderInputMap(headCell: HTMLVegaTableHeadCellElement, renderInput: ColumnRenderInputModel): void;
+  /**
+   * Store body cell render input mapping for pinned cells (used to update sticky positions).
+   *
+   * Only stores cells that require sticky positioning (left/right or no-pinned-end).
+   *
+   * @param {HTMLElement} cell - The body cell element.
+   * @param {ColumnRenderInputModel} renderInput - Associated render input model.
+   */
+  addCellRenderInputMap(cell: HTMLVegaTableCellElement, renderInput: ColumnRenderInputModel): void;
+  /**
+   * Expose the internal head-cell -> render-input mapping.
+   *
+   * @typedef {import('../../../../types/components').HTMLVegaTableHeadCellElement} HTMLVegaTableHeadCellElement
+   * @returns {Map<HTMLVegaTableHeadCellElement, ColumnRenderInputModel>} Map of head cell elements to render input.
+   */
+  getHeadCellRenderInputMap(): Map<HTMLVegaTableHeadCellElement, ColumnRenderInputModel>;
+  /**
+   * Expose the internal map of pinned body cells to their render inputs.
+   *
+   * @typedef {import('../../../../types/components').HTMLVegaTableCellElement} HTMLVegaTableCellElement
+   * @returns {Map<HTMLVegaTableCellElement, ColumnRenderInputModel>} Map of body cell hosts requiring sticky positioning.
+   */
+  getPinnedColumnBodyCellRenderInputMap(): Map<HTMLVegaTableCellElement, ColumnRenderInputModel>;
+  /**
+   * Register remote invocation callbacks to allow DOM nodes to request render inputs.
+   */
+  private registerRenderInputRICObserver;
+  /**
+   * Unregister remote invocation callbacks previously registered.
+   */
+  private unRegisterRenderInputRICObserver;
+  /**
+   * Build the ColumnRenderInputModel forest from the current ColumnStructureModel.
+   */
+  private setRenderInputModel;
+}

package/dist/types/components/vega-table/slimmers/renderers/vega-table-body-renderer.d.ts

@@ -11,6 +11,7 @@ export declare class VegaTableBodyRenderer extends VegaSlimmer {
   vegaTablePaginationController: VegaTable['vegaTablePaginationController'];
   vegaTableRowSelectionController: VegaTable['vegaTableRowSelectionController'];
   vegaTableRowRenderer: VegaTable['vegaTableRowRenderer'];
+  columnStructureModel: VegaTable['columnStructureModel'];
   private tableFormRef;
   getTableFormRef(): Nullable<HTMLVegaFormElement>;
   render(): HTMLTableSectionElement;

package/dist/types/components/vega-table/slimmers/renderers/vega-table-cell-renderer.d.ts

@@ -1,11 +1,14 @@
 import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
-import { VegaTableColumnConfig, VegaTableDataSourceItem } from '../../interface';
+import { VegaTableDataSourceItem } from '../../interface';
 import { VegaTable } from '../../vega-table';
+import { ColumnRenderInputModel } from '../controllers/dto/column-render-input-model';
 export declare class VegaTableCellRenderer extends VegaSlimmer {
   rowKey: VegaTable['rowKey'];
+  columns: VegaTable['columns'];
   vegaTableDataSourceController: VegaTable['vegaTableDataSourceController'];
   vegaTableEditableController: VegaTable['vegaTableEditableController'];
-  render(column: VegaTableColumnConfig, record: VegaTableDataSourceItem, index: number): HTMLTableCellElement;
+  vegaTableRenderInputController: VegaTable['vegaTableRenderInputController'];
+  render(renderInput: ColumnRenderInputModel, record: VegaTableDataSourceItem, index: number): HTMLTableCellElement;
   private renderTableCellContent;
   /**
    * Generate edit component by

package/dist/types/components/vega-table/slimmers/renderers/vega-table-col-group-renderer.d.ts

@@ -2,6 +2,7 @@ import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
 import { VegaTable } from '../../vega-table';
 export declare class VegaTableColGroupRenderer extends VegaSlimmer {
   paddingX: VegaTable['paddingX'];
+  columnStructureModel: VegaTable['columnStructureModel'];
   columns: VegaTable['columns'];
   rowExpandable: VegaTable['rowExpandable'];
   vegaTableRowSelectionController: VegaTable['vegaTableRowSelectionController'];

package/dist/types/components/vega-table/slimmers/renderers/vega-table-header-renderer.d.ts

@@ -8,6 +8,9 @@ export declare class VegaTableHeaderRenderer extends VegaSlimmer {
   rowSelection: VegaTable['rowSelection'];
   vegaTableSortController: VegaTable['vegaTableSortController'];
   vegaTableDataSourceController: VegaTable['vegaTableDataSourceController'];
+  vegaTableRenderInputController: VegaTable['vegaTableRenderInputController'];
   render(): HTMLTableSectionElement;
-  private renderHeaderColumnCells;
+  private renderHeaderRows;
+  private renderGroupCell;
+  private renderCell;
 }

package/dist/types/components/vega-table/slimmers/renderers/vega-table-pinned-renderer.d.ts

@@ -0,0 +1,18 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaTable } from '../../vega-table';
+import { PageResizeObserverSlimmer } from '../../../../helpers/slimmers/page-resize-observer-slimmer';
+export declare class VegaTablePinnedRenderer extends VegaSlimmer {
+  host: VegaTable['host'];
+  columnStructureModel: VegaTable['columnStructureModel'];
+  paddingX: VegaTable['paddingX'];
+  vegaTableRenderInputController: VegaTable['vegaTableRenderInputController'];
+  protected readonly pageResizeObserverSlimmer: PageResizeObserverSlimmer;
+  componentDidLoad(): void;
+  componentDidRender(): void;
+  private updateTableCellPinnedPosition;
+  private getRowShadowThWidths;
+  private getLeafWidths;
+  private updateCellPinnedPosition;
+  private updateTableRowPinnedPosition;
+  private updatePinnedPosition;
+}

package/dist/types/components/vega-table/slimmers/renderers/vega-table-renderer.d.ts

@@ -9,6 +9,7 @@ export declare class VegaTableRenderer extends VegaSlimmer {
   density: VegaTable['density'];
   dataSource: VegaTable['dataSource'];
   striped: VegaTable['striped'];
+  columnStructureModel: VegaTable['columnStructureModel'];
   vegaTableHeaderRenderer: VegaTable['vegaTableHeaderRenderer'];
   vegaTableBodyRenderer: VegaTable['vegaTableBodyRenderer'];
   vegaTableColGroupRenderer: VegaTable['vegaTableColGroupRenderer'];

package/dist/types/components/vega-table/slimmers/renderers/vega-table-row-renderer.d.ts

@@ -2,11 +2,11 @@ import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
 import { VegaTableRowProps } from '../../interface';
 import { VegaTable } from '../../vega-table';
 export declare class VegaTableRowRenderer extends VegaSlimmer {
-  columns: VegaTable['columns'];
   rowClickEventEmitter: VegaTable['rowClickEventEmitter'];
   vegaTableEditableController: VegaTable['vegaTableEditableController'];
   vegaTableCellRenderer: VegaTable['vegaTableCellRenderer'];
   striped: VegaTable['striped'];
+  vegaTableRenderInputController: VegaTable['vegaTableRenderInputController'];
   render(rowProps: VegaTableRowProps, editable?: boolean): HTMLTableRowElement;
   private renderTableRowComponent;
 }

package/dist/types/components/vega-table/vega-table-cell/slimmers/controllers/vega-table-cell-state-controller.d.ts

@@ -4,6 +4,10 @@ import { VegaTableCell } from '../../vega-table-cell';
  * Controller for the table row states
  */
 export declare class VegaTableCellStateController extends SubStateObserverSlimmer<HTMLVegaTableCellElement> {
+  host: VegaTableCell['host'];
   density: VegaTableCell['density'];
+  rowDivider: VegaTableCell['rowDivider'];
+  columnDivider: VegaTableCell['columnDivider'];
+  clickable: VegaTableCell['clickable'];
   constructor();
 }

package/dist/types/components/vega-table/vega-table-cell/slimmers/controllers/vega-table-row-state-controller.d.ts

@@ -0,0 +1,15 @@
+import { SubStateObserverSlimmer } from '../../../../../helpers/slimmers/sub-state/sub-state-observer-slimmer';
+import { VegaTableCell } from '../../vega-table-cell';
+/**
+ * Controller for the table row states
+ */
+export declare class VegaTableRowStateController extends SubStateObserverSlimmer<HTMLVegaTableCellElement> {
+  checked: VegaTableCell['checked'];
+  striped: VegaTableCell['striped'];
+  expanded: VegaTableCell['expanded'];
+  /**
+   * Component lifecycle - [componentWillLoad]{@link VegaTableCell.componentWillLoad}
+   */
+  componentWillRender(): void;
+  constructor();
+}

package/dist/types/components/vega-table/vega-table-cell/vega-table-cell.d.ts

@@ -5,12 +5,14 @@ import { BreakpointsTokenType } from '../../../types/design-token.type';
 import { PageResizeObserverSlimmer } from '../../../helpers/slimmers/page-resize-observer-slimmer';
 import { GlobalSlimmers } from '../../../vega-slimmer/vega-slimmer-core';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../../helpers/slimmers/component-usage-runtime-metrics';
+import { VegaTableRowStateController } from './slimmers/controllers/vega-table-row-state-controller';
 /**
  * @vegaVersion 1.44.0
  */
 export declare class VegaTableCell {
   protected readonly globalSlimmers: GlobalSlimmers;
   protected readonly vegaTableCellStateController: VegaTableCellStateController;
+  protected readonly vegaTableRowStateController: VegaTableRowStateController;
   protected readonly pageResizeObserverSlimmer: PageResizeObserverSlimmer;
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaTableCellElement>;
   host: HTMLVegaTableCellElement;
@@ -19,6 +21,12 @@ export declare class VegaTableCell {
    * Sync from {@link VegaTable.density}
    */
   density?: ResponsiveType<VegaTableDensityType>;
+  rowDivider?: boolean;
+  columnDivider?: boolean;
+  clickable?: boolean;
+  checked?: boolean;
+  striped?: boolean;
+  expanded?: boolean;
   /**
    * Determines the alignment of text within the cell.
    *
@@ -49,4 +57,6 @@ export declare class VegaTableCell {
   width?: string;
   render(): VegaTableCell;
   private getCellOverflowClass;
+  private onMouseEnter;
+  private onMouseLeave;
 }

package/dist/types/components/vega-table/vega-table-expand-row/slimmers/renderers/vega-table-expand-row-renderer.d.ts

@@ -1,6 +1,7 @@
 import { VegaSlimmer } from '../../../../../vega-slimmer/vega-slimmer-core';
 import { VegaTableExpandRow } from '../../vega-table-expand-row';
 export declare class VegaTableExpandRowRenderer extends VegaSlimmer {
+  host: VegaTableExpandRow['host'];
   rowKey: VegaTableExpandRow['rowKey'];
   expanded: VegaTableExpandRow['expanded'];
   checked: VegaTableExpandRow['checked'];

package/dist/types/components/vega-table/vega-table-head-cell/slimmers/controllers/vega-table-head-cell-state-controller.d.ts

@@ -5,5 +5,6 @@ import { VegaTableHeadCell } from '../../vega-table-head-cell';
  */
 export declare class VegaTableHeadCellStateController extends SubStateObserverSlimmer<HTMLVegaTableHeadCellElement> {
   density: VegaTableHeadCell['density'];
+  columnDivider: VegaTableHeadCell['columnDivider'];
   constructor();
 }

package/dist/types/components/vega-table/vega-table-head-cell/vega-table-head-cell.d.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from '../../../stencil-public-runtime';
-import { VegaTableColumnBreakpoint, VegaTableDensityType, VegaTableHeadCellClickEvent, VegaTableSortConfig, VegaTableSorterConfig, VegaTableSortOrderType } from '../interface';
+import { VegaTableColumnBreakpoint, VegaTableDensityType, VegaTableHeadCellClickEvent, VegaTablePinnedType, VegaTableSortConfig, VegaTableSorterConfig, VegaTableSortOrderType } from '../interface';
 import { EventEmitSlimmerBase } from '../../../helpers/event-manager/slimmers/event-emit-slimmer';
 import { GlobalSlimmers } from '../../../vega-slimmer/vega-slimmer-core';
 import { ResponsiveType } from '../../../types/ui.type';
@@ -26,6 +26,7 @@ export declare class VegaTableHeadCell {
    * Sync from {@link VegaTable.density}
    */
   density?: ResponsiveType<VegaTableDensityType>;
+  columnDivider?: boolean;
   /**
    * Defines the screen width at which the column becomes hidden.
    *    If not set, the column remains visible at all times.
@@ -63,6 +64,12 @@ export declare class VegaTableHeadCell {
    * @vegaVersion 2.42.0
    */
   sortConfig?: VegaTableSortConfig;
+  /**
+   * Specifies the pinned type of the head cell.
+   *
+   * @vegaVersion __VERSION__
+   */
+  pinned?: VegaTablePinnedType;
   /**
    * An event emitter notifying that the head cell has been clicked.
    *

package/dist/types/components/vega-table/vega-table-head-row/slimmers/renderers/vega-table-head-row-renderer.d.ts

@@ -27,4 +27,5 @@ export declare class VegaTableHeadRowRenderer extends VegaSlimmer {
   private handleSelectAll;
   private renderHeaderExpandableCell;
   private handleClick;
+  private getRowRenderInput;
 }

package/dist/types/components/vega-table/vega-table-row/vega-table-row.d.ts

@@ -13,6 +13,7 @@ import { ResponsiveType } from '../../../types/ui.type';
 import { BreakpointsTokenType } from '../../../types/design-token.type';
 import { PageResizeObserverSlimmer } from '../../../helpers/slimmers/page-resize-observer-slimmer';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../../helpers/slimmers/component-usage-runtime-metrics';
+import { SubStateNotifySlimmerBase } from '../../../helpers/slimmers/sub-state/sub-state-notify-slimmer-base';
 /**
  * @vegaVersion 1.44.0
  */
@@ -28,6 +29,8 @@ export declare class VegaTableRow {
   protected checkboxValueChangeEventPrevent: ChildNodesEventPreventSlimmer;
   protected readonly pageResizeObserverSlimmer: PageResizeObserverSlimmer;
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaTableRowElement>;
+  protected readonly checkedNotifySlimmer: SubStateNotifySlimmerBase;
+  protected readonly expandedNotifySlimmer: SubStateNotifySlimmerBase;
   host: HTMLVegaTableRowElement;
   currentBreakpoint: BreakpointsTokenType;
   clicked?: boolean;
@@ -52,10 +55,12 @@ export declare class VegaTableRow {
    * Indicates whether the row's checkbox is checked.
    */
   checked?: boolean;
+  watchChecked(): void;
   /**
    * Indicates whether the row is expanded.
    */
   expanded?: boolean;
+  watchExpanded(): void;
   /**
    * Sync from {@link VegaTable.rowDivider}
    */