@heartlandone/vega-sandbox-pr-1521-50c1985674900121427674628ab8007f890f27d7 2.27.0

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

@@ -0,0 +1,143 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { GlobalSlimmers } from '../../vega-slimmer/vega-slimmer-core';
+import { VegaInputPhoneNumberRenderer } from './slimmers/renderers/vega-input-phone-number-renderer';
+import { CountrySelectRenderer } from './slimmers/renderers/country-select-renderer';
+import { PhoneNumberInputRenderer } from './slimmers/renderers/phone-number-input-renderer';
+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 { 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';
+import { ChildNodesEventPreventSlimmer } from '../../helpers/event-manager/slimmers/child-nodes-event-prevent-slimmer';
+import { VegaCountryCode, VegaCountryType } from './types';
+/**
+ * @vegaVersion 2.18.0
+ */
+export declare class VegaInputPhoneNumber {
+  protected readonly globalSlimmers: GlobalSlimmers;
+  protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaInputRangeElement>;
+  protected valueController: VegaInputPhoneNumberValueController;
+  protected inputPhoneNumberRenderer: VegaInputPhoneNumberRenderer;
+  protected countrySelectRenderer: CountrySelectRenderer;
+  protected phoneNumberInputRenderer: PhoneNumberInputRenderer;
+  protected countrySelectController: CountrySelectController;
+  protected changeEventEmitter: EventEmitSlimmerBase;
+  protected countryChangeEventEmitter: EventEmitSlimmerBase;
+  protected inputPhoneNumberEventPrevent: ChildNodesEventPreventSlimmer;
+  protected readonly formFieldController: FormFieldControllerSlimmer<string>;
+  host: HTMLVegaInputPhoneNumberElement;
+  phoneNumberInputValue: string;
+  /**
+   * Specifies the label or title for the phone number input field.
+   *
+   * It provides descriptive text that helps identify the
+   *    purpose or content expected in the input field.
+   *
+   * @vegaVersion 2.18.0
+   */
+  label: string;
+  /**
+   * Specifies the size of the phone number input field.
+   *
+   * @vegaVersion 2.18.0
+   */
+  size: 'default' | 'small';
+  /**
+   * Determines whether the phone number input field is required.
+   *
+   * @vegaVersion 2.18.0
+   */
+  required: boolean;
+  /**
+   * Determines whether the phone number input field is disabled.
+   *
+   * @vegaVersion 2.18.0
+   */
+  disabled: boolean;
+  /**
+   * Specifies the default country calling code using the two-letter uppercase country code.
+   *
+   * @vegaVersion 2.18.0
+   */
+  countryCode: VegaCountryCode;
+  watchCountryCode(newCountryCode: VegaCountryCode, oldCountryCode: VegaCountryCode): void;
+  /**
+   * Specifies the countries available for selection.
+   *
+   * Note: By default, 245 codes are provided, but loading all of them may take time. To improve performance, it is recommended to include only the necessary codes.
+   *
+   * @vegaVersion 2.18.0
+   */
+  allowedCountryCodes: VegaCountryCode[];
+  /**
+   * Specifies the value of the phone number input in [E.164]{@link https://en.wikipedia.org/wiki/E.164} format.
+   *
+   * @VegaWarning Note: The input phone number field will always have a value. If no phone number is entered, the default format is `+{default_country_code}`. For example, if the default country code is US, the default value will be `+1`.
+   * @vegaVersion 2.18.0
+   */
+  value: string;
+  watchValue(newValue: string, oldValue: string): void;
+  /**
+   * Specifies custom validation rules for the phone number input field.
+   *
+   * @vegaVersion 2.18.0
+   */
+  validationRules: FormFieldValidationRule<unknown>[];
+  watchValidationRules(): void;
+  /**
+   * Indicates whether the current value in the field is considered valid
+   *    based on the defined validation rules.
+   *
+   * @vegaVersion 2.18.0
+   */
+  isValid: boolean;
+  /**
+   * Determines whether the phone number input field should undergo automatic validation
+   *    during the user's input.
+   *
+   * @vegaVersion 2.18.0
+   */
+  autoValidation: boolean;
+  /**
+   * Specifies a placeholder string that displays as a temporary hint
+   *    or example inside the input field.
+   *
+   * @vegaVersion 2.18.0
+   */
+  placeholder: string;
+  /**
+   * Provides a supplementary prompt message that assists users in
+   *    understanding the expected value for the input field.
+   *
+   * @vegaVersion 2.18.0
+   */
+  hint: string;
+  /**
+   * An event emitter notifying a value change.
+   *
+   * @vegaVersion 2.18.0
+   */
+  vegaChange: EventEmitter<string>;
+  /**
+   * An event emitter notifying a value change.
+   *
+   * @eventSemantics namespace:native
+   * @vegaVersion 2.18.0
+   */
+  change: EventEmitter<string>;
+  /**
+   * An event emitter notifying a country change.
+   *
+   * @vegaVersion 2.18.0
+   */
+  vegaCountryChange: EventEmitter<VegaCountryType>;
+  /**
+   * An event emitter notifying a country change.
+   *
+   * @eventSemantics namespace:native
+   * @vegaVersion 2.18.0
+   */
+  countryChange: EventEmitter<VegaCountryType>;
+  render(): VegaInputPhoneNumber;
+}

package/dist/types/components/vega-input-range/slimmers/controllers/vega-input-range-value-controller.d.ts

@@ -0,0 +1,40 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaInputRange } from '../../vega-input-range';
+import { InputRangeValueType, RangeInputIndexType } from '../../types';
+/** The `VegaInputRangeValueController` class in TypeScript manages the value and events of an input range component. */
+export declare class VegaInputRangeValueController extends VegaSlimmer {
+  protected value: VegaInputRange['value'];
+  protected host: VegaInputRange['host'];
+  protected changeEventEmitter: VegaInputRange['changeEventEmitter'];
+  /**
+   * This function emits an event and notifies after a value change if the new value is different from the old value.
+   *
+   * @param {InputRangeValueType} newValue - The `newValue` parameter represents the new value of an input range element.
+   * @param {InputRangeValueType} oldValue - The `oldValue` parameter represents the previous value of an input range element before it was changed.
+   */
+  emitEventAndNotifyAfterValueChange(newValue: InputRangeValueType, oldValue: InputRangeValueType): void;
+  /**
+   * The function `updateValueByRangeIndex` updates the value of an array based on the specified index.
+   *
+   * @param {string} itemValue - The `itemValue` parameter is a string representing the value that will be updated in the range input.
+   * @param {RangeInputIndexType} index - The `index` parameter in the `updateValueByRangeIndex` function is used to determine which element in the array `this.value` should be updated.
+   */
+  updateValueByRangeIndex(itemValue: string, index: RangeInputIndexType): void;
+  /**
+   * The function `setValue` sets the value of an input range component in TypeScript.
+   *
+   * @param {InputRangeValueType} value - The `value` parameter in the `setValue` method is of type `InputRangeValueType`.
+   */
+  setValue(value: InputRangeValueType): void;
+  /**
+   * The function `valueGuard` checks if the input value is an array with exactly two elements, where each element is either a string or a number.
+   *
+   * @param {InputRangeValueType} value - The `value` parameter is expected to be an array with a length
+   * of 2, where each element in the array is either a string or a number. The `valueGuard` function
+   * returns `true` if these conditions are met, and `false` otherwise.
+   * @returns {boolean} The `valueGuard` function is returning a boolean value. It checks if the `value` parameter
+   * is an array with a length of 2, and if every item in the array is either a string or a number. If
+   * these conditions are met, the function returns `true`, otherwise it returns `false`.
+   */
+  private valueGuard;
+}

package/dist/types/components/vega-input-range/slimmers/renderers/vega-input-range-clear-icon-renderer.d.ts

@@ -0,0 +1,25 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaInputRange } from '../../vega-input-range';
+export declare class VegaInputRangeClearIconRenderer extends VegaSlimmer {
+  protected showClearIcon: VegaInputRange['showClearIcon'];
+  protected value: VegaInputRange['value'];
+  protected disabled: VegaInputRange['disabled'];
+  protected inputRangeInputRenderer: VegaInputRange['inputRangeInputRenderer'];
+  protected valueController: VegaInputRange['valueController'];
+  /**
+   * This function renders a clear icon element for an input range with specific styling and event handlers.
+   *
+   * @returns {HTMLElement} the clear button
+   */
+  render(): HTMLElement;
+  /**
+   * Set the component value to empty and focus on the first input element
+   */
+  private clearInputRangeValue;
+  /**
+   * It is responsible for determining whether the clear icon should be displayed based on certain conditions.
+   *
+   * @returns {boolean} boolean result
+   */
+  private shouldShowClearIcon;
+}

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

@@ -0,0 +1,64 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaInputRange } from '../../vega-input-range';
+import { RangeInputIndexType } from '../../types';
+export declare class VegaInputRangeInputRenderer extends VegaSlimmer {
+  static readonly defaultPlaceholder: string[];
+  protected value: VegaInputRange['value'];
+  protected prefixIcon: VegaInputRange['prefixIcon'];
+  protected disabled: VegaInputRange['disabled'];
+  protected min: VegaInputRange['min'];
+  protected max: VegaInputRange['max'];
+  protected size: VegaInputRange['size'];
+  protected placeholder: VegaInputRange['placeholder'];
+  protected showClearIcon: VegaInputRange['showClearIcon'];
+  protected valueController: VegaInputRange['valueController'];
+  protected clearIconRenderer: VegaInputRange['clearIconRenderer'];
+  protected translationSlimmer: VegaInputRange['translationSlimmer'];
+  private isMobileDevice;
+  private minFieldInputRef;
+  private maxFieldInputRef;
+  /**
+   * The function `getInputRefByIndex` returns the HTML input element reference based on the index provided.
+   *
+   * @param {RangeInputIndexType} index - The `index` parameter in the `getInputRefByIndex` function is
+   * of type `RangeInputIndexType`. This type is used to specify whether the index refers to the minimum
+   * or maximum input field in a range input element.
+   * @returns {HTMLElement} The `getInputRefByIndex` function returns either the `minFieldInputRef` or
+   * `maxFieldInputRef` based on the `index` provided.
+   */
+  getInputRefByIndex(index: RangeInputIndexType): HTMLVegaInputElement;
+  /**
+   * The below method is e2e-test covered in
+   * @see{module:vega-input-range-label-click}
+   */
+  focusFirstInput: () => void;
+  /** The `render()` method in the `VegaInputRangeInputRenderer` class is responsible for rendering the JSX structure of the input range component. Here's a breakdown of what the `render()` method is doing: */
+  render(): HTMLElement;
+  /**
+   * Get the input props object by range index
+   *
+   * @param {number} index the range index
+   * @returns {InputPropsType} the input props object
+   */
+  private getInputPropsByRangeIndex;
+  /**
+   * update the component value when the range input value change
+   *
+   * @param {NotifyObserverPayload<string>} payload the input value and the input element object
+   */
+  private inputValueChange;
+  /**
+   * get the input placeholder text by the input range index
+   *
+   * @param {number} index the range index 0|1
+   * @returns {string} the input placeholder text
+   */
+  private getPlaceholderByIndex;
+  /**
+   * get the input value by the input range index
+   *
+   * @param {number} index 0|1
+   * @returns {string} the input value
+   */
+  private getDefaultValueByIndex;
+}

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

@@ -0,0 +1,36 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaInputRange } from '../../vega-input-range';
+/** The class VegaInputRangeRenderer is a TypeScript React component that renders an input range field with custom label, hint, and styling options. */
+export declare class VegaInputRangeRenderer extends VegaSlimmer {
+  protected required: VegaInputRange['required'];
+  protected disabled: VegaInputRange['disabled'];
+  protected label: VegaInputRange['label'];
+  protected hint: VegaInputRange['hint'];
+  protected stack: VegaInputRange['stack'];
+  protected inputRangeInputRenderer: VegaInputRange['inputRangeInputRenderer'];
+  private inputRangeContainerRef;
+  /**
+   * This function returns the reference to the input range container element in a TypeScript React component.
+   *
+   * @returns {HTMLElement} An HTMLElement, specifically the inputRangeContainerRef.
+   */
+  getInputRangeContainerRef(): HTMLElement;
+  /**
+   * The render function returns a JSX structure that includes a vega-flex container with a vega-field-label and an input range input renderer.
+   *
+   * @returns {HTMLElement} An HTMLElement is being returned. The code snippet is a render method of a component that
+   * returns a structure containing a vega-flex element with various attributes and child elements,
+   * including a vega-field-label and the result of calling the render method of
+   * inputRangeInputRenderer. Additionally, the renderHintDom method is being called and its result is
+   * included in the returned structure.
+   */
+  render(): HTMLElement;
+  /**
+   * The function `renderHintDom` returns a label element with a hint text if the `hint` property is provided.
+   *
+   * @returns {HTMLElement|null} A `label` element with the class `vega-input-range-hint` containing a `vega-font` element
+   * with the variant `font-footnote1-short` and color `text-secondary`, displaying the hint text stored
+   * in the `this.hint` property.
+   */
+  private renderHintDom;
+}

package/dist/types/components/vega-input-range/types.d.ts

@@ -0,0 +1,5 @@
+export type InputRangeValueType = string[];
+
+export type RangeInputIndexType = 0 | 1;
+
+export type InputRangeStackType = 'vertical' | 'horizontal';

package/dist/types/components/vega-input-range/vega-input-range.d.ts

@@ -0,0 +1,169 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { FormFieldValidationRule } from '../../helpers/validator/rules/form-field-validation-rule';
+import { GlobalSlimmers } from '../../vega-slimmer/vega-slimmer-core';
+import { VegaInputRangeRenderer } from './slimmers/renderers/vega-input-range-renderer';
+import { EventEmitSlimmerBase } from '../../helpers/event-manager/slimmers/event-emit-slimmer';
+import { FormFieldControllerSlimmer } from '../../helpers/slimmers/form-field-controller-slimmer';
+import { InputRangeStackType, InputRangeValueType } from './types';
+import { VegaInputRangeValueController } from './slimmers/controllers/vega-input-range-value-controller';
+import { VegaInputRangeInputRenderer } from './slimmers/renderers/vega-input-range-input-renderer';
+import { ChildNodesEventPreventSlimmer } from '../../helpers/event-manager/slimmers/child-nodes-event-prevent-slimmer';
+import { VegaInputRangeClearIconRenderer } from './slimmers/renderers/vega-input-range-clear-icon-renderer';
+import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
+import { TranslationSlimmer } from '../../helpers/slimmers/translation';
+/**
+ * @vegaVersion 2.2.0
+ */
+export declare class VegaInputRange {
+  protected readonly globalSlimmers: GlobalSlimmers;
+  protected translationSlimmer: TranslationSlimmer<HTMLVegaInputRangeElement>;
+  protected formFieldController: FormFieldControllerSlimmer<InputRangeValueType>;
+  protected inputRangeInputRenderer: VegaInputRangeInputRenderer;
+  protected clearIconRenderer: VegaInputRangeClearIconRenderer;
+  protected inputRangeRenderer: VegaInputRangeRenderer;
+  protected valueController: VegaInputRangeValueController;
+  protected inputChangeEventPrevent: ChildNodesEventPreventSlimmer;
+  protected changeEventEmitter: EventEmitSlimmerBase;
+  protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaInputRangeElement>;
+  host: HTMLVegaInputRangeElement;
+  /**
+   * Specifies the label or title for the input range.
+   *
+   * It provides descriptive text that helps identify the
+   *    purpose or content expected in the input field.
+   *
+   * @vegaVersion 2.2.0
+   */
+  label: string;
+  /**
+   * Represents a pre-set or default value for the input field.
+   *
+   * It allows you to initialize the field with a specific value,
+   *    which is displayed to the user when the input is
+   *    initially rendered.
+   *
+   * If the value is too long, it may be truncated with
+   *    an ellipsis for visual presentation.
+   *
+   * @vegaVersion 2.2.0
+   */
+  value: InputRangeValueType;
+  /**
+   * The input range component is embedded in other components.
+   *
+   * If modifying the input value does not meet the requirements
+   *    of other components, such as limiting the maximum value, etc.,
+   *    you need to modify the value of the input range component and
+   *    display it in real time.
+   *
+   * Since the value of `inputRef` retains the old value,
+   *    it needs to be updated manually when a value changes.
+   *
+   * @param {InputRangeValueType} newValue - The `newValue` parameter represents the new value of the input range.
+   * @param {InputRangeValueType} oldValue - The `oldValue` parameter represents the previous value of the input range before it was changed to the `newValue`.
+   */
+  watchValue(newValue: InputRangeValueType, oldValue: InputRangeValueType): void;
+  /**
+   * Specifies an icon or symbol that appears before the input range,
+   *    providing visual context or enhancing the aesthetic appearance
+   *    of the input.
+   *
+   * @vegaVersion 2.2.0
+   */
+  prefixIcon: string;
+  /**
+   * Determines whether the clear icon should be displayed.
+   *
+   * @vegaVersion 2.2.0
+   */
+  showClearIcon: boolean;
+  /**
+   * Sets the minimum allowable numeric value for the input value.
+   *
+   * @vegaVersion 2.2.0
+   */
+  min: number;
+  /**
+   * Sets the maximum allowable numeric value for the input value.
+   *
+   * @vegaVersion 2.2.0
+   */
+  max: number;
+  /**
+   * Determines whether the input range is required.
+   *
+   * @vegaVersion 2.2.0
+   */
+  required: boolean;
+  /**
+   * Indicates whether the current value in the field is considered valid
+   *    based on the defined validation rules.
+   *
+   * @vegaVersion 2.2.0
+   */
+  isValid: boolean;
+  /**
+   * Determines whether the input field should undergo automatic validation
+   *    during the user's input.
+   *
+   * @vegaVersion 2.2.0
+   */
+  autoValidation: boolean;
+  /**
+   * Defines custom validation rules for the input field.
+   *
+   * @vegaVersion 2.2.0
+   */
+  validationRules: FormFieldValidationRule<unknown>[];
+  watchValidationRules(): void;
+  /**
+   * Defines the size of the input range,
+   *    specifying its width or length.
+   *
+   * @vegaVersion 2.2.0
+   */
+  size: 'default' | 'small';
+  /**
+   * Specifies a placeholder string that displays as a temporary hint
+   *    or example inside the input field.
+   *
+   * It indicates the expected format or pattern of the input.
+   *
+   * @vegaVersion 2.2.0
+   */
+  placeholder: [string, string];
+  /**
+   * Determines whether the input range is disabled.
+   *
+   * @vegaVersion 2.2.0
+   */
+  disabled: boolean;
+  /**
+   * Provides a supplementary prompt message that assists users in
+   *    understanding the expected value for the input field.
+   *
+   * @vegaVersion 2.2.0
+   */
+  hint: string;
+  /**
+   * Determines the arrangement and appearance of
+   *    the label and input areas.
+   *
+   * @vegaVersion 2.2.0
+   */
+  stack: InputRangeStackType;
+  /**
+   * An event emitter notifying a value change.
+   *
+   * @vegaVersion 2.2.0
+   */
+  vegaChange: EventEmitter<[number, number]>;
+  /**
+   * An event emitter notifying a value change.
+   *
+   * @eventSemantics namespace:native
+   * @vegaVersion 2.2.0
+   */
+  change: EventEmitter<[number, number]>;
+  render(): VegaInputRange;
+}

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

@@ -0,0 +1,21 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaInputSelect } from '../../vega-input-select';
+/** The `VegaInputSelectDropdownController` class is a TypeScript React component that controls the behavior of a dropdown select input. */
+export declare class VegaInputSelectDropdownController extends VegaSlimmer {
+  isDropdownShow: VegaInputSelect['isDropdownShow'];
+  vegaSearch: VegaInputSelect['vegaSearch'];
+  searchEventEmitter: VegaInputSelect['searchEventEmitter'];
+  vegaInputSelectValueController: VegaInputSelect['vegaInputSelectValueController'];
+  sourceController: VegaInputSelect['sourceController'];
+  source: VegaInputSelect['source'];
+  /** The `onDropdownShow` function is setting the `isDropdownShow` property of the`VegaInputSelectDropdownController` class to `true`. This function is called when the dropdown select input is shown. */
+  onDropdownShow: () => void;
+  /** The `onDropdownHide` function is setting the `isDropdownShow` property of the `VegaInputSelectDropdownController` class to `false`. This function is called when the dropdown select input is hidden. */
+  onDropdownHide: () => void;
+  /**
+   * The function `addDropdownObserver` adds event observers to a dropdown element.
+   *
+   * @param {HTMLElement} dropdownRef - The `dropdownRef` parameter is a reference to the HTML element representing the dropdown component.
+   */
+  addDropdownObserver(dropdownRef: HTMLVegaDropdownElement): void;
+}

package/dist/types/components/vega-input-select/slimmers/controllers/vega-input-select-items-slot-controler.d.ts

@@ -0,0 +1,19 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { MutationObserverSlimmer } from '../../../../helpers/slimmers/mutation-observer/mutation-observer-slimmer';
+/**
+ * The class `VegaInputSelectItemsSlotController` extends `VegaSlimmer` and manages
+ * appending host items to a dropdown element.
+ */
+export declare class VegaInputSelectItemsSlotController extends VegaSlimmer {
+  protected mutationObserver: MutationObserverSlimmer;
+  private host;
+  private vegaInputSelectDropdownRenderer;
+  /**
+   * Component lifecycle - [componentDidLoad]
+   */
+  componentDidLoad(): void;
+  /**
+   * The function appends host items to a dropdown element.
+   */
+  private appendHostItemsToDropdown;
+}

package/dist/types/components/vega-input-select/slimmers/controllers/vega-input-select-lazy-load-controller.d.ts

@@ -0,0 +1,28 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaInputSelect } from '../../vega-input-select';
+/**
+ * VegaInputSelectLazyLoadController
+ */
+export declare class VegaInputSelectLazyLoadController extends VegaSlimmer {
+  sourceLazyLoadCallback: VegaInputSelect['sourceLazyLoadCallback'];
+  isLazyLoading: VegaInputSelect['isLazyLoading'];
+  sourceController: VegaInputSelect['sourceController'];
+  vegaInputSelectDropdownRenderer: VegaInputSelect['vegaInputSelectDropdownRenderer'];
+  private hasMore;
+  /**
+   * Observer scroll to bottom on vegaVirtualScroll
+   */
+  componentDidLoad(): void;
+  /**
+   * Get virtualScroll
+   *
+   * @returns {Nullable<HTMLElement>} - virtualScroll
+   */
+  private getVirtualScroll;
+  /**
+   * The function `onScrollToBottom` logs a message and emits an event if lazy loading is enabled.
+   *
+   * @param {VegaVirtualScrollToBottomEvent} payload - payload
+   */
+  private onScrollToBottom;
+}

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

@@ -0,0 +1,29 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { SelectSourceItem, SelectType, SelectValueType } from '../../types';
+import { Nullable } from '../../../../types/general';
+/**
+ * The `VegaInputSelectSourceController` class manages the source data for
+ * a dropdown input component in TypeScript.
+ */
+export declare class VegaInputSelectSourceController extends VegaSlimmer {
+  private source;
+  /**
+   * convert the dropdown source when the component watchSource call
+   */
+  handleSourceChange: () => void;
+  /**
+   * Append items to source
+   *
+   * @param {SelectSourceItem[]} items - Appendable items
+   */
+  appendSourceItems(items: SelectSourceItem[]): void;
+  /**
+   * This TypeScript function retrieves an item from a source array based on its ID.
+   *
+   * @param {SelectValueType<SelectType>} id - The `id` parameter in the `getItem` function is of type `SelectValueType<SelectType>`,
+   * which means it can accept a value that corresponds to the `SelectType` defined in the function.
+   * @returns { Nullable<SelectSourceItem>} The `getItem` function is returning a `SelectSourceItem` object that matches the provided
+   * `id`, or `null` if no matching item is found in the `source` array.
+   */
+  getItem(id: SelectValueType<SelectType>): Nullable<SelectSourceItem>;
+}

package/dist/types/components/vega-input-select/slimmers/controllers/vega-input-select-value-controller.d.ts

@@ -0,0 +1,31 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { SelectType, SelectValueType } from '../../types';
+/** The `VegaInputSelectValueController` class is a TypeScript React component that handles the value and change events for an input select component. */
+export declare class VegaInputSelectValueController extends VegaSlimmer {
+  private value;
+  private selectType;
+  private changeEventEmitter;
+  private host;
+  private sourceController;
+  /**
+   * handle the value change when the component watchValue call
+   *
+   * @param {SelectValueType<SelectType>} newValue the new value
+   * @param {SelectValueType<SelectType>} oldValue the old value
+   */
+  handleValueChange: (newValue: SelectValueType<SelectType>, oldValue: SelectValueType<SelectType>) => void;
+  /**
+   * The function sets the value of a select input if it passes a value guard check.
+   *
+   * @param {unknown} value - The `value` parameter is the value that you want to set for the `value` property. It
+   * can be of any type that extends the `SelectType` type.
+   */
+  setValue<T extends SelectType>(value: SelectValueType<T>): void;
+  /**
+   * The function `valueGuard` checks if the input value is valid based on the select type.
+   *
+   * @param {SelectValueType<SelectType>} value - The `value` parameter is of type `SelectValueType<SelectType>`.
+   * @returns {boolean} a boolean value.
+   */
+  private valueGuard;
+}

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

@@ -0,0 +1,37 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { Nullable } from '../../../../types/general';
+/** The `VegaInputSelectDropdownRenderer` class is a TypeScript React component that renders a dropdown select input with various customization options. */
+export declare class VegaInputSelectDropdownRenderer extends VegaSlimmer {
+  private dropdown;
+  private inputSelectContainer;
+  private itemsSlotRef;
+  private value;
+  private source;
+  private host;
+  private selectType;
+  private isDropdownShow;
+  private vegaDropdownProps;
+  private prefixIcon;
+  private placeholder;
+  private selectedLabel;
+  private isLazyLoading;
+  private vegaInputSelectDropdownController;
+  private sourceController;
+  private translationSlimmer;
+  show(): Promise<void>;
+  hide(): Promise<void>;
+  getDropdownRef(): HTMLVegaDropdownElement;
+  getInputSelectContainerRef(): HTMLDivElement;
+  getItemsSlotRef(): Nullable<HTMLElement>;
+  render(): HTMLVegaDropdownElement;
+  private renderItemsSlot;
+  private renderContainer;
+  private renderPrefixIcon;
+  private renderToggleIcon;
+  private renderSelectContainer;
+  private renderMultipleSelected;
+  private renderSingleSelected;
+  private preventBlur;
+  private getVegaDropdownProperties;
+  private getDropdownSource;
+}