@globalpayments/vega 2.60.0 → 2.62.0

package/dist/types/components/vega-rich-text-editor/extensions/tokens/token-node.d.ts

@@ -0,0 +1,39 @@
+import { RTETextBlock } from '../../dto/blocks/text-block';
+import { RTETextNode } from '../../dto/nodes/text-node';
+import { RTENodeAnnotationMapKey, RTENodeAnnotationMapValue, VegaRTETokenNode } from '../../interface';
+/**
+ * Token node for the Vega Rich Text Editor.
+ */
+export declare class RTETokenNode extends RTETextNode {
+  type: string;
+  token: string;
+  constructor(id: string, token: string, text: string, parentBlock: RTETextBlock, annotations?: Map<RTENodeAnnotationMapKey, RTENodeAnnotationMapValue>);
+  /**
+   * @inheritDoc
+   */
+  static from(value: VegaRTETokenNode, parent: RTETextBlock): RTETokenNode;
+  /**
+   * Converts the token node to a JSON representation.
+   *
+   * @returns {VegaRTETokenNode} - The JSON representation of the token node.
+   */
+  toJSON(): VegaRTETokenNode;
+  /**
+   * Determines if the token node is content editable.
+   *
+   * @returns {boolean} - Always returns false for token nodes.
+   */
+  isContentEditable(): boolean;
+  /**
+   * Clones the token node.
+   *
+   * @returns {RTETokenNode} - The cloned token node.
+   */
+  clone(): RTETokenNode;
+  /**
+   * Converts the token node to an HTML representation.
+   *
+   * @returns {string} - The HTML representation of the token node.
+   */
+  toHtml(): string;
+}

package/dist/types/components/vega-rich-text-editor/extensions/tokens/token-toolbar-button-renderer.d.ts

@@ -0,0 +1,47 @@
+import { RTEExtensionContext, VegaRTECreateElementFunction, VegaRTEToolbarRenderContext, VegaRTERenderResult, RTEDropdownListItem } from '../../interface';
+import { VegaRTEToolbarButtonRenderer } from '../base-toolbar-button-renderer';
+/**
+ * Renderer for the token toolbar button in the Vega Rich Text Editor.
+ */
+export declare class RTETokenToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+  private tokenList;
+  private extensionContext;
+  constructor(tokenList: RTEDropdownListItem[]);
+  /**
+   * Sets the RTE extension context.
+   *
+   * @param {RTEExtensionContext} context - The context of the RTE extension.
+   */
+  injectExtensionContext(context: RTEExtensionContext): void;
+  /**
+   * Renders the token toolbar button.
+   *
+   * @param {VegaRTECreateElementFunction} createElement Function to create elements in the rich text editor.
+   * @param {VegaRTEToolbarRenderContext} editorContext The render context for the editor.
+   * @returns {VegaRTERenderResult} Token toolbar button.
+   */
+  render(createElement: VegaRTECreateElementFunction, editorContext: VegaRTEToolbarRenderContext): VegaRTERenderResult;
+  /**
+   * Checks if the token toolbar button is disabled.
+   *
+   * @returns {boolean} True if the button is disabled, false otherwise.
+   */
+  protected isDisabled(): boolean;
+  /**
+   * Handles the button click event. No need this method for token button.
+   *
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   */
+  protected handleButtonClick(editorContext: VegaRTEToolbarRenderContext): void;
+  /**
+   * Handles the token item click event from the dropdown.
+   *
+   * @param {string} itemKey - The key of the clicked token item.
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   */
+  protected handleDropdownClick(itemKey: string, editorContext: VegaRTEToolbarRenderContext): void;
+  /**
+   * Refreshes the editor UI.
+   */
+  private flushEditorUI;
+}

package/dist/types/components/vega-rich-text-editor/interface.d.ts

@@ -18,6 +18,7 @@ import { RTEHtmlBlock } from './dto/blocks/html-block';
 import { InlineHtmlAnnotation } from './dto/annotations/inline-html-annotation';
 import type { RTERange } from './dto/range';
 import type { RTENode } from './dto/nodes/node.abstract';
+import type { VegaRTEContent } from './dto/content-state';
 
 export type ToolbarButtonConfig = {
 	icon: string;
@@ -302,7 +303,7 @@ export type VegaRTECreateElementFunction = <
 	children?: VegaRTERenderNode | VegaRTERenderNode[],
 ) => VegaRTERenderResult;
 
-export type VegaRTEExtensionContext = {
+export type VegaRTEToolbarRenderContext = {
 	host: HTMLVegaRichTextEditorElement;
 	rteRange: RTERange;
 	sourceEditMode: boolean;
@@ -320,3 +321,53 @@ export type FocusNodeRangeState = {
 	startNode: RTENode;
 	startOffset: number;
 };
+
+export type RTEExtensionContext = {
+	host: HTMLVegaRichTextEditorElement;
+	/**
+	 * Check if the editor is in source edit mode.
+	 *
+	 * @returns {boolean} - Whether the editor is in source edit mode.
+	 */
+	isSourceEditMode: () => boolean;
+	/**
+	 * Get the currently selected nodes in the editor.
+	 *
+	 * @returns {RTENode[]} - An array of currently selected RTENode objects.
+	 */
+	getSelectedNodes: () => RTENode[];
+	/**
+	 * Flush the editor value to the host. Auto focus the last node if autoFocusLastNode is true.
+	 * Sometimes, the editor will lose focus after change the editor value, so we need to focus the last node again.
+	 * Or apply the update cursor position action to focus the cursor to the specified position.
+	 *
+	 * @example flushValue(newValue, true);
+	 * @example flushValue(newValue); host.value.apply(new UpdateCursorPositionAction(node, offset));
+	 * @param {VegaRTEContent} value - The content value to flush.
+	 * @param {boolean} autoFocusLastNode - Whether to auto-focus the last node after flushing.
+	 */
+	flushValue: (value: VegaRTEContent, autoFocusLastNode?: boolean) => void;
+};
+
+export type RTEToolbarButtonProps = {
+	icon?: string;
+	label?: string;
+	showArrowIcon?: boolean;
+};
+
+export type RTEDropdownListItem = { key: string; label: string; icon?: string };
+
+export type RTEToolbarDropdownProps = {
+	source?: RTEDropdownListItem[];
+	selectType?: 'none' | 'single';
+	selectedSourceKey?: string;
+	maxHeight?: number;
+	alignment?: 'start' | 'center' | 'end';
+};
+
+export type RTELanguageContentMap = Record<string, VegaRTEContent | VegaRTEContentBlock[] | undefined>;
+
+export type RTELanguageExtensionState = {
+	selectedLanguage: string;
+	contentMap: RTELanguageContentMap;
+};

package/dist/types/components/vega-rich-text-editor/public-api.d.ts

@@ -0,0 +1,29 @@
+export { VegaRTEContent } from './dto/content-state';
+export { RTENode } from './dto/nodes/node.abstract';
+export { RTEDecoratorNode } from './dto/nodes/decorator-node';
+export { RTETextNode } from './dto/nodes/text-node';
+export { RTETextBlock } from './dto/blocks/text-block';
+export { RTEBlock } from './dto/blocks/block.abstract';
+export { VegaRTEExtension } from './extensions/extension.abstract';
+export { VegaRTEExtensionRenderer } from './extensions/base-extension-renderer';
+export { VegaRTEToolbarButtonRenderer } from './extensions/base-toolbar-button-renderer';
+export { RTETokenToolbarButtonRenderer } from './extensions/tokens/token-toolbar-button-renderer';
+export { RTETokenNode } from './extensions/tokens/token-node';
+export { RTETokenNodeRenderer } from './extensions/tokens/token-node-renderer';
+export { VegaRTETokenExtension } from './extensions/tokens/token-extension';
+export { RTELanguageToolbarButtonRenderer } from './extensions/languages/language-toolbar-button-renderer';
+export { VegaRTELanguageExtension } from './extensions/languages/language-extension';
+export { ModifyContentAction } from './dto/actions/modify-content-action.abstract';
+export { AppendChildrenAction } from './dto/actions/append-child-nodes-action';
+export { RemoveChildrenAction } from './dto/actions/remove-child-action';
+export { InsertChildrenAfterAction } from './dto/actions/insert-children-after-block';
+export { InsertChildrenBeforeAction } from './dto/actions/insert-children-before-block';
+export { InsertNodeToNearestRootAction } from './dto/actions/insert-node-to-nearest-root-action';
+export { UpdateCursorPositionAction } from './dto/actions/update-cursor-position-action';
+export { CustomAttributeAnnotation } from './dto/annotations/custom-attribute-annotation';
+export { CustomClassAnnotation } from './dto/annotations/custom-class-annotation';
+export { CustomStyleAnnotation } from './dto/annotations/custom-style-annotation';
+export { ActionHandleStrategy } from './dto/action-handle-strategies/action-handle-strategy.abstract';
+export { RTERange } from './dto/range';
+export { ElementToDTOStrategy } from './slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy.abstract';
+export { VegaRTEPresetToolbarItems } from './constants/constant';

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/extension-controller.d.ts

@@ -0,0 +1,44 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaRichTextEditor } from '../../vega-rich-text-editor';
+import { VegaRTEExtension } from '../../extensions/extension.abstract';
+/**
+ * Inject the editor context to the extensions.
+ */
+export declare class RTEExtensionController extends VegaSlimmer {
+  protected extensions: VegaRichTextEditor['extensions'];
+  protected host: HTMLVegaRichTextEditorElement;
+  protected sourceView: VegaRichTextEditor['sourceView'];
+  protected valueController: VegaRichTextEditor['valueController'];
+  protected selectionController: VegaRichTextEditor['selectionController'];
+  /**
+   * Initializes the extension context for all registered extensions.
+   * This method is called when the component is connected and whenever the extensions property changes.
+   */
+  protected initialExtensionContext(): void;
+  /**
+   * Update extension context when extensions property changes.
+   *
+   * @param {VegaRTEExtension[]} newValue - New extensions array.
+   * @param {VegaRTEExtension[]} oldValue - Old extensions array.
+   */
+  protected handleExtensionsChange(newValue: VegaRTEExtension[], oldValue: VegaRTEExtension[]): void;
+  /**
+   * Flush the editor value to the host. Auto focus the last node if autoFocusLastNode is true.
+   *
+   * @param {VegaRTEContent} value - The content value to flush.
+   * @param {boolean} autoFocusLastNode - Whether to auto-focus the last node after flushing.
+   */
+  private flushValue;
+  /**
+   * Check if the editor is in source edit mode.
+   *
+   * @returns {boolean} - Whether the editor is in source edit mode.
+   */
+  private isSourceEditMode;
+  /**
+   * Get the currently selected nodes in the editor.
+   *
+   * @returns {RTENode[]} - An array of currently selected RTENode objects.
+   */
+  private getSelectedNodes;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy.abstract.d.ts

@@ -1,10 +1,19 @@
 import { Nullable } from '../../../../../../types/general';
-import { RTEContentBlock, VegaRTECustomNode, VegaRTETextAnnotations, VegaRTETransformOptions } from '../../../../interface';
+import { RTEContentBlock, VegaRTEAnnotations, VegaRTECustomNode, VegaRTETextAnnotations, VegaRTETransformOptions } from '../../../../interface';
 import { RTEBlock } from '../../../../dto/blocks/block.abstract';
+import { HtmlElementToAnnotationGenerateOptions } from './annotation-handler/html-element-to-annotation-generator';
 /**
  * Abstract class to define strategies for processing HTML elements
  */
 export declare abstract class ElementToDTOStrategy {
+  /**
+   * Convert element style attributes to text annotations.
+   *
+   * @param {HTMLElement} element - Current html element.
+   * @param {HtmlElementToAnnotationGenerateOptions} options - Options for generating annotations.
+   * @returns {VegaRTEAnnotations} - Generated annotations.
+   */
+  protected generateTextStyleAnnotations(element: HTMLElement, options?: HtmlElementToAnnotationGenerateOptions): VegaRTEAnnotations;
   abstract canHandle(elementsArray: HTMLElement[], currentIndex: number, options: VegaRTETransformOptions): number;
   abstract handle(elementsArray: HTMLElement[], options?: VegaRTETransformOptions, parentTextAnnotations?: VegaRTETextAnnotations): Nullable<RTEBlock | VegaRTECustomNode>;
   abstract appendChildBlocks(currentBlock: RTEContentBlock, childBlocks: RTEContentBlock[]): void;

package/dist/types/components/vega-rich-text-editor/slimmers/renderers/toolbar-renderer.d.ts

@@ -25,4 +25,10 @@ export declare class ToolbarRenderer extends VegaSlimmer {
   render(): HTMLElement;
   private getToolbarBtnRenderer;
   private renderVegaDivider;
+  /**
+   * Renders the toolbar items based on the configured toolbar groups and items.
+   *
+   * @returns {[HTMLElement[], number]} A tuple containing the rendered toolbar items and the count of displayed items.
+   */
+  private renderToolbarItems;
 }

package/dist/types/components/vega-rich-text-editor/slimmers/renderers/tools/toolbar-button-slimmer.abstract.d.ts

@@ -16,6 +16,10 @@ export declare abstract class ToolbarButtonSlimmer extends VegaSlimmer {
   private readonly autoFocusOnClick;
   protected constructor({ icon, tooltip, autoFocusOnClick }: ToolbarButtonConfig);
   setIcon(icon: string): void;
+  /**
+   * Whether the button is hidden or not.
+   */
+  isHidden(): boolean;
   render(): HTMLElement;
   /**
    * The wrapper for the button.
@@ -36,10 +40,6 @@ export declare abstract class ToolbarButtonSlimmer extends VegaSlimmer {
    * Whether the button is disabled or not.
    */
   protected isDisabled(): boolean;
-  /**
-   * Whether the button is hidden or not.
-   */
-  protected isHidden(): boolean;
   protected preventLostFocus(): {
     onMouseDown: (e: Event) => void;
   };

package/dist/types/components/vega-rich-text-editor/slimmers/renderers/tools/visual-mode-toolbar-button-slimmer.abstract.d.ts

@@ -7,6 +7,13 @@ import { VegaRichTextEditor } from '../../../vega-rich-text-editor';
 export declare abstract class VisualModeToolbarButtonSlimmer extends ToolbarButtonSlimmer {
   protected readonly sourceView: VegaRichTextEditor['sourceView'];
   protected constructor(config: ToolbarButtonConfig);
+  /**
+   * Determines if the button should be hidden.
+   * Hide the button when the editor is in source view mode, except for the source edit button.
+   *
+   * @returns {boolean} - True if the button is hidden, false otherwise.
+   */
+  isHidden(): boolean;
   /**
    * Determines if the button should be disabled.
    * Determines whether should disable the button or not when the editor is not in source view mode, except for the source edit button.
@@ -14,11 +21,4 @@ export declare abstract class VisualModeToolbarButtonSlimmer extends ToolbarButt
    * @returns {boolean} - True if the button is disabled, false otherwise.
    */
   protected isDisabled(): boolean;
-  /**
-   * Determines if the button should be hidden.
-   * Hide the button when the editor is in source view mode, except for the source edit button.
-   *
-   * @returns {boolean} - True if the button is hidden, false otherwise.
-   */
-  protected isHidden(): boolean;
 }

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

@@ -42,6 +42,8 @@ import { HistoryController } from './slimmers/controllers/history-controller';
 import { CodeBlockToolbarButtonSlimmer } from './slimmers/renderers/tools/code-block-toolbar-button-slimmer';
 import { InternalCodeBlockSelectionController } from './slimmers/controllers/internal-code-block-selection-controller';
 import { SourceEditToolbarButtonSlimmer } from './slimmers/renderers/tools/source-edit-toolbar-button-slimmer';
+import { VegaRTEExtension } from './extensions/extension.abstract';
+import { RTEExtensionController } from './slimmers/controllers/extension-controller';
 /**
  * @vegaVersion 2.34.0
  */
@@ -85,6 +87,7 @@ export declare class VegaRichTextEditor {
   protected readonly deleteSelectedNodesController: DeleteSelectedNodesController;
   protected readonly historyController: HistoryController;
   protected readonly internalCodeBlockSelectionController: InternalCodeBlockSelectionController;
+  protected readonly rteExtensionController: RTEExtensionController;
   host: HTMLVegaRichTextEditorElement;
   richTextContentEditable: boolean;
   watchRichTextContentEditable(): void;
@@ -186,6 +189,13 @@ export declare class VegaRichTextEditor {
    */
   validationRules: FormFieldValidationRule<unknown>[];
   watchValidationRules(): void;
+  /**
+   * Specifies the configuration for the rich text editor extensions.
+   *
+   * @vegaVersion 2.62.0
+   */
+  extensions: VegaRTEExtension[];
+  watchExtensions(): void;
   /**
    * An event emitter notifying a value change.
    *

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

@@ -185,6 +185,7 @@ export declare type VegaTableRowProps = {
   rowKey: string;
   index: number;
   record: VegaTableDataSourceItem;
+  isLastRow: boolean;
   isVisibleInCurrentPage?: boolean;
 };
 export declare type VegaTableEditComponentProps = {

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

@@ -11,6 +11,7 @@ export declare class VegaTableChildrenController extends VegaSlimmer {
   currentData: VegaTable['currentData'];
   rowSelection: VegaTable['rowSelection'];
   striped: VegaTable['striped'];
+  rowDivider: VegaTable['rowDivider'];
   vegaTableDataSourceController: VegaTable['vegaTableDataSourceController'];
   vegaTableRenderer: VegaTable['vegaTableRenderer'];
   isTemplateRenderMode: VegaTable['isTemplateRenderMode'];
@@ -40,6 +41,10 @@ export declare class VegaTableChildrenController extends VegaSlimmer {
    * {@link VegaTable.watchStriped}
    */
   watchStriped(): void;
+  /**
+   * {@link VegaTable.watchRowDivider}
+   */
+  watchRowDivider(): void;
   /**
    * Syncs up the properties of vega-table-row
    */
@@ -47,7 +52,7 @@ export declare class VegaTableChildrenController extends VegaSlimmer {
   /**
    * Sync up the properties of vega-table-expand-row
    */
-  private syncRowStriped;
+  private syncRowStates;
   /**
    * Syncs up the properties of vega-table-head-row
    */
@@ -59,4 +64,11 @@ export declare class VegaTableChildrenController extends VegaSlimmer {
    * @param {number} index - index of the row
    */
   private updateRowStriped;
+  /**
+   * Update the row striped attr
+   *
+   * @param {HTMLElement} row - row or expand row element
+   * @param {boolean} isLastRow - Is last row
+   */
+  private updateRowDivider;
 }

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

@@ -3,6 +3,7 @@ import { VegaTable } from '../../vega-table';
 import { Nullable } from '../../../../types/general';
 export declare class VegaTableBodyRenderer extends VegaSlimmer {
   striped: VegaTable['striped'];
+  rowDivider: VegaTable['rowDivider'];
   columns: VegaTable['columns'];
   currentBreakpoint: VegaTable['currentBreakpoint'];
   rowExpandable: VegaTable['rowExpandable'];

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

@@ -6,6 +6,7 @@ export declare class VegaTableRowRenderer extends VegaSlimmer {
   vegaTableEditableController: VegaTable['vegaTableEditableController'];
   vegaTableCellRenderer: VegaTable['vegaTableCellRenderer'];
   striped: VegaTable['striped'];
+  rowDivider: VegaTable['rowDivider'];
   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

@@ -6,7 +6,6 @@ import { VegaTableCell } from '../../vega-table-cell';
 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 → vega-table-row-state-subscriber.d.ts}

@@ -3,13 +3,10 @@ import { VegaTableCell } from '../../vega-table-cell';
 /**
  * Controller for the table row states
  */
-export declare class VegaTableRowStateController extends SubStateObserverSlimmer<HTMLVegaTableCellElement> {
+export declare class VegaTableRowStateSubscriber extends SubStateObserverSlimmer<HTMLVegaTableCellElement> {
   checked: VegaTableCell['checked'];
-  striped: VegaTableCell['striped'];
   expanded: VegaTableCell['expanded'];
-  /**
-   * Component lifecycle - [componentWillLoad]{@link VegaTableCell.componentWillLoad}
-   */
-  componentWillRender(): void;
+  striped: VegaTableCell['striped'];
+  rowDivider: VegaTableCell['rowDivider'];
   constructor();
 }

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

@@ -5,14 +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';
+import { VegaTableRowStateSubscriber } from './slimmers/controllers/vega-table-row-state-subscriber';
 /**
  * @vegaVersion 1.44.0
  */
 export declare class VegaTableCell {
   protected readonly globalSlimmers: GlobalSlimmers;
   protected readonly vegaTableCellStateController: VegaTableCellStateController;
-  protected readonly vegaTableRowStateController: VegaTableRowStateController;
+  protected readonly vegaTableRowStateSubscriber: VegaTableRowStateSubscriber;
   protected readonly pageResizeObserverSlimmer: PageResizeObserverSlimmer;
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaTableCellElement>;
   host: HTMLVegaTableCellElement;

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

@@ -6,5 +6,6 @@ export declare class VegaTableExpandRowRenderer extends VegaSlimmer {
   expanded: VegaTableExpandRow['expanded'];
   checked: VegaTableExpandRow['checked'];
   colSpan: VegaTableExpandRow['colSpan'];
+  striped: VegaTableExpandRow['striped'];
   render(): HTMLTableRowElement;
 }

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

@@ -45,5 +45,11 @@ export declare class VegaTableExpandRow {
    * @vegaVersion 1.44.0
    */
   rowKey: string;
+  /**
+   * Specifies whether alternate colors should be applied to the expand row.
+   *
+   * @vegaVersion 2.61.0
+   */
+  striped: boolean;
   render(): VegaTableExpandRow;
 }

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

@@ -9,7 +9,6 @@ export declare class VegaTableRowStateController extends SubStateObserverSlimmer
   clickable: VegaTableRow['clickable'];
   paddingX: VegaTableRow['paddingX'];
   selectionType: VegaTableRow['selectionType'];
-  rowDivider: VegaTableRow['rowDivider'];
   columnDivider: VegaTableRow['columnDivider'];
   density: VegaTableRow['density'];
   constructor();

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

@@ -31,6 +31,8 @@ export declare class VegaTableRow {
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaTableRowElement>;
   protected readonly checkedNotifySlimmer: SubStateNotifySlimmerBase;
   protected readonly expandedNotifySlimmer: SubStateNotifySlimmerBase;
+  protected readonly stripedNotifySlimmer: SubStateNotifySlimmerBase;
+  protected readonly rowDividerNotifySlimmer: SubStateNotifySlimmerBase;
   host: HTMLVegaTableRowElement;
   currentBreakpoint: BreakpointsTokenType;
   clicked?: boolean;
@@ -61,10 +63,6 @@ export declare class VegaTableRow {
    */
   expanded?: boolean;
   watchExpanded(): void;
-  /**
-   * Sync from {@link VegaTable.rowDivider}
-   */
-  rowDivider?: boolean;
   /**
    * Sync from {@link VegaTable.columnDivider}
    */
@@ -79,6 +77,20 @@ export declare class VegaTableRow {
    * @vegaVersion 1.44.0
    */
   rowKey: string;
+  /**
+   * Specifies whether alternate colors should be applied to the row.
+   *
+   * @vegaVersion 2.61.0
+   */
+  striped: boolean;
+  watchStriped(): void;
+  /**
+   * Specifies whether dividers should be displayed in the row.
+   *
+   * @vegaVersion 2.61.0
+   */
+  rowDivider: boolean;
+  watchRowDivider(): void;
   /**
    * An event emitter notifying that the row has been clicked.
    *