@heartlandone/vega 2.100.0 → 2.102.0

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

@@ -1,6 +1,7 @@
 import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
 import { VegaTable } from '../../vega-table';
 import { ColumnRenderInputModel } from './dto/column-render-input-model';
+import { RowKind } from './dto/row-render-input-model';
 /**
  * VegaTableRenderInputController
  *
@@ -13,11 +14,20 @@ import { ColumnRenderInputModel } from './dto/column-render-input-model';
 export declare class VegaTableRenderInputController extends VegaSlimmer {
   host: VegaTable['host'];
   columnStructureModel: VegaTable['columnStructureModel'];
+  hasExpandableRow: VegaTable['hasExpandableRow'];
+  paddingX: VegaTable['paddingX'];
+  rowDraggable: VegaTable['rowDraggable'];
+  rowExpandable: VegaTable['rowExpandable'];
+  rowSelection: VegaTable['rowSelection'];
+  isTemplateRenderMode: VegaTable['isTemplateRenderMode'];
   private columnRenderInputModels;
   private leavesRenderInputModels;
   private headRowRenderInputMap;
   private headCellRenderInputMap;
-  private pinnedColumnBodyCellRenderInputMap;
+  private bodyCellRenderInputMap;
+  private hasPendingCellRenderInputChange;
+  private rowRenderInputMap;
+  private footCellRenderInputMap;
   private cellRenderInputChangeTaskQueue;
   /**
    * Register remote invocation observers when controller is connected.
@@ -36,7 +46,7 @@ export declare class VegaTableRenderInputController extends VegaSlimmer {
   componentWillLoad(): void;
   /**
    * Notify body cells about render input changes after the table has re-rendered.
-   * This ensures ref callbacks have fired and the pinnedColumnBodyCellRenderInputMap is up-to-date.
+   * This ensures ref callbacks have fired and the body-cell render inputs are up-to-date.
    * Called via component lifecycle mapping.
    */
   componentDidRender(): Promise<void>;
@@ -45,6 +55,8 @@ export declare class VegaTableRenderInputController extends VegaSlimmer {
    * Called via watch mapping.
    */
   watchColumnStructureModel(): Promise<void>;
+  /** Clear cached row inputs when row-related table state changes. */
+  watchRowStructure(): void;
   /**
    * Return render input models for table body (flattened leaves).
    *
@@ -80,14 +92,19 @@ export declare class VegaTableRenderInputController extends VegaSlimmer {
    */
   clearHeadRenderInputMaps(): 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).
+   * Store body cell render input mapping without retaining disconnected cell hosts.
    *
    * @param {HTMLElement} cell - The body cell element.
    * @param {ColumnRenderInputModel} renderInput - Associated render input model.
    */
   addCellRenderInputMap(cell: HTMLVegaTableCellElement, renderInput: ColumnRenderInputModel): void;
+  /**
+   * Store row render input mapping for remote invocation.
+   *
+   * @param {HTMLElement} row - Row host element.
+   * @param {RowKind} kind - Row variant.
+   */
+  addRowRenderInputMap(row: HTMLElement, kind: RowKind): void;
   /**
    * Expose the internal head-cell -> render-input mapping.
    *
@@ -96,12 +113,32 @@ export declare class VegaTableRenderInputController extends VegaSlimmer {
    */
   getHeadCellRenderInputMap(): Map<HTMLVegaTableHeadCellElement, ColumnRenderInputModel>;
   /**
-   * Expose the internal map of pinned body cells to their render inputs.
+   * Return a snapshot of currently rendered body cells and their render inputs.
    *
    * @typedef {import('../../../../types/components').HTMLVegaTableCellElement} HTMLVegaTableCellElement
-   * @returns {Map<HTMLVegaTableCellElement, ColumnRenderInputModel>} Map of body cell hosts requiring sticky positioning.
+   * @returns {Map<HTMLVegaTableCellElement, ColumnRenderInputModel>} Current body-cell render inputs.
    */
   getPinnedColumnBodyCellRenderInputMap(): Map<HTMLVegaTableCellElement, ColumnRenderInputModel>;
+  /**
+   * Recompute per-column sticky pinned offsets (`leftOffsetPx` / `rightOffsetPx`) on
+   * every registered head, body, and foot cell render input,
+   * then notify subscribers so pinned cells re-render with the new offsets.
+   *
+   * This is the write-side of the declarative pinned pipeline described in VD-9881:
+   * instead of {@link VegaTablePinnedRenderer} mutating each cell's shadow-DOM
+   * `style.left`/`style.right`, the controller populates the offset on the DTO and
+   * pinned cells consume it from their own `render()` via a JSX `style` prop.
+   *
+   * Idempotent — safe to call multiple times per lifecycle event. Measurement of
+   * `prevShadowThWidth`, `nextShadowThWidth`, and `leafWidths` lives with the pinned
+   * renderer (it needs those values for other passes too — breakpoint-hidden column
+   * detection, template-mode leaf zipping, etc.) and is supplied by the caller.
+   *
+   * @param {number} prevShadowThWidth - Aggregate width of leading row-fixed cells (left padding).
+   * @param {number} nextShadowThWidth - Aggregate width of trailing row-fixed cells (right padding).
+   * @param {number[]} leafWidths - Rendered width of each leaf column, indexed by columnIndex.
+   */
+  recomputePinnedOffsets(prevShadowThWidth: number, nextShadowThWidth: number, leafWidths: number[]): void;
   /**
    * Register remote invocation callbacks to allow DOM nodes to request render inputs.
    */
@@ -110,6 +147,33 @@ export declare class VegaTableRenderInputController extends VegaSlimmer {
    * Unregister remote invocation callbacks previously registered.
    */
   private unRegisterRenderInputRICObserver;
+  /** Register authored template rows and cells with their render inputs. */
+  private registerTemplateCellRenderInputs;
+  /**
+   * Compare the structural fields that determine a cell render input.
+   *
+   * @param {ColumnRenderInputModel} current - Existing render input.
+   * @param {ColumnRenderInputModel} candidate - Newly computed render input.
+   * @returns {boolean} Whether the structural fields match.
+   */
+  private hasSameCellStructure;
+  /** Notify consumers that table render inputs changed. */
+  private notifyRenderInputChange;
+  /**
+   * Create and cache render input for a requesting row.
+   *
+   * @param {HTMLElement} row - Requesting row host.
+   * @returns {RowRenderInputModel} Cached row render input.
+   */
+  private createRowRenderInput;
+  /**
+   * Build row render input from current table state.
+   *
+   * @param {RowKind} kind - Row variant.
+   * @param {HTMLElement} row - Row host used for header metadata lookup.
+   * @returns {RowRenderInputModel} Current row render input.
+   */
+  private createRowRenderInputModel;
   /**
    * Build the ColumnRenderInputModel forest from the current ColumnStructureModel.
    */

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

@@ -13,6 +13,7 @@ export declare class VegaTableBodyRenderer extends VegaSlimmer {
   vegaTableRowRenderer: VegaTable['vegaTableRowRenderer'];
   columnStructureModel: VegaTable['columnStructureModel'];
   vegaTableExpandRowController: VegaTable['vegaTableExpandRowController'];
+  vegaTableRenderInputController: VegaTable['vegaTableRenderInputController'];
   private tableFormRef;
   private tableBodyRef;
   getTableFormRef(): Nullable<HTMLVegaFormElement>;

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

@@ -4,99 +4,14 @@ import { PageResizeObserverSlimmer } from '../../../../helpers/slimmers/page-res
 export declare class VegaTablePinnedRenderer extends VegaSlimmer {
   host: VegaTable['host'];
   columnStructureModel: VegaTable['columnStructureModel'];
-  paddingX: VegaTable['paddingX'];
   isTemplateRenderMode: VegaTable['isTemplateRenderMode'];
   vegaTableRenderInputController: VegaTable['vegaTableRenderInputController'];
   protected readonly pageResizeObserverSlimmer: PageResizeObserverSlimmer;
-  private previouslyStyledCells;
-  private dynamicRightDividerCells;
-  private dynamicLeftDividerCells;
-  private dynamicHideRightBorderCells;
-  private templateColspanSyncedCells;
-  private clearPinnedPositionsTaskQueue;
   componentDidLoad(): void;
-  componentDidRender(): Promise<void>;
+  componentDidRender(): void;
   watchColumnStructureModel(): void;
-  private updateTableCellPinnedPosition;
-  /**
-   * Resolve the DOM root that holds the table rows.
-   *
-   * In data-source mode rows are rendered into the table's shadow root; in template mode the
-   * authored rows are slotted, so they live in the host's light DOM.
-   *
-   * @returns {ShadowRoot | HTMLElement} The container to query rows from.
-   */
+  private recomputeRenderInputs;
   private getRowContainerRoot;
-  /**
-   * Position authored template body and foot leaf cells by zipping them with the leaf render
-   * inputs in authored order, advancing by each cell's colSpan. Also applies the pinned-boundary
-   * divider classes (mirroring the body cell's render()), since authored body/foot cells have no
-   * render-input of their own in template mode.
-   *
-   * @param {number} prevShadowThWidth - Aggregate width of leading fixed columns (table left padding).
-   * @param {number[]} leafWidths - Rendered width of each leaf column, indexed by columnIndex.
-   * @param {number} nextShadowThWidth - Aggregate width of trailing fixed columns (table right padding).
-   */
-  private updateTemplateLeafCellPinnedPosition;
-  /**
-   * Record an authored template leaf cell's shadow cell as the last visible left-pinned / first &
-   * last visible right-pinned cell of its row, so the shared dynamic-boundary logic can shift the
-   * boundary divider onto it when the static boundary column is breakpoint-hidden.
-   *
-   * @param {HTMLElement} row - The authored body or foot row (used as the per-row grouping key).
-   * @param {HTMLVegaTableCellElement} leafCell - Authored body or foot cell host.
-   * @param {ColumnRenderInputModel} renderInput - Render input of the cell's first leaf.
-   * @param {Map<HTMLElement, HTMLElement>} lastVisibleLeftPinnedBodyCells - Per-row last visible left-pinned shadow cell.
-   * @param {Map<HTMLElement, HTMLElement>} firstVisibleRightPinnedBodyCells - Per-row first visible right-pinned shadow cell.
-   * @param {Map<HTMLElement, HTMLElement>} lastVisibleRightPinnedBodyCells - Per-row last visible right-pinned shadow cell.
-   */
-  private trackVisiblePinnedTemplateCell;
-  /**
-   * Reduce an authored template pinned cell's shadow <td> colspan to the number of *visible*
-   * columns it spans. Breakpoint-hidden columns report width 0 but Chrome still counts them in the
-   * table grid, so without this a pinned span drifts out of column-alignment with the header
-   * (VD-9540). Only applies to pinned cells; skipped off-screen / in jsdom where every width is 0.
-   *
-   * @param {HTMLVegaTableCellElement} leafCell - Authored body or foot cell host.
-   * @param {ColumnRenderInputModel} renderInput - Render input of the cell's first leaf.
-   * @param {number} colSpan - The cell's originally declared colspan.
-   * @param {number[]} leafWidths - Rendered width of each leaf column, indexed by columnIndex.
-   * @param {boolean} allLeafWidthsHidden - True when every leaf width is 0 (off-screen / jsdom).
-   */
-  private syncTemplateLeafColspan;
-  /**
-   * Restore the authored colspan on every template cell whose shadow <td> was shrunk by
-   * {@link syncTemplateLeafColspan}. Runs on cleanup so removing `pinned` at runtime does not leave
-   * a body/foot cell stuck at the breakpoint-shrunk colspan once positioning no longer runs (VD-9768).
-   */
-  private restoreTemplateLeafColspan;
-  /**
-   * Apply the pinned-boundary divider classes to an authored template body/foot cell's shadow
-   * cell, merging boundary flags across the leaves the cell spans. Tracked in the dynamic sets so
-   * the next positioning pass clears and re-evaluates them (matching the data-source cleanup path).
-   *
-   * @param {HTMLVegaTableCellElement} cell - Authored body or foot cell host.
-   * @param {ColumnRenderInputModel[]} spannedLeaves - Leaf render inputs the cell spans.
-   */
-  private applyTemplateLeafDividerClass;
-  private getRowShadowThWidths;
+  private getRowFixedWidths;
   private getLeafWidths;
-  private syncColspanForHiddenColumns;
-  /**
-   * Count how many columns in a span are actually visible (leaf width > 0). Breakpoint-hidden
-   * columns report width 0 because their <th> is display:none; Chrome ignores that on the table
-   * grid, so a spanning cell's shadow <td> colspan must be reduced to the visible count to stay
-   * column-aligned (VD-9540). Shared by data-source and template positioning paths.
-   *
-   * @param {number[]} leafWidths - Rendered width of each leaf column, indexed by columnIndex.
-   * @param {number} startIndex - columnIndex of the first leaf the spanning cell covers.
-   * @param {number} declaredColspan - The cell's originally declared colspan.
-   * @returns {number} The number of visible columns in the span (>= 1).
-   */
-  private countVisibleColspan;
-  private resolveCellColSpan;
-  private updateCellPinnedPosition;
-  private updateTableRowPinnedPosition;
-  private clearAllPinnedPositions;
-  private updatePinnedPosition;
 }

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

@@ -1,11 +1,11 @@
 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'];
   colSpan: VegaTableExpandRow['colSpan'];
   striped: VegaTableExpandRow['striped'];
+  renderInput: VegaTableExpandRow['renderInput'];
   render(): HTMLTableRowElement;
 }

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

@@ -7,6 +7,9 @@ import { BreakpointsTokenType } from '../../../types/design-token.type';
 import { VegaTableExpandRowColSpanController } from './slimmers/controllers/vega-table-expand-row-col-span-controller';
 import { PageResizeObserverSlimmer } from '../../../helpers/slimmers/page-resize-observer-slimmer';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../../helpers/slimmers/component-usage-runtime-metrics';
+import { VegaTableChildRenderInputConsumerSlimmer } from '../../../helpers/slimmers/vega-table-child-render-input-consumer-slimmer';
+import { RowRenderInputModel } from '../slimmers/controllers/dto/row-render-input-model';
+import { Nullable } from '../../../types/general';
 /**
  * @vegaVersion 1.44.0
  */
@@ -18,9 +21,11 @@ export declare class VegaTableExpandRow {
   protected readonly vegaTableExpandRowStateController: VegaTableExpandRowStateController;
   protected readonly vegaTableExpandRowColSpanController: VegaTableExpandRowColSpanController;
   protected readonly pageResizeObserverSlimmer: PageResizeObserverSlimmer;
+  protected readonly vegaTableRenderInputConsumerSlimmer: VegaTableChildRenderInputConsumerSlimmer;
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaTableExpandRowElement>;
   host: HTMLVegaTableExpandRowElement;
   currentBreakpoint: BreakpointsTokenType;
+  renderInput: Nullable<RowRenderInputModel>;
   watchCurrentBreakpoint(): void;
   /**
    * Whether the expandable host row has multiple selection checkbox.

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

@@ -6,5 +6,6 @@ export declare class VegaTableFootCellRenderer extends VegaSlimmer {
   textAlign: VegaTableFootCell['textAlign'];
   colSpan: VegaTableFootCell['colSpan'];
   width: VegaTableFootCell['width'];
+  renderInput: VegaTableFootCell['renderInput'];
   render(): VegaTableFootCell;
 }

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

@@ -6,6 +6,9 @@ import { PageResizeObserverSlimmer } from '../../../helpers/slimmers/page-resize
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../../helpers/slimmers/component-usage-runtime-metrics';
 import { VegaTableFootCellRenderer } from './slimmers/renderers/vega-table-foot-cell-renderer';
 import { BreakpointsTokenType } from '../../../types/design-token.type';
+import { VegaTableChildRenderInputConsumerSlimmer } from '../../../helpers/slimmers/vega-table-child-render-input-consumer-slimmer';
+import { ColumnRenderInputModel } from '../slimmers/controllers/dto/column-render-input-model';
+import { Nullable } from '../../../types/general';
 /**
  * @vegaVersion 2.68.1
  */
@@ -15,8 +18,10 @@ export declare class VegaTableFootCell {
   protected readonly vegaTableFootCellRenderer: VegaTableFootCellRenderer;
   protected readonly pageResizeObserverSlimmer: PageResizeObserverSlimmer;
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaTableFootCellElement>;
+  protected readonly vegaTableRenderInputConsumerSlimmer: VegaTableChildRenderInputConsumerSlimmer;
   host: HTMLVegaTableFootCellElement;
   currentBreakpoint: BreakpointsTokenType;
+  renderInput: Nullable<ColumnRenderInputModel>;
   /**
    * Sync from {@link VegaTable.density}
    */

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

@@ -3,9 +3,7 @@ import { VegaTableFootRow } from '../../vega-table-foot-row';
 export declare class VegaTableFootRowRenderer extends VegaSlimmer {
   host: VegaTableFootRow['host'];
   paddingX: VegaTableFootRow['paddingX'];
-  selectionType: VegaTableFootRow['selectionType'];
-  hasExpandableRow: VegaTableFootRow['hasExpandableRow'];
-  draggable: VegaTableFootRow['draggable'];
+  renderInput: VegaTableFootRow['renderInput'];
   render(): VegaTableFootRow;
   private renderFooterSelectionCell;
   private renderFooterExpandableCell;

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

@@ -6,6 +6,9 @@ import { VegaTableDensityType } from '../interface';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../../helpers/slimmers/component-usage-runtime-metrics';
 import { PageResizeObserverSlimmer } from '../../../helpers/slimmers/page-resize-observer-slimmer';
 import { BreakpointsTokenType } from '../../../types/design-token.type';
+import { VegaTableChildRenderInputConsumerSlimmer } from '../../../helpers/slimmers/vega-table-child-render-input-consumer-slimmer';
+import { RowRenderInputModel } from '../slimmers/controllers/dto/row-render-input-model';
+import { Nullable } from '../../../types/general';
 /**
  * @vegaVersion 2.68.1
  */
@@ -15,8 +18,10 @@ export declare class VegaTableFootRow {
   protected readonly vegaTableFootRowRenderer: VegaTableFootRowRenderer;
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaTableFootRowElement>;
   protected readonly pageResizeObserverSlimmer: PageResizeObserverSlimmer;
+  protected readonly vegaTableRenderInputConsumerSlimmer: VegaTableChildRenderInputConsumerSlimmer;
   host: HTMLVegaTableFootRowElement;
   currentBreakpoint: BreakpointsTokenType;
+  renderInput: Nullable<RowRenderInputModel>;
   /**
    * Indicates whether the table has a expandable row.
    */

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

@@ -3,12 +3,9 @@ import { VegaTableHeadRow } from '../../vega-table-head-row';
 export declare class VegaTableHeadRowRenderer extends VegaSlimmer {
   host: VegaTableHeadRow['host'];
   paddingX: VegaTableHeadRow['paddingX'];
-  selectionType: VegaTableHeadRow['selectionType'];
   hideSelectAll: VegaTableHeadRow['hideSelectAll'];
   selectAllDisabled: VegaTableHeadRow['selectAllDisabled'];
   checkedAll: VegaTableHeadRow['checkedAll'];
-  hasExpandableRow: VegaTableHeadRow['hasExpandableRow'];
-  draggable: VegaTableHeadRow['draggable'];
   isEmptyTable: VegaTableHeadRow['isEmptyTable'];
   isTemplateRenderMode: VegaTableHeadRow['isTemplateRenderMode'];
   renderInput: VegaTableHeadRow['renderInput'];
@@ -30,5 +27,4 @@ export declare class VegaTableHeadRowRenderer extends VegaSlimmer {
   private renderHeaderDraggableCell;
   private renderHeaderExpandableCell;
   private handleClick;
-  private getRowRenderInput;
 }

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

@@ -1,6 +1,6 @@
 import { GlobalSlimmers } from '../../../vega-slimmer/vega-slimmer-core';
 import { Nullable } from '../../../types/general';
-import { ColumnRenderInputModel } from '../slimmers/controllers/dto/column-render-input-model';
+import { RowRenderInputModel } from '../slimmers/controllers/dto/row-render-input-model';
 import { VegaTableHeadRowRenderer } from './slimmers/renderers/vega-table-head-row-renderer';
 import { VegaTableHeadRowController } from './slimmers/controllers/vega-table-head-row-controller';
 import { VegaTableHeadRowStateController } from './slimmers/controllers/vega-table-head-row-state-controller';
@@ -57,7 +57,7 @@ export declare class VegaTableHeadRow {
    * Whether the parent table is template render mode
    */
   isTemplateRenderMode: boolean;
-  renderInput: Nullable<ColumnRenderInputModel[]>;
+  renderInput: Nullable<RowRenderInputModel>;
   /**
    * Sync from {@link VegaTable.rowDraggable}
    */

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

@@ -10,16 +10,15 @@ export declare class VegaTableRowRenderer extends VegaSlimmer {
   expanded: VegaTableRow['expanded'];
   paddingX: VegaTableRow['paddingX'];
   expandable: VegaTableRow['expandable'];
-  hasExpandableRow: VegaTableRow['hasExpandableRow'];
   vegaClick: VegaTableRow['vegaClick'];
-  selectionType: VegaTableRow['selectionType'];
-  draggable: VegaTableRow['draggable'];
+  renderInput: VegaTableRow['renderInput'];
   vegaTableRowSelectionController: VegaTableRow['vegaTableRowSelectionController'];
   vegaTableRowExpandController: VegaTableRow['vegaTableRowExpandController'];
   vegaTableRowClickController: VegaTableRow['vegaTableRowClickController'];
   expandEventEmitter: VegaTableRow['expandEventEmitter'];
   private parentTableRef;
   connectedCallback(): void;
+  componentDidRender(): void;
   getParentTableRef(): Nullable<HTMLVegaTableElement>;
   render(): VegaTableRow;
   private renderExpandRowSpace;

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

@@ -14,6 +14,8 @@ 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';
+import { VegaTableChildRenderInputConsumerSlimmer } from '../../../helpers/slimmers/vega-table-child-render-input-consumer-slimmer';
+import { RowRenderInputModel } from '../slimmers/controllers/dto/row-render-input-model';
 /**
  * @vegaVersion 1.44.0
  */
@@ -24,6 +26,7 @@ export declare class VegaTableRow {
   protected readonly vegaTableRowExpandController: VegaTableRowExpandController;
   protected readonly vegaTableRowClickController: VegaTableRowClickController;
   protected readonly vegaTableRowStateController: VegaTableRowStateController;
+  protected readonly vegaTableRenderInputConsumerSlimmer: VegaTableChildRenderInputConsumerSlimmer;
   protected clickEventEmitter: EventEmitSlimmerBase;
   protected expandEventEmitter: EventEmitSlimmerBase;
   protected checkboxValueChangeEventPrevent: ChildNodesEventPreventSlimmer;
@@ -35,6 +38,7 @@ export declare class VegaTableRow {
   protected readonly rowDividerNotifySlimmer: SubStateNotifySlimmerBase;
   host: HTMLVegaTableRowElement;
   currentBreakpoint: BreakpointsTokenType;
+  renderInput: Nullable<RowRenderInputModel>;
   clicked?: boolean;
   /**
    * Indicates whether the table has an expandable row.