@heartlandone/vega-sandbox-pr-1455-d20754632ba30d960fe2d750e022c5b897306226 2.28.0

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

@@ -0,0 +1,235 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { FormControlOption, FormValidateResult } from './types';
+import { GlobalSlimmers } from '../../vega-slimmer/vega-slimmer-core';
+import { EventEmitSlimmerBase } from '../../helpers/event-manager/slimmers/event-emit-slimmer';
+import { ChildNodesEventPreventSlimmer } from '../../helpers/event-manager/slimmers/child-nodes-event-prevent-slimmer';
+import { ChildNodesNotifyObserverSlimmer } from '../../helpers/event-manager/slimmers/child-nodes-notify-observer-slimmer';
+import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
+/**
+ * @vegaVersion 1.3.0
+ */
+export declare class VegaForm {
+  protected readonly globalSlimmers: GlobalSlimmers;
+  protected submitEventEmitter: EventEmitSlimmerBase;
+  protected resetEventEmitter: EventEmitSlimmerBase;
+  protected validateEventEmitter: EventEmitSlimmerBase;
+  protected childEventPrevent: ChildNodesEventPreventSlimmer;
+  protected childFormValidateEventPrevent: ChildNodesEventPreventSlimmer;
+  protected childNotifyObserver: ChildNodesNotifyObserverSlimmer<unknown>;
+  protected childNodeValueChangeObserver: ChildNodesNotifyObserverSlimmer<unknown>;
+  protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaFormElement>;
+  private invalidFieldPathMap;
+  private pendingValidFieldPathMap;
+  private controlledFieldPathSet;
+  private formFieldDisconnectedObserver;
+  private formEventsObserver;
+  private formFieldPendingValidObserver;
+  host: HTMLVegaFormElement;
+  /**
+   * Indicates whether the current form-controlled elements are valid.
+   *
+   * Form-controlled elements are considered for validation if they
+   *    have the `data-vega-form` property.
+   *
+   * Disabled and invisible elements are excluded from validation.
+   *
+   * If the value is `undefined`, it means there are no
+   *    form-controlled elements that can be validated.
+   *
+   * **Additional Notes:**
+   *   1. When depending on `isValid` for form validation, it is advised
+   *      not to modify the following properties of the monitored DOM:
+   *      - `disabled` property
+   *      - Element visibility style
+   *   2. As this property relies heavily on the `VegaValidate` event emitted,
+   *      it is highly recommended to enable auto-validation for all
+   *      form-controlled elements to ensure that the value reflects
+   *      the most up-to-date form validation status.
+   *
+   * @vegaVersion 1.3.0
+   */
+  isValid: boolean | null;
+  watchIsValid(): void;
+  /**
+   * Indicates whether the value of any current
+   *    form-controlled elements has been changed.
+   *
+   *   1. When the value of any form-controlled element is changed,
+   *      this parameter is set to `true`.
+   *   2. When resetting the form, this parameter is set to `false`.
+   *   3. When invoking the `setValue` method, this parameter is set to `false`.
+   *
+   * @vegaVersion 1.3.0
+   */
+  isTouched: boolean;
+  /**
+   * An event emitter notifying the change in the validation result.
+   *
+   * @vegaVersion 1.9.1
+   */
+  vegaValidate: EventEmitter<boolean>;
+  /**
+   * An event emitter notifying the change in the validation result.
+   *
+   * @eventSemantics namespace:native
+   * @vegaVersion 2.0.0
+   */
+  validate: EventEmitter<boolean>;
+  /**
+   * An event emitter notifying the submission of the form.
+   *
+   * @vegaVersion 1.24.0
+   */
+  vegaFormSubmit: EventEmitter<unknown>;
+  /**
+   * An event emitter notifying the submission of the form.
+   *
+   * @eventSemantics namespace:native
+   * @vegaVersion 2.0.0
+   */
+  formSubmit: EventEmitter<unknown>;
+  /**
+   * An event emitter notifying the reset of the form.
+   *
+   * @vegaVersion 1.24.0
+   */
+  vegaFormReset: EventEmitter;
+  /**
+   * An event emitter notifying the reset of the form.
+   *
+   * @eventSemantics namespace:native
+   * @vegaVersion 2.0.0
+   */
+  formReset: EventEmitter;
+  /**
+   * When the vegaForm is deleted, it is necessary to notify
+   *    the parent's vegaForm to update its isValid status.
+   */
+  disconnectedCallback(): Promise<void>;
+  componentDidLoad(): Promise<void>;
+  /**
+   * Invoke this method asynchronously to retrieve the validation result for
+   *    all the vega field elements nested within the `vega-form`.
+   *
+   * If an element is a `vega-form` itself, it will recursively
+   *    invoke its `valid()` method.
+   *
+   * @param {boolean | 'rule'} showError determine whether the validation result should be reflected in UI
+   * @return {Promise<FormValidateResult> } validation result
+   * @vegaVersion 1.3.0
+   */
+  valid(showError?: boolean | 'rule'): Promise<FormValidateResult>;
+  /**
+   * Invoke this method asynchronously to retrieve the values for
+   *    all the available vega field elements nested within the `vega-form`.
+   *
+   * @param {FormControlOption} [option] form control option to skip disabled/invisible components
+   * @return {Promise<T>} object with key and field value as key-value pair
+   * @vegaVersion 1.3.0
+   */
+  getValue<T>(option?: FormControlOption): Promise<T>;
+  /**
+   * Invoke this method to prefill the `vega-form` with the given value.
+   *
+   * This action will also set the `isTouched` property to `false`.
+   *
+   * @param value to prefill into the vega-form
+   * @param {FormControlOption} [option] form control option to skip disabled/invisible components
+   * @vegaVersion 1.3.0
+   */
+  setValue<T>(value: T, option?: FormControlOption): Promise<void>;
+  /**
+   * Invoke this method to reset the vega field elements in the form to
+   *    the default value provided, or an empty string if
+   *    no default value is found.
+   *
+   * @param defaultValueMap map of the vega form field name to default value
+   * @param {FormControlOption} [option] form control option to skip disabled/invisible components
+   *
+   * @vegaVersion 1.3.0
+   */
+  reset(defaultValueMap?: unknown, option?: FormControlOption): Promise<void>;
+  private static getFormFieldValue;
+  render(): VegaForm;
+  /**
+   * If the element is valid, remove it from the set of
+   *    invalid elements. If the element is invalid,
+   *    add it to the set of invalid elements.
+   *
+   * @param {NotifyObserverPayload<boolean>} payload - CustomEvent<boolean> the vegaValidate subject notify from child elements
+   */
+  private updateInternalValidStatus;
+  /**
+   * If the value of any child elements have changed,
+   *    make 'isTouched' prop as false.
+   */
+  private updateInternalTouchedStatus;
+  /**
+   * Navigate the immediate child node under current vega form element with the following strategy
+   *  - if a matched vega field element found, will pass it to the visitor method passed in
+   *  - if a non-matched node found, it will call itself recursively and pass the node as the second parameter
+   * Once the navigation is finished, it will wait for all the pending visitor/self-invocation promise finished before return
+   *
+   * @param visitor async callback method that will be invoked if a matched vega field element found
+   * @param {FormControlOption} [option] form control option to skip disabled/invisible components
+   * @param [startElementNode] element node that the navigation will be started from, default is the current host element
+   * @return {Promise<void>} return void wrapped with promise to notify the navigation is done
+   */
+  private navigateVegaFormChildren;
+  /**
+   * Update the {@link isValid} property value based on the size of {@link invalidFieldPathSet}
+   * If the number of invalid elements is zero, then the form is valid.
+   */
+  private updateIsValidFlag;
+  /**
+   * It returns the value of data-vega-form that the given element is associated with, if child HTMLElements share the same data-vega-form property name
+   * in the same vega-form, then includePath has to be set to be true to get a complete path to avoid the confusion of isValid checking.
+   *
+   * @param {HTMLElement} element - The element that is being validated.
+   * @param {boolean} [includePath] - If true, the field name will include the path to the field. For
+   * example, if the field is in a vega-form with the name "address", the field name will be "address ->
+   * street".
+   * @returns The name of the field.
+   */
+  private getFormFieldName;
+  /**
+   * Return true if the HTMLElement has data-vega-form property and it's not disabled and not invisible if these two properties have to be checked.
+   *
+   * @param {HTMLElement} element - The HTMLElement to check.
+   * @param {boolean} skipDisabled - If true, then disabled form fields will be skipped.
+   * @param {boolean} skipInvisible - If true, only visible elements will be visited.
+   * @returns a boolean value.
+   */
+  private shouldVisitElement;
+  /**
+   * This function registers an observer with the ChangeManager that will be notified when a element
+   * delete operation is triggered
+   */
+  private initFormFieldDisconnectedObserver;
+  /**
+   * If the deleted element is a child or grandchild of current vegaForm, the isValid of all these vegaForms will be updated.
+   *
+   * @param {DisconnectedElementOperationPayload} payload -  the delete element and vegaForm array.
+   * @returns {boolean} A boolean value.
+   */
+  private canAcceptFormFieldDisconnectedOperation;
+  /**
+   * Get the fieldName of the deleted element in the current vegaForm, delete it from the invalidFieldPathSet array, and update isValid at the same time.
+   */
+  private updateInvalidFieldPath;
+  private registerFormSubmitChangeManager;
+  /**
+   * The below method is e2e-test covered in
+   * @see{module:vega-form-field-enter-to-submit-e2e}
+   */
+  private canAcceptFormSubmitEvent;
+  private handleSubmitEvents;
+  private registerFormResetChangeManager;
+  private canAcceptFormResetEvent;
+  private handleResetEvents;
+  private registerFormFieldPendingValidChangeManager;
+  private canAcceptFormFieldPendingValid;
+  private handleFieldPendingValid;
+  private isElementInCurrentForm;
+  private handleChildFormFieldElementValid;
+}

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

@@ -0,0 +1,66 @@
+import { ResponsiveType, GridRowsType, GridColumnsType, GapType } from '../../types/ui.type';
+import { GlobalSlimmers } from '../../vega-slimmer/vega-slimmer-core';
+import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
+/**
+ * @vegaVersion 1.3.0
+ */
+export declare class VegaGrid {
+  protected readonly globalSlimmers: GlobalSlimmers;
+  protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaGridElement>;
+  host: HTMLVegaGridElement;
+  /**
+   * Determines the configuration of the grid columns.
+   *    It can be provided as an integer, string, or a responsive map
+   *    using key-value pairs.
+   *
+   * If provided as an integer from 1 to 12, each column will have the same width.
+   *    The CSS for this configuration is `grid-template-columns: repeat(number, minmax(0, 1fr))`.
+   *
+   * If provided as a string in the format of n-auto
+   *    (e.g., `1-auto`, `2-auto`, ..., `12-auto`),
+   *    each column will have auto width. The CSS for this configuration is
+   *    `grid-template-columns: repeat(number, auto)`.
+   *
+   * Alternatively, you can use a responsive map to define different column configurations
+   *    for various breakpoints. The keys in the map should represent the breakpoints,
+   *    such as `default` or `L`, and the values can be integers or strings following the
+   *    same patterns mentioned above.
+   *
+   * @vegaVersion 1.3.0
+   */
+  column: ResponsiveType<GridColumnsType>;
+  /**
+   * Determines the configuration of the grid rows.
+   *    It can be provided as an integer, string, or a responsive map
+   *    using key-value pairs.
+   *
+   * If provided as an integer from 1 to 6, each row will have the same height.
+   *    The CSS for this configuration is `grid-template-rows: repeat(number, minmax(0, 1fr))`.
+   *
+   * If provided as a string in the format of n-auto
+   *    (e.g., `1-auto`, `2-auto`, ..., `6-auto`),
+   *    each row will have auto height. The CSS for this configuration is
+   *    `grid-template-rows: repeat(number, auto)`.
+   *
+   * Alternatively, you can use a responsive map to define different row configurations
+   *    for various breakpoints. The keys in the map should represent the breakpoints,
+   *    such as `default` or `L`, and the values can be integers or strings following the
+   *    same patterns mentioned above.
+   *
+   * @vegaVersion 1.3.0
+   */
+  row: ResponsiveType<GridRowsType>;
+  /**
+   * Determines the spacing between grid cells.
+   *
+   * It can be provided as a spacing value, such as `size-16` or `size-24`.
+   *
+   * Alternatively, you can use a responsive map to define different gap values for
+   *    various breakpoints. The keys in the map should represent the breakpoints,
+   *    such as `default` or `L`, and the values should be spacing values.
+   *
+   * @vegaVersion 1.3.0
+   */
+  gap: ResponsiveType<GapType>;
+  render(): VegaGrid;
+}

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

@@ -0,0 +1,12 @@
+import { GlobalSlimmers } from '../../vega-slimmer/vega-slimmer-core';
+import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
+/**
+ * @VegaInternalComponent
+ * @vegaVersion 2.20.1
+ */
+export declare class VegaHint {
+  protected readonly globalSlimmers: GlobalSlimmers;
+  protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaHintElement>;
+  host: HTMLVegaHintElement;
+  render(): VegaHint;
+}

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

@@ -0,0 +1,76 @@
+import { SpacingTokenType, TextColorsTokenType } from '../../types/design-token.type';
+import { GlobalSlimmers } from '../../vega-slimmer/vega-slimmer-core';
+import { VegaComponentUsageRuntimeMetricsSlimmer } from '../../helpers/slimmers/component-usage-runtime-metrics';
+/**
+ * @vegaVersion 1.0.4
+ */
+export declare class VegaIcon {
+  private static readonly iconStyleCache;
+  protected readonly globalSlimmers: GlobalSlimmers;
+  protected vegaComponentUsageRuntimeMetricsSlimmer: VegaComponentUsageRuntimeMetricsSlimmer<HTMLVegaIconElement>;
+  host: HTMLVegaIconElement;
+  /**
+   * Specifies the required icon design token for the icon.
+   *
+   * @vegaVersion 1.0.4
+   */
+  icon: string;
+  /**
+   * The below method is e2e-test covered in
+   * @see {module:icon-changed-from-vega-icon-to-fa-icon-class}
+   */
+  watchIcon(): void;
+  /**
+   * Specifies the width and height of the icon.
+   *    For Third Party Icons (e.g., Font Awesome),
+   *    it sets the icon's font-size.
+   *
+   * @vegaVersion 1.0.4
+   */
+  size: SpacingTokenType;
+  /**
+   * Specifies the color of the icon.
+   *
+   * If the color prop is `undefined`, it defaults to `currentColor`.
+   *
+   * @vegaVersion 1.26.0
+   */
+  color?: TextColorsTokenType;
+  componentWillLoad(): void;
+  render(): VegaIcon;
+  /**
+   * Verify whether the icon is FA icon or not
+   *
+   * @param {string} icon - the icon name
+   * @returns {boolean} - return true if the icon is FA icon
+   */
+  private isThirdPartyIcon;
+  private renderForVegaIconToken;
+  /**
+   * The below method is e2e-test covered in
+   * @see {module:render-correct-size-with-fa-icon}
+   * @see {module:append-fa-icon-styles-to-shadow-dom}
+   */
+  private renderForThirdPartyIcon;
+  private formatAndValidSize;
+  /**
+   * The below method is e2e-test covered in
+   * @see {module:render-correct-size-with-fa-icon}
+   */
+  private formatThirdPartyIconSize;
+  /**
+   * The below method is e2e-test covered in
+   * @see {module:console-warn-when-load-fa-lib-timeout}
+   */
+  private cloneFAIconStyles;
+  /**
+   * The below method is e2e-test covered in
+   * @see {module:append-fa-icon-styles-to-shadow-dom}
+   */
+  private appendStyles;
+  /**
+   * The below method is e2e-test covered in
+   * @see {module:append-fa-icon-styles-to-shadow-dom}
+   */
+  private getIconStyleHTML;
+}

package/dist/types/components/vega-image-uploader/slimmers/controllers/vega-image-uploader-actions-visibility-controller.d.ts

@@ -0,0 +1,14 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaImageUploader } from '../../vega-image-uploader';
+/** The `VegaImageUploaderActionsVisibilityController` class is responsible for handling the focus and hiding of backdrop and tooltip elements in a Vega Image Uploader component. */
+export declare class VegaImageUploaderActionsVisibilityController extends VegaSlimmer {
+  host: VegaImageUploader['host'];
+  value: VegaImageUploader['value'];
+  /** trigger a vegaChange event when component value change */
+  handleValueChange(): void;
+  /**
+   * The function hides the backdrop and actions of a vega-image-uploader component by blurring the active element.
+   * The activeElement should be div.image-preview-container and replace button
+   */
+  private hideBackDropAndActions;
+}

package/dist/types/components/vega-image-uploader/slimmers/controllers/vega-image-uploader-input-controller.d.ts

@@ -0,0 +1,15 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaImageUploader } from '../../vega-image-uploader';
+/** The VegaImageUploaderInputController class is responsible for handling user interactions and controlling the input element of the VegaImageUploader component. */
+export declare class VegaImageUploaderInputController extends VegaSlimmer {
+  inputRenderer: VegaImageUploader['vegaImageUploaderInputRenderer'];
+  disabled: VegaImageUploader['disabled'];
+  /**
+   * The function triggers a click event on a file input element if it is not disabled.
+   */
+  triggerInputClick(): void;
+  /**
+   * The function "resetInput" clears the value of a file input element.
+   */
+  resetInput(): void;
+}

package/dist/types/components/vega-image-uploader/slimmers/controllers/vega-image-uploader-preview-controller.d.ts

@@ -0,0 +1,36 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaImageUploader } from '../../vega-image-uploader';
+import { VegaFile } from '../../types';
+import { Nullable } from '../../../../types/general';
+/** The `VegaImageUploaderPreviewController` class is responsible for showing a preview of an uploaded image in a modal. */
+export declare class VegaImageUploaderPreviewController extends VegaSlimmer {
+  value: VegaImageUploader['value'];
+  private previewModalRef;
+  /**
+   * remove preview modal when component destroy
+   */
+  disconnectedCallback(): void;
+  /**
+   * The `getImagePreviewURL` method is responsible for generating the URL of the image preview. It
+   * checks if `this.value` exists, and if so, it returns the URL of the uploaded file (`(this.value as
+   * VegaUploadedFile).url`). If the URL is not available, it falls back to creating a temporary URL
+   * using `URL.createObjectURL(this.value as File)`. This temporary URL is used for previewing the
+   * image until it is uploaded or saved permanently.
+   *
+   * @param {VegaFile} [file] the file object which needs to convert to a URL
+   * @returns {Nullable<string>} the url of image
+   */
+  getImagePreviewURL: (file?: VegaFile) => Nullable<string>;
+  /**
+   * The `showPreview` function displays an image preview in a modal, either by generating a new modal or updating an existing one.
+   */
+  showPreview(): void;
+  /**
+   * The `generatePreviewModal` method is a private method of the `VegaImageUploaderPreviewController`
+   * class. It is responsible for creating a modal element and appending it to the document body.
+   *
+   * @param {Nullable<string>} imagePreviewURL the image url
+   * @returns {HTMLElement} a preview vega modal
+   */
+  private generatePreviewModal;
+}

package/dist/types/components/vega-image-uploader/slimmers/controllers/vega-image-uploader-remove-controller.d.ts

@@ -0,0 +1,18 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaImageUploader } from '../../vega-image-uploader';
+/** The `VegaImageUploaderRemoveController` class is responsible for handling the removal of images from the `VegaImageUploader` component. */
+export declare class VegaImageUploaderRemoveController extends VegaSlimmer {
+  valueController: VegaImageUploader['vegaImageUploaderValueController'];
+  removeEventEmitter: VegaImageUploader['removeEventEmitter'];
+  private removeDialogRef;
+  /**
+   * remove the dialog when element destroy
+   */
+  disconnectedCallback(): void;
+  /**
+   * open a vega dialog confirm remove the file
+   */
+  showRemoveDialog: () => void;
+  /** The `handleRemoveFile` method is responsible for removing the image from the `VegaImageUploader` component. */
+  handleRemoveFile: () => void;
+}

package/dist/types/components/vega-image-uploader/slimmers/controllers/vega-image-uploader-value-controller.d.ts

@@ -0,0 +1,18 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaImageUploader } from '../../vega-image-uploader';
+import { VegaFile } from '../../types';
+/** The VegaImageUploaderValueController class is responsible for handling the value and change events of a VegaImageUploader component. */
+export declare class VegaImageUploaderValueController extends VegaSlimmer {
+  value: VegaImageUploader['value'];
+  changeEventEmitter: VegaImageUploader['changeEventEmitter'];
+  host: VegaImageUploader['host'];
+  inputController: VegaImageUploader['vegaImageUploaderInputController'];
+  /** trigger a vegaChange event when component value change */
+  handleValueChange(): void;
+  /**
+   * The function sets the value of a variable to either a VegaFile object or null.
+   *
+   * @param {VegaFile | null} value - The value parameter is of type VegaFile or null.
+   */
+  setValue(value: VegaFile | null): void;
+}

package/dist/types/components/vega-image-uploader/slimmers/renderers/vega-image-uploader-actions-renderer.d.ts

@@ -0,0 +1,40 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaImageUploader } from '../../vega-image-uploader';
+/** The `VegaImageUploaderActionsRenderer` class is a TypeScript React component that renders action buttons for an image uploader component. */
+export declare class VegaImageUploaderActionsRenderer extends VegaSlimmer {
+  inputController: VegaImageUploader['vegaImageUploaderInputController'];
+  valueController: VegaImageUploader['vegaImageUploaderValueController'];
+  previewController: VegaImageUploader['vegaImageUploaderPreviewController'];
+  removeController: VegaImageUploader['vegaImageUploaderRemoveController'];
+  disabled: VegaImageUploader['disabled'];
+  showPreviewButton: VegaImageUploader['showPreviewButton'];
+  showRemoveButton: VegaImageUploader['showRemoveButton'];
+  showReplaceButton: VegaImageUploader['showReplaceButton'];
+  removeEventEmitter: VegaImageUploader['removeEventEmitter'];
+  /**
+   * The handleClick function takes a type parameter and performs different actions based on the value of the type.
+   *
+   * @param {string} type - The `type` parameter is a string that represents the type of action to be performed. It can have one of the following values: 'Preview', 'Delete', or 'Replace'.
+   */
+  handleClick(type: string): void;
+  /**
+   * The render function returns a span element with action buttons based on certain conditions.
+   *
+   * @returns {HTMLSpanElement | null} an HTMLSpanElement if the condition "withActions" is true. Otherwise, it returns null.
+   */
+  render(): HTMLSpanElement | null;
+  /**
+   * render the action button by action type, preview button, delete button
+   *
+   * @param {UploaderActionTypes} actionType action type
+   * @returns {HTMLVegaButtonCircleElement} tooltip element
+   */
+  private renderActionButton;
+  /**
+   * get action button props icon, onClick, label by action type
+   *
+   * @param {UploaderActionTypes} actionType action type
+   * @returns {Nullable<ActionButtonOptions>} the options result
+   */
+  private getButtonOptions;
+}

package/dist/types/components/vega-image-uploader/slimmers/renderers/vega-image-uploader-default-content-renderer.d.ts

@@ -0,0 +1,17 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaImageUploader } from '../../vega-image-uploader';
+/** The VegaImageUploaderDefaultContentRenderer class is a TypeScript React component that renders a button-like element for uploading images. */
+export declare class VegaImageUploaderDefaultContentRenderer extends VegaSlimmer {
+  inputController: VegaImageUploader['vegaImageUploaderInputController'];
+  actionTitle: VegaImageUploader['actionTitle'];
+  actionSubTitle: VegaImageUploader['actionSubTitle'];
+  translationSlimmer: VegaImageUploader['translationSlimmer'];
+  /**
+   * The render function returns a div element with a button-like appearance that triggers a click event when clicked or when the enter key is pressed.
+   *
+   * @returns {HTMLDivElement} The render() method is returning an HTMLDivElement.
+   */
+  render(): HTMLDivElement;
+  private renderSubtitle;
+  private handleUploaderClick;
+}

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

@@ -0,0 +1,23 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaImageUploader } from '../../vega-image-uploader';
+/** The VegaImageUploaderInputRenderer class is a TypeScript React component that renders an input element of type "file" for uploading images and provides methods for accessing and manipulating the file input element. */
+export declare class VegaImageUploaderInputRenderer extends VegaSlimmer {
+  valueController: VegaImageUploader['vegaImageUploaderValueController'];
+  accept: VegaImageUploader['accept'];
+  private fileInputRef;
+  /**
+   * The `getFileInputRef()` method is returning a reference to the HTMLInputElement that represents the
+   * file input element in the component's render method. This allows other parts of the code to access
+   * and manipulate the file input element if needed.
+   *
+   * @returns {HTMLInputElement} the input ref
+   */
+  getFileInputRef(): HTMLInputElement;
+  /** The `render()` method is defining the JSX/HTML structure that will be rendered by this component. In this case, it is returning an `<input>` element of type "file". */
+  render(): HTMLInputElement;
+  /**
+   * The below method is e2e-test covered in
+   * @see{module:the-value-will-be-changed-when-selected-the-image-file}
+   */
+  private handleFileInputChange;
+}

package/dist/types/components/vega-image-uploader/slimmers/renderers/vega-image-uploader-preview-content-renderer.d.ts

@@ -0,0 +1,13 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaImageUploader } from '../../vega-image-uploader';
+/** The VegaImageUploaderPreviewContentRenderer class is responsible for rendering an image preview container with an image and optional actions element. */
+export declare class VegaImageUploaderPreviewContentRenderer extends VegaSlimmer {
+  actionsRenderer: VegaImageUploader['vegaImageUploaderActionsRenderer'];
+  /**
+   * The function renders an image preview container with an image and optional actions element.
+   *
+   * @param {string} imagePreviewURL - A string representing the URL of the image to be previewed.
+   * @returns {HTMLDivElement} an HTMLDivElement includes an image and action buttons
+   */
+  render(imagePreviewURL: string): HTMLDivElement;
+}

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

@@ -0,0 +1,30 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaImageUploader } from '../../vega-image-uploader';
+/** The VegaImageUploaderRenderer class is a TypeScript React component that renders a VegaImageUploader with different content based on its status. */
+export declare class VegaImageUploaderRenderer extends VegaSlimmer {
+  inputRenderer: VegaImageUploader['vegaImageUploaderInputRenderer'];
+  defaultContentRenderer: VegaImageUploader['vegaImageUploaderDefaultContentRenderer'];
+  previewContentRenderer: VegaImageUploader['vegaImageUploaderPreviewContentRenderer'];
+  uploadingContentRenderer: VegaImageUploader['vegaImageUploaderUploadingContentRenderer'];
+  previewController: VegaImageUploader['vegaImageUploaderPreviewController'];
+  value: VegaImageUploader['value'];
+  disabled: VegaImageUploader['disabled'];
+  status: VegaImageUploader['status'];
+  label: VegaImageUploader['label'];
+  required: VegaImageUploader['required'];
+  width: VegaImageUploader['width'];
+  height: VegaImageUploader['height'];
+  hint: VegaImageUploader['hint'];
+  private imageUploaderContainerRef;
+  getImageUploaderContainer(): HTMLElement;
+  /**
+   * The render function returns a JSX element that represents a VegaImageUploader component with a disabled border if it is disabled and does not have a value.
+   *
+   * @returns {VegaImageUploader} The render() function is returning a JSX element of type VegaImageUploader.
+   */
+  render(): VegaImageUploader;
+  private renderLabelDom;
+  private renderContentByStatus;
+  private renderHint;
+  private getSize;
+}

package/dist/types/components/vega-image-uploader/slimmers/renderers/vega-image-uploader-uploading-content-renderer.d.ts

@@ -0,0 +1,15 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaImageUploader } from '../../vega-image-uploader';
+/** The VegaImageUploaderUploadingContentRenderer class is a TypeScript React component that renders a cancel action button for an image uploader. */
+export declare class VegaImageUploaderUploadingContentRenderer extends VegaSlimmer {
+  removeController: VegaImageUploader['vegaImageUploaderRemoveController'];
+  status: VegaImageUploader['status'];
+  cancelEventEmitter: VegaImageUploader['cancelEventEmitter'];
+  /**
+   * The above function renders a div element with a cancel action button that triggers a function when clicked or when the enter key is pressed.
+   *
+   * @returns {HTMLDivElement} The render() method is returning an HTMLDivElement.
+   */
+  render(): HTMLDivElement;
+  private handleCancelUploading;
+}