@globalpayments/vega 2.33.0 → 2.34.0

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

@@ -0,0 +1,102 @@
+import { Nullable } from '../../../types/general';
+import { RTENode } from './nodes/node.abstract';
+export declare type RTERangeOptions = {
+  startNode: Node | RTENode;
+  endNode: Node | RTENode;
+  startOffset: number;
+  endOffset: number;
+};
+/** Manages selection range for a rich text editor, providing methods to set, sync, and create native ranges based on RTENodes and Nodes. */
+export declare class RTERange {
+  private _startContainer;
+  private _endContainer;
+  private _startOffset;
+  private _endOffset;
+  private _startNode;
+  private _endNode;
+  private _oldNativeRange;
+  /**
+   * Initial the rte range properties
+   *
+   * @param {Node} [startContainer] The range start element.
+   * @param {Node} [endContainer] The range end element.
+   * @param {number} [startOffset] The range start element content offset, default value is 0.
+   * @param {number} [endOffset]  The range end element content offset, default value is 0.
+   * @param {RTENode} [startNode] The range start node, the start node could be null if the start element is root element.
+   * @param {RTENode} [endNode]  The range start node, the start node could be null if the start element is root element.
+   * @param {Range} [nativeRange] The browser native range instance.
+   */
+  constructor(startContainer?: Nullable<Node>, endContainer?: Nullable<Node>, startOffset?: number, endOffset?: number, startNode?: Nullable<RTENode>, endNode?: Nullable<RTENode>, nativeRange?: Range);
+  /**
+   * Returns the start container as a Node or null if it is not set.
+   * The start container could be null when the dom node should be create after re-render.
+   *
+   * @returns {Nullable<Node>} The range start element.
+   */
+  get startContainer(): Nullable<Node>;
+  /**
+   * Returns the end container as a Node or null if it is not set.
+   * The end container could be null when the dom node should be create after re-render.
+   *
+   * @returns {Nullable<Node>} The range start element.
+   */
+  get endContainer(): Nullable<Node>;
+  /**
+   * Returns the range start RTE node as a RTENode or null if it is not set.
+   * The start RTENode could be null when the range start node is the root element of the rich text editor.
+   *
+   * @returns {Nullable<RTENode>} The range start element.
+   */
+  get startNode(): Nullable<RTENode>;
+  /**
+   * Returns the range end RTE node as a RTENode or null if it is not set.
+   * The end RTENode could be null when the range end node is the root element of the rich text editor.
+   *
+   * @returns {Nullable<RTENode>} The range start element.
+   */
+  get endNode(): Nullable<RTENode>;
+  /**
+   * Returns range's start offset.
+   *
+   * @returns {number} The character length in text node or the element index of parent element.
+   */
+  get startOffset(): number;
+  /**
+   * Returns range's start offset.
+   *
+   * @returns {number} The character length in text node or the element index of parent element.
+   */
+  get endOffset(): number;
+  /**
+   * Updates the range options for a Rich Text Editor.
+   * This method will called after modify the content, the start node and end node should be rte node.
+   * This method will called after selectionchange event emit, the start node and end node should be the html node.
+   *
+   * @param {RTERangeOptions} options - An object that contains the following properties:
+   * @param {Range} [nativeRange] - The native range instance
+   * @returns {RTERange} - The new RTERange instance
+   */
+  updateRTERange(options: RTERangeOptions, nativeRange?: Range): RTERange;
+  /**
+   * Creates a Range object based on start and end nodes and offsets.
+   * Invoke this method to get the future range state if the range content modified.
+   * Invoke this method to get the native range instance if range start node and end node not defined
+   *
+   * @returns {Nullable<Range>} The range instance. The return value could be null if the start node or end node are not rendered.
+   */
+  toNativeRange(): Nullable<Range>;
+  /**
+   * Retrieves the DOM element associated with a given RTENode entity.
+   *
+   * @param {Nullable<RTENode>} node - Represents a node in a Rich Text Editor.
+   * @returns {Nullable<Node>} a Node object or null.
+   */
+  private getElementByRTENode;
+  /**
+   * Retrieves an RTENode based on the given element by checking its type and parent elements.
+   *
+   * @param {Node} element - An element in the DOM (Document Object Model).
+   * @returns { Nullable<RTENode>} Returns a nullable `RTENode` object.
+   */
+  private getRTENodeByElement;
+}

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

@@ -0,0 +1,175 @@
+import { VegaComponentInterface } from '../../types/ui.type';
+import { RTETextBlock } from './dto/blocks/text-block';
+import { JSXBase } from '../../stencil-public-runtime';
+import { RTEImageBlock } from './dto/blocks/image-block';
+import { RTEListItemBlock } from './dto/blocks/list-item-block';
+import { RTEListBlock } from './dto/blocks/list-block';
+import { NodeAnnotation, NodeAnnotationTypeEnum } from './dto/annotations/node-annotation.abstract';
+import { InternalAnnotationTypeEnum } from './dto/annotations/annotation.abstract';
+import { SelectionRangeAnnotation } from './dto/annotations/selection-range-annotation';
+import { VegaRichTextImageEditorSizeType } from './vega-rich-text-image-editor/types';
+
+export type ToolbarButtonConfig = {
+	icon: string;
+	tooltip: Partial<Pick<VegaComponentInterface<HTMLVegaTooltipElement>, 'text'>>;
+};
+
+export type AnnotationStyle = JSXBase.HTMLAttributes['style'];
+
+export type VegaRTETextStyleType =
+	| 'title'
+	| 'subtitle'
+	| 'paragraph'
+	| 'heading-1'
+	| 'heading-2'
+	| 'heading-3';
+
+export type VegaRTETextBlockType =
+	| 'title'
+	| 'subtitle'
+	| 'paragraph'
+	| 'heading-1'
+	| 'heading-2'
+	| 'heading-3'
+	| 'list-item';
+
+export type VegaRTEListBlockType = 'bullet-list' | 'number-list';
+
+export type RTEBlockType = VegaRTETextBlockType | VegaRTEListBlockType | 'image';
+
+export type RTEContentBlock = RTETextBlock | RTEImageBlock | RTEListBlock | RTEListItemBlock;
+
+export type VegaRTEBlockAnnotations = {
+	textAlign?: VegaRTEBlockAlignment;
+	indent?: number;
+};
+
+export type ListType = 'bullet-list' | 'number-list';
+
+export type VegaRTELink = { href: string; groupKey: string };
+
+export type VegaRTETextAnnotations = {
+	bold?: boolean;
+	italic?: boolean;
+	underline?: boolean;
+	strikethrough?: boolean;
+	textColor?: string;
+	link?: VegaRTELink;
+	code?: never;
+};
+
+export type VegaRTEImageAnnotations = {
+	size?: VegaRichTextImageEditorSizeType;
+	alt?: string;
+};
+
+export type VegaRTECodeAnnotations = {
+	code: boolean;
+	bold?: never;
+	italic?: never;
+	underline?: never;
+	strikethrough?: never;
+	color?: never;
+	link?: never;
+};
+
+export type VegaRTEBaseNode = { id: string; type: 'text' | 'image' };
+
+export type VegaRTEText = {
+	type: 'text';
+	text: string;
+	annotations?: VegaRTETextAnnotations;
+};
+
+export type VegaRTECode = {
+	type: 'text';
+	text: string;
+	annotations?: VegaRTECodeAnnotations;
+};
+
+export type VegaRTETextNode = VegaRTEBaseNode & (VegaRTEText | VegaRTECode);
+
+export type VegaRTEImageNode = {
+	id: string;
+	type: 'image';
+	url: string;
+	annotations?: VegaRTEImageAnnotations;
+};
+
+export type VegaRTEBlockAlignment = 'left' | 'center' | 'right' | 'justify';
+
+export type VegaRTEImageBlock = {
+	id: string;
+	type: 'image';
+	nodes: VegaRTEImageNode[];
+	annotations?: VegaRTEBlockAnnotations;
+};
+
+export interface VegaRTEBlockBase {
+	id: string;
+	annotations?: VegaRTEBlockAnnotations;
+}
+
+export interface VegaRTETextBlock extends VegaRTEBlockBase {
+	type: VegaRTETextBlockType;
+	nodes: VegaRTETextNode[];
+	annotations?: VegaRTEBlockAnnotations & {
+		textStyle?: VegaRTETextStyleType;
+	};
+}
+
+export type VegaRTEListItemBlock = VegaRTETextBlock & {
+	type: 'list-item';
+	children?: VegaRTEListBlock[];
+};
+
+export type VegaRTEListBlock = VegaRTEBlockBase & {
+	type: VegaRTEListBlockType;
+	blocks: VegaRTEListItemBlock[];
+};
+
+export type VegaRTEContentBlock =
+	| VegaRTETextBlock
+	| VegaRTEImageBlock
+	| VegaRTEListBlock
+	| VegaRTEListItemBlock;
+
+export type VegaRTEToolbarItem =
+	| 'clearStyle'
+	| 'bold'
+	| 'textStyles'
+	| 'italic'
+	| 'underline'
+	| 'strikethrough'
+	| 'code'
+	| 'link'
+	| 'moreIndent'
+	| 'textColor'
+	| 'lessIndent'
+	| 'image'
+	| 'bullets'
+	| 'numbers'
+	| 'bulletsNumbers'
+	| 'horizontalAlignment'
+	| 'leftAlign'
+	| 'centerAlign'
+	| 'rightAlign'
+	| 'justified';
+
+export type VegaRTEColorSchema = {
+	key: string;
+	light: string;
+	dark: string;
+};
+
+export type RTENodeAnnotationMapKey =
+	| keyof typeof NodeAnnotationTypeEnum
+	| keyof typeof InternalAnnotationTypeEnum;
+
+export type RTENodeAnnotationMapValue = NodeAnnotation | SelectionRangeAnnotation;
+
+export type VegaRichTextEditorImage = { file: File; sendBackUploadedURLCallback: (url: string) => void };
+
+export type RTERenderContext = { editable?: boolean };
+
+export type HeadingLevel = 1 | 2 | 3;

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/focus-controller.d.ts

@@ -0,0 +1,33 @@
+import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
+import { VegaRichTextEditor } from '../../vega-rich-text-editor';
+/**
+ * Focus controller for RTE
+ */
+export declare class FocusController extends VegaSlimmer {
+  protected readonly vegaRichTextEditorRenderer: VegaRichTextEditor['vegaRichTextEditorRenderer'];
+  protected readonly selectionController: VegaRichTextEditor['selectionController'];
+  protected readonly valueController: VegaRichTextEditor['valueController'];
+  protected readonly value: VegaRichTextEditor['value'];
+  /**
+   * Focus on the last text node of the last block.
+   *
+   * @param {{ newLine?: boolean }} options - The options of the method
+   * @param {boolean} options.newLine - Should a new line be added before the last text node
+   * @returns {Promise<void>} - A promise that resolves when the focus is set
+   */
+  focusOnLastTextNode(options?: {
+    newLine?: boolean;
+  }): Promise<void>;
+  /**
+   * Do a focus on the last text node of the last block
+   *
+   * @param {RTEContentBlock} lastBlock - The last block of the content
+   */
+  private doFocusOnLastTextNode;
+  /**
+   * Move the caret to the end of the node
+   *
+   * @param {Node} targetNode - The node to move the caret to
+   */
+  private setCaretRangeToNodeEnd;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-handler/element-to-dto-handler.abstract.d.ts

@@ -0,0 +1,67 @@
+import { Nullable } from '../../../../../../types/general';
+import { RTETextBlock } from '../../../../dto/blocks/text-block';
+import { RTEContentBlock } from '../../../../interface';
+/**
+ * Abstract class of element to DTO handler
+ */
+export declare abstract class ElementToDTOHandlerAbstract {
+  private static currentTextBlockElement;
+  protected abstract currentEntityElement: HTMLElement;
+  protected abstract currentVirtualElement: HTMLElement;
+  /**
+   * At new of handler, We need to inherit the style of the parent element
+   *   and clone an empty element so that the child elements can be appended.
+   *
+   * @param {HTMLElement} element - Current element.
+   */
+  constructor(element: HTMLElement);
+  /**
+   * Can be handle, the class inherit this class should implement it.
+   *
+   * @param {HTMLElement} element - Current element.
+   * @returns {boolean} Can be handle.
+   */
+  static canHandle(element: HTMLElement): boolean;
+  /**
+   * Transform current text block to a DTO.
+   *
+   * @returns {RTETextBlock} Current text block.
+   */
+  static currentTextBlockElementToDTO(): RTETextBlock;
+  /**
+   * Get current text block element.
+   *
+   * @returns {HTMLDivElement} - Current text block element.
+   */
+  protected static getCurrentTextBlockElement(): HTMLDivElement;
+  /**
+   * While it a empty block. we should use new line span instead this block.
+   *
+   * @param {HTMLElement} blockElement - Current block element.
+   * @returns {boolean} - is handled.
+   */
+  protected handleEmptyBlock(blockElement: HTMLElement): boolean;
+  /**
+   * Inherit style of parent.
+   *
+   * @param {HTMLElement} element - Current element.
+   */
+  private setEntityElementStyle;
+  /**
+   * Set current element.
+   *   while element is a text node, we should wrap it and inherit it style
+   *   otherwise, we should clone it and clear content.
+   *
+   * @param {HTMLElement} element - Current element.
+   */
+  private setElement;
+  /**
+   * Create a new line span.
+   *
+   * @returns {HTMLElement} - new line span.
+   */
+  private createNewLineSpan;
+  abstract handle(blockElement: Nullable<HTMLElement>): RTEContentBlock[];
+  abstract childElements(): HTMLElement[];
+  abstract getNextBlockElement(currentBlockElement: Nullable<HTMLElement>): Nullable<HTMLElement>;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-handler/element-to-dto-processor.d.ts

@@ -0,0 +1,29 @@
+import { RTEContentBlock } from '../../../../interface';
+/**
+ * Element to DTO processor
+ */
+export declare class ElementToDTOProcessor {
+  private elementHandlers;
+  /**
+   * Transform element to block DTO.
+   *
+   * @param {HTMLElement} element - An pasted element.
+   * @returns {RTEContentBlock[]} Block DTO.
+   */
+  process(element: HTMLElement): RTEContentBlock[];
+  /**
+   * Transform elements to block DTO.
+   *
+   * @param {HTMLElement[]} elements - An pasted elements.
+   * @param {HTMLElement} blockElement - Current block element.
+   * @returns {RTEContentBlock[]} Block DTO.
+   */
+  private transformDomToDto;
+  /**
+   * Checks if the given element is valid to parse.
+   *
+   * @param {HTMLElement} element - The pasted element.
+   * @returns {boolean} Is valid
+   */
+  private isInvalidElement;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-handler/image-to-dto-handler.d.ts

@@ -0,0 +1,37 @@
+import { RTEContentBlock } from '../../../../interface';
+import { ElementToDTOHandlerAbstract } from './element-to-dto-handler.abstract';
+/**
+ * Transform image element to DTO.
+ */
+export declare class ImageToDTOHandler extends ElementToDTOHandlerAbstract {
+  protected currentEntityElement: HTMLElement;
+  protected currentVirtualElement: HTMLElement;
+  /**
+   * Can be transform.
+   *
+   * @param {HTMLElement} element - An pasted element.
+   * @returns {boolean} Result.
+   */
+  static canHandle(element: HTMLElement): boolean;
+  /**
+   * Special the child elements of current.
+   *
+   * @returns {HTMLElement[]} - child elements.
+   */
+  childElements(): HTMLElement[];
+  /**
+   * Transform element to DTO.
+   *   When blockElement is exist, it means that the current element is a child node,
+   *   and we need to wait for its root block to be converted into a dto.
+   *   Otherwise, the current node is the root node, and we can directly convert it.
+   *
+   * @returns {RTEContentBlock[]} - Block DTO.
+   */
+  handle(): RTEContentBlock[];
+  /**
+   * Get the block element for child nodes
+   *
+   * @returns {HTMLElement} - Block element for child nodes.
+   */
+  getNextBlockElement(): HTMLElement;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-handler/inline-block-to-dto-handler.d.ts

@@ -0,0 +1,35 @@
+import { Nullable } from '../../../../../../types/general';
+import { RTEContentBlock } from '../../../../interface';
+import { ElementToDTOHandlerAbstract } from './element-to-dto-handler.abstract';
+/**
+ * Transform link element to DTO.
+ */
+export declare class InlineBlockToDTOHandler extends ElementToDTOHandlerAbstract {
+  protected currentEntityElement: HTMLElement;
+  protected currentVirtualElement: HTMLElement;
+  /**
+   * Can be transform.
+   *
+   * @returns {boolean} Result.
+   */
+  static canHandle(): boolean;
+  /**
+   * Special the child elements of current.
+   *
+   * @returns {HTMLElement[]} - child elements.
+   */
+  childElements(): HTMLElement[];
+  /**
+   * The inline block is a child element, and there is no need to convert it to a dto here
+   *
+   * @returns {RTEContentBlock[]} - Empty dto.
+   */
+  handle(): RTEContentBlock[];
+  /**
+   * Get the block element for child nodes
+   *
+   * @param {Nullable<HTMLElement>} blockElement - Current block container.
+   * @returns {Nullable<HTMLElement>} - blockElement.
+   */
+  getNextBlockElement(blockElement: Nullable<HTMLElement>): Nullable<HTMLElement>;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-handler/link-to-dto-handler.d.ts

@@ -0,0 +1,37 @@
+import { Nullable } from '../../../../../../types/general';
+import { RTEContentBlock } from '../../../../interface';
+import { ElementToDTOHandlerAbstract } from './element-to-dto-handler.abstract';
+/**
+ * Transform link element to DTO.
+ */
+export declare class LinkToDTOHandler extends ElementToDTOHandlerAbstract {
+  protected currentEntityElement: HTMLElement;
+  protected currentVirtualElement: HTMLElement;
+  constructor(element: HTMLElement);
+  /**
+   * Can be transform.
+   *
+   * @param {HTMLElement} element - An pasted element.
+   * @returns {boolean} Result.
+   */
+  static canHandle(element: HTMLElement): boolean;
+  /**
+   * Special the child elements of current.
+   *
+   * @returns {HTMLElement[]} - child elements.
+   */
+  childElements(): HTMLElement[];
+  /**
+   * Format and append element for it block element.
+   *
+   * @param {Nullable<HTMLElement>} blockElement - Current block container.
+   * @returns {RTEContentBlock[]} - Block DTO.
+   */
+  handle(blockElement: Nullable<HTMLElement>): RTEContentBlock[];
+  /**
+   * Get the block element for child nodes
+   *
+   * @returns {HTMLElement} - Block element for child nodes.
+   */
+  getNextBlockElement(): HTMLElement;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-handler/list-item-to-dto-handler.d.ts

@@ -0,0 +1,36 @@
+import { Nullable } from '../../../../../../types/general';
+import { RTEContentBlock } from '../../../../interface';
+import { ElementToDTOHandlerAbstract } from './element-to-dto-handler.abstract';
+/**
+ * Transform list element to DTO.
+ */
+export declare class ListItemToDTOHandler extends ElementToDTOHandlerAbstract {
+  protected currentEntityElement: HTMLElement;
+  protected currentVirtualElement: HTMLElement;
+  /**
+   * Can be transform.
+   *
+   * @param {HTMLElement} element - An pasted element.
+   * @returns {boolean} Result.
+   */
+  static canHandle(element: HTMLElement): boolean;
+  /**
+   * Special the child elements of current.
+   *
+   * @returns {HTMLElement[]} - child elements.
+   */
+  childElements(): HTMLElement[];
+  /**
+   * Append list item node to it block element.
+   *
+   * @param {Nullable<HTMLElement>} blockElement - Current block container.
+   * @returns {RTEContentBlock[]} - Block DTO.
+   */
+  handle(blockElement: Nullable<HTMLElement>): RTEContentBlock[];
+  /**
+   * Get the block element for child nodes
+   *
+   * @returns {HTMLElement} - Block element for child nodes.
+   */
+  getNextBlockElement(): HTMLElement;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-handler/list-to-dto-handler.d.ts

@@ -0,0 +1,39 @@
+import { Nullable } from '../../../../../../types/general';
+import { RTEContentBlock } from '../../../../interface';
+import { ElementToDTOHandlerAbstract } from './element-to-dto-handler.abstract';
+/**
+ * Transform list element to DTO.
+ */
+export declare class ListToDTOHandler extends ElementToDTOHandlerAbstract {
+  protected currentEntityElement: HTMLElement;
+  protected currentVirtualElement: HTMLElement;
+  /**
+   * Can be transform.
+   *
+   * @param {HTMLElement} element - An pasted element.
+   * @returns {boolean} Result.
+   */
+  static canHandle(element: HTMLElement): boolean;
+  /**
+   * Special the child elements of current.
+   *
+   * @returns {HTMLElement[]} - child elements.
+   */
+  childElements(): HTMLElement[];
+  /**
+   * Transform element to DTO.
+   *   When blockElement is exist, it means that the current element is a child node,
+   *   and we need to append and wait for its root block to be converted into a dto.
+   *   Otherwise, the current node is the root node, and we can directly convert it.
+   *
+   * @param {Nullable<HTMLElement>} blockElement - Current block container.
+   * @returns {RTEContentBlock[]} - Block DTO.
+   */
+  handle(blockElement: Nullable<HTMLElement>): RTEContentBlock[];
+  /**
+   * Get the block element for child nodes
+   *
+   * @returns {HTMLElement} - Block element for child nodes.
+   */
+  getNextBlockElement(): HTMLElement;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-handler/paragraph-to-dto-handler.d.ts

@@ -0,0 +1,39 @@
+import { Nullable } from '../../../../../../types/general';
+import { RTEContentBlock } from '../../../../interface';
+import { ElementToDTOHandlerAbstract } from './element-to-dto-handler.abstract';
+/**
+ * Transform paragraph.
+ */
+export declare class ParagraphToDTOHandler extends ElementToDTOHandlerAbstract {
+  protected currentEntityElement: HTMLElement;
+  protected currentVirtualElement: HTMLElement;
+  /**
+   * Can be transform.
+   *
+   * @param {HTMLElement} element - An pasted element.
+   * @returns {boolean} Result.
+   */
+  static canHandle(element: HTMLElement): boolean;
+  /**
+   * Special the child elements of current.
+   *
+   * @returns {HTMLElement[]} - child elements.
+   */
+  childElements(): HTMLElement[];
+  /**
+   * Transform element to DTO.
+   *   When blockElement is exist, it means that the current element is a child node,
+   *   and we need to wait for its root block to be converted into a dto.
+   *   Otherwise, the current node is the root node, and we can directly convert it.
+   *
+   * @param {Nullable<HTMLElement>} blockElement - Current block container.
+   * @returns {RTEContentBlock[]} - Block DTO.
+   */
+  handle(blockElement: Nullable<HTMLElement>): RTEContentBlock[];
+  /**
+   * Get the block element for child nodes
+   *
+   * @returns {HTMLElement} - Block element for child nodes.
+   */
+  getNextBlockElement(): HTMLElement;
+}

package/dist/types/components/vega-rich-text-editor/slimmers/controllers/helper/element-to-dto-handler/text-block-to-dto-handler.d.ts

@@ -0,0 +1,46 @@
+import { Nullable } from '../../../../../../types/general';
+import { RTEContentBlock } from '../../../../interface';
+import { ElementToDTOHandlerAbstract } from './element-to-dto-handler.abstract';
+/**
+ * Transform text block element to DTO.
+ */
+export declare class TextBlockToDTOHandler extends ElementToDTOHandlerAbstract {
+  protected currentEntityElement: HTMLElement;
+  protected currentVirtualElement: HTMLElement;
+  /**
+   * Can be transform.
+   *
+   * @param {HTMLElement} element - An pasted element.
+   * @returns {boolean} Result.
+   */
+  static canHandle(element: HTMLElement): boolean;
+  /**
+   * Get type of element.
+   *
+   * @param {HTMLElement} element - An pasted element.
+   * @returns {string} type.
+   */
+  static getElementType(element: HTMLElement): string;
+  /**
+   * Special the child elements of current.
+   *
+   * @returns {HTMLElement[]} - child elements.
+   */
+  childElements(): HTMLElement[];
+  /**
+   * Transform element to DTO.
+   *   When blockElement is exist, it means that the current element is a child node,
+   *   and we need to wait for its root block to be converted into a dto.
+   *   Otherwise, the current node is the root node, and we can directly convert it.
+   *
+   * @param {Nullable<HTMLElement>} blockElement - Current block container.
+   * @returns {RTEContentBlock[]} - Block DTO.
+   */
+  handle(blockElement: Nullable<HTMLElement>): RTEContentBlock[];
+  /**
+   * Get the block element for child nodes
+   *
+   * @returns {HTMLElement} - Block element for child nodes.
+   */
+  getNextBlockElement(): HTMLElement;
+}