@globalpayments/vega 2.96.0 → 2.98.0

package/dist/types/components/vega-selection-chip/vega-selection-chip-group/vega-selection-chip-group.d.ts

@@ -8,7 +8,7 @@ import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../../helpers/slimme
 import { VegaSelectionChipGroupSelectType } from './interface';
 import { SubStateNotifySlimmerBase } from '../../../helpers/slimmers/sub-state/sub-state-notify-slimmer-base';
 import { ChildNodesEventPreventSlimmer } from '../../../helpers/event-manager/slimmers/child-nodes-event-prevent-slimmer';
-import { FormFieldControllerSlimmer } from '../../../helpers/slimmers/form-field-controller-slimmer';
+import { FormFieldControllerSlimmer } from '../../../helpers/slimmers/form/form-field-controller-slimmer';
 import { EventEmitSlimmerBase } from '../../../helpers/event-manager/slimmers/event-emit-slimmer';
 /**
  * @vegaVersion 2.22.0
@@ -75,6 +75,14 @@ export declare class VegaSelectionChipGroup {
    * @vegaVersion 2.90.0
    */
   optional: boolean;
+  /**
+   * Specifies the name attribute used to identify the form field during data submission.
+   *   It functions identically to the `data-vega-form` attribute but operates at a lower priority.
+   *
+   * @default ''
+   * @vegaVersion 2.97.0
+   */
+  name: string;
   /**
    * Indicates if the selection chip group is disabled.
    *

package/dist/types/components/vega-selection-chip/vega-selection-chip.d.ts

@@ -12,6 +12,8 @@ import { PageResizeObserverSlimmer } from '../../helpers/slimmers/page-resize-ob
 import { EventEmitSlimmerBase } from '../../helpers/event-manager/slimmers/event-emit-slimmer';
 import { VegaSelectionChipGroupSelectType } from './vega-selection-chip-group/interface';
 /**
+ * A Selection Chip represents a selectable option within a Selection Chip Group.
+ *
  * @vegaVersion 2.22.0
  */
 export declare class VegaSelectionChip {

package/dist/types/components/vega-selection-tile/vega-selection-tile-group/vega-selection-tile-group.d.ts

@@ -5,7 +5,7 @@ import { EventEmitSlimmerBase } from '../../../helpers/event-manager/slimmers/ev
 import { ChildNodesNotifyObserverSlimmer } from '../../../helpers/event-manager/slimmers/child-nodes-notify-observer-slimmer';
 import { VegaSelectionTileGroupValueController } from './slimmers/controllers/vega-selection-tile-group-value-controller';
 import { SubStateNotifySlimmerBase } from '../../../helpers/slimmers/sub-state/sub-state-notify-slimmer-base';
-import { FormFieldControllerSlimmer } from '../../../helpers/slimmers/form-field-controller-slimmer';
+import { FormFieldControllerSlimmer } from '../../../helpers/slimmers/form/form-field-controller-slimmer';
 import { ChildNodesEventPreventSlimmer } from '../../../helpers/event-manager/slimmers/child-nodes-event-prevent-slimmer';
 import { VegaSelectionTileGroupItemsController } from './slimmers/controllers/vega-selection-tile-group-items-controller';
 import { FormFieldValidationRule } from '../../../helpers/validator/rules/form-field-validation-rule';
@@ -96,6 +96,14 @@ export declare class VegaSelectionTileGroup {
    * @vegaVersion 2.89.0
    */
   optional: boolean;
+  /**
+   * Specifies the name attribute used to identify the form field during data submission.
+   *   It functions identically to the `data-vega-form` attribute but operates at a lower priority.
+   *
+   * @default ''
+   * @vegaVersion 2.97.0
+   */
+  name: string;
   /**
    * Indicates if the selection tile group is disabled.
    *

package/dist/types/components/vega-selection-tile/vega-selection-tile.d.ts

@@ -9,6 +9,8 @@ import { ChildNodesEventPreventSlimmer } from '../../helpers/event-manager/slimm
 import { ChildNodesNotifyObserverSlimmer } from '../../helpers/event-manager/slimmers/child-nodes-notify-observer-slimmer';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
 /**
+ * A Selection Tile represents a selectable option within a Selection Tile Group.
+ *
  * @vegaVersion 2.7.0
  */
 export declare class VegaSelectionTile {

package/dist/types/components/vega-sidenav/vega-sidenav.d.ts

@@ -9,6 +9,8 @@ import { SubStateNotifySlimmerBase } from '../../helpers/slimmers/sub-state/sub-
 import { VegaSidenavOpenStatusController } from './slimmers/controllers/vega-sidenav-open-status-controller';
 import { EventEmitSlimmerBase } from '../../helpers/event-manager/slimmers/event-emit-slimmer';
 /**
+ * The Sidebar Navigation component displays a hierarchical navigation structure.
+ *
  * @deprecated This component will be removed soon, please consider using `vega-left-nav` component instead.
  * @vegaVersion 1, v2.29.0
  */

package/dist/types/components/vega-signature-capture/vega-signature-capture.d.ts

@@ -6,13 +6,15 @@ import { WrittenModeRenderer } from './slimmers/written-mode/renderers/written-m
 import { VegaSignatureCaptureMode, VegaSignatureValue } from './types';
 import { WrittenModeSvgController } from './slimmers/written-mode/controllers/written-mode-svg-controller';
 import { EventEmitSlimmerBase } from '../../helpers/event-manager/slimmers/event-emit-slimmer';
-import { FormFieldControllerSlimmer } from '../../helpers/slimmers/form-field-controller-slimmer';
+import { FormFieldControllerSlimmer } from '../../helpers/slimmers/form/form-field-controller-slimmer';
 import { FormFieldValidationRule } from '../../helpers/validator/rules/form-field-validation-rule';
 import { HeightType, ResponsiveType } from '../../types/ui.type';
 import { PageResizeObserverSlimmer } from '../../helpers/slimmers/page-resize-observer-slimmer';
 import { BreakpointsTokenType } from '../../types/design-token.type';
 import { TranslationSlimmer } from '../../helpers/slimmers/translation';
 /**
+ * This component displays an area for users to draw their signature, emulating a signature captured on paper.
+ *
  * @vegaVersion 2.19.0
  */
 export declare class VegaSignatureCapture {
@@ -62,6 +64,14 @@ export declare class VegaSignatureCapture {
    * @vegaVersion 2.89.0
    */
   optional: boolean;
+  /**
+   * Specifies the name attribute used to identify the form field during data submission.
+   *   It functions identically to the `data-vega-form` attribute but operates at a lower priority.
+   *
+   * @default ''
+   * @vegaVersion 2.97.0
+   */
+  name: string;
   /**
    * Determines whether the clear button is displayed.
    *

package/dist/types/components/vega-skeleton/vega-skeleton.d.ts

@@ -10,6 +10,8 @@ import { VegaSkeletonEllipseRenderer } from './slimmers/renderers/vega-skeleton-
 import { CornersType, HeightType, WidthType } from '../../types/ui.type';
 import { VegaSkeletonType } from './interface';
 /**
+ * A Skeleton component is used to create placeholders representing content on a page.
+ *
  * @vegaVersion 2.15.0
  */
 export declare class VegaSkeleton {

package/dist/types/components/vega-stepper/vega-stepper.d.ts

@@ -1,10 +1,12 @@
 import { EventEmitter } from '../../stencil-public-runtime';
 import { GlobalSlimmers } from '../../vega-slimmer/vega-slimmer-core';
-import { FormFieldControllerSlimmer } from '../../helpers/slimmers/form-field-controller-slimmer';
+import { FormFieldControllerSlimmer } from '../../helpers/slimmers/form/form-field-controller-slimmer';
 import { ChildNodesEventPreventSlimmer } from '../../helpers/event-manager/slimmers/child-nodes-event-prevent-slimmer';
 import { EventEmitSlimmerBase } from '../../helpers/event-manager/slimmers/event-emit-slimmer';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
 /**
+ * The Stepper component allows users to modify a numerical value either by text input or with increment and decrement buttons.
+ *
  * @vegaVersion 1.0.5
  */
 export declare class VegaStepper {
@@ -81,6 +83,14 @@ export declare class VegaStepper {
    * @vegaVersion 1.18.0
    */
   autoValidation: boolean;
+  /**
+   * Specifies the name attribute used to identify the form field during data submission.
+   *   It functions identically to the `data-vega-form` attribute but operates at a lower priority.
+   *
+   * @default ''
+   * @vegaVersion 2.97.0
+   */
+  name: string;
   /**
    * Specifies the style variant for the stepper buttons.
    *

package/dist/types/components/vega-tab-group/vega-tab-group.d.ts

@@ -17,6 +17,8 @@ import { ChildNodesEventPreventSlimmer } from '../../helpers/event-manager/slimm
 import { EventEmitSlimmerBase } from '../../helpers/event-manager/slimmers/event-emit-slimmer';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
 /**
+ * The Tab Group component organizes content into separate views, and allows users to switch between them without navigating away from the parent page.
+ *
  * @vegaVersion 1.0.6
  */
 export declare class VegaTabGroup {

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

@@ -2,15 +2,15 @@ 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.
+ * with data source and template-derived column configuration.
  *
  * 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'];
+  templateGroupColumns: VegaTable['templateGroupColumns'];
   columnStructureModel: VegaTable['columnStructureModel'];
   /**
    * Component lifecycle hook mapped to the host's componentWillLoad.
@@ -28,8 +28,12 @@ export declare class VegaTableColumnStructureModelController extends VegaSlimmer
    */
   watchGroupColumns(): void;
   /**
-   * Build and assign the ColumnStructureModel from current `columns` and `groupColumns`.
-   * Uses `ColumnStructureModel.from` which returns a root model representing the column tree.
+   * Rebuilds the ColumnStructureModel when template-derived grouping changes.
+   */
+  watchTemplateGroupColumns(): void;
+  /**
+   * Build and assign the ColumnStructureModel from current inputs.
+   * Template-derived grouping takes precedence over the public `groupColumns` input.
    */
   private setColumnStructureModel;
 }

package/dist/types/components/vega-table/slimmers/controllers/vega-table-head-template-structure-controller.d.ts

@@ -0,0 +1,168 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { MutationObserverSlimmer } from '../../../../helpers/slimmers/mutation-observer/mutation-observer-slimmer';
+import { VegaTable } from '../../vega-table';
+/**
+ * Derives column configuration from the authored `<vega-table-head>` markup.
+ *
+ * Currently produces grouped-column configuration; header-declared column concerns
+ * (e.g. pinning) are intended to live here as well.
+ */
+export declare class VegaTableHeadTemplateStructureController extends VegaSlimmer {
+  host: VegaTable['host'];
+  isTemplateRenderMode: VegaTable['isTemplateRenderMode'];
+  templateGroupColumns: VegaTable['templateGroupColumns'];
+  vegaTableRenderInputController: VegaTable['vegaTableRenderInputController'];
+  protected templateHeadObserver: MutationObserverSlimmer;
+  private templateHeadStructureObserver;
+  private observedTemplateHead;
+  private lastTemplateHeadStructureSnapshot;
+  /**
+   * Refresh template grouping before the mutation observer resumes after reconnecting.
+   */
+  connectedCallback(): void;
+  /**
+   * Used by {@link templateHeadObserver} to stop observing while the table is disconnected.
+   */
+  disconnectedCallback(): void;
+  /**
+   * Initialize template grouping before the column structure is built.
+   */
+  componentWillLoad(): void;
+  /**
+   * Used by {@link templateHeadObserver}.
+   */
+  componentDidLoad(): void;
+  /**
+   * Rebuild template grouping when render mode changes.
+   */
+  watchTemplateRenderMode(): void;
+  /**
+   * Update the internal template grouping configuration.
+   */
+  private setTemplateGroupColumns;
+  /**
+   * Recompute template grouping and row/cell render-input mappings after template head changes.
+   *
+   * Map registration is done here directly instead of via watchColumnStructureModel because
+   * this controller is registered before the render-input controller. If map registration
+   * were deferred to the columnStructureModel watcher, render inputs would still be stale
+   * (render-input controller's watcher hasn't fired yet due to slimmer registration order).
+   */
+  private handleTemplateHeadStructureChange;
+  /**
+   * Collect a normalized snapshot for template-head hierarchy keys.
+   *
+   * This lets us ignore duplicated observer notifications that represent the same logical
+   * structure (e.g. reflected-attribute path and explicit watcher path firing for one update).
+   *
+   * @returns {Nullable<TemplateHeadStructureCell[]>} Snapshot of current template head structure.
+   */
+  private getTemplateHeadStructureSnapshot;
+  /**
+   * Compare two structure snapshots by authored order and key values.
+   *
+   * @param {Nullable<TemplateHeadStructureCell[]>} nextSnapshot - Latest snapshot.
+   * @param {Nullable<TemplateHeadStructureCell[]>} prevSnapshot - Previous snapshot.
+   * @returns {boolean} True when snapshots represent the same logical structure.
+   */
+  private isSameTemplateHeadStructure;
+  /**
+   * Register explicit head-cell structure-change observer for property-assignment updates.
+   */
+  private registerTemplateHeadStructureObserver;
+  /**
+   * Unregister explicit head-cell structure-change observer.
+   */
+  private unRegisterTemplateHeadStructureObserver;
+  /**
+   * Find authored template head element under table host.
+   *
+   * @typedef {import('../../../../types/components').HTMLVegaTableHeadElement} HTMLVegaTableHeadElement
+   * @returns {Nullable<HTMLVegaTableHeadElement>} Template head element if present.
+   */
+  private getTemplateHead;
+  /**
+   * Register template head rows/cells with render-input maps using authored position.
+   *
+   * This mirrors data-source mode, where header renderer registers maps during JSX ref callbacks.
+   * Runtime changes are notified after the column model rebuilds, keeping maps ready without a
+   * second notification for the same template mutation.
+   */
+  private registerTemplateHeadMaps;
+  /**
+   * Convert a hand-authored template head into the public grouped-column model.
+   *
+   * Grouping needs authored keys: every cell must have a unique `groupKey`, and cells below the
+   * first row must declare `parentGroupKey` pointing to a cell in the immediately preceding row.
+   * Pinning, in contrast, is purely positional, so a header without group keys that only declares edge
+   * `pinned` is handled by {@link getFlatPinnedColumns} instead of being treated as unkeyed.
+   * Group labels are derived from cell text and default to an empty string because template
+   * markup remains responsible for the visible content.
+   *
+   * @returns {Nullable<VegaTableGroupColumnConfig[]>} Derived grouping configuration; null for a
+   * header without group keys with no edge pinning, or an empty array for malformed structured markup.
+   */
+  private getTemplateGroupColumns;
+  /**
+   * Derive flat, position-keyed leaf columns for a header without group keys whose only column concern is
+   * edge pinning. Grouping requires authored keys, but pinning is positional, so a single-row
+   * header that declares `pinned` without any `group-key` still yields pinned leaf columns.
+   *
+   * Returns null when the header spans multiple rows (grouping cannot be inferred without keys) or
+   * declares no honorable edge pin, preserving the legacy behavior where a plain header without group keys
+   * derives no column model and simply renders its authored cells.
+   *
+   * @param {TemplateColumnNode[]} nodes - Template nodes in authored order (all row 0 when valid).
+   * @returns {Nullable<VegaTableGroupColumnConfig[]>} Position-keyed leaf configs, or null.
+   */
+  private getFlatPinnedColumns;
+  /**
+   * Drop `pinned` from top-level cells that are not at the physical edge.
+   *
+   * Data-source mode reorders columns to `[left, none, right]` via `orderChildrenByPinned`, so any
+   * pinned column ends up at an edge. Template mode renders authored cells in place and never
+   * reorders them, and sticky pinning only works when the pinned column already sits at the edge.
+   * So we honor `pinned` only for a contiguous leading run (left) and trailing run (right) of the
+   * authored top-level cells; a pinned cell anywhere in between would freeze mid-table and let the
+   * columns authored before it scroll underneath, so its pin is ignored.
+   *
+   * @param {TemplateColumnNode[]} topLevelNodes - Row-0 nodes in authored (physical) order.
+   */
+  private dropNonEdgePinned;
+  /**
+   * Flatten the authored template head rows into row-major template nodes.
+   *
+   * @param {HTMLElement} templateHead - Authored `<vega-table-head>` element.
+   * @returns {TemplateColumnNode[]} Template nodes in authored order.
+   */
+  private collectTemplateNodes;
+  /**
+   * Validate parent references and link each node to its parent in place.
+   *
+   * Children must reference a cell in the immediately preceding row, be grouped by parent, and
+   * list parents left-to-right; first-row cells must not declare a parent.
+   *
+   * @param {TemplateColumnNode[]} nodes - Template nodes in authored order.
+   * @param {Map<string, TemplateColumnNode>} nodesByKey - Node lookup by group key.
+   * @returns {boolean} True when the hierarchy is well-formed.
+   */
+  private linkTemplateNodes;
+  /**
+   * Convert a template node tree into a grouped-column configuration.
+   *
+   * @param {TemplateColumnNode} node - Template node to convert.
+   * @returns {VegaTableGroupColumnConfig} Group or leaf configuration.
+   */
+  private toGroupColumnConfig;
+  /**
+   * Read a reflected template-cell property with an attribute fallback.
+   *
+   * The `pinned` variant returns only valid pinning values; invalid values return undefined.
+   *
+   * @param {HTMLElement} cell - Template head cell.
+   * @param {'groupKey' | 'parentGroupKey' | 'pinned'} property - Component property name.
+   * @param {'group-key' | 'parent-group-key' | 'pinned'} attribute - Reflected attribute name.
+   * @returns {string | undefined} Normalized property value.
+   */
+  private getCellProperty;
+}

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

@@ -13,7 +13,6 @@ import { ColumnRenderInputModel } from './dto/column-render-input-model';
 export declare class VegaTableRenderInputController extends VegaSlimmer {
   host: VegaTable['host'];
   columnStructureModel: VegaTable['columnStructureModel'];
-  vegaTableColGroupRenderer: VegaTable['vegaTableColGroupRenderer'];
   private columnRenderInputModels;
   private leavesRenderInputModels;
   private headRowRenderInputMap;
@@ -72,6 +71,14 @@ export declare class VegaTableRenderInputController extends VegaSlimmer {
    * @param {ColumnRenderInputModel} renderInput - Associated render input model.
    */
   addHeadCellRenderInputMap(headCell: HTMLVegaTableHeadCellElement, renderInput: ColumnRenderInputModel): void;
+  /**
+   * Clear all head row and head cell render-input mappings.
+   *
+   * Used by template-mode lifecycle to invalidate stale grouped-header metadata
+   * before re-registering current mappings. In data-source mode the header renderer
+   * re-registers via ref callbacks each render, so stale entries are overwritten naturally.
+   */
+  clearHeadRenderInputMaps(): void;
   /**
    * Store body cell render input mapping for pinned cells (used to update sticky positions).
    *

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

@@ -5,20 +5,96 @@ 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>;
   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 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 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;

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

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

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

@@ -0,0 +1,12 @@
+import { VegaSlimmer } from '../../../../../vega-slimmer/vega-slimmer-core';
+import { VegaTableHeadCell } from '../../vega-table-head-cell';
+/**
+ * Controller for head-cell template structure notifications.
+ */
+export declare class VegaTableHeadCellTemplateStructureController extends VegaSlimmer {
+  host: VegaTableHeadCell['host'];
+  /**
+   * Notify table template-structure observers when template group keys are updated.
+   */
+  notifyTemplateHeadStructureChange(): void;
+}

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

@@ -10,6 +10,7 @@ import { PageResizeObserverSlimmer } from '../../../helpers/slimmers/page-resize
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../../helpers/slimmers/component-usage-runtime-metrics';
 import { SortIconRenderer } from './slimmers/renderers/sort-icon-renderer';
 import { VegaTableHeadCellSortConfigController } from './slimmers/controllers/vega-table-head-cell-sort-config-controller';
+import { VegaTableHeadCellTemplateStructureController } from './slimmers/controllers/vega-table-head-cell-template-structure-controller';
 import { ColumnRenderInputModel } from '../slimmers/controllers/dto/column-render-input-model';
 import { VegaTableChildRenderInputConsumerSlimmer } from '../../../helpers/slimmers/vega-table-child-render-input-consumer-slimmer';
 /**
@@ -23,6 +24,7 @@ export declare class VegaTableHeadCell {
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaTableHeadCellElement>;
   protected sortIconRenderer: SortIconRenderer;
   protected readonly vegaTableHeadCellSortConfigController: VegaTableHeadCellSortConfigController;
+  protected readonly vegaTableHeadCellTemplateStructureController: VegaTableHeadCellTemplateStructureController;
   protected readonly vegaTableRenderInputConsumerSlimmer: VegaTableChildRenderInputConsumerSlimmer;
   host: HTMLVegaTableHeadCellElement;
   currentBreakpoint: BreakpointsTokenType;
@@ -75,6 +77,23 @@ export declare class VegaTableHeadCell {
    * @vegaVersion 2.57.0
    */
   pinned?: VegaTablePinnedType;
+  watchPinned(): void;
+  /**
+   * Explicit header-node key binding for mapping template head cells to grouped header nodes.
+   * The key may point to either a group node or a leaf node from the computed grouped header tree.
+   *
+   * @vegaVersion 2.98.0
+   */
+  groupKey?: string;
+  watchGroupKey(): void;
+  /**
+   * Parent header-node key used to derive grouped hierarchy in template render mode.
+   * Omit this property for cells in the first header row.
+   *
+   * @vegaVersion 2.98.0
+   */
+  parentGroupKey?: string;
+  watchParentGroupKey(): void;
   /**
    * An event emitter notifying that the head cell has been clicked.
    *

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

@@ -34,13 +34,17 @@ import { ColumnStructureModel } from './slimmers/controllers/dto/column-structur
 import { VegaTableRenderInputController } from './slimmers/controllers/vega-table-render-input-controller';
 import { VegaTablePinnedRenderer } from './slimmers/renderers/vega-table-pinned-renderer';
 import { VegaTableRowDraggableController } from './slimmers/controllers/vega-table-row-draggable-controller';
+import { VegaTableHeadTemplateStructureController } from './slimmers/controllers/vega-table-head-template-structure-controller';
 /**
+ * A Table component presents structured data in rows and columns for easy comparison, manipulation, and display of information.
+ *
  * @vegaVersion 1.3.0
  */
 export declare class VegaTable {
   protected readonly globalSlimmers: GlobalSlimmers;
   protected translationSlimmer: TranslationSlimmer<HTMLVegaTableElement>;
   protected readonly vegaTableRenderModeController: VegaTableRenderModeController;
+  protected readonly vegaTableHeadTemplateStructureController: VegaTableHeadTemplateStructureController;
   protected readonly vegaTableColumnStructureModelController: VegaTableColumnStructureModelController;
   protected readonly vegaTableRenderInputController: VegaTableRenderInputController;
   protected readonly vegaTablePinnedRenderer: VegaTablePinnedRenderer;
@@ -120,6 +124,8 @@ export declare class VegaTable {
    */
   isTemplateRenderMode: boolean;
   watchTemplateRenderMode(): void;
+  templateGroupColumns: VegaTableGroupColumnConfig[] | null;
+  watchTemplateGroupColumns(): void;
   columnStructureModel: ColumnStructureModel;
   watchColumnStructureModel(): void;
   expandableRows: string[];

package/dist/types/components/vega-textarea/vega-textarea.d.ts

@@ -1,13 +1,15 @@
 import { EventEmitter } from '../../stencil-public-runtime';
 import { FormFieldValidationRule } from '../../helpers/validator/rules/form-field-validation-rule';
 import { GlobalSlimmers } from '../../vega-slimmer/vega-slimmer-core';
-import { FormFieldControllerSlimmer } from '../../helpers/slimmers/form-field-controller-slimmer';
+import { FormFieldControllerSlimmer } from '../../helpers/slimmers/form/form-field-controller-slimmer';
 import { EventEmitSlimmerBase } from '../../helpers/event-manager/slimmers/event-emit-slimmer';
 import { ChildNodesEventPreventSlimmer } from '../../helpers/event-manager/slimmers/child-nodes-event-prevent-slimmer';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
 import { LabelSuffixButtonConfig } from '../vega-field-label/types';
 import { Nullable } from '../../types/general';
 /**
+ * A Text Area component allows users to enter multiple lines of plain text content.
+ *
  * @vegaVersion 1.11.0
  */
 export declare class VegaTextarea {
@@ -178,6 +180,14 @@ export declare class VegaTextarea {
    * @vegaVersion 2.88.0
    */
   optional: boolean;
+  /**
+   * Specifies the name attribute used to identify the form field during data submission.
+   *   It functions identically to the `data-vega-form` attribute but operates at a lower priority.
+   *
+   * @default ''
+   * @vegaVersion 2.97.0
+   */
+  name: string;
   /**
    * Determines whether the user can vertically resize the text area by
    * dragging its bottom-right corner. When `false`, the resize handle is

package/dist/types/components/vega-time-picker/vega-time-picker.d.ts

@@ -2,7 +2,7 @@ import { EventEmitter } from '../../stencil-public-runtime';
 import { TimeFormat } from '../../types/general';
 import { FormFieldValidationRule } from '../../helpers/validator/rules/form-field-validation-rule';
 import { GlobalSlimmers } from '../../vega-slimmer/vega-slimmer-core';
-import { FormFieldControllerSlimmer } from '../../helpers/slimmers/form-field-controller-slimmer';
+import { FormFieldControllerSlimmer } from '../../helpers/slimmers/form/form-field-controller-slimmer';
 import { VegaTimePickerLabelRenderer } from './slimmers/renderers/vega-time-picker-label-renderer';
 import { VegaTimePickerSingleInputRenderer } from './slimmers/renderers/vega-time-picker-single-input-renderer';
 import { TimePickerDropdownSource, TimePickerModeType, TimePickerValueType, TimeValue, VegaDropdownPropsForTimePicker } from './types';
@@ -21,6 +21,8 @@ import { EventEmitSlimmerBase } from '../../helpers/event-manager/slimmers/event
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
 import { TranslationSlimmer } from '../../helpers/slimmers/translation';
 /**
+ * The Time Picker allows users to select a specific time, either by entering a text value or from a list of available values.
+ *
  * @vegaVersion 1.12.0
  */
 export declare class VegaTimePicker {
@@ -94,6 +96,14 @@ export declare class VegaTimePicker {
    * @vegaVersion 2.89.0
    */
   optional: boolean;
+  /**
+   * Specifies the name attribute used to identify the form field during data submission.
+   *   It functions identically to the `data-vega-form` attribute but operates at a lower priority.
+   *
+   * @default ''
+   * @vegaVersion 2.97.0
+   */
+  name: string;
   /**
    * Specifies placeholder strings that provide a temporary hint
    *    or example inside the time input field.