@globalpayments/vega 2.34.0 → 2.35.0

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

@@ -13,10 +13,15 @@ export declare class VegaInputPhoneNumberValueController extends VegaSlimmer {
   protected countrySelectController: VegaInputPhoneNumber['countrySelectController'];
   protected changeEventEmitter: VegaInputPhoneNumber['changeEventEmitter'];
   protected phoneNumberInputValue: VegaInputPhoneNumber['phoneNumberInputValue'];
+  protected emptyValueEnabled: VegaInputPhoneNumber['emptyValueEnabled'];
   /**
    * componentWillLoad
    */
   componentWillLoad(): void;
+  /**
+   * watch emptyValueEnabled change
+   */
+  watchEmptyValueEnabled(): void;
   /**
    * The `watchValue` function updates a value and emits change events based on certain conditions.
    *
@@ -77,4 +82,18 @@ export declare class VegaInputPhoneNumberValueController extends VegaSlimmer {
    * starting from the length of the calling code prefix for the specified `country`.
    */
   private removeCallingCodePrefix;
+  /**
+   * Set value
+   *
+   * @param {string} inputValue - The value of phone number input.
+   * @param {Function} formatValue - Format value callback
+   */
+  private trySetValue;
+  /**
+   * Should set value of phone number to empty string
+   *
+   * @param {string} inputValue - The value of phone number input
+   * @returns {boolean} -
+   */
+  private shouldSetEmptyValue;
 }

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

@@ -70,6 +70,15 @@ export declare class VegaInputPhoneNumber {
    * @vegaVersion 2.18.0
    */
   allowedCountryCodes: VegaCountryCode[];
+  /**
+   * Specifies whether the phone number input field can be set to an empty value.
+   *   When set to true, the value of phoneNumber is cleared when the input field is empty.
+   *   When set to false, the value of phoneNumber is always composed of the country code and phone number, even if the input field is empty.
+   *
+   * @vegaVersion 2.35.0
+   */
+  emptyValueEnabled: boolean;
+  watchEmptyValueEnabled(): void;
   /**
    * Specifies the value of the phone number input in [E.164]{@link https://en.wikipedia.org/wiki/E.164} format.
    *

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

@@ -37,6 +37,7 @@ export declare class VegaPagination {
    * @vegaVersion 1.3.0
    */
   total: number;
+  watchTotal(): void;
   /**
    * Specifies the number of data items to be displayed per page in
    *    the pagination component.

package/dist/types/components/vega-rich-text-content/slimmers/renderers/vega-rich-text-content-renderer.d.ts

@@ -6,6 +6,7 @@ export declare class VegaRichTextContentRenderer extends VegaSlimmer {
   contentEditable: VegaRichTextContent['contentEditable'];
   content: VegaRichTextContent['content'];
   private richTextContentRef;
+  private readonly blockRenderers;
   constructor();
   /**
    * Get the rich text content element
@@ -16,5 +17,6 @@ export declare class VegaRichTextContentRenderer extends VegaSlimmer {
   render(): VegaRichTextContent;
   private renderRichTextContent;
   private renderContent;
+  private getBlockRenderer;
   private shouldShowPlaceholder;
 }

package/dist/types/components/vega-rich-text-editor/dto/annotations/bold-annotation.d.ts

@@ -15,13 +15,6 @@ export declare class BoldAnnotation extends NodeAnnotation {
    * @returns {[NodeAnnotationTypeEnum.BOLD, BoldAnnotation]} Map item for the annotation
    */
   static from(bold: boolean): [NodeAnnotationTypeEnum.BOLD, BoldAnnotation];
-  /**
-   * Generate the map item for the annotation by html element
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {[NodeAnnotationTypeEnum.BOLD, BoldAnnotation]} Map item for the annotation
-   */
-  static fromHTML(node: HTMLElement): [NodeAnnotationTypeEnum.BOLD, BoldAnnotation];
   /**
    * Generate the JSON representation of the annotation
    *

package/dist/types/components/vega-rich-text-editor/dto/annotations/code-annotation.d.ts

@@ -15,13 +15,6 @@ export declare class CodeAnnotation extends NodeAnnotation {
    * @returns {[NodeAnnotationTypeEnum.CODE, CodeAnnotation]} Map item for the annotation
    */
   static from(code: boolean): [NodeAnnotationTypeEnum.CODE, CodeAnnotation];
-  /**
-   * Generate the map item for the annotation by html element
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {[NodeAnnotationTypeEnum.CODE, CodeAnnotation]} Map item for the annotation
-   */
-  static fromHTML(node: HTMLElement): [NodeAnnotationTypeEnum.CODE, CodeAnnotation];
   /**
    * Generate the JSON representation of the annotation
    *

package/dist/types/components/vega-rich-text-editor/dto/annotations/horizontal-alignment-annotation.d.ts

@@ -15,20 +15,6 @@ export declare class HorizontalAlignmentAnnotation extends BlockAnnotation {
    * @returns {[BlockAnnotationTypeEnum.ALIGNMENT, HorizontalAlignmentAnnotation]} Map item for the annotation
    */
   static from(textAlign: VegaRTEBlockAlignment): [BlockAnnotationTypeEnum.ALIGNMENT, HorizontalAlignmentAnnotation];
-  /**
-   * Generate the map item for the annotation by html element
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {[BlockAnnotationTypeEnum.ALIGNMENT, HorizontalAlignmentAnnotation]} Map item for the annotation
-   */
-  static fromHTML(node: HTMLElement): Nullable<[BlockAnnotationTypeEnum.ALIGNMENT, HorizontalAlignmentAnnotation]>;
-  /**
-   * Get the text alignment of an HTML element.
-   *
-   * @param {HTMLElement} node - An HTMLElement.
-   * @returns {Nullable<VegaRTEBlockAlignment>} text alignment.
-   */
-  private static getTextAlign;
   /**
    * Generate the JSON item of the annotation
    *

package/dist/types/components/vega-rich-text-editor/dto/annotations/image-annotation.d.ts

@@ -18,14 +18,6 @@ export declare class ImageAnnotation extends NodeAnnotation {
    * @returns {[NodeAnnotationTypeEnum.IMAGE, ImageAnnotation]} Map item for the annotation
    */
   static from(size: VegaRichTextImageEditorSizeType, alt: string): [NodeAnnotationTypeEnum.IMAGE, ImageAnnotation];
-  /**
-   * Generate the map item for the annotation
-   *
-   * @param {VegaRichTextImageEditorSizeType} size - size.
-   * @param {string} alt - alt.
-   * @returns {[NodeAnnotationTypeEnum.IMAGE, ImageAnnotation]} Map item for the annotation
-   */
-  static fromHTML(size: VegaRichTextImageEditorSizeType, alt: string): [NodeAnnotationTypeEnum.IMAGE, ImageAnnotation];
   /**
    * Generate the JSON representation of the annotation
    *

package/dist/types/components/vega-rich-text-editor/dto/annotations/indent-annotation.d.ts

@@ -15,20 +15,6 @@ export declare class IndentAnnotation extends BlockAnnotation {
    * @returns {[BlockAnnotationTypeEnum.INDENT, IndentAnnotation]} Map item for the annotation
    */
   static from(indent: number): [BlockAnnotationTypeEnum.INDENT, IndentAnnotation];
-  /**
-   * Generate the map item for the annotation by html element
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {[BlockAnnotationTypeEnum.INDENT, IndentAnnotation]} Map item for the annotation
-   */
-  static fromHTML(node: HTMLElement): Nullable<[BlockAnnotationTypeEnum.INDENT, IndentAnnotation]>;
-  /**
-   * Retrieves the left margin value of an HTML element.
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {number} margin left.
-   */
-  private static getMarginLeft;
   /**
    * Generate the JSON item of the annotation
    *

package/dist/types/components/vega-rich-text-editor/dto/annotations/italic-annotation.d.ts

@@ -15,13 +15,6 @@ export declare class ItalicAnnotation extends NodeAnnotation {
    * @returns {Nullable<[NodeAnnotationTypeEnum.ITALIC, ItalicAnnotation]>} Map item for the annotation
    */
   static from(italic: boolean): [NodeAnnotationTypeEnum.ITALIC, ItalicAnnotation];
-  /**
-   * Generate the map item for the annotation by html element
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {[NodeAnnotationTypeEnum.ITALIC, ItalicAnnotation]} Map item for the annotation
-   */
-  static fromHTML(node: HTMLElement): [NodeAnnotationTypeEnum.ITALIC, ItalicAnnotation];
   /**
    * Generate the JSON representation of the annotation
    *

package/dist/types/components/vega-rich-text-editor/dto/annotations/link-annotation.d.ts

@@ -15,13 +15,6 @@ export declare class LinkAnnotation extends NodeAnnotation {
    * @returns {[NodeAnnotationTypeEnum.LINK, LinkAnnotation]} Map item for the annotation
    */
   static from(link: VegaRTELink): [NodeAnnotationTypeEnum.LINK, LinkAnnotation];
-  /**
-   * Generate the map item for the annotation by html element
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {[NodeAnnotationTypeEnum.LINK, LinkAnnotation]} Map item for the annotation
-   */
-  static fromHTML(node: HTMLElement): Nullable<[NodeAnnotationTypeEnum.LINK, LinkAnnotation]>;
   /**
    * Generate the JSON representation of the annotation
    *

package/dist/types/components/vega-rich-text-editor/dto/annotations/link-group-annotation.d.ts

@@ -1,6 +1,5 @@
 import { Annotation, InternalAnnotationTypeEnum } from './annotation.abstract';
 import { RTETextNode } from '../nodes/text-node';
-import { RTERenderContext } from '../../interface';
 /**
  * Annotation to represent a link of grouped nodes
  */
@@ -8,9 +7,4 @@ export declare class LinkGroupAnnotation extends Annotation {
   readonly type: InternalAnnotationTypeEnum;
   linkGroups: Map<string, RTETextNode[]>;
   constructor(groupKey: string);
-  renderNodes(nodes: RTETextNode[], { editable }: RTERenderContext): HTMLElement[];
-  private renderLinkEditorWrapper;
-  private renderLink;
-  private isLinkGroup;
-  private groupNodesByLink;
 }

package/dist/types/components/vega-rich-text-editor/dto/annotations/strikethrough-annotation.d.ts

@@ -15,13 +15,6 @@ export declare class StrikethroughAnnotation extends NodeAnnotation {
    * @returns {[NodeAnnotationTypeEnum.STRIKETHROUGH, StrikethroughAnnotation]} Map item for the annotation
    */
   static from(strikethrough: boolean): [NodeAnnotationTypeEnum.STRIKETHROUGH, StrikethroughAnnotation];
-  /**
-   * Generate the map item for the annotation by html element
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {[NodeAnnotationTypeEnum.STRIKETHROUGH, StrikethroughAnnotation]} Map item for the annotation
-   */
-  static fromHTML(node: HTMLElement): [NodeAnnotationTypeEnum.STRIKETHROUGH, StrikethroughAnnotation];
   /**
    * Generate the JSON representation of the annotation
    *

package/dist/types/components/vega-rich-text-editor/dto/annotations/text-color-annotation.d.ts

@@ -15,13 +15,6 @@ export declare class TextColorAnnotation extends NodeAnnotation {
    * @returns {[NodeAnnotationTypeEnum.TEXT_COLOR, TextColorAnnotation]} Map item for the annotation
    */
   static from(textColor: string): [NodeAnnotationTypeEnum.TEXT_COLOR, TextColorAnnotation];
-  /**
-   * Generate the map item for the annotation by html element
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {[NodeAnnotationTypeEnum.TEXT_COLOR, TextColorAnnotation]} Map item for the annotation
-   */
-  static fromHTML(node: HTMLElement): Nullable<[NodeAnnotationTypeEnum.TEXT_COLOR, TextColorAnnotation]>;
   /**
    * Generate the JSON representation of the annotation
    *

package/dist/types/components/vega-rich-text-editor/dto/annotations/text-style-annotation.d.ts

@@ -15,20 +15,6 @@ export declare class TextStyleAnnotation extends BlockAnnotation {
    * @returns {[BlockAnnotationTypeEnum.TEXT_STYLE, TextStyleAnnotation]} Map item for the annotation
    */
   static from(textStyle: VegaRTETextStyleType): [BlockAnnotationTypeEnum.TEXT_STYLE, TextStyleAnnotation];
-  /**
-   * Generate the map item for the annotation by html element
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {[BlockAnnotationTypeEnum.TEXT_STYLE, TextStyleAnnotation]} Map item for the annotation
-   */
-  static fromHTML(node: HTMLElement): [BlockAnnotationTypeEnum.TEXT_STYLE, TextStyleAnnotation];
-  /**
-   * Get the type of block.
-   *
-   * @param {HTMLElement} node - An HTMLElement.
-   * @returns {VegaRTETextStyleType} text style type.
-   */
-  private static getTextStyle;
   /**
    * Generate the JSON representation of the annotation
    *

package/dist/types/components/vega-rich-text-editor/dto/annotations/underline-annotation.d.ts

@@ -15,13 +15,6 @@ export declare class UnderlineAnnotation extends NodeAnnotation {
    * @returns {[NodeAnnotationTypeEnum.UNDERLINE, UnderlineAnnotation]} Map item for the annotation
    */
   static from(underline: boolean): [NodeAnnotationTypeEnum.UNDERLINE, UnderlineAnnotation];
-  /**
-   * Generate the map item for the annotation by html element
-   *
-   * @param {HTMLElement} node - An html element.
-   * @returns {[NodeAnnotationTypeEnum.UNDERLINE, UnderlineAnnotation]} Map item for the annotation
-   */
-  static fromHTML(node: HTMLElement): [NodeAnnotationTypeEnum.UNDERLINE, UnderlineAnnotation];
   /**
    * Generate the JSON representation of the annotation
    *

package/dist/types/components/vega-rich-text-editor/dto/blocks/block.abstract.d.ts

@@ -1,4 +1,4 @@
-import { AnnotationStyle, RTEBlockType, RTERenderContext, VegaRTEBlockAnnotations, VegaRTEBlockBase } from '../../interface';
+import { RTEBlockType, VegaRTEBlockAnnotations, VegaRTEBlockBase } from '../../interface';
 import { BlockAnnotation, BlockAnnotationTypeEnum } from '../annotations/block-annotation.abstract';
 import { AnnotationAction } from '../actions/annotation-action.abstract';
 import { Nullable } from '../../../../types/general';
@@ -13,7 +13,7 @@ import { BlockBaseOperator } from '../helper/block-base-operator';
  */
 export declare abstract class RTEBlock extends BlockBaseOperator {
   id: string;
-  protected annotationMap: Map<keyof typeof BlockAnnotationTypeEnum | InternalAnnotationTypeEnum.LINK_GROUP, BlockAnnotation | LinkGroupAnnotation>;
+  annotationMap: Map<keyof typeof BlockAnnotationTypeEnum | InternalAnnotationTypeEnum.LINK_GROUP, BlockAnnotation | LinkGroupAnnotation>;
   abstract type: RTEBlockType;
   abstract parent: VegaRTEContent | RTEBlock;
   protected constructor(id: string);
@@ -30,14 +30,6 @@ export declare abstract class RTEBlock extends BlockBaseOperator {
    * `BlockAnnotationTypeEnum` and a `BlockAnnotation` object.
    */
   protected static createAnnotationEntity(type: keyof VegaRTEBlockAnnotations, value: unknown): Nullable<[BlockAnnotationTypeEnum, BlockAnnotation]>;
-  /**
-   * Create annotations for block element.
-   *
-   * @param {string} type - Annotations type.
-   * @param {HTMLElement} node - current node.
-   * @returns {Nullable<[BlockAnnotationTypeEnum, BlockAnnotation]>} - result.
-   */
-  protected static createAnnotationEntityFromHTML(type: string, node: HTMLElement): Nullable<[BlockAnnotationTypeEnum, BlockAnnotation]>;
   /**
    * Class to JSON object
    *
@@ -57,7 +49,6 @@ export declare abstract class RTEBlock extends BlockBaseOperator {
    * @param {AnnotationAction} action - Annotation action
    */
   apply(action: AnnotationAction | ModifyContentAction): void;
-  abstract render(renderContext?: RTERenderContext): HTMLElement;
   /**
    * Apply action to block
    *
@@ -70,18 +61,6 @@ export declare abstract class RTEBlock extends BlockBaseOperator {
    * @param {AnnotationAction} action - Annotation action
    */
   protected applyAnnotationAction(action: AnnotationAction): void;
-  /**
-   * Get styles from annotations
-   *
-   * @returns {AnnotationStyle} - Annotation style
-   */
-  protected getStyles(): AnnotationStyle;
-  /**
-   * Get classes from annotations
-   *
-   * @returns {AnnotationStyle} - Annotation style
-   */
-  protected getClasses(): string;
   /**
    * Appends a list of RTENode objects to the current node's child nodes and sets the parent block of each node to the current node.
    *

package/dist/types/components/vega-rich-text-editor/dto/blocks/image-block.d.ts

@@ -1,4 +1,4 @@
-import { RTEBlockType, VegaRTEImageBlock, RTERenderContext } from '../../interface';
+import { RTEBlockType, VegaRTEImageBlock } from '../../interface';
 import { RTEBlock } from './block.abstract';
 import { RTEImageNode } from '../nodes/image-node';
 import { ModifyContentAction } from '../actions/modify-content-action.abstract';
@@ -11,19 +11,36 @@ export declare class RTEImageBlock extends RTEBlock {
   nodes: RTEImageNode[];
   parent: VegaRTEContent;
   constructor(id: string);
+  /**
+   * Converts a VegaRTEImageBlock object into an RTEImageBlock object by mapping nodes and creating annotations.
+   *
+   * @param {VegaRTEImageBlock} block - The block object to be converted.
+   * @returns {RTEImageBlock} An instance of `RTEImageBlock`
+   */
   static from(block: VegaRTEImageBlock): RTEImageBlock;
-  static fromHTML(node: HTMLImageElement | HTMLDivElement): RTEImageBlock;
+  /**
+   * @inheritDoc
+   */
   toJSON(): VegaRTEImageBlock;
+  /**
+   * @inheritDoc
+   */
   isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
   getLastNode(): RTEImageNode;
-  render(renderContext?: RTERenderContext): HTMLElement;
   /**
-   * Apply modify action to block
+   * Apply a modify action to block
    *
    * @param {ModifyContentAction} action - Modify action
    */
   protected doModifyActionApply(action: ModifyContentAction): void;
-  private registerRef;
+  /**
+   * Removes a specified child node from a list of nodes and triggers a parent action if the list becomes empty.
+   *
+   * @param {RemoveChildAction} action - Action to be performed when removing a child node from the list of nodes.
+   */
   private removeChildNode;
   /**
    * The image offset should be 0 or 1
@@ -31,14 +48,60 @@ export declare class RTEImageBlock extends RTEBlock {
    *
    * @param {RTEImageNode} imageNode The split point image node
    * @param {number} imageOffset The cursor point 0 | 1
+   * @returns {Nullable<RTEBlock>} The new block after split
    */
   private splitImageNodes;
+  /**
+   * Creates a new RTEImageBlock instance with the provided RTEImageNode instances appended to it.
+   *
+   * @param {RTEImageNode[]} nodes - An array of RTEImageNode objects that will be used to create a new RTEImageBlock instance.
+   * @returns {RTEImageBlock} A new `RTEImageBlock` object with the provided `nodes` appended to it.
+   */
   private cloneWithNodes;
+  /**
+   * Used to split a block of text at a specific position and insert a new paragraph block.
+   *
+   * @param {RTEImageNode} splitNode - The node that needs to be split into separate blocks.
+   * @param {number} startOffsetOfNode - The index or position within the `splitNode` where the block should be broken or split.
+   * @returns {Nullable<RTEBlock>} Returns either a new paragraph block or the new block created after splitting the original block.
+   */
   private breakSingleBlock;
+  /**
+   * Breaks a single block of text at a specified offset and returns the first node of the new paragraph if created.
+   *
+   * @param {RTEImageNode} splitNode - It represents a node in a rich text editor that contains an image.
+   * @param {number} startOffset - The index at which the line break should occur within the `RTEImageNode` block.
+   * @returns {Nullable<RTETextNode>} Returning the first node of the `newParagraph` block if `newParagraph` is not null.
+   */
   private lineBreakSingleBlock;
+  /**
+   * Checks if the caret position is at the start of a specified RTEImageNode.
+   *
+   * @param {RTEImageNode} node - `RTEImageNode` - a node representing an image in a rich text editor.
+   * @param {number} startOffset - The position within the text node where the caret is located.
+   * @returns {boolean} a boolean value, which indicates whether the caret position is at the start of the RTEImageNode.
+   */
   private isCaretPositionAtStart;
+  /**
+   * Checks if the caret position is at the end of a given RTEImageNode.
+   *
+   * @param {RTEImageNode} node - `node` is a RTEImageNode
+   * @param {number} startOffset - The position within the `RTEImageNode` where the caret is located.
+   * @returns {boolean}Returns a boolean value indicating whether the caret position is at the end of the `RTEImageNode`.
+   */
   private isCaretPositionAtEnd;
+  /**
+   * Inserts a new paragraph block with a line break after a selected block of text in a rich text editor.
+   *
+   * @param {RTEBlock[]} selectedBlocks - An array of RTEBlock objects that represent the blocks that have been selected for a specific action in the Rich Text Editor.
+   * @returns {Nullable<RTETextNode>} Returns a Nullable RTETextNode.
+   */
   private lineBreakMultipleBlocks;
+  /**
+   * Deletes content from a block node based on specific conditions.
+   *
+   * @param {DeleteBlockContentAction} action - Delete block content action
+   */
   private deleteNodeContent;
   /**
    * Image will always create new image block

package/dist/types/components/vega-rich-text-editor/dto/blocks/list-block.d.ts

@@ -1,30 +1,71 @@
 import { RTEBlock } from './block.abstract';
-import { RTERenderContext, VegaRTEListBlock, VegaRTEListBlockType } from '../../interface';
+import { VegaRTEListBlock, VegaRTEListBlockType } from '../../interface';
 import { RTEListItemBlock } from './list-item-block';
 import { ModifyContentAction } from '../actions/modify-content-action.abstract';
 import { VegaRTEContent } from '../content-state';
 import { RTETextNode } from '../nodes/text-node';
+/**
+ * List block
+ */
 export declare class RTEListBlock extends RTEBlock {
   type: VegaRTEListBlockType;
   blocks: RTEListItemBlock[];
   parent: RTEListItemBlock | VegaRTEContent;
   constructor(id: string, type: VegaRTEListBlockType);
+  /**
+   * Converts a VegaRTEListBlock object to an RTEListBlock
+   *
+   * @param {VegaRTEListBlock} block - Converts a `VegaRTEListBlock` object into an `RTEListBlock`.
+   * @returns {RTEListBlock} Return an instance of `RTEListBlock`
+   */
   static from(block: VegaRTEListBlock): RTEListBlock;
-  static fromHTML(node: HTMLUListElement | HTMLOListElement): RTEListBlock;
+  /**
+   * @inheritDoc
+   */
   toJSON(): VegaRTEListBlock;
+  /**
+   * @inheritDoc
+   */
   isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
   getLastNode(): RTETextNode;
-  render(renderContext?: RTERenderContext): HTMLElement;
   /**
    * Apply a modify action to block
    *
    * @param {ModifyContentAction} action - Modify action
    */
   protected doModifyActionApply(action: ModifyContentAction): void;
+  /**
+   * Converts a RTEListItemBlock to a RTETextBlock representing a paragraph.
+   *
+   * @param {RTEListItemBlock} block - The block that will be covered
+   * @returns {RTETextBlock} Returns a `RTETextBlock`.
+   */
   private toParagraph;
-  private registerRef;
+  /**
+   * Covert block to List
+   *
+   * @param {TransformListAction} action - Modify action
+   */
   private convertToList;
+  /**
+   * Covert block to paragraph
+   *
+   * @param {TransformListAction} action - Modify action
+   */
   private convertToParagraph;
+  /**
+   * Inserts an image block into a rich text editor block based on the parent block type.
+   *
+   * @param {InsertImageToBlockAction} action - Modify action
+   */
   private insertImage;
+  /**
+   * Removes a specified block and handles the removal of nested lists if necessary.
+   *
+   * @param {RTEBlock} blockToBeRemoved - block that will be removed
+   */
   private removeListItemBlock;
 }

package/dist/types/components/vega-rich-text-editor/dto/blocks/list-item-block.d.ts

@@ -1,33 +1,97 @@
-import { VegaRTEListItemBlock, RTERenderContext } from '../../interface';
+import { VegaRTEListItemBlock } from '../../interface';
 import { RTETextNode } from '../nodes/text-node';
 import { RTEListBlock } from './list-block';
 import { ModifyContentAction } from '../actions/modify-content-action.abstract';
 import { RTETextBlock } from './text-block';
 import { RTEBlock } from './block.abstract';
+/**
+ * List item block
+ */
 export declare class RTEListItemBlock extends RTETextBlock {
   children?: RTEListBlock[];
   parent: RTEListBlock;
   constructor(id: string, children?: RTEListBlock[]);
+  /**
+   * Converts a VegaRTEListItemBlock object to an RTEListItemBlock
+   *
+   * @param {VegaRTEListBlock} block - Converts a `VegaRTEListItemBlock` object into an `RTEListItemBlock`.
+   * @returns {RTEListBlock} Return an instance of `RTEListItemBlock`
+   */
   static from(block: VegaRTEListItemBlock): RTEListItemBlock;
-  static fromHTML(node: HTMLLIElement): RTEListItemBlock;
+  /**
+   * @inheritDoc
+   */
   toJSON(): VegaRTEListItemBlock;
+  /**
+   * @inheritDoc
+   */
   cloneWithNodes(nodes: RTETextNode[]): RTEBlock;
+  /**
+   * @inheritDoc
+   */
   isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
   getLastNode(): RTETextNode;
-  render(renderContext?: RTERenderContext): HTMLElement;
   /**
    * Apply a modify action to block
    *
    * @param {ModifyContentAction} action - Modify action
    */
   protected doModifyActionApply(action: ModifyContentAction): void;
-  private renderChildren;
+  /**
+   * Remove the list child node
+   *
+   * @param {RemoveChildAction} action - Modify action
+   */
   private removeListChildNode;
+  /**
+   * Remove the nest list
+   *
+   * @param {RemoveNestListAction} action - Modify action
+   */
   private removeNestList;
+  /**
+   * Iterates through a list of RTEListBlock and sets their parent property to the current object, then replaces the children property with the new list.
+   *
+   * @param {RTEListBlock[]} newList - new list that you want to replace the existing children of the current object with.
+   */
   private replaceNestList;
+  /**
+   * Split list item block
+   *
+   * @param {SplitBlockWithNodeAction} action - Modify action
+   */
   private splitListItemBlock;
+  /**
+   * Breaks a single list item block at a specific position.
+   *
+   * @param {RTETextNode} splitNode - The node that needs to be split within a list item block.
+   * @param {number} startOffsetOfNode - The index within the `splitNode` where the break operation should occur.
+   * @returns {Nullable<RTEBlock>} Returns either a new `RTEListItemBlock` if the caret
+   * position is at the end of the `splitNode`, or it returns the result of splitting the block at the
+   * caret position if it is neither at the start nor at the end.
+   */
   private breakSingleListItemBlock;
+  /**
+   * Breaks a list item at the end and handles the insertion of a new list item or paragraph accordingly.
+   *
+   * @param {RTEListItemBlock} newListItem - Item that represents a new list item to be added to the existing list.
+   * @returns {RTEBlock} Returns a `RTEBlock`.
+   */
   private breakListItemAtEnd;
+  /**
+   * Delete list node content
+   *
+   * @param {DeleteBlockContentAction} action - Modify action
+   */
   private deleteListNodeContent;
+  /**
+   * Copy the inline style to new node
+   *
+   * @param {RTETextNode} needCopedNode - The node that needed to be copied to
+   * @returns {RTETextNode} Returns a `RTETextNode`.
+   */
   private copyInlineStyleToNewNode;
 }