@globalpayments/vega 2.91.0 → 2.93.0

package/dist/types/components/vega-accordion/slimmers/vega-accordion-renderer.d.ts

@@ -11,6 +11,7 @@ export declare class VegaAccordionRenderer extends VegaSlimmer {
   showExpandIcon: VegaAccordion['showExpandIcon'];
   expandController: VegaAccordion['expandController'];
   translationSlimmer: VegaAccordion['translationSlimmer'];
+  host: VegaAccordion['host'];
   render(): HTMLElement;
   private renderHeader;
   private renderPrefixIcon;
@@ -19,4 +20,5 @@ export declare class VegaAccordionRenderer extends VegaSlimmer {
   private renderContent;
   private renderTitleSlot;
   private getExpandIconAriaLabel;
+  private getSlottedTitleText;
 }

package/dist/types/components/vega-combo-box/types.d.ts

@@ -4,7 +4,12 @@
 export type VegaDropdownPropsForComboBox = Partial<
 	Pick<
 		HTMLVegaDropdownElement,
-		'positionRelativeTo' | 'maxHeight' | 'matchContainerHeight' | 'dynamicOption' | 'isLoading'
+		| 'positionRelativeTo'
+		| 'maxHeight'
+		| 'matchContainerHeight'
+		| 'dynamicOption'
+		| 'isLoading'
+		| 'allowSelectAll'
 	>
 >;
 /**

package/dist/types/components/vega-combo-box/vega-combo-box.d.ts

@@ -143,6 +143,7 @@ export declare class VegaComboBox {
    * @vegaVersion 1.11.0
    */
   vegaDropdownProps: VegaDropdownPropsForComboBox;
+  watchVegaDropdownProps(): void;
   /**
    * Determines whether to display the associated dropdown menu and
    *    filter its options based on the text entered into the combo box.

package/dist/types/components/vega-dropdown/constants.d.ts

@@ -0,0 +1 @@
+export declare const VEGA_DROPDOWN_SELECT_ALL_KEY: string;

package/dist/types/components/vega-dropdown/slimmers/controllers/vega-dropdown-appender-controller.d.ts

@@ -20,6 +20,8 @@ export declare class VegaDropdownAppenderController extends ElementAppenderSlimm
   placement: VegaDropdown['placement'];
   alignment: VegaDropdown['alignment'];
   renderer: VegaDropdown['renderer'];
+  sourceController: VegaDropdown['sourceController'];
+  selectAllController: VegaDropdown['selectAllController'];
   searchRenderer: VegaDropdown['searchRenderer'];
   showEventEmitter: VegaDropdown['showEventEmitter'];
   hideEventEmitter: VegaDropdown['hideEventEmitter'];

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

@@ -12,9 +12,11 @@ export declare class VegaDropdownChildrenController extends VegaSlimmer {
   listRenderer: VegaDropdown['listRenderer'];
   renderer: VegaDropdown['renderer'];
   selectedController: VegaDropdown['selectedController'];
+  selectAllController: VegaDropdown['selectAllController'];
   protected mutationObserver: MutationObserverSlimmer;
   private labelSet;
   private keySet;
+  private previousSelectableKeys;
   /**
    * Component lifecycle - [disconnectedCallback]
    */
@@ -31,6 +33,10 @@ export declare class VegaDropdownChildrenController extends VegaSlimmer {
    * The function "watchSource" synchronizes the dropdown current data.
    */
   watchSource(): void;
+  /**
+   * Manually sync template/slot-based data after dynamic DOM mutations.
+   */
+  syncTemplateData(): void;
   /**
    * The function checks if a given label exists in a label set.
    *
@@ -45,15 +51,38 @@ export declare class VegaDropdownChildrenController extends VegaSlimmer {
    * @returns {boolean} A boolean value indicating whether the given key exists in the keySet.
    */
   isKeyExist(key: string): boolean;
+  /**
+   * Returns the keys of all non-disabled slot items.
+   * Used by the Select All controller to enumerate selectable items in template/slot mode.
+   *
+   * @returns {string[]} Keys of selectable (non-disabled) template items.
+   */
+  getSelectableKeys(): string[];
   /**
    * The function syncs up the current data of a dropdown based on the render mode.
    */
   private syncUpDropdownCurrentData;
+  /**
+   * Updates previous selectable template keys and triggers re-render when Select All visibility changes.
+   *
+   */
+  private updateTemplateSelectableKeysAndRefresh;
+  /**
+   * Re-syncs Select All sentinel state for template mode after slot item mutations.
+   */
+  private syncTemplateSelectAllState;
   /**
    * The `syncUpDropdownCurrentDataBySlot` method is responsible for
    * synchronizing the current data in a dropdown based on the items present in the slot.
    */
   private collectKeyAndLabelFromSlot;
+  /**
+   * Check whether a template item belongs to the current dropdown instead of a nested dropdown.
+   *
+   * @param {HTMLVegaDropdownItemElement} item - Template mode dropdown item element.
+   * @returns {boolean} True only when the nearest dropdown ancestor is current host.
+   */
+  private isCurrentDropdownTemplateItem;
   /**
    * The function collects unique labels and keys from a nested array of objects.
    *
@@ -67,6 +96,13 @@ export declare class VegaDropdownChildrenController extends VegaSlimmer {
    * The below method is e2e-test covered in @see{module:vega-dropdown-items-dom-change-e2e}
    */
   private clearDropdownCurrentData;
+  /**
+   * Returns the dropdown content box element, or falls back to the host element if not yet available.
+   * Handles cases where `getDropdownContentBoxRef()` returns null during early lifecycle phases.
+   *
+   * @returns {HTMLElement} The dropdown content box or host element.
+   */
+  private getContainerElement;
   /**
    * The function `notifyTemplateItemsChange` notifies changes to dropdown items within a container element.
    */

package/dist/types/components/vega-dropdown/slimmers/controllers/vega-dropdown-select-all-controller.d.ts

@@ -0,0 +1,107 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaDropdown } from '../../vega-dropdown';
+import { DropdownSourceItem, VegaDropdownSourceItem } from '../../types';
+/**
+ * Determine Select All indeterminate state from selected keys and selectable keys.
+ *
+ * @param {string[] | string} keys - Current selected keys.
+ * @param {string[]} allKeys - Selectable keys for current mode.
+ * @param {string} selectAllKey - Internal Select All sentinel key.
+ * @returns {boolean} True when selection is partial.
+ */
+export declare const calculateSelectAllIndeterminate: (keys: string[] | string, allKeys: string[], selectAllKey?: string) => boolean;
+/**
+ * Determine indeterminate state specifically for the Select All item.
+ *
+ * @param {string} itemKey - Current dropdown item key.
+ * @param {string[] | string} keys - Current selected keys.
+ * @param {DropdownSourceItem[]} source - Source items (used in source mode).
+ * @param {string} selectAllKey - Internal Select All sentinel key.
+ * @returns {boolean} True when current item is Select All and selection is partial.
+ */
+export declare const isSelectAllItemIndeterminate: (itemKey: string, keys: string[] | string, source: DropdownSourceItem[], selectAllKey?: string) => boolean;
+/**
+ * The `VegaDropdownSelectAllController` encapsulates all Select All behavior.
+ * It is used when allowSelectAll is enabled.
+ */
+export declare class VegaDropdownSelectAllController extends VegaSlimmer {
+  allowSelectAll: VegaDropdown['allowSelectAll'];
+  selectType: VegaDropdown['selectType'];
+  translationSlimmer: VegaDropdown['translationSlimmer'];
+  renderModeController: VegaDropdown['renderModeController'];
+  childrenController: VegaDropdown['childrenController'];
+  private readonly selectAllKey;
+  /**
+   * Determine if Select All behavior should be active for current dropdown mode.
+   *
+   * @returns {boolean} True when allowSelectAll is enabled and selectType is multiple.
+   */
+  isEnabled(): boolean;
+  /**
+   * Add synthetic Select All option to source when enabled.
+   *
+   * @param {VegaDropdownSourceItem[]} source - The original source array.
+   * @returns {VegaDropdownSourceItem[]} Source with Select All item added at the start, or original source if not enabled.
+   */
+  getSourceWithSelectAll(source: VegaDropdownSourceItem[]): VegaDropdownSourceItem[];
+  /**
+   * Remove internal Select All key from selected keys.
+   *
+   * @param {string[]} keys - The current selected keys array.
+   * @returns {string[]} Keys with the internal Select All key removed.
+   */
+  filterOutSelectAllKey(keys: string[]): string[];
+  /**
+   * Toggle key selection in multiple mode, including Select All interactions.
+   *
+   * @param {DropdownSourceItem[]} source - The full source array of dropdown items.
+   * @param {string[]} selectedKeys - The currently selected keys.
+   * @param {string} key - The key that was clicked.
+   * @returns {string[]} Updated selected keys after the toggle operation.
+   */
+  toggleSelectionForMultiple(source: DropdownSourceItem[], selectedKeys: string[], key: string): string[];
+  /**
+   * Keep Select All internal key aligned with current selected keys.
+   *
+   * @param {DropdownSourceItem[]} source - The full source array of dropdown items.
+   * @param {string[]} keys - The current selected keys to synchronize.
+   * @returns {string[]} Keys with Select All key added or removed based on whether all items are selected.
+   */
+  syncSelectedKeysWithSelectAll(source: DropdownSourceItem[], keys: string[]): string[];
+  /**
+   * Check if a key is valid for selection in multiple mode.
+   *
+   * @param {string} key - The key to check.
+   * @returns {boolean} True if the key is the internal Select All key and feature is enabled.
+   */
+  isAllowedVirtualKey(key: string): boolean;
+  /**
+   * Determine whether Select All should be rendered in an indeterminate state.
+   *
+   * @param {string[] | string} keys - Current selected keys.
+   * @param {DropdownSourceItem[]} source - Source items (used in source mode).
+   * @returns {boolean} True when some but not all selectable items are selected.
+   */
+  isSelectAllIndeterminate(keys: string[] | string, source: DropdownSourceItem[]): boolean;
+  /**
+   * Returns the internal Select All item key.
+   * Used by renderers to inject the synthetic Select All item into the template/slot list.
+   *
+   * @returns {string} The Select All key.
+   */
+  getSelectAllItemKey(): string;
+  /**
+   * Determine whether template/slot mode should render the synthetic Select All row.
+   *
+   * @returns {boolean} True when Select All is enabled in template mode and there is at least one selectable real item.
+   */
+  shouldRenderTemplateSelectAll(): boolean;
+  /**
+   * Collect selectable keys from the source or DOM while skipping disabled items.
+   * In slot/template mode, keys are read from the rendered DOM via the children controller.
+   *
+   * @param {DropdownSourceItem[]} source - The dropdown source array (used in source mode only).
+   * @returns {string[]} The keys that can be selected.
+   */
+  private getSelectableKeys;
+}

package/dist/types/components/vega-dropdown/slimmers/controllers/vega-dropdown-selected-controller.d.ts

@@ -1,5 +1,6 @@
 import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
 import { VegaDropdown } from '../../vega-dropdown';
+import { VegaDropdownSelectAllController } from './vega-dropdown-select-all-controller';
 /**
  * The `VegaDropdownSelectedController` class handles the selection of items in a dropdown menu,
  * either adding them to an array or setting them as the only selected item.
@@ -15,7 +16,9 @@ export declare class VegaDropdownSelectedController extends VegaSlimmer {
   childrenController: VegaDropdown['childrenController'];
   renderModeController: VegaDropdown['renderModeController'];
   dropdownClickEventEmitter: VegaDropdown['dropdownClickEventEmitter'];
+  selectAllClickEventEmitter: VegaDropdown['selectAllClickEventEmitter'];
   resetEventEmitter: VegaDropdown['resetEventEmitter'];
+  selectAllController: VegaDropdownSelectAllController;
   /**
    * Component lifecycle - componentWillLoad
    */
@@ -46,6 +49,11 @@ export declare class VegaDropdownSelectedController extends VegaSlimmer {
    * @returns {void} -.
    */
   watchSelectType(): void;
+  /**
+   * The function `watchAllowSelectAll` normalizes selectedSourceKey when allowSelectAll changes,
+   * keeping the internal Select All key in sync with current selection state.
+   */
+  watchAllowSelectAll(): void;
   /**
    * The function "watchSelectedSourceKey" assigns a value to the variable "selectedSourceKey" by calling
    * the function "checkSelectedSourceKey" with the current value of "selectedSourceKey" as an argument.
@@ -111,6 +119,15 @@ export declare class VegaDropdownSelectedController extends VegaSlimmer {
    * @returns {void} The function `checkSelectedSourceKey` returns either a string or an array of strings.
    */
   private checkSelectedSourceKey;
+  /**
+   * Normalizes the selectedSourceKey value to match the shape expected by the current selectType.
+   * Ensures that switching selectType at runtime (e.g. single → multiple) coerces the stored key
+   * into the correct type (array for multiple, string for single, empty string for none).
+   *
+   * @param {string | string[]} key - The current selectedSourceKey value to normalize.
+   * @returns {string | string[]} The normalized key matching the current selectType shape.
+   */
+  private normalizeSelectedSourceKeyBySelectType;
   /**
    * The function checks if multiple selected keys exist and removes invalid keys, returning the valid
    * keys.

package/dist/types/components/vega-dropdown/slimmers/controllers/vega-dropdown-source-controller.d.ts

@@ -9,6 +9,7 @@ export declare class VegaDropdownSourceController extends VegaSlimmer {
   sourceForRender: VegaDropdown['sourceForRender'];
   searchController: VegaDropdown['searchController'];
   renderModeController: VegaDropdown['renderModeController'];
+  selectAllController: VegaDropdown['selectAllController'];
   /**
    * Component lifecycle - [componentWillLoad]
    */
@@ -19,6 +20,10 @@ export declare class VegaDropdownSourceController extends VegaSlimmer {
   watchSource(): void;
   /** watchCaseSensitive */
   watchCaseSensitive(): void;
+  /**
+   * Watch allowSelectAll property changes
+   */
+  watchAllowSelectAll(): void;
   /**
    * The function sets the source for rendering by searching for a formatted source.
    */

package/dist/types/components/vega-dropdown/slimmers/renderers/vega-dropdown-list-renderer.d.ts

@@ -15,6 +15,8 @@ export declare class VegaDropdownListRenderer extends VegaSlimmer {
   scrollableController: VegaDropdown['scrollableController'];
   translationSlimmer: VegaDropdown['translationSlimmer'];
   virtualizationThreshold: VegaDropdown['virtualizationThreshold'];
+  allowSelectAll: VegaDropdown['allowSelectAll'];
+  selectAllController: VegaDropdown['selectAllController'];
   private virtualScrollRef;
   private templateContainerRef;
   private defaultMaxHeightOfItemsContainer;

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

@@ -1,3 +1,11 @@
+/**
+ * Detail payload emitted by `vegaDropdownSelectAllClick` / `dropdownSelectAllClick`.
+ *
+ * `true` means all selectable items are now selected.
+ * `false` means Select All has been cleared.
+ */
+export type VegaDropdownSelectAllClickEventDetail = boolean;
+
 /**
  * Configuration for a single dropdown item.
  */

package/dist/types/components/vega-dropdown/vega-dropdown-item/slimmers/controllers/vega-dropdown-item-state-controller.d.ts

@@ -8,8 +8,33 @@ export declare class VegaDropdownItemStateController extends SubStateObserverSli
   selectType: VegaDropdownItem['selectType'];
   itemKey: VegaDropdownItem['itemKey'];
   selected: VegaDropdownItem['selected'];
+  indeterminate: VegaDropdownItem['indeterminate'];
   prefixIconSlot: VegaDropdownItem['prefixIconSlot'];
   itemDisplayRule: VegaDropdownItem['itemDisplayRule'];
   itemTooltipProps: VegaDropdownItem['itemTooltipProps'];
+  private readonly selectAllKey;
+  /**
+   * Initializes the dropdown item state controller with parent state observer setup
+   */
   constructor();
+  /**
+   * Gets the source of the parent dropdown, with fallback logic for different rendering modes
+   *
+   * @returns {VegaDropdown['source']} The source array from parent dropdown or content-box parent ref
+   */
+  private getParentDropdownSource;
+  /**
+   * Gets the parent dropdown element for the current item.
+   * Supports both direct template ancestry and content-box appender fallback.
+   *
+   * @returns {Nullable<HTMLVegaDropdownElement>} The parent dropdown element when found, otherwise null/undefined
+   */
+  private getParentDropdown;
+  /**
+   * Determines if the select-all checkbox should display in indeterminate state
+   *
+   * @param {VegaDropdown['selectedSourceKey']} selectedSourceKey - The currently selected keys
+   * @returns {boolean} True if this is a select-all item with some but not all items selected
+   */
+  private isSelectAllIndeterminate;
 }

package/dist/types/components/vega-dropdown/vega-dropdown-item/slimmers/renderers/vega-dropdown-item-renderer.d.ts

@@ -8,6 +8,7 @@ export declare class VegaDropdownItemRenderer extends VegaSlimmer {
   prefixIconSlot: VegaDropdownItem['prefixIconSlot'];
   disabled: VegaDropdownItem['disabled'];
   selected: VegaDropdownItem['selected'];
+  indeterminate: VegaDropdownItem['indeterminate'];
   selectType: VegaDropdownItem['selectType'];
   height: VegaDropdownItem['height'];
   itemDisplayRule: VegaDropdownItem['itemDisplayRule'];

package/dist/types/components/vega-dropdown/vega-dropdown-item/vega-dropdown-item.d.ts

@@ -32,6 +32,10 @@ export declare class VegaDropdownItem {
    * Specifies the dropdown item's selected status.
    */
   selected: boolean;
+  /**
+   * Specifies whether the dropdown item checkbox should show indeterminate state.
+   */
+  indeterminate: boolean;
   /**
    * Specifies the dropdown item's rule of display.
    */

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

@@ -24,6 +24,7 @@ import { VegaDropdownScrollableController } from './slimmers/controllers/vega-dr
 import { VegaDropdownRemoteInvocationController } from './slimmers/controllers/vega-dropdown-remote-invocation-controller';
 import { TranslationSlimmer } from '../../helpers/slimmers/translation';
 import { VegaDropdownResetRenderer } from './slimmers/renderers/vega-dropdown-reset-renderer';
+import { VegaDropdownSelectAllController } from './slimmers/controllers/vega-dropdown-select-all-controller';
 /**
  * @vegaVersion 1.3.0
  */
@@ -41,6 +42,7 @@ export declare class VegaDropdown {
   protected readonly keyboardController: VegaDropdownKeyboardController;
   protected readonly appenderController: VegaDropdownAppenderController;
   protected readonly searchController: VegaDropdownSearchController;
+  protected readonly selectAllController: VegaDropdownSelectAllController;
   /**
    * childrenController should be defined before selectedController,
    *     which can ensure collecting information before verifying it.
@@ -58,6 +60,7 @@ export declare class VegaDropdown {
   protected showEventEmitter: EventEmitSlimmerBase;
   protected hideEventEmitter: EventEmitSlimmerBase;
   protected dropdownClickEventEmitter: EventEmitSlimmerBase;
+  protected selectAllClickEventEmitter: EventEmitSlimmerBase;
   protected resetEventEmitter: EventEmitSlimmerBase;
   protected createEventEmitter: EventEmitSlimmerBase;
   protected searchEventEmitter: EventEmitSlimmerBase;
@@ -311,6 +314,15 @@ export declare class VegaDropdown {
    * @vegaVersion 2.74.0
    */
   searchNoResultsText: string;
+  /**
+   * Allows users to select or deselect all items in the dropdown.
+   *    Only applicable when selectType is set to 'multiple'.
+   *    When enabled, a "Select All" option is added to the dropdown menu.
+   *
+   * @vegaVersion 2.93.0
+   */
+  allowSelectAll: boolean;
+  watchAllowSelectAll(): void;
   /**
    * An event emitter notifying that a dropdown item has been clicked.
    *
@@ -327,6 +339,24 @@ export declare class VegaDropdown {
    * @vegaVersion 2.0.0
    */
   dropdownClick: EventEmitter<string>;
+  /**
+   * An event emitter notifying that the Select All option has been clicked.
+   *
+   * The event's `detail` property is `true` when all items become selected,
+   * and `false` when Select All is cleared.
+   *
+   * @vegaVersion 2.93.0
+   */
+  vegaDropdownSelectAllClick: EventEmitter<boolean>;
+  /**
+   * An event emitter notifying that the Select All option has been clicked.
+   *
+   * The event's `detail` property is `true` when all items become selected,
+   * and `false` when Select All is cleared.
+   * @eventSemantics namespace:native
+   * @vegaVersion 2.93.0
+   */
+  dropdownSelectAllClick: EventEmitter<boolean>;
   /**
    * An event emitter notifying that the dropdown has been displayed,
    *    either programmatically or via user interaction.
@@ -472,5 +502,23 @@ export declare class VegaDropdown {
    * @vegaVersion 1.47.0
    */
   setSelection(keys: string[] | string): Promise<void>;
+  /**
+   * Invoke this method to manually sync template/slot-based dropdown data.
+   * Useful when template items are dynamically added or removed.
+   *
+   * @example
+   * const dropdown = document.querySelector("vega-dropdown");
+   * const itemsContainer = dropdown.querySelector('[slot="items"]');
+   *
+   * const item = document.createElement('vega-dropdown-item');
+   * item.itemKey = 'new-item';
+   * item.label = 'New item';
+   * itemsContainer.appendChild(item);
+   *
+   * await dropdown.syncTemplateData();
+   *
+   * @vegaVersion 2.93.0
+   */
+  syncTemplateData(): Promise<void>;
   render(): VegaDropdown;
 }

package/dist/types/components/vega-field-label/slimmers/renderers/vega-field-label-suffix-element-renderer.d.ts

@@ -16,6 +16,7 @@ export declare class VegaFieldLabelSuffixElementRenderer extends VegaSlimmer {
    * Render a vega button circle component.
    *
    * @param {string} icon the button icon name
+   * @param {VegaButtonCircleSize} buttonSize the button size
    * @returns {HTMLVegaButtonCircleElement} vega button circle component
    */
   private renderSuffixButton;

package/dist/types/components/vega-field-label/types.d.ts

@@ -1,3 +1,5 @@
+import { VegaButtonCircleSize } from '../vega-button-circle/types';
+
 /**
  * @deprecated Please use `LabelSuffixButtonConfig` instead
  * Configuration for the label suffix button (deprecated).
@@ -25,6 +27,16 @@ export type LabelSuffixButtonConfig = {
 	 * Icon name to display in the suffix button.
 	 */
 	icon: string;
+	/**
+	 * Controls the size of the suffix button trigger icon.
+	 */
+	buttonSize?: VegaButtonCircleSize;
+	/**
+	 * Center aligns the label text and suffix button icon.
+	 *
+	 * When omitted or false, default layout behavior is preserved.
+	 */
+	centerAlign?: boolean;
 } & Partial<
 	Pick<
 		HTMLVegaTooltipElement,

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

@@ -12,6 +12,7 @@ export declare class VegaModalRenderer extends VegaSlimmer {
   margin: VegaModal['margin'];
   size: VegaModal['size'];
   height: VegaModal['height'];
+  corners: VegaModal['corners'];
   showCloseButton: VegaModal['showCloseButton'];
   modalTitle: VegaModal['modalTitle'];
   contentMaxHeight: VegaModal['contentMaxHeight'];
@@ -25,7 +26,7 @@ export declare class VegaModalRenderer extends VegaSlimmer {
   private modalContainer;
   getModalContentRef(): HTMLElement | null;
   getModalFooterRef(): HTMLElement | null;
-  getModalContainerRef(): HTMLElement | null;
+  getModalContainerRef(): HTMLVegaBoxElement | null;
   render(): VegaModal;
   private renderContainer;
   private renderHeader;

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

@@ -1,5 +1,5 @@
 import { EventEmitter } from '../../stencil-public-runtime';
-import { MarginType, PaddingType, ResponsiveType, SizeType } from '../../types/ui.type';
+import { CornersType, MarginType, PaddingType, ResponsiveType, SizeType } from '../../types/ui.type';
 import { BreakpointsTokenType } from '../../types/design-token.type';
 import { VegaModalBackdrop, VegaModalBackdropColor, VegaModalSectionPadding } from './types';
 import { GlobalSlimmers } from '../../vega-slimmer/vega-slimmer-core';
@@ -175,6 +175,14 @@ export declare class VegaModal {
    */
   contentMaxHeight: ResponsiveType<number | string>;
   watchContentMaxHeight(): void;
+  /**
+   * Defines the corner of the modal dialog.
+   *    It accepts a string value representing a valid
+   *    border radius token.
+   *
+   * @vegaVersion 2.93.0
+   */
+  corners: ResponsiveType<CornersType>;
   /**
    * Provides a callback function that is triggered when a user clicks the
    *    close button located in the top right corner of the modal.

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/block-merge-nodes-strategy.d.ts

@@ -13,4 +13,13 @@ export declare class BlockMergeNodesStrategy extends ActionHandleStrategy<MergeT
    * @param {RTETextBlock | RTEImageBlock} target - The first text block or image block.
    */
   protected handleAction(action: MergeTwoBlocksNodesAction, target: RTETextBlock | RTEImageBlock): void;
+  /**
+   * Re-registers the link group annotation on the target block for any merged nodes that carry a
+   * link. The link group annotation lives on the block being removed, so without this the merged
+   * link nodes would lose their hyperlink rendering.
+   *
+   * @param {RTENode[]} mergedNodes - The nodes that were appended to the target block.
+   * @param {RTETextBlock} target - The text block that received the merged nodes.
+   */
+  private transferLinkGroups;
 }

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/delete-selected-content-strategy.d.ts

@@ -0,0 +1,13 @@
+import { DeleteSelectedContentAction } from '../../actions/delete-selected-content-action';
+import type { RTEBlock } from '../../blocks/block.abstract';
+import type { VegaRTEContent } from '../../content-state';
+import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
+/**
+ * DeleteSelectedContentStrategy is responsible for handling the deletion of selected content within the rich text editor.
+ */
+export declare class DeleteSelectedContentStrategy extends ActionHandleStrategy<DeleteSelectedContentAction, RTEBlock | VegaRTEContent> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: DeleteSelectedContentAction): void;
+}

package/dist/types/components/vega-rich-text-editor/dto/action-handle-strategies/modify-content-strategies/paste-content-strategy.d.ts

@@ -1,12 +1,22 @@
 import { PasteContentAction } from '../../actions/paste-content-action';
 import { RTEBlock } from '../../blocks/block.abstract';
 import { ActionHandleStrategy } from '../action-handle-strategy.abstract';
-/**
- * Strategy to handle the paste content into function block.
- */
+/** Handles pasted content in a block. */
 export declare class PasteContentStrategy extends ActionHandleStrategy<PasteContentAction, RTEBlock> {
   /**
-   * @inheritDoc
+   * Handles pasted content for the target block.
+   *
+   * @param {PasteContentAction} action - The paste action to apply.
+   * @param {RTEBlock} target - The block receiving the pasted content.
+   * @returns {void}
    */
   protected handleAction(action: PasteContentAction, target: RTEBlock): void;
+  /**
+   * Merges a single pasted block inline at the cursor position.
+   *
+   * @param {PasteContentAction} action - The paste action being processed.
+   * @param {RTEBlock} target - The block receiving the inline merge.
+   * @returns {void}
+   */
+  private inlineMergeSingleBlock;
 }

package/dist/types/components/vega-rich-text-editor/dto/actions/delete-selected-content-action.d.ts

@@ -0,0 +1,12 @@
+import { ModifyContentAction, ModifyContentActionType } from './modify-content-action.abstract';
+/**
+ * Delete the currently selected content from the editor.
+ *
+ * @example currentVegaRTEContent.apply(new DeleteSelectedContentAction(host, mergeFlag))
+ */
+export declare class DeleteSelectedContentAction extends ModifyContentAction {
+  type: ModifyContentActionType;
+  mergeFlag: boolean;
+  host: HTMLVegaRichTextEditorElement;
+  constructor(host: HTMLVegaRichTextEditorElement, mergeFlag: boolean, flushable?: boolean);
+}

package/dist/types/components/vega-rich-text-editor/dto/actions/modify-content-action.abstract.d.ts

@@ -28,7 +28,8 @@ export declare enum ModifyContentActionType {
   'UPDATE_CURSOR_POSITION' = "UPDATE_CURSOR_POSITION",
   'INSERT_TEXT_TO_DECORATOR_NODE' = "INSERT_TEXT_TO_DECORATOR_NODE",
   'INSERT_NODE_TO_NEAREST_ROOT' = "INSERT_NODE_TO_NEAREST_ROOT",
-  'PASTE_CONTENT' = "PASTE_CONTENT"
+  'PASTE_CONTENT' = "PASTE_CONTENT",
+  'DELETE_SELECTED_CONTENT' = "DELETE_SELECTED_CONTENT"
 }
 /**
  * Abstract class for update node content, delete node, insert node

package/dist/types/components/vega-rich-text-editor/dto/actions/paste-content-action.d.ts

@@ -16,5 +16,12 @@ export declare class PasteContentAction extends ModifyContentAction {
   startOffset: number;
   rteRange: Nullable<RTERange>;
   futureFocusBlock: RTEBlock;
+  futureFocusAtEnd: boolean;
+  /**
+   * When set by PasteContentStrategy after an inline single-block merge, the caret
+   * is placed at this node / offset instead of the block-level fallback position.
+   */
+  futureFocusNode?: RTENode;
+  futureFocusNodeOffset?: number;
   constructor(blocksToBeInserted: RTEBlock[], startNode: RTENode, startOffset: number, rteRange?: RTERange);
 }

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

@@ -91,6 +91,22 @@ export declare class RTERange {
    * @returns {Nullable<Range>} The range instance. The return value could be null if the start node or end node are not rendered.
    */
   toNativeRange(): Nullable<Range>;
+  /**
+   * Clamps an offset to the valid bound of a DOM container so that
+   * `Range.setStart` / `Range.setEnd` never throw `IndexSizeError`.
+   *
+   * A stored selection offset can become stale or unit-mismatched when an undo
+   * restores a selection captured against different content — for example after
+   * find-and-replace shrinks a text node, or when the selection node's DOM
+   * container is its parent element (offset measured in child-node count rather
+   * than characters, as for non-editable token / logic-control nodes). Text
+   * containers are bounded by character length, element containers by child count.
+   *
+   * @param {Node} container - The DOM container the offset applies to.
+   * @param {number} offset - The desired offset.
+   * @returns {number} The offset clamped to `[0, container length]`.
+   */
+  private clampOffsetToContainer;
   /**
    * Retrieves an RTENode based on the given element by checking its type and parent elements.
    *