@heartlandone/vega 2.84.0 → 2.86.0

package/dist/types/components/vega-color-swatch/vega-color-swatch-picker/slimmers/renderers/color-swatch-picker-renderer.d.ts

@@ -1,6 +1,7 @@
 import { VegaSlimmer } from '../../../../../vega-slimmer/vega-slimmer-core';
 import { VegaColorSwatchPicker } from '../../vega-color-swatch-picker';
 export declare class ColorSwatchPickerRenderer extends VegaSlimmer {
+  protected host: VegaColorSwatchPicker['host'];
   protected value: VegaColorSwatchPicker['value'];
   protected internalColor: VegaColorSwatchPicker['internalColor'];
   protected label: VegaColorSwatchPicker['label'];
@@ -12,8 +13,10 @@ export declare class ColorSwatchPickerRenderer extends VegaSlimmer {
   protected colorSwatchInputRenderer: VegaColorSwatchPicker['colorSwatchInputRenderer'];
   protected colorSwatchPickerValueController: VegaColorSwatchPicker['colorSwatchPickerValueController'];
   protected translationSlimmer: VegaColorSwatchPicker['translationSlimmer'];
+  protected leftSlotProjection: VegaColorSwatchPicker['leftSlotProjection'];
   private containerRef;
   private popoverRef;
+  private leftContainerRef;
   /**
    * Hides the color swatch picker popover.
    */
@@ -24,6 +27,12 @@ export declare class ColorSwatchPickerRenderer extends VegaSlimmer {
    * @returns {HTMLDivElement} The container element of the color swatch picker.
    */
   getContainerRef(): HTMLDivElement;
+  /**
+   * Gets the reference to the left container element inside the popover.
+   *
+   * @returns {HTMLDivElement} The left container element.
+   */
+  getLeftContainerRef(): HTMLDivElement;
   render(): HTMLElement;
   private renderButtonGroup;
   /**

package/dist/types/components/vega-color-swatch/vega-color-swatch-picker/vega-color-swatch-picker.d.ts

@@ -13,16 +13,20 @@ import { TranslationSlimmer } from '../../../helpers/slimmers/translation';
 import { VegaColorSwatchPickerFormatOption } from './types';
 import { ColorSwatchPickerColorFormatController } from './slimmers/controllers/color-swatch-picker-color-format-controller';
 import { ChildNodesEventPreventSlimmer } from '../../../helpers/event-manager/slimmers/child-nodes-event-prevent-slimmer';
+import { PopoverNestedSlotProjectionSlimmer } from '../../../helpers/slimmers/popover-nested-slot-projection-slimmer';
 /**
  * A color swatch picker component.
  *
  * @vegaVersion 2.84.0
+ *
+ * @slot swatch-picker-left - Custom content rendered on the left side of the picker popover. When provided, the popover switches to a two-column layout with a vertical divider.
  */
 export declare class VegaColorSwatchPicker {
   protected readonly globalSlimmers: GlobalSlimmers;
   protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaColorSwatchPickerElement>;
   protected readonly formFieldController: FormFieldControllerSlimmer<string>;
   protected translationSlimmer: TranslationSlimmer<HTMLVegaColorSwatchPickerElement>;
+  protected leftSlotProjection: PopoverNestedSlotProjectionSlimmer;
   protected colorSwatchPickerRenderer: ColorSwatchPickerRenderer;
   protected colorSwatchGridRenderer: ColorSwatchGridRenderer;
   protected colorSwatchInputRenderer: ColorSwatchInputRenderer;
@@ -113,6 +117,7 @@ export declare class VegaColorSwatchPicker {
    *   within the color swatch picker popover.
    *
    * @vegaVersion 2.84.0
+   * @defaultValue hexColorIcon
    */
   inputPrefixIcon: string;
   /**
@@ -129,6 +134,7 @@ export declare class VegaColorSwatchPicker {
    * Applies only when `showInput` is set to `true`.
    *
    * @vegaVersion 2.84.0
+   * @defaultValue hexColorFormatter
    */
   inputFormatter: VegaColorSwatchPickerFormatOption;
   watchInputFormatter(): void;

package/dist/types/components/vega-color-swatch/vega-color-swatch.d.ts

@@ -55,16 +55,16 @@ export declare class VegaColorSwatch {
   /**
    * Specifies the visual style and prominence of the swatch.
    *    It determines how the swatch will be presented to the user.
-   * - 'swatch': Displays the color fill.
-   * - 'clear': Displays a diagonal line to indicate no color (clear selection).
+   * - `swatch`: Displays the color fill.
+   * - `clear`: Displays a diagonal line to indicate no color (clear selection).
    *
    * @vegaVersion 2.82.0
    */
   variant: VegaColorSwatchVariant;
   /**
    * Controls the outer shape of the swatch.
-   * - 'basket': Rounded corners for spaced layouts.
-   * - 'block': Square corners for dense or flush layouts.
+   * - `basket`: Rounded corners for spaced layouts.
+   * - `block`: Square corners for dense or flush layouts.
    *
    * @vegaVersion 2.82.0
    */

package/dist/types/components/vega-date-picker/vega-date-picker-calendar/slimmers/renderers/vega-date-picker-month-item-renderer.d.ts

@@ -12,6 +12,7 @@ export declare class VegaDatePickerMonthItemRenderer extends VegaSlimmer {
   calendarSelection: VegaDatePickerCalendar['calendarSelection'];
   staticHeight: VegaDatePickerCalendar['staticHeight'];
   mode: VegaDatePickerCalendar['mode'];
+  fillContainer: VegaDatePickerCalendar['fillContainer'];
   size: VegaDatePickerCalendar['size'];
   isDualMonths: VegaDatePickerCalendar['isDualMonths'];
   isDateDisabled: VegaDatePickerCalendar['isDateDisabled'];

package/dist/types/components/vega-date-picker/vega-date-picker-calendar/vega-date-picker-calendar.d.ts

@@ -57,6 +57,13 @@ export declare class VegaDatePickerCalendar {
    * @vegaVersion 2.72.0
    */
   size: DatePickerCalendarSizeType;
+  /**
+   * Specifies whether to allow the calendar picker to fill the width and height of its parent container.
+   *    As default, the calendar picker has a max width and height limit based on the size and mode variant.
+   *
+   * @vegaVersion 2.86.0
+   */
+  fillContainer: boolean;
   /**
    * Specifies the selection mode of the date picker calendar.
    *
@@ -102,6 +109,7 @@ export declare class VegaDatePickerCalendar {
   clearButton: boolean;
   /**
    * Specifies the calendar is static height.
+   *    It means the height of calendar will not change according to the number of weeks in the month.
    *
    * @vegaVersion 2.72.0
    */

package/dist/types/components/vega-input-phone-number/vega-input-phone-number.d.ts

@@ -6,6 +6,7 @@ import { PhoneNumberInputRenderer } from './slimmers/renderers/phone-number-inpu
 import { VegaInputPhoneNumberValueController } from './slimmers/controllers/vega-input-phone-number-value-controller';
 import { FormFieldValidationRule } from '../../helpers/validator/rules/form-field-validation-rule';
 import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
+import { AriaAttributesValueMapper } from '../../helpers/slimmers/mutation-observer/aria-attributes-value-mapper';
 import { FormFieldControllerSlimmer } from '../../helpers/slimmers/form-field-controller-slimmer';
 import { CountrySelectController } from './slimmers/controllers/country-select-controller';
 import { EventEmitSlimmerBase } from '../../helpers/event-manager/slimmers/event-emit-slimmer';
@@ -25,6 +26,7 @@ export declare class VegaInputPhoneNumber {
   protected countrySelectController: CountrySelectController;
   protected changeEventEmitter: EventEmitSlimmerBase;
   protected countryChangeEventEmitter: EventEmitSlimmerBase;
+  protected ariaAttributesValueMapper: AriaAttributesValueMapper;
   protected inputPhoneNumberEventPrevent: ChildNodesEventPreventSlimmer;
   protected readonly formFieldController: FormFieldControllerSlimmer<string>;
   host: HTMLVegaInputPhoneNumberElement;

package/dist/types/components/vega-nav/vega-left-nav/slimmers/controllers/vega-left-nav-backdrop-controller.d.ts

@@ -1,6 +1,7 @@
 import { VegaLeftNav } from '../../vega-left-nav';
 import { LeftNavOpenStateType } from '../../../interface';
 import { PageResizeObserverSlimmer } from '../../../../../helpers/slimmers/page-resize-observer-slimmer';
+import { Nullable } from '../../../../../types/general';
 export declare class VegaLeftNavBackdropController extends PageResizeObserverSlimmer {
   openState: VegaLeftNav['openState'];
   showAsOverlay: VegaLeftNav['showAsOverlay'];
@@ -15,7 +16,7 @@ export declare class VegaLeftNavBackdropController extends PageResizeObserverSli
   constructor();
   watchOpenState(newState: LeftNavOpenStateType): void;
   watchShowAsOverlay(): void;
-  getBackdrop(): HTMLElement;
+  getBackdrop(): Nullable<HTMLElement>;
   shouldShowBackdrop(): boolean;
   /**
    * The below method is e2e-test covered in

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

@@ -70,6 +70,8 @@ export declare abstract class VegaRTEToolbarButtonRenderer {
   protected renderDropdownGroup(h: VegaRTECreateElementFunction, item: RTEDropdownListGroup): VegaRTERenderResult;
   /**
    * Renders a common toolbar button with optional icon, label, and arrow icon.
+   * When a tooltip is provided via `buttonProps.tooltip`, the button is wrapped
+   * in a `vega-tooltip` element, matching the behavior of default toolbar buttons.
    *
    * @param {VegaRTECreateElementFunction} h - Create element function.
    * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-dynamic-popover-renderer.d.ts

@@ -1,4 +1,4 @@
-import { RTERenderContext, VegaRTEColorSchema, VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
+import { RTERenderContext, VegaRTEColorSchema } from '../../../interface';
 import { Nullable } from '../../../../../types/general';
 import { RTETableBlock } from '../dto/table-block';
 import { TablePopoverBaseRenderer } from './table-popover-base-renderer';
@@ -10,14 +10,14 @@ import { TablePopoverBaseRenderer } from './table-popover-base-renderer';
  */
 export declare class TableDynamicPopoverRenderer extends TablePopoverBaseRenderer {
   private popoverRef;
-  private getTableRef;
+  private tablePropertiesFormRef;
+  private cellPropertiesFormRef;
+  private readonly tableColorSchema;
   private selectionAnchorRef;
-  private tableColorSchema;
   private currentTableBlock;
   private currentFocusNode;
-  private tablePropertiesFormRef;
-  private cellPropertiesFormRef;
   private popoverCloseType;
+  private getTableRef;
   private tablePropertiesHandlerMap;
   private cellPropertiesHandlerMap;
   constructor(colors: VegaRTEColorSchema[], renderContext: RTERenderContext);
@@ -39,14 +39,18 @@ export declare class TableDynamicPopoverRenderer extends TablePopoverBaseRendere
    */
   hide(): Promise<void>;
   /**
-   * Renders a vega-popover whose target and content are provided dynamically by callers.
+   * Re-targets the shared popovers to the given table.
+   *
+   * @param {RTETableBlock} tableBlock - The clicked table's block data.
+   * @param {() => HTMLElement} getTableRef - Getter for the clicked table's DOM element.
+   */
+  reTarget(tableBlock: RTETableBlock, getTableRef: () => Nullable<HTMLElement>): void;
+  /**
+   * Builds the popover DOM and appends it to the given container.
    *
-   * @param {VegaRTECreateElementFunction} h - The create element function.
-   * @param {() => HTMLElement} getTableRef - Current table DOM reference
-   * @param {RTETableBlock} renderData - Current table block being rendered.
-   * @returns {VegaRTERenderResult} The rendered popover host.
+   * @returns {Nullable<HTMLElement>} The constructed popover element.
    */
-  render(h: VegaRTECreateElementFunction, getTableRef: () => Nullable<HTMLElement>, renderData: RTETableBlock): VegaRTERenderResult;
+  render(): Nullable<HTMLElement>;
   /**
    * Updates the visibility of the pre-rendered content blocks based on type.
    *

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-renderer.d.ts

@@ -5,10 +5,15 @@ import { RTETableBlock } from '../dto/table-block';
  * Renderer for the RTETableBlock.
  */
 export declare class RTETableBlockRenderer extends VegaRTEExtensionRenderer {
+  private tableToolbar;
   /**
    * @inheritDoc
    */
   doRender(h: VegaRTECreateElementFunction, renderData: RTETableBlock, rteContext: RTERenderContext): VegaRTERenderResult;
+  /**
+   * Destroys the table toolbar popover.
+   */
+  destroy(): void;
   /**
    * @inheritDoc
    */
@@ -35,4 +40,14 @@ export declare class RTETableBlockRenderer extends VegaRTEExtensionRenderer {
    * @param {HTMLElement} tableRef - The table trigger element used to locate the rich text content container.
    */
   private destroySelectionAnchor;
+  /**
+   * Renders the table setting popover toolbar if the context is editable.
+   *
+   * @param {RTERenderContext} rteContext - The rendering context of the rich text editor.
+   */
+  private renderTableToolbar;
+  /**
+   * Destroys the table setting popover toolbar if it exists.
+   */
+  private destroyTableToolbar;
 }

package/dist/types/components/vega-rich-text-editor/extensions/table/renderers/table-setting-popover-renderer.d.ts

@@ -1,47 +1,50 @@
-import { VegaRTECreateElementFunction, VegaRTERenderResult } from '../../../interface';
 import { RTETableBlock } from '../dto/table-block';
-import { TableDynamicPopoverRenderer } from './table-dynamic-popover-renderer';
 import { TablePopoverBaseRenderer } from './table-popover-base-renderer';
+import { RTERenderContext } from '../../../interface';
 /**
- * Centralizes the popover rendering and interaction logic for table settings.
+ * Shared popover renderer for table settings.
  */
 export declare class TableSettingPopoverRenderer extends TablePopoverBaseRenderer {
   private popoverRef;
   private tableSettingRef;
-  private tableData;
+  private tableBlock;
   private tableDynamicPopover;
-  private popoverShow;
+  private popoverContainer;
   private settingHandlers;
+  constructor(renderContext: RTERenderContext);
   /**
-   * Show table setting popover when table is clicked.
-   * Only the popover belonging to the nearest table will be shown,
-   * which avoids outer tables showing their popover when an inner (nested) table is clicked.
+   * Destroys the dynamic popover renderer and removes the container from the DOM.
+   */
+  destroy(): void;
+  /**
+   * Re-targets and shows the table setting popover for the clicked table.
    *
-   * @param {MouseEvent} event - The MouseEvent that triggered the table action
-   * @param {HTMLElement} trigger - The element that can triggered the popover open.
+   * @param {MouseEvent} event - The MouseEvent that triggered the click.
+   * @param {RTETableBlock} tableBlock - The clicked table's block data.
+   * @param {() => HTMLElement} getTableRef - Getter for the clicked table's DOM element.
    */
-  handleTableClick: (event: MouseEvent, trigger: HTMLElement) => void;
+  handleTableClick: (event: MouseEvent, tableBlock: RTETableBlock, getTableRef: () => HTMLElement) => void;
   /**
    * Sync the selected cells from the table selection to the table setting component.
    */
   syncSelectedCells: () => void;
   /**
-   * Render the popover host and inject the table-setting component with refs wired up.
-   *
-   * @param {VegaRTECreateElementFunction} h - The create element function.
-   * @param {RTETableBlock} renderData - The table block to render.
-   * @param {() => HTMLElement} getTableRef - Current table DOM reference
-   * @param {TableDynamicPopoverRenderer} tableDynamicPopover - Renderer used to show
-   *  the secondary table popover (for example, table-properties-specific settings).
-   * @returns {VegaRTERenderResult} The rendered popover structure.
+   * Builds the popover DOM and appends it to the RTE host. Idempotent: subsequent calls are no-ops.
    */
-  render(h: VegaRTECreateElementFunction, renderData: RTETableBlock, getTableRef: () => HTMLElement, tableDynamicPopover: TableDynamicPopoverRenderer): VegaRTERenderResult;
+  render(): void;
   /**
-   * Updates the table setting component caption state to match the given table data.
+   * Updates the table setting component caption state to match the current table data.
    */
   private updateTableSettingCaption;
   /**
-   * Receive setting menu click events.
+   * Re-targets the shared popovers to the given table.
+   *
+   * @param {RTETableBlock} tableBlock - The clicked table's block data.
+   * @param {() => HTMLElement} getTableRef - Getter for the clicked table's DOM element.
+   */
+  private reTarget;
+  /**
+   * Handles setting menu click events.
    *
    * @param {CustomEvent<Array<string>>} event - The custom event emitted from the setting menu.
    */

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

@@ -805,6 +805,11 @@ export type RTEToolbarButtonProps = {
 	 * Whether to display the arrow icon.
 	 */
 	showArrowIcon?: boolean;
+	/**
+	 * Optional tooltip configuration for the button.
+	 * When provided, the button will be wrapped in a vega-tooltip.
+	 */
+	tooltip?: Partial<Pick<HTMLVegaTooltipElement, 'text'>>;
 };
 
 /**

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

@@ -9,9 +9,21 @@ export declare class VegaSelectionTileRenderer extends VegaSlimmer {
   disabled: VegaSelectionTile['disabled'];
   checked: VegaSelectionTile['checked'];
   showError: VegaSelectionTile['showError'];
+  value: VegaSelectionTile['value'];
   checkedController: VegaSelectionTile['checkedController'];
   private selectorContainerRef;
   getSelectorContainerRef(): HTMLElement;
+  /**
+   * Activation handler invoked from the host's `@Listen('click')` listener
+   * (registered on the host element itself). The host carries
+   * `role="radio"`/`"checkbox"`, `tabindex`, and the activation listeners,
+   * so this is the only interactive node per tile. VoiceOver's VO+Space
+   * dispatches a synthetic click on the focused host, which reaches this
+   * function through `VegaSelectionTile.onHostClick()`.
+   */
+  activate: () => void;
+  handleTileKeydown: (event: KeyboardEvent) => void;
+  getAccessibleName(): string;
   render(): HTMLElement;
   private renderContent;
   private renderPrefixIcon;

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

@@ -6,7 +6,6 @@ export declare class VegaSelectionTileGroupRenderer extends VegaSlimmer {
   required: VegaSelectionTileGroup['required'];
   hint: VegaSelectionTileGroup['hint'];
   layout: VegaSelectionTileGroup['layout'];
-  selectType: VegaSelectionTileGroup['selectType'];
   itemsController: VegaSelectionTileGroup['itemsController'];
   private groupContainerRef;
   getGroupContainerRef(): HTMLElement;

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

@@ -97,4 +97,6 @@ export declare class VegaSelectionTile {
    */
   change: EventEmitter<string>;
   render(): VegaSelectionTile;
+  private onHostClick;
+  private onHostKeyDown;
 }

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

@@ -2,6 +2,7 @@ import { VNode } from '../../stencil-public-runtime';
 import * as VegaComponents from '../../components';
 import { JSXBase } from '../../stencil-public-runtime';
 import { BreakpointsForPrefixType } from '../../types/ui.type';
+export type { DragDropEventPayload } from '../../types/ui.type';
 /**
  * A virtual DOM node
  */
@@ -493,3 +494,4 @@ export declare type TableHeadCellObserverPayload = {
  * Column pinning position for horizontal scrolling layout.
  */
 export declare type VegaTablePinnedType = 'left' | 'right';
+export declare type VegaTableRowExpandableType = boolean | ((rowKey: string) => boolean);

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

@@ -1,5 +1,6 @@
 import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
 import { VegaTable } from '../../vega-table';
+import { VegaTableDataSourceItem } from '../../interface';
 /**
  * The expand row controller of VegaTable
  */
@@ -7,7 +8,10 @@ export declare class VegaTableExpandRowController extends VegaSlimmer {
   static readonly expandRowSlotNamePrefix: string;
   host: VegaTable['host'];
   expandedRowKeySet: VegaTable['expandedRowKeySet'];
+  expandableRows: VegaTable['expandableRows'];
+  hasExpandableRow: VegaTable['hasExpandableRow'];
   rowExpandable: VegaTable['rowExpandable'];
+  currentData: VegaTable['currentData'];
   rowExpandEventEmitter: VegaTable['rowExpandEventEmitter'];
   vegaTableDataSourceController: VegaTable['vegaTableDataSourceController'];
   private mutationObserver;
@@ -20,6 +24,10 @@ export declare class VegaTableExpandRowController extends VegaSlimmer {
    * Component lifecycle - disconnectedCallback
    */
   disconnectedCallback(): void;
+  /**
+   * Component lifecycle - componentWillLoad
+   */
+  componentWillLoad(): void;
   /**
    * Component lifecycle - componentDidLoad
    */
@@ -50,6 +58,17 @@ export declare class VegaTableExpandRowController extends VegaSlimmer {
    * The callback to handle [watchRowExpandable]{@link VegaTable.watchRowExpandable}
    */
   watchRowExpandable(): void;
+  /**
+   * Set the expandable rows based on the rowExpandable prop
+   */
+  watchCurrentData(): void;
+  /**
+   * Whether the row is expandable
+   *
+   * @param {VegaTableDataSourceItem} row - The row data
+   * @returns {boolean} Return true if the row is expandable
+   */
+  isExpandableRow: (row: VegaTableDataSourceItem) => boolean;
   /**
    * Whether the row is expandable
    *
@@ -90,4 +109,20 @@ export declare class VegaTableExpandRowController extends VegaSlimmer {
    * @returns {boolean} a boolean value indicating whether the input is acceptable observer.
    */
   private isAcceptableTableRowObserver;
+  /**
+   * Sets expandable rows and hasExpandableRow based on rowExpandable and currentData
+   */
+  private setExpandableRows;
+  /**
+   * Whether the row is expandable by rowKey
+   *
+   * @param {string} rowKey - The row key of the row
+   * @returns {boolean} Return true if the row is expandable
+   */
+  private isRowExpandable;
+  /**
+   * Clear the expand row slot which is not expandable anymore to avoid confusion,
+   *    this can be triggered by the change of rowExpandable or currentData
+   */
+  private clearUnusedExpandRowSlot;
 }

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

@@ -0,0 +1,52 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaTable } from '../../vega-table';
+import { DraggableElementSlimmer } from '../../../../helpers/slimmers/draggable-element-slimmer';
+/**
+ * The row draggable controller for the vega-table
+ */
+export declare class VegaTableRowDraggableController extends VegaSlimmer {
+  rowDraggable: VegaTable['rowDraggable'];
+  protected host: VegaTable['host'];
+  protected vegaTableDataSourceController: VegaTable['vegaTableDataSourceController'];
+  protected isTemplateRenderMode: VegaTable['isTemplateRenderMode'];
+  protected vegaTableBodyRenderer: VegaTable['vegaTableBodyRenderer'];
+  protected vegaTableSortController: VegaTable['vegaTableSortController'];
+  protected rowDragDropEventEmitter: VegaTable['rowDragDropEventEmitter'];
+  protected readonly draggableElementSlimmer: DraggableElementSlimmer;
+  /**
+   * Component lifecycle - [connectedCallback]{@link VegaPopover.connectedCallback}
+   */
+  connectedCallback(): void;
+  /**
+   * Component lifecycle - [disconnectedCallback]{@link VegaPopover.disconnectedCallback}
+   */
+  disconnectedCallback(): void;
+  /**
+   * Component lifecycle - [componentDidLoad]{@link VegaPopover.componentDidLoad}
+   */
+  componentDidLoad(): void;
+  /**
+   * Watches for changes to the rowDraggable property and initializes or destroys the DraggableElement instance accordingly.
+   * If rowDraggable is true, it calls setRowDraggableElement to initialize the instance;
+   * if false, it calls destroyRowDraggableElement to clean up.
+   */
+  watchRowDraggable(): void;
+  /**
+   * Resolve the draggable container for current render mode.
+   *
+   * @returns {Nullable<HTMLElement>} The table body container used by drag behavior.
+   */
+  private getDragContainer;
+  /**
+   * Handles the drag and drop event emitted by the DraggableElement instance, re-emitting it through the rowDragDropEventEmitter with additional details.
+   *
+   * @param {DragDropEventPayload} payload - An object containing payload about the drag event.
+   */
+  private onDragDrop;
+  /**
+   * Handles the logic for reordering rows in the table when a drag and drop action is completed.
+   *
+   * @param {DragDropEventPayload} payload - An object containing details about the completed drag event, including fromIndex and toIndex.
+   */
+  private onDragEnd;
+}

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

@@ -22,6 +22,10 @@ export declare class VegaTableSortController extends VegaSlimmer {
    * @param {VegaTableSortOrderType} nextSortOrder - The next sorter order
    */
   handleHeadSortClick(column: VegaTableColumnConfig, nextSortOrder: VegaTableSortOrderType): void;
+  /**
+   * The method to clear all sorters
+   */
+  clearSorter: () => void;
   /**
    * Sync the default sort order from the columns
    */

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

@@ -6,15 +6,17 @@ export declare class VegaTableBodyRenderer extends VegaSlimmer {
   rowDivider: VegaTable['rowDivider'];
   columns: VegaTable['columns'];
   currentBreakpoint: VegaTable['currentBreakpoint'];
-  rowExpandable: VegaTable['rowExpandable'];
   rowClickable: VegaTable['rowClickable'];
   vegaTableDataSourceController: VegaTable['vegaTableDataSourceController'];
   vegaTablePaginationController: VegaTable['vegaTablePaginationController'];
   vegaTableRowSelectionController: VegaTable['vegaTableRowSelectionController'];
   vegaTableRowRenderer: VegaTable['vegaTableRowRenderer'];
   columnStructureModel: VegaTable['columnStructureModel'];
+  vegaTableExpandRowController: VegaTable['vegaTableExpandRowController'];
   private tableFormRef;
+  private tableBodyRef;
   getTableFormRef(): Nullable<HTMLVegaFormElement>;
+  getTableBodyRef(): Nullable<HTMLVegaTableBodyElement>;
   render(): HTMLTableSectionElement;
   private renderTableBody;
 }

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

@@ -4,7 +4,8 @@ export declare class VegaTableColGroupRenderer extends VegaSlimmer {
   paddingX: VegaTable['paddingX'];
   columnStructureModel: VegaTable['columnStructureModel'];
   columns: VegaTable['columns'];
-  rowExpandable: VegaTable['rowExpandable'];
+  hasExpandableRow: VegaTable['hasExpandableRow'];
+  rowDraggable: VegaTable['rowDraggable'];
   vegaTableRowSelectionController: VegaTable['vegaTableRowSelectionController'];
   render(): HTMLElement;
   private getColResponsiveClass;

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

@@ -20,6 +20,7 @@ export declare const generateTextAlignClass: (align: ColumnAlignType) => string;
  *
  * @param {number} columnLength - The number of columns in a table or grid.
  * @param {boolean} withMultipleSelection - A boolean value indicating whether the table has a column for multiple selection.
- * @returns {number} the value of `columnLength` plus 2 if `withMultipleSelection` is true, or plus 1 if `withMultipleSelection` is false.
+ * @param {boolean} withRowDraggable - A boolean value indicating whether the table has a column for row draggable.
+ * @returns {number} the value of `columnLength` plus 2 if `withMultipleSelection` is true, or plus 1 if `withMultipleSelection` is false, plus 1 if `withRowDraggable` is true.
  */
-export declare const generateColSpan: (columnLength: number, withMultipleSelection: boolean) => number;
+export declare const generateColSpan: (columnLength: number, withMultipleSelection: boolean, withRowDraggable: boolean) => number;

package/dist/types/components/vega-table/vega-table-expand-row/slimmers/controllers/vega-table-expand-row-col-span-controller.d.ts

@@ -7,6 +7,7 @@ export declare class VegaTableExpandRowColSpanController extends VegaSlimmer {
   host: VegaTableExpandRow['host'];
   colSpan: VegaTableExpandRow['colSpan'];
   withMultipleSelection: VegaTableExpandRow['withMultipleSelection'];
+  withRowDraggable: VegaTableExpandRow['withRowDraggable'];
   /**
    * Update the expand row content col span when component will load
    */
@@ -19,6 +20,10 @@ export declare class VegaTableExpandRowColSpanController extends VegaSlimmer {
    * Update the expand row content col span when selection type changed
    */
   watchWithMultipleSelection(): void;
+  /**
+   * Update the expand row content col span when draggable state changed
+   */
+  watchWithRowDraggable(): void;
   /**
    * Update state colSpan
    */

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

@@ -7,6 +7,7 @@ import { VegaTableExpandRowColSpanController } from './vega-table-expand-row-col
 export declare class VegaTableExpandRowStateController extends SubStateObserverSlimmer<HTMLVegaTableExpandRowElement> {
   host: VegaTableExpandRow['host'];
   withMultipleSelection: VegaTableExpandRow['withMultipleSelection'];
+  withRowDraggable: VegaTableExpandRow['withRowDraggable'];
   vegaTableExpandRowColSpanController: VegaTableExpandRowColSpanController;
   constructor();
 }

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

@@ -27,6 +27,8 @@ export declare class VegaTableExpandRow {
    */
   withMultipleSelection: boolean;
   watchWithMultipleSelection(): void;
+  withRowDraggable: boolean;
+  watchWithRowDraggable(): void;
   /**
    * Indicates whether the row is expanded.
    */

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

@@ -9,7 +9,8 @@ export declare class VegaTableFootRowStateController extends SubStateObserverSli
   paddingX: VegaTableFootRow['paddingX'];
   columnDivider: VegaTableFootRow['columnDivider'];
   density: VegaTableFootRow['density'];
-  expandable: VegaTableFootRow['expandable'];
+  hasExpandableRow: VegaTableFootRow['hasExpandableRow'];
+  draggable: VegaTableFootRow['draggable'];
   constructor();
   /**
    * Update the selection config with the new config

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

@@ -4,8 +4,10 @@ export declare class VegaTableFootRowRenderer extends VegaSlimmer {
   host: VegaTableFootRow['host'];
   paddingX: VegaTableFootRow['paddingX'];
   selectionType: VegaTableFootRow['selectionType'];
-  expandable: VegaTableFootRow['expandable'];
+  hasExpandableRow: VegaTableFootRow['hasExpandableRow'];
+  draggable: VegaTableFootRow['draggable'];
   render(): VegaTableFootRow;
   private renderFooterSelectionCell;
   private renderFooterExpandableCell;
+  private renderFooterDraggableCell;
 }