@globalpayments/vega 2.55.1 → 2.57.0

package/dist/types/components/vega-rich-text-editor/dto/blocks/list-item-block.d.ts

@@ -7,9 +7,15 @@ import { RTEBlock } from './block.abstract';
  * List item block
  */
 export declare class RTEListItemBlock extends RTETextBlock {
-  children?: RTEListBlock[];
+  /**
+   * TODO: Refactor the list item properties children and nestList, merge two properties together.
+   *
+   * 1. Update the type of `children` to include `RTEListBlock` as a possible type.
+   * 2. The list block children should text block array and nest list block array, The text block should wrap a `li` tag when rendering.
+   */
+  nestList?: RTEListBlock[];
   parent: RTEListBlock;
-  constructor(id: string, children?: RTEListBlock[]);
+  constructor(id: string, nestList?: RTEListBlock[]);
   /**
    * Converts a VegaRTEListItemBlock object to an RTEListItemBlock
    *

package/dist/types/components/vega-rich-text-editor/dto/blocks/text-block.d.ts

@@ -9,9 +9,9 @@ import { RTEListBlock } from './list-block';
 /**
  * Text block
  */
-export declare class RTETextBlock extends RTEBlock {
+export declare class RTETextBlock extends RTEBlock<VegaRTEContent | RTEListBlock, RTETextNode> {
   type: VegaRTETextBlockType;
-  nodes: RTETextNode[];
+  children: RTETextNode[];
   parent: VegaRTEContent | RTEListBlock;
   constructor(id: string, type: VegaRTETextBlockType);
   /**

package/dist/types/components/vega-rich-text-editor/dto/content-state.d.ts

@@ -9,7 +9,7 @@ import { Nullable } from '../../../types/general';
  * Class representing the content state of the rich text editor.
  */
 export declare class VegaRTEContent {
-  blocks: RTEContentBlock[];
+  children: RTEContentBlock[];
   constructor(blocks: RTEContentBlock[]);
   /**
    * Converts a JSON array of blocks to a class array of RTEContentBlock.

package/dist/types/components/vega-rich-text-editor/dto/nodes/code-block-node.d.ts

@@ -12,9 +12,9 @@ declare type VegaRTECodeNode = VegaRTEBaseNode & {
 /**
  * RTE code node DTO class.
  */
-export declare class RTECodeBlockNode extends RTENode {
+export declare class RTECodeBlockNode extends RTENode<RTECodeBlock> {
   type: NodeTypeEnum;
-  parentBlock: RTECodeBlock;
+  parent: RTECodeBlock;
   text: string;
   language?: VegaRTECodeBlock['language'];
   annotationMap: Map<InternalAnnotationTypeEnum.SELECTION_RANGE, SelectionRangeAnnotation>;

package/dist/types/components/vega-rich-text-editor/dto/nodes/image-node.d.ts

@@ -6,9 +6,9 @@ import { ModifyContentAction } from '../actions/modify-content-action.abstract';
 /**
  * Image node
  */
-export declare class RTEImageNode extends RTENode {
+export declare class RTEImageNode extends RTENode<RTEImageBlock> {
   readonly type: NodeTypeEnum;
-  parentBlock: RTEImageBlock;
+  parent: RTEImageBlock;
   url: string;
   constructor(id: string, url: string, parentBlock: RTEImageBlock, annotationMap?: Map<RTENodeAnnotationMapKey, RTENodeAnnotationMapValue>);
   /**

package/dist/types/components/vega-rich-text-editor/dto/nodes/node.abstract.d.ts

@@ -12,11 +12,11 @@ export declare type NodeAnnotations = Map<RTENodeAnnotationMapKey, RTENodeAnnota
 /**
  * Abstract class for all nodes
  */
-export declare abstract class RTENode {
+export declare abstract class RTENode<P extends RTEBlock = RTEBlock> {
   id: string;
   annotationMap: NodeAnnotations;
   abstract readonly type: NodeTypeEnum;
-  abstract parentBlock: RTEBlock;
+  abstract parent: P;
   protected constructor(id: string, annotationMap?: Map<RTENodeAnnotationMapKey, RTENodeAnnotationMapValue>);
   /**
    * Get annotation by type
@@ -56,7 +56,7 @@ export declare abstract class RTENode {
    */
   protected cloneAnnotations(): NodeAnnotations;
   abstract toJSON(): VegaRTEBaseNode;
-  abstract clone(): RTENode;
+  abstract clone(): RTENode<P>;
   protected abstract doAnnotationActionApply(action: AnnotationAction): void;
   protected abstract doModifyActionApply(action: ModifyContentAction): void;
 }

package/dist/types/components/vega-rich-text-editor/dto/nodes/text-node.d.ts

@@ -9,10 +9,10 @@ export declare type Link = {
 /**
  * Text node
  */
-export declare class RTETextNode extends RTENode {
+export declare class RTETextNode extends RTENode<RTETextBlock> {
   readonly type: NodeTypeEnum;
   text: string;
-  parentBlock: RTETextBlock;
+  parent: RTETextBlock;
   constructor(id: string, text: string, parentBlock: RTETextBlock, annotationMap?: Map<RTENodeAnnotationMapKey, RTENodeAnnotationMapValue>);
   /**
    * Creates an RTETextNode from a VegaRTETextNode with annotations and a parent RTETextBlock.

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

@@ -52,6 +52,7 @@ export declare type VegaTableColumnConfig = {
    * Whether the table cell can be edited
    */
   editable?: boolean;
+  pinned?: VegaTablePinnedType;
   /**
    * Editable table cell's form item type
    */
@@ -65,6 +66,35 @@ export declare type VegaTableColumnConfig = {
    */
   renderFormItem?: VegaTableCellFormItemRenderFunction;
 };
+export declare type VegaTableGroupColumnConfig = VegaTableColumnGroupingModel | VegaTableColumnGroupingLeafModel;
+/**
+ * Represents a group header node in `groupColumns`.
+ * Use this type to define hierarchical headers (multi-row groups).
+ *
+ * @property {string} key - Unique identifier for the group node.
+ * @property {string} label - Text displayed in the group header. Its presence indicates this node is a non-leaf group.
+ * @property {VegaTablePinnedType} [pinned] - Optional pinning applied to descendant leaf columns.
+ *   Note: `pinned` only takes effect if the group node is at the top level of `groupColumns`.
+ * @property {(VegaTableColumnGroupingModel|VegaTableColumnGroupingLeafModel)[]} [children] -
+ *   Nested group nodes or leaf references.
+ *   Leaf references must match a column `key` in `columns`.
+ */
+export declare type VegaTableColumnGroupingModel = {
+  key: string;
+  label: string;
+  pinned?: VegaTablePinnedType;
+  children?: (VegaTableColumnGroupingModel | VegaTableColumnGroupingLeafModel)[];
+};
+/**
+ * Represents a leaf reference inside `groupColumns`.
+ * Used to link a column from the flat `columns` array into a group.
+ *
+ * @property {string} key -  The `key` of the referenced column in `columns`.
+ *   If the key is missing, the renderer outputs an empty header cell.
+ */
+export declare type VegaTableColumnGroupingLeafModel = {
+  key: string;
+};
 export declare type VegaTableColumnBreakpoint = BreakpointsForPrefixType;
 export declare type VegaTableFormItemType = 'input' | 'input-select' | 'stepper' | 'checkbox' | 'textarea' | 'combo-box' | 'date-picker' | 'time-picker';
 export declare type VegaTableFormItemProps = (form: HTMLVegaFormElement, 
@@ -233,3 +263,4 @@ export declare type VegaTableRowSelectAllEventDetail = {
 export declare type TableHeadCellObserverPayload = {
   host: HTMLVegaTableHeadCellElement;
 };
+export declare type VegaTablePinnedType = 'left' | 'right';

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'];