@heartlandone/vega 2.84.0 → 2.85.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-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-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;
 }

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

@@ -18,9 +18,9 @@ export declare class VegaTableFootRow {
   host: HTMLVegaTableFootRowElement;
   currentBreakpoint: BreakpointsTokenType;
   /**
-   * Indicates whether the row is expandable.
+   * Indicates whether the table has a expandable row.
    */
-  expandable: boolean;
+  hasExpandableRow: boolean;
   /**
    * Configures row selection behavior.
    */
@@ -33,6 +33,10 @@ export declare class VegaTableFootRow {
    * Sync from {@link VegaTable.columnDivider}
    */
   columnDivider?: boolean;
+  /**
+   * Sync from {@link VegaTable.rowDraggable}
+   */
+  draggable?: boolean;
   /**
    * Sync from {@link VegaTable.density}
    */

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

@@ -16,6 +16,7 @@ export declare class VegaTableHead {
    * Indicates whether the table header is fixed.
    */
   fixed: boolean;
+  connectedCallback(): void;
   disconnectedCallback(): void;
   render(): VegaTableHead;
   private handleTableHeadRefChange;

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

@@ -5,13 +5,14 @@ import { SubStateObserverSlimmer } from '../../../../../helpers/slimmers/sub-sta
  */
 export declare class VegaTableHeadRowStateController extends SubStateObserverSlimmer<HTMLVegaTableHeadRowElement> {
   host: VegaTableHeadRow['host'];
-  expandable: VegaTableHeadRow['expandable'];
+  hasExpandableRow: VegaTableHeadRow['hasExpandableRow'];
   selectionType: VegaTableHeadRow['selectionType'];
   paddingX: VegaTableHeadRow['paddingX'];
   columnDivider: VegaTableHeadRow['columnDivider'];
   density: VegaTableHeadRow['density'];
   isTemplateRenderMode: VegaTableHeadRow['isTemplateRenderMode'];
   isEmptyTable: VegaTableHeadRow['isEmptyTable'];
+  draggable: VegaTableHeadRow['draggable'];
   constructor();
   /**
    * Update the selection config with the new config

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

@@ -7,7 +7,8 @@ export declare class VegaTableHeadRowRenderer extends VegaSlimmer {
   hideSelectAll: VegaTableHeadRow['hideSelectAll'];
   selectAllDisabled: VegaTableHeadRow['selectAllDisabled'];
   checkedAll: VegaTableHeadRow['checkedAll'];
-  expandable: VegaTableHeadRow['expandable'];
+  hasExpandableRow: VegaTableHeadRow['hasExpandableRow'];
+  draggable: VegaTableHeadRow['draggable'];
   isEmptyTable: VegaTableHeadRow['isEmptyTable'];
   isTemplateRenderMode: VegaTableHeadRow['isTemplateRenderMode'];
   renderInput: VegaTableHeadRow['renderInput'];
@@ -26,6 +27,7 @@ export declare class VegaTableHeadRowRenderer extends VegaSlimmer {
   render(): VegaTableHeadRow;
   private renderHeaderSelectionCell;
   private handleSelectAll;
+  private renderHeaderDraggableCell;
   private renderHeaderExpandableCell;
   private handleClick;
   private getRowRenderInput;

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

@@ -26,9 +26,9 @@ export declare class VegaTableHeadRow {
   host: HTMLVegaTableHeadRowElement;
   currentBreakpoint: BreakpointsTokenType;
   /**
-   * Indicates whether the row is expandable.
+   * Indicates whether the table has an expandable row.
    */
-  expandable: boolean;
+  hasExpandableRow: boolean;
   /**
    * Configures row selection behavior.
    */
@@ -58,6 +58,10 @@ export declare class VegaTableHeadRow {
    */
   isTemplateRenderMode: boolean;
   renderInput: Nullable<ColumnRenderInputModel[]>;
+  /**
+   * Sync from {@link VegaTable.rowDraggable}
+   */
+  draggable?: boolean;
   /**
    * Indicates whether the checkbox is disabled.
    *

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

@@ -6,11 +6,14 @@ import { SubStateObserverSlimmer } from '../../../../../helpers/slimmers/sub-sta
 export declare class VegaTableRowStateController extends SubStateObserverSlimmer<HTMLVegaTableRowElement> {
   host: VegaTableRow['host'];
   expandable: VegaTableRow['expandable'];
+  hasExpandableRow: VegaTableRow['hasExpandableRow'];
   clickable: VegaTableRow['clickable'];
   paddingX: VegaTableRow['paddingX'];
   selectionType: VegaTableRow['selectionType'];
   columnDivider: VegaTableRow['columnDivider'];
   density: VegaTableRow['density'];
+  draggable: VegaTableRow['draggable'];
+  rowKey: VegaTableRow['rowKey'];
   constructor();
   /**
    * Component watch method - [watchRowSelection]{@link VegaTableRow.watchSelectionType}

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

@@ -10,8 +10,10 @@ 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'];
   vegaTableRowSelectionController: VegaTableRow['vegaTableRowSelectionController'];
   vegaTableRowExpandController: VegaTableRow['vegaTableRowExpandController'];
   vegaTableRowClickController: VegaTableRow['vegaTableRowClickController'];
@@ -21,6 +23,7 @@ export declare class VegaTableRowRenderer extends VegaSlimmer {
   getParentTableRef(): Nullable<HTMLVegaTableElement>;
   render(): VegaTableRow;
   private renderExpandRowSpace;
+  private renderDragIcon;
   private renderRowSelection;
   private renderExpandIcon;
   private onRowClick;

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

@@ -36,6 +36,10 @@ export declare class VegaTableRow {
   host: HTMLVegaTableRowElement;
   currentBreakpoint: BreakpointsTokenType;
   clicked?: boolean;
+  /**
+   * Indicates whether the table has an expandable row.
+   */
+  hasExpandableRow?: boolean;
   /**
    * Indicates whether the row is expandable.
    */
@@ -71,6 +75,10 @@ export declare class VegaTableRow {
    * Sync from {@link VegaTable.density}
    */
   density?: ResponsiveType<VegaTableDensityType>;
+  /**
+   * Sync from {@link VegaTable.rowDraggable}
+   */
+  draggable: boolean;
   /**
    * Defines a unique key for the row.
    *