@globalpayments/vega 2.73.0 → 2.76.0

package/dist/types/helpers/slimmers/position-calculation/base-position-calculation-strategy.d.ts

@@ -6,6 +6,15 @@ import { ElementAppenderShowConfig } from '../../ui/element-appender';
  */
 export declare abstract class BasePositionCalculationStrategy extends VegaSlimmer {
   abstract showConfig: ElementAppenderShowConfig;
+  /**
+   * Whether the controller should adjust/recompute position at this time.
+   *
+   * This hook allows strategies to avoid unnecessary work (for example, on scroll) by deciding
+   * whether a re-position is required.
+   *
+   * @returns {boolean} True when the controller should proceed with width/height/position adjustments.
+   */
+  shouldAdjustPosition(): boolean;
   /**
    * Get the position box.
    *
@@ -15,6 +24,54 @@ export declare abstract class BasePositionCalculationStrategy extends VegaSlimme
    * returns an ElementPositionBox.
    */
   protected getPositionBox(placement?: PlacementType[], alignment?: PositionAlignmentType[]): ElementPositionBox;
+  /**
+   * Whether the alignment space is enough
+   *
+   * @param {ElementScrollDimension} containerBox - The bounding box of the container element.
+   * @param {ElementBoundBox} targetBox - The position of the target element.
+   * @param {ElementBoundBox} elementBox - The box of the element that we're trying to position.
+   * @param {PlacementType} placement - The placement of the element relative to the target.
+   * @param {PlacementType} alignment - The alignment of the element relative to the target.
+   * @returns {boolean} return true if it has enough space, otherwise false
+   */
+  protected hasEnoughAlignmentSpace(containerBox: ElementScrollDimension, targetBox: ElementBoundBox, elementBox: ElementBoundBox, placement: PlacementType, alignment: PositionAlignmentType): boolean;
+  /**
+   * Calculate the left position of the element
+   *
+   * @param {ElementBoundBox} elementBox - The position box of the element.
+   * @param {ElementBoundBox} targetBox - The position box of the target element that is attached to.
+   * @param {PlacementType} placement - The placement of the element.
+   * @param {PositionAlignmentType} alignment - The alignment of the element
+   * @returns {number} The left position of the element.
+   */
+  protected calculateLeft(elementBox: ElementBoundBox, targetBox: ElementBoundBox, placement: PlacementType, alignment: PositionAlignmentType): number;
+  /**
+   * Calculate the top position of the element
+   *
+   * @param {ElementBoundBox} elementBox - The position box of the element.
+   * @param {ElementBoundBox} targetBox - The position box of the target element that is attached to.
+   * @param {PlacementType} placement - The placement of the element.
+   * @param {PositionAlignmentType} alignment - The alignment of the element
+   * @returns {number} the top position of the element.
+   */
+  protected calculateTop(elementBox: ElementBoundBox, targetBox: ElementBoundBox, placement: PlacementType, alignment: PositionAlignmentType): number;
+  /**
+   * It returns acceptable alignments.
+   *
+   * @returns {PositionAlignmentType[]} acceptable alignments
+   */
+  protected getAlignments(): PositionAlignmentType[];
+  /**
+   * It takes a list of placements and returns the first placement that has enough space to place the
+   * element
+   *
+   * @param {ElementScrollDimension} containerBox - The box of the container element.
+   * @param {ElementBoundBox} elementBox - The box of the element to be placed.
+   * @param {ElementBoundBox} targetBox - The box of the target element.
+   * @param {PlacementType[]} placements - The placements that we want to try.
+   * @returns {PlacementType} A function that takes in a containerBox, elementBox, targetBox, placements, and element.
+   */
+  protected getSuitablePlacement(containerBox: ElementScrollDimension, elementBox: ElementBoundBox, targetBox: ElementBoundBox, placements: PlacementType[]): PlacementType;
   /**
    * "Get the width, height, and top position of an element."
    *
@@ -37,12 +94,6 @@ export declare abstract class BasePositionCalculationStrategy extends VegaSlimme
    * @returns {PlacementType[]} ordered placements.
    */
   private getPlacements;
-  /**
-   * It returns acceptable alignments.
-   *
-   * @returns {PositionAlignmentType[]} acceptable alignments
-   */
-  private getAlignments;
   /**
    * It takes a placement, a target box, and a element box, and returns an element box
    *
@@ -60,37 +111,6 @@ export declare abstract class BasePositionCalculationStrategy extends VegaSlimme
    * @returns {TranslocationType} A translocation object with X and Y properties.
    */
   private getTranslocationBox;
-  /**
-   * Calculate the left position of the element
-   *
-   * @param {ElementBoundBox} elementBox - The position box of the element.
-   * @param {ElementBoundBox} targetBox - The position box of the target element that is attached to.
-   * @param {PlacementType} placement - The placement of the element.
-   * @param {PositionAlignmentType} alignment - The alignment of the element
-   * @returns {number} The left position of the element.
-   */
-  private calculateLeft;
-  /**
-   * Calculate the top position of the element
-   *
-   * @param {ElementBoundBox} elementBox - The position box of the element.
-   * @param {ElementBoundBox} targetBox - The position box of the target element that is attached to.
-   * @param {PlacementType} placement - The placement of the element.
-   * @param {PositionAlignmentType} alignment - The alignment of the element
-   * @returns {number} the top position of the element.
-   */
-  private calculateTop;
-  /**
-   * It takes a list of placements and returns the first placement that has enough space to place the
-   * element
-   *
-   * @param {ElementScrollDimension} containerBox - The box of the container element.
-   * @param {ElementBoundBox} elementBox - The box of the element to be placed.
-   * @param {ElementBoundBox} targetBox - The box of the target element.
-   * @param {PlacementType[]} placements - The placements that we want to try.
-   * @returns {PlacementType} A function that takes in a containerBox, elementBox, targetBox, placements, and element.
-   */
-  private getSuitablePlacement;
   /**
    * It takes a list of alignments and returns the suitable one that has enough space to fit the element
    *
@@ -102,17 +122,6 @@ export declare abstract class BasePositionCalculationStrategy extends VegaSlimme
    * @returns {PositionAlignmentType} the alignment that is suitable for the element.
    */
   private getSuitableAlignment;
-  /**
-   * Whether the alignment space is enough
-   *
-   * @param {ElementScrollDimension} containerBox - The bounding box of the container element.
-   * @param {ElementBoundBox} targetBox - The position of the target element.
-   * @param {ElementBoundBox} elementBox - The box of the element that we're trying to position.
-   * @param {PlacementType} placement - The placement of the element relative to the target.
-   * @param {PlacementType} alignment - The alignment of the element relative to the target.
-   * @returns {boolean} return true if it has enough space, otherwise false
-   */
-  private hasEnoughAlignmentSpace;
   /**
    * If the placement is top or left, then the target's top or left position must be greater than or
    * equal to the element's height or width. If the placement is bottom or right, then the container's

package/dist/types/helpers/slimmers/position-calculation/position-calculation-controller.d.ts

@@ -11,6 +11,11 @@ export declare class PositionCalculationController extends VegaSlimmer {
   protected readonly bodyPositionStrategy: BodyPositionCalculationStrategy;
   protected readonly screenPositionStrategy: ScreenPositionCalculationStrategy;
   private positionStrategy;
+  /**
+   * Clears any pending screen-position scroll animation frame callback.
+   * Call this when the appendable is hidden/destroyed.
+   */
+  clearScreenPositionScrollFrame(): void;
   /**
    * Sets the calculate postion strategy.
    */

package/dist/types/helpers/slimmers/position-calculation/screen-position-calculation-strategy.d.ts

@@ -1,5 +1,5 @@
 import { ElementAppenderShowConfig } from '../../ui/element-appender';
-import { ElementBoundBox, ElementPositionBox, ElementScrollDimension } from '../../../types/ui.type';
+import { ElementBoundBox, ElementPositionBox, ElementScrollDimension, PlacementType, PositionAlignmentType } from '../../../types/ui.type';
 import { BasePositionCalculationStrategy } from './base-position-calculation-strategy';
 /**
  * calculate position by screen container
@@ -7,6 +7,23 @@ import { BasePositionCalculationStrategy } from './base-position-calculation-str
 export declare class ScreenPositionCalculationStrategy extends BasePositionCalculationStrategy {
   showConfig: ElementAppenderShowConfig;
   private previousPositionBox;
+  private previousTargetRect;
+  private scrollFrameRequestId;
+  private usePreviousPlacement;
+  private readonly scrollPositionUpdateStrategy;
+  /**
+   * For screen-positioned appendable we may get a lot of scroll events.
+   * This hook throttles the check with requestAnimationFrame and only allows an adjust when
+   * the strategy determines we should update.
+   *
+   * @returns {boolean} True when controller should perform a position adjustment.
+   */
+  shouldAdjustPosition(): boolean;
+  /**
+   * Clears any pending scroll animation frame callback.
+   * Call this when popover is hidden/destroyed to avoid leaks and stale callbacks.
+   */
+  clearScrollFrame(): void;
   /**
    * Get the position of the element in the container according to the target element and the placement
    * If give a translocation, it will apply the translocation to the result.
@@ -31,4 +48,27 @@ export declare class ScreenPositionCalculationStrategy extends BasePositionCalcu
    * @returns {ElementScrollDimension} An object with two properties: width and height.
    */
   protected getElementScrollDimension(): ElementScrollDimension;
+  /**
+   * Whether the alignment space is enough
+   *
+   * @param {ElementScrollDimension} containerBox - The bounding box of the container element.
+   * @param {ElementBoundBox} targetBox - The position of the target element.
+   * @param {ElementBoundBox} elementBox - The box of the element that we're trying to position.
+   * @param {PlacementType} placement - The placement of the element relative to the target.
+   * @param {PlacementType} alignment - The alignment of the element relative to the target.
+   * @returns {boolean} return true if it has enough space, otherwise false
+   */
+  protected hasEnoughAlignmentSpace(containerBox: ElementScrollDimension, targetBox: ElementBoundBox, elementBox: ElementBoundBox, placement: PlacementType, alignment: PositionAlignmentType): boolean;
+  /**
+   * Screen-specific suitable placement selection.
+   * Tries to find a placement that has enough alignment space within the viewport first,
+   * otherwise falls back to the base strategy.
+   *
+   * @param {ElementScrollDimension} containerBox - The bounding box of the container.
+   * @param {ElementBoundBox} elementBox - The box of the element to place.
+   * @param {ElementBoundBox} targetBox - The box of the target element.
+   * @param {PlacementType[]} placements - Ordered list of placements to try.
+   * @returns {PlacementType} The chosen placement.
+   */
+  protected getSuitablePlacement(containerBox: ElementScrollDimension, elementBox: ElementBoundBox, targetBox: ElementBoundBox, placements: PlacementType[]): PlacementType;
 }

package/dist/types/helpers/slimmers/position-calculation/screen-scroll-position-update.d.ts

@@ -0,0 +1,39 @@
+export declare type ScrollPositionUpdateDecision = {
+  shouldUpdate: boolean;
+};
+export declare type ScrollPositionUpdateStrategyContext = {
+  currentTargetRect: DOMRect;
+  appendableRect: DOMRect;
+  previousTargetRect: DOMRect;
+  viewportWidth: number;
+  viewportHeight: number;
+};
+/**
+ * Updates position on scroll When the target rect changes, we recompute placement/alignment.
+ */
+export declare class ScreenScrollPositionUpdate {
+  private viewportWidth;
+  private viewportHeight;
+  /**
+   * Determines whether the appendable element's position should update on scroll.
+   *
+   * @param {ScrollPositionUpdateStrategyContext} context - Current/previous rectangles plus viewport size.
+   * @returns {ScrollPositionUpdateDecision} Decision that indicates whether to recompute position.
+   */
+  shouldUpdatePosition(context: ScrollPositionUpdateStrategyContext): ScrollPositionUpdateDecision;
+  /**
+   * Whether the rect is fully within the viewport bounds.
+   *
+   * @param {DOMRect} rect - The DOMRect to check.
+   * @returns {boolean} True when rect is fully within the viewport.
+   */
+  private isRectEntirelyWithinViewport;
+  /**
+   * Whether the element is fully outside the viewport.
+   * If true, the rect has "disappeared" from the viewport.
+   *
+   * @param {DOMRect} rect - The DOMRect to check.
+   * @returns {boolean} True when rect is completely outside viewport bounds.
+   */
+  private isRectOutsideViewport;
+}

package/dist/types/helpers/ui/element-appender.d.ts

@@ -41,7 +41,6 @@ export declare class ElementAppender {
   private showConfigCallbackTarget;
   private showConfig;
   private container;
-  private previousTargetRect;
   /**
    * The `constructor` function is used to initialize the `showConfigCallback` and
    * `showConfigCallbackTarget` properties of the class.

package/dist/types/index.d.ts

@@ -4,3 +4,5 @@ export * from './constants/public-api';
 export * from './helpers/public-api';
 export * from './types/public-api';
 export * from './helpers/validator/public-rules';
+export { VegaRTEContent } from './components/vega-rich-text-editor/dto/content-state';
+export * from './components/vega-rich-text-editor/public-api';

package/dist/types/polyfill/prism/index.d.ts

@@ -0,0 +1,3 @@
+export { tokenize } from './tokenizer';
+export { getLanguageGrammar } from './languages/language-registry';
+export type { SyntaxToken, Grammar, GrammarPattern, GrammarEntry } from './types';

package/dist/types/polyfill/prism/languages/css.d.ts

@@ -0,0 +1,6 @@
+import { Grammar } from '../types';
+/**
+ * Grammar definition for CSS syntax highlighting.
+ * Handles selectors, properties, values, at-rules, comments, strings, and other CSS constructs.
+ */
+export declare const cssGrammar: Grammar;

package/dist/types/polyfill/prism/languages/javascript.d.ts

@@ -0,0 +1,7 @@
+import { Grammar } from '../types';
+/**
+ * Grammar definition for JavaScript syntax highlighting.
+ * Handles keywords, operators, strings, template literals, numbers,
+ * regex literals, comments, functions, classes, and other JS constructs.
+ */
+export declare const javascriptGrammar: Grammar;

package/dist/types/polyfill/prism/languages/jsx.d.ts

@@ -0,0 +1,7 @@
+import { Grammar } from '../types';
+/**
+ * Grammar definition for JSX syntax highlighting.
+ * Extends JavaScript grammar with JSX tag syntax for React components,
+ * including self-closing tags, expressions in braces, and embedded markup attributes.
+ */
+export declare const jsxGrammar: Grammar;

package/dist/types/polyfill/prism/languages/language-registry.d.ts

@@ -0,0 +1,8 @@
+import { Grammar } from '../types';
+/**
+ * Retrieve the grammar for a given language identifier.
+ *
+ * @param {string} language - The language identifier (e.g., 'js', 'css', 'html', 'ts', 'jsx', 'tsx').
+ * @returns {Grammar | undefined} The grammar definition, or undefined if the language is not registered.
+ */
+export declare function getLanguageGrammar(language: string): Grammar | undefined;

package/dist/types/polyfill/prism/languages/markup.d.ts

@@ -0,0 +1,6 @@
+import { Grammar } from '../types';
+/**
+ * Grammar definition for HTML/Markup syntax highlighting.
+ * Handles tags, attributes, comments, doctypes, CDATA, entities, and embedded content.
+ */
+export declare const markupGrammar: Grammar;

package/dist/types/polyfill/prism/languages/tsx.d.ts

@@ -0,0 +1,7 @@
+import { Grammar } from '../types';
+/**
+ * Grammar definition for TSX (TypeScript + JSX) syntax highlighting.
+ * Merges TypeScript and JSX grammars, supporting both type annotations
+ * and JSX tag syntax in the same file.
+ */
+export declare const tsxGrammar: Grammar;

package/dist/types/polyfill/prism/languages/typescript.d.ts

@@ -0,0 +1,2 @@
+import { Grammar } from '../types';
+export declare const typescriptGrammar: Grammar;

package/dist/types/polyfill/prism/test/css.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/polyfill/prism/test/javascript.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/polyfill/prism/test/jsx.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/polyfill/prism/test/language-registry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/polyfill/prism/test/markup.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/polyfill/prism/test/test-utils.d.ts

@@ -0,0 +1,10 @@
+import { SyntaxToken } from '../types';
+/**
+ * Recursively find all tokens of a given type within a token array.
+ * Traverses nested token content arrays to find deeply nested tokens.
+ *
+ * @param {(string | SyntaxToken)[]} tokens - The token array to search.
+ * @param {string} type - The token type to filter by.
+ * @returns {SyntaxToken[]} All tokens matching the specified type.
+ */
+export declare const findTokensByType: (tokens: (string | SyntaxToken)[], type: string) => SyntaxToken[];

package/dist/types/polyfill/prism/test/tokenizer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/polyfill/prism/test/tsx.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/polyfill/prism/test/typescript.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/polyfill/prism/tokenizer.d.ts

@@ -0,0 +1,17 @@
+import { Grammar, SyntaxToken } from './types';
+/**
+ * Core tokenizer that converts source code into syntax tokens based on a grammar definition.
+ * This is a local replacement for Prism tokenize.
+ *
+ * The tokenizer works by:
+ * 1. Pre-processing greedy patterns to claim their matched regions first
+ * 2. Iterating through all grammar rules in order
+ * 3. Finding regex matches in the source text
+ * 4. Splitting the text into matched (typed) and unmatched (plain) segments
+ * 5. Recursively tokenizing nested content when an `inside` grammar is specified
+ *
+ * @param {string} code - The source code string to tokenize.
+ * @param {Grammar} grammar - The grammar rules to apply for tokenization.
+ * @returns {(string | SyntaxToken)[]} An array of plain strings and syntax tokens.
+ */
+export declare function tokenize(code: string, grammar: Grammar): (string | SyntaxToken)[];

package/dist/types/polyfill/prism/types.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Represents a token produced by the syntax highlighting tokenizer.
+ * A token has a type (e.g. 'keyword', 'string', 'comment') and content
+ * which can be a string, a single nested token, or an array of mixed strings and tokens.
+ */
+export interface SyntaxToken {
+  type: string;
+  content: string | SyntaxToken | (string | SyntaxToken)[];
+}
+/**
+ * A grammar rule pattern used for tokenizing source code.
+ * Each pattern has a regex to match and an optional `inside` grammar for nested tokenization.
+ */
+export interface GrammarPattern {
+  pattern: RegExp;
+  lookbehind?: boolean;
+  greedy?: boolean;
+  inside?: Grammar;
+}
+/**
+ * A grammar is a map of token type names to their pattern definitions.
+ * Each entry can be a single pattern, an array of patterns, or a nested grammar reference.
+ */
+export declare type GrammarEntry = GrammarPattern | GrammarPattern[];
+export declare type Grammar = Record<string, GrammarEntry>;

package/dist/types/polyfill/tinycolor/tinycolor-polyfill.d.ts

@@ -0,0 +1,149 @@
+/**
+ * TinyColor Polyfill - A lightweight color manipulation utility.
+ *
+ * This is a drop-in replacement for tinycolor2, implementing only the methods
+ * used in the Vega theme overriding system.
+ *
+ * @see VD-5026 - [Zero Dependencies] remove tinycolor2 dependency
+ */
+declare type RgbaValue = {
+  r: number;
+  g: number;
+  b: number;
+  a: number;
+};
+/**
+ * TinyColor polyfill class for color manipulation.
+ * Implements the same interface as tinycolor2.Instance for the methods used in Vega.
+ */
+export declare class TinyColorPolyfill {
+  private _r;
+  private _g;
+  private _b;
+  private _a;
+  /**
+   * Create a new TinyColorPolyfill instance.
+   *
+   * @param {string | RgbaValue} color - The color to parse.
+   */
+  constructor(color: string | RgbaValue);
+  /**
+   * Clamp a value between a minimum and maximum.
+   *
+   * @param {number} value - The value to clamp.
+   * @param {number} min - The minimum allowed value.
+   * @param {number} max - The maximum allowed value.
+   * @returns {number} The clamped value.
+   */
+  private static clamp;
+  /**
+   * Parse a color string or RGBA object into an RgbaValue.
+   *
+   * Supported formats:
+   * - Hex: #RGB, #RRGGBB, #RRGGBBAA
+   * - RGB: rgb(r, g, b)
+   * - RGBA: rgba(r, g, b, a)
+   * - Object: { r, g, b, a? }
+   *
+   * @param {string | RgbaValue} color - The color to parse.
+   * @returns {RgbaValue} The parsed RGBA value.
+   */
+  private static parseColor;
+  /**
+   * Parse a hex color string into RGBA values.
+   *
+   * @param {string} hex - The hex color string (e.g., "#fff", "#ffffff", "#ffffffff").
+   * @returns {RgbaValue} The parsed RGBA value.
+   */
+  private static parseHex;
+  /**
+   * Parse an RGB or RGBA string into RGBA values.
+   *
+   * @param {string} rgbString - The RGB/RGBA string (e.g., "rgb(255, 128, 0)" or "rgba(255, 128, 0, 0.5)").
+   * @returns {RgbaValue} The parsed RGBA value.
+   */
+  private static parseRgbString;
+  /**
+   * Convert RGB to HSL.
+   *
+   * @param {number} r - Red (0-255).
+   * @param {number} g - Green (0-255).
+   * @param {number} b - Blue (0-255).
+   * @returns {HslValue} The HSL values (h: 0-360, s: 0-1, l: 0-1).
+   */
+  private static rgbToHsl;
+  /**
+   * Convert HSL to RGB.
+   *
+   * @param {number} h - Hue (0-360).
+   * @param {number} s - Saturation (0-1).
+   * @param {number} l - Lightness (0-1).
+   * @returns {RgbValue} The RGB values (0-255).
+   */
+  private static hslToRgb;
+  /**
+   * Calculate the perceived brightness of a color using the YIQ formula.
+   * This matches tinycolor2's brightness calculation.
+   *
+   * @param {number} r - Red (0-255).
+   * @param {number} g - Green (0-255).
+   * @param {number} b - Blue (0-255).
+   * @returns {number} Brightness value (0-255).
+   */
+  private static getBrightness;
+  /**
+   * Check if the color is dark (brightness < 128).
+   *
+   * @returns {boolean} True if the color is considered dark.
+   */
+  isDark(): boolean;
+  /**
+   * Check if the color is light (brightness >= 128).
+   *
+   * @returns {boolean} True if the color is considered light.
+   */
+  isLight(): boolean;
+  /**
+   * Create a copy of this color.
+   *
+   * @returns {TinyColorPolyfill} A new TinyColorPolyfill instance with the same values.
+   */
+  clone(): TinyColorPolyfill;
+  /**
+   * Lighten the color by a given amount.
+   * Note: tinycolor2 accepts negative values to darken.
+   *
+   * @param {number} amount - The amount to lighten (0-100). Negative values darken.
+   * @returns {TinyColorPolyfill} This instance for chaining.
+   */
+  lighten(amount?: number): TinyColorPolyfill;
+  /**
+   * Darken the color by a given amount.
+   *
+   * @param {number} amount - The amount to darken (0-100).
+   * @returns {TinyColorPolyfill} This instance for chaining.
+   */
+  darken(amount?: number): TinyColorPolyfill;
+  /**
+   * Set the alpha (opacity) of the color.
+   *
+   * @param {number} alpha - The alpha value (0-1).
+   * @returns {TinyColorPolyfill} This instance for chaining.
+   */
+  setAlpha(alpha: number): TinyColorPolyfill;
+  /**
+   * Get the RGBA representation of the color.
+   *
+   * @returns {RgbaValue} The RGBA values.
+   */
+  toRgb(): RgbaValue;
+}
+/**
+ * Factory function to create a TinyColorPolyfill instance.
+ * This provides API compatibility with tinycolor2's default export.
+ *
+ * @param {string | RgbaValue} color - The color to parse.
+ * @returns {TinyColorPolyfill} A new TinyColorPolyfill instance.
+ */
+export declare function tinycolor(color: string | RgbaValue): TinyColorPolyfill;
+export {};

package/dist/types/polyfill/tinycolor/tinycolor-polyfill.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/types/components.type.d.ts

@@ -32,6 +32,7 @@ export {
 	TextAlignType,
 	TranslocationType,
 	VegaComponentInterface,
+	VegaEATriggerType,
 	VegaFlexProps,
 	WidthType,
 } from '../types/ui.type';
@@ -146,12 +147,14 @@ export {
 	InputType,
 	InputValueUpdateTriggeredBy,
 	MaskConfigType,
+	VegaInputSuggestionsDropdownConfig,
 } from '../components/vega-input/types';
 export { FormFieldValidationRule as FormFieldValidationRule1 } from '../types/components.type';
 export { VegaCountryType } from '../components/vega-input-phone-number/types';
 export { InputRangeStackType, InputRangeValueType } from '../components/vega-input-range/types';
 export {
 	SelectedLabelType,
+	SelectedLabelTypeForAllModes,
 	SelectSourceItem,
 	SelectType,
 	SelectValueType,
@@ -180,7 +183,10 @@ export {
 	VegaPaginationLayoutType,
 } from '../components/vega-pagination/types';
 export { PieChartOptions } from '../helpers/chart/pie-chart';
-export { VegaProgressTrackerDirectionType } from '../components/vega-progress-tracker/type';
+export {
+	VegaProgressTrackerDirectionType,
+	VegaProgressTrackerStepItem,
+} from '../components/vega-progress-tracker/type';
 export { VegaRTEContent } from '../components/vega-rich-text-editor/dto/content-state';
 export { VegaRTEExtension } from '../components/vega-rich-text-editor/extensions/extension.abstract';
 export {

package/dist/types/types/design-token.type.d.ts

@@ -7,15 +7,51 @@ import { Shadows } from '../constants/tokens/shadows';
 import { Spacing } from '../constants/tokens/spacing';
 import { TypographyKeys } from '../constants/tokens/typography';
 import { Borders } from '../constants/tokens/borders';
+/**
+ * Token key for border radius values.
+ */
 export declare type BorderRadiusTokenType = keyof typeof BorderRadius;
+/**
+ * Token key for breakpoints; includes a default fallback.
+ */
 export declare type BreakpointsTokenType = keyof typeof Breakpoints | 'default';
+/**
+ * Allowed values for color tokens.
+ */
 export declare type ColorsTokenType = typeof Colors[number];
+/**
+ * Allowed values for text color tokens.
+ */
 export declare type TextColorsTokenType = typeof TextColors[number];
+/**
+ * Allowed values for background color tokens.
+ */
 export declare type BackgroundColorsTokenType = typeof BackgroundColors[number];
+/**
+ * Allowed values for border color tokens.
+ */
 export declare type BorderColorsTokenType = typeof BorderColors[number];
+/**
+ * Allowed values for border style tokens.
+ */
 export declare type BordersTokenType = typeof Borders[number];
+/**
+ * Icon token string; can be from predefined list or a Font Awesome class.
+ */
 export declare type IconsTokenType = typeof Icons[number] | `fas ${string}`;
+/**
+ * Token values for ring styles.
+ */
 export declare type RingsTokenType = typeof Rings[number];
+/**
+ * Token values for shadow styles.
+ */
 export declare type ShadowsTokenType = typeof Shadows[number];
+/**
+ * Token key for spacing values.
+ */
 export declare type SpacingTokenType = keyof typeof Spacing;
+/**
+ * Token values for typography styles.
+ */
 export declare type TypographyTokenType = typeof TypographyKeys[number];

package/dist/types/types/flag.type.d.ts

@@ -1,3 +1,6 @@
 import { CountryCode } from 'libphonenumber-js';
 
+/**
+ * Country calling code identifier used for phone number formatting.
+ */
 export type VegaCountryCode = CountryCode;