@globalpayments/vega 2.58.0 → 2.59.0

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

@@ -1,5 +1,5 @@
 import { NodeAnnotation, NodeAnnotationTypeEnum } from './node-annotation.abstract';
-import { AnnotationStyle } from '../../interface';
+import { AnnotationStyle, RTERenderContext } from '../../interface';
 import { Nullable } from '../../../../types/general';
 /**
  * Annotation to make text bold
@@ -26,9 +26,11 @@ export declare class BoldAnnotation extends NodeAnnotation {
    */
   clone(): BoldAnnotation;
   /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} Bold style
+   * @inheritDoc
+   */
+  renderClass(options?: RTERenderContext): Nullable<string>;
+  /**
+   * @inheritDoc
    */
-  render(): Nullable<AnnotationStyle>;
+  renderStyle(options?: RTERenderContext): Nullable<AnnotationStyle>;
 }

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

@@ -1,9 +1,10 @@
 import { Annotation, InternalAnnotationTypeEnum } from './annotation.abstract';
+import { CommonAnnotationTypeEnum } from './common-annotation.abstract';
 import { NodeAnnotationTypeEnum } from './node-annotation.abstract';
 /**
  * Annotation to host which annotations will be clear formatting
  */
 export declare class ClearFormattingAnnotation extends Annotation {
   readonly type: InternalAnnotationTypeEnum;
-  items: NodeAnnotationTypeEnum[];
+  items: (NodeAnnotationTypeEnum | CommonAnnotationTypeEnum)[];
 }

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

@@ -1,5 +1,5 @@
 import { NodeAnnotation, NodeAnnotationTypeEnum } from './node-annotation.abstract';
-import { AnnotationStyle } from '../../interface';
+import { AnnotationStyle, RTERenderContext } from '../../interface';
 import { Nullable } from '../../../../types/general';
 /**
  * Annotation to make text code
@@ -7,14 +7,16 @@ import { Nullable } from '../../../../types/general';
 export declare class CodeAnnotation extends NodeAnnotation {
   readonly type: NodeAnnotationTypeEnum;
   code: boolean;
-  constructor(code: boolean);
+  useInternalStyle: boolean;
+  constructor(code: boolean, useInternalStyle?: boolean);
   /**
    * Generate the map item for the annotation
    *
    * @param {boolean} code - Bold annotation
+   * @param {boolean} useInternalStyle - Whether to use default style for the link
    * @returns {[NodeAnnotationTypeEnum.CODE, CodeAnnotation]} Map item for the annotation
    */
-  static from(code: boolean): [NodeAnnotationTypeEnum.CODE, CodeAnnotation];
+  static from(code: boolean, useInternalStyle?: boolean): [NodeAnnotationTypeEnum.CODE, CodeAnnotation];
   /**
    * Generate the JSON representation of the annotation
    *
@@ -26,15 +28,11 @@ export declare class CodeAnnotation extends NodeAnnotation {
    */
   clone(): CodeAnnotation;
   /**
-   * Generate the class for the annotation
-   *
-   * @returns {Nullable<string>} - Annotation class
+   * @inheritDoc
    */
-  renderClass(): Nullable<string>;
+  renderClass(options?: RTERenderContext): Nullable<string>;
   /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} Bold style
+   * @inheritDoc
    */
-  render(): Nullable<AnnotationStyle>;
+  renderStyle(options?: RTERenderContext): Nullable<AnnotationStyle>;
 }

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

@@ -0,0 +1,20 @@
+import { Annotation } from './annotation.abstract';
+import { Nullable } from '../../../../types/general';
+export declare enum CommonAnnotationTypeEnum {
+  CUSTOM_ATTRIBUTE = "CUSTOM_ATTRIBUTE",
+  CUSTOM_CLASS = "CUSTOM_CLASS",
+  CUSTOM_STYLE = "CUSTOM_STYLE"
+}
+/**
+ * CommonAnnotation is an abstract class that represents common annotation for block and node.
+ */
+export declare abstract class CommonAnnotation extends Annotation {
+  abstract readonly type: CommonAnnotationTypeEnum;
+  /**
+   * Generate the JSON item of the annotation
+   *
+   * @returns {Nullable<Record<string, unknown>>} JSON item of the annotation
+   */
+  abstract toJSON(): Nullable<Record<string, unknown>>;
+  abstract clone(): CommonAnnotation;
+}

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

@@ -0,0 +1,44 @@
+import { RTERenderCustomAttributes } from '../../interface';
+import { CommonAnnotation, CommonAnnotationTypeEnum } from './common-annotation.abstract';
+/**
+ * Annotation to add custom attributes of element
+ */
+export declare class CustomAttributeAnnotation extends CommonAnnotation {
+  readonly type: CommonAnnotationTypeEnum.CUSTOM_ATTRIBUTE;
+  private customAttribute;
+  private readonly BOOLEAN_ATTRS;
+  constructor(customAttribute: Record<string, string>);
+  /**
+   * Generate the map item for the annotation
+   *
+   * @param {Record<string, string>} customizeAttribute - custom attribute annotation
+   * @returns {[CommonAnnotationTypeEnum.CUSTOM_ATTRIBUTE, CustomAttributeAnnotation]} Map item for the annotation
+   */
+  static from(customizeAttribute: Record<string, string>): [CommonAnnotationTypeEnum.CUSTOM_ATTRIBUTE, CustomAttributeAnnotation];
+  /**
+   * Generate the JSON representation of the annotation
+   *
+   * @returns {Record<string, unknown>} JSON representation of the annotation
+   */
+  toJSON(): Record<string, unknown>;
+  /**
+   * Create a new custom attribute annotation
+   *
+   * @returns {CustomAttributeAnnotation} - Custom attribute annotation
+   */
+  clone(): CustomAttributeAnnotation;
+  /**
+   * Generate the custom attribute of current element, excluding 'style' and 'class'
+   *
+   * @param {string[]} filterAttr - should filter these existed attrs
+   * @returns {string[]} - Custom attributes
+   */
+  toString(filterAttr?: string[]): string[];
+  /**
+   * Generate the custom attribute for the annotation
+   *
+   * @param {RTERenderCustomAttributes} options - should filter these certain attrs
+   * @returns {Record<string, string>} custom attribute
+   */
+  render(options?: RTERenderCustomAttributes): Record<string, string>;
+}

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

@@ -0,0 +1,40 @@
+import { CommonAnnotation, CommonAnnotationTypeEnum } from './common-annotation.abstract';
+/**
+ * Annotation to add custom class of element
+ */
+export declare class CustomClassAnnotation extends CommonAnnotation {
+  readonly type: CommonAnnotationTypeEnum.CUSTOM_CLASS;
+  customClass: string[];
+  constructor(customClass: string[]);
+  /**
+   * Generate the map item for the annotation
+   *
+   * @param {string[]} customClass - custom class annotation
+   * @returns {[CommonAnnotationTypeEnum.CUSTOM_CLASS, CustomClassAnnotation]} Map item for the annotation
+   */
+  static from(customClass: string[]): [CommonAnnotationTypeEnum.CUSTOM_CLASS, CustomClassAnnotation];
+  /**
+   * Generate the JSON representation of the annotation
+   *
+   * @returns {Record<string, unknown>} JSON representation of the annotation
+   */
+  toJSON(): Record<string, unknown>;
+  /**
+   * Create a new custom class annotation
+   *
+   * @returns {CustomClassAnnotation} - Custom class annotation
+   */
+  clone(): CustomClassAnnotation;
+  /**
+   * Generate the custom class of current element
+   *
+   * @returns {string} - Custom class
+   */
+  toString(): string;
+  /**
+   * Generate the custom attribute for the annotation
+   *
+   * @returns {string[]} custom classes
+   */
+  renderClass(): string[];
+}

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

@@ -0,0 +1,48 @@
+import { AnnotationStyle } from '../../interface';
+import { CommonAnnotation, CommonAnnotationTypeEnum } from './common-annotation.abstract';
+/**
+ * Annotation to add custom attributes of element
+ */
+export declare class CustomStyleAnnotation extends CommonAnnotation {
+  type: CommonAnnotationTypeEnum.CUSTOM_STYLE;
+  customStyle: AnnotationStyle;
+  constructor(customStyle: AnnotationStyle);
+  /**
+   * Generate the map item for the annotation
+   *
+   * @param {AnnotationStyle} customStyle - custom attribute annotation
+   * @returns {[CommonAnnotationTypeEnum.CUSTOM_STYLE, CustomStyleAnnotation]} Map item for the annotation
+   */
+  static from(customStyle: Record<string, string>): [CommonAnnotationTypeEnum.CUSTOM_STYLE, CustomStyleAnnotation];
+  /**
+   * Generate the JSON representation of the annotation
+   *
+   * @returns {Record<string, unknown>} JSON representation of the annotation
+   */
+  toJSON(): Record<string, unknown>;
+  /**
+   * Create a new custom attribute annotation
+   *
+   * @returns {CustomStyleAnnotation} - Custom attribute annotation
+   */
+  clone(): CustomStyleAnnotation;
+  /**
+   * Generate the custom attribute for the annotation
+   *
+   * @returns {AnnotationStyle} custom attribute
+   */
+  renderStyle(): AnnotationStyle;
+  /**
+   * Remove the style
+   *
+   * @param {string[]} styleKeys - custom attribute annotation
+   * @returns {AnnotationStyle} Map item for the annotation
+   */
+  removeStyles(styleKeys: string[]): AnnotationStyle;
+  /**
+   * Generate the custom style string for the annotation
+   *
+   * @returns {string} custom style string
+   */
+  toString(): string;
+}

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

@@ -1,5 +1,5 @@
 import { BlockAnnotation, BlockAnnotationTypeEnum } from './block-annotation.abstract';
-import { AnnotationStyle, VegaRTEBlockAlignment } from '../../interface';
+import { AnnotationStyle, RTERenderContext, VegaRTEBlockAlignment } from '../../interface';
 import { Nullable } from '../../../../types/general';
 /**
  * Annotation to make block with horizontal alignment
@@ -22,19 +22,15 @@ export declare class HorizontalAlignmentAnnotation extends BlockAnnotation {
    */
   toJSON(): Record<string, unknown>;
   /**
-   * Generate the class for the annotation
-   *
-   * @returns {string} - Annotation class
+   * @inheritDoc
    */
-  renderClass(): string;
+  renderClass(options?: RTERenderContext): Nullable<string>;
   /**
    * @inheritDoc
    */
   clone(): HorizontalAlignmentAnnotation;
   /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} - Annotation style
+   * @inheritDoc
    */
-  render(): Nullable<AnnotationStyle>;
+  renderStyle(options?: RTERenderContext): Nullable<AnnotationStyle>;
 }

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

@@ -1,15 +1,15 @@
 import { NodeAnnotation, NodeAnnotationTypeEnum } from './node-annotation.abstract';
 import { Nullable } from '../../../../types/general';
-import { AnnotationStyle } from '../../interface';
+import { AnnotationStyle, RTERenderContext } from '../../interface';
 import { VegaRichTextImageEditorSizeType } from '../../vega-rich-text-image-editor/types';
 /**
  * Annotation for image
  */
 export declare class ImageAnnotation extends NodeAnnotation {
   readonly type: NodeAnnotationTypeEnum;
-  size: VegaRichTextImageEditorSizeType;
+  size: Nullable<VegaRichTextImageEditorSizeType>;
   alt: string;
-  constructor(size: VegaRichTextImageEditorSizeType, alt: string);
+  constructor(size: Nullable<VegaRichTextImageEditorSizeType>, alt: string);
   /**
    * Generate the map item for the annotation
    *
@@ -17,7 +17,7 @@ export declare class ImageAnnotation extends NodeAnnotation {
    * @param {string} alt - Image alt
    * @returns {[NodeAnnotationTypeEnum.IMAGE, ImageAnnotation]} Map item for the annotation
    */
-  static from(size: VegaRichTextImageEditorSizeType, alt: string): [NodeAnnotationTypeEnum.IMAGE, ImageAnnotation];
+  static from(size: Nullable<VegaRichTextImageEditorSizeType>, alt: string): [NodeAnnotationTypeEnum.IMAGE, ImageAnnotation];
   /**
    * Generate the JSON representation of the annotation
    *
@@ -29,9 +29,11 @@ export declare class ImageAnnotation extends NodeAnnotation {
    */
   clone(): ImageAnnotation;
   /**
-   * Generate the style for the image
-   *
-   * @returns {Nullable<AnnotationStyle>} image style
+   * @inheritDoc
+   */
+  renderClass(options?: RTERenderContext): Nullable<string>;
+  /**
+   * @inheritDoc
    */
-  render(): Nullable<AnnotationStyle>;
+  renderStyle(options?: RTERenderContext): Nullable<AnnotationStyle>;
 }

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

@@ -25,10 +25,14 @@ export declare class IndentAnnotation extends BlockAnnotation {
    * @inheritDoc
    */
   clone(): IndentAnnotation;
+  /**
+   * @inheritDoc
+   */
+  renderClass(): Nullable<string>;
   /**
    * Generate the style for the annotation
    *
    * @returns {Nullable<AnnotationStyle>} - Annotation style
    */
-  render(): Nullable<AnnotationStyle>;
+  renderStyle(): Nullable<AnnotationStyle>;
 }

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

@@ -0,0 +1,37 @@
+import { Annotation } from './annotation.abstract';
+import { CustomAttributeAnnotation } from './custom-attribute-annotation';
+import { NodeAnnotationTypeEnum } from './node-annotation.abstract';
+import { CustomClassAnnotation } from './custom-class-annotation';
+import { CustomStyleAnnotation } from './custom-style-annotation';
+import { VegaInlineHtmlSchema } from '../../interface';
+/**
+ * Inline HTML annotation
+ */
+export declare class InlineHtmlAnnotation extends Annotation {
+  readonly type: NodeAnnotationTypeEnum.INLINE_HTML;
+  htmlTag: string;
+  child?: InlineHtmlAnnotation;
+  customAttribute?: CustomAttributeAnnotation;
+  customClass?: CustomClassAnnotation;
+  customStyle?: CustomStyleAnnotation;
+  constructor(htmlTag: string);
+  /**
+   * Generate the map item for the annotation
+   *
+   * @param {VegaInlineHtmlSchema} inlineHtml - Inline HTML node
+   * @returns {[NodeAnnotationTypeEnum.INLINE_HTML, InlineHtmlAnnotation]} Map item for the annotation
+   */
+  static from(inlineHtml: VegaInlineHtmlSchema): [NodeAnnotationTypeEnum.INLINE_HTML, InlineHtmlAnnotation];
+  /**
+   * Create a new inline HTML annotation
+   *
+   * @returns {InlineHtmlAnnotation} - Inline HTML annotation
+   */
+  clone(): InlineHtmlAnnotation;
+  /**
+   * Generate the JSON representation of the annotation
+   *
+   * @returns {Record<string, unknown>} JSON representation of the annotation
+   */
+  toJSON(): Record<string, unknown>;
+}

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

@@ -0,0 +1,31 @@
+import { BlockAnnotation, BlockAnnotationTypeEnum } from './block-annotation.abstract';
+import { AnnotationStyle } from '../../interface';
+import { Nullable } from '../../../../types/general';
+/**
+ * Internal wrapper annotation for block node.
+ */
+export declare class InternalWrapperAnnotation extends BlockAnnotation {
+  readonly type: BlockAnnotationTypeEnum.INTERNAL_WRAPPER;
+  internalWrapper: boolean;
+  constructor(internalWrapper: boolean);
+  /**
+   * @inheritDoc
+   */
+  static from(internalWrapper: boolean): [BlockAnnotationTypeEnum.INTERNAL_WRAPPER, InternalWrapperAnnotation];
+  /**
+   * @inheritDoc
+   */
+  clone(): BlockAnnotation;
+  /**
+   * @inheritDoc
+   */
+  renderClass(): Nullable<string>;
+  /**
+   * @inheritDoc
+   */
+  renderStyle(): Nullable<AnnotationStyle>;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): Nullable<Record<string, unknown>>;
+}

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

@@ -1,5 +1,5 @@
 import { NodeAnnotation, NodeAnnotationTypeEnum } from './node-annotation.abstract';
-import { AnnotationStyle } from '../../interface';
+import { AnnotationStyle, RTERenderContext } from '../../interface';
 import { Nullable } from '../../../../types/general';
 /**
  * Annotation to make text Italic
@@ -26,9 +26,11 @@ export declare class ItalicAnnotation extends NodeAnnotation {
    */
   clone(): ItalicAnnotation;
   /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} Italic style
+   * @inheritDoc
+   */
+  renderClass(options?: RTERenderContext): Nullable<string>;
+  /**
+   * @inheritDoc
    */
-  render(): Nullable<AnnotationStyle>;
+  renderStyle(options?: RTERenderContext): Nullable<AnnotationStyle>;
 }

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

@@ -7,14 +7,16 @@ import { Nullable } from '../../../../types/general';
 export declare class LinkAnnotation extends NodeAnnotation {
   readonly type: NodeAnnotationTypeEnum;
   link: VegaRTELink;
-  constructor(link: VegaRTELink);
+  useInternalStyle: boolean;
+  constructor(link: VegaRTELink, useInternalStyle?: boolean);
   /**
    * Generate the map item for the annotation
    *
    * @param {VegaRTELink} link - Bold annotation
+   * @param {boolean} useInternalStyle - Whether to use default style for the link
    * @returns {[NodeAnnotationTypeEnum.LINK, LinkAnnotation]} Map item for the annotation
    */
-  static from(link: VegaRTELink): [NodeAnnotationTypeEnum.LINK, LinkAnnotation];
+  static from(link: VegaRTELink, useInternalStyle?: boolean): [NodeAnnotationTypeEnum.LINK, LinkAnnotation];
   /**
    * Generate the JSON representation of the annotation
    *
@@ -33,9 +35,11 @@ export declare class LinkAnnotation extends NodeAnnotation {
    */
   toEqual(annotation: LinkAnnotation): boolean;
   /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} Link style
+   * @inheritDoc
+   */
+  renderClass(): Nullable<string>;
+  /**
+   * @inheritDoc
    */
-  render(): Nullable<AnnotationStyle>;
+  renderStyle(): Nullable<AnnotationStyle>;
 }

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

@@ -1,5 +1,7 @@
 import { Annotation, InternalAnnotationTypeEnum } from './annotation.abstract';
 import { RTETextNode } from '../nodes/text-node';
+import { AnnotationStyle, RTERenderContext } from '../../interface';
+import { LinkAnnotation } from './link-annotation';
 /**
  * Annotation to represent a link of grouped nodes
  */
@@ -8,4 +10,51 @@ export declare class LinkGroupAnnotation extends Annotation {
   linkGroups: Map<string, RTETextNode[]>;
   constructor(groupKey: string);
   clone(): LinkGroupAnnotation;
+  /**
+   * Convert the custom style, class and attribute to string which html can used
+   *
+   * @param {linkAnnotation} linkAnnotation current link annotation which saved custom style, class and attribute.
+   * @param {RTERenderContext} options - options.
+   * @returns {string} - string.
+   */
+  toString(linkAnnotation: LinkAnnotation, options?: RTERenderContext): string;
+  /**
+   * Convert the custom style, class and attribute to JSX attributes
+   *
+   * @param {linkAnnotation} linkAnnotation current link annotation which saved custom style, class and attribute.
+   * @param {RTERenderContext} options - options.
+   * @returns {Record<string, string | AnnotationStyle>} JSX used attributes.
+   */
+  toJsx(linkAnnotation: LinkAnnotation, options?: RTERenderContext): Record<string, string | AnnotationStyle>;
+  /**
+   * Get the custom class for the annotation
+   *
+   * @param {linkAnnotation} linkAnnotation current link annotation which saved custom style, class and attribute.
+   * @param {RTERenderContext} options - options.
+   * @returns {string[]} Link class
+   */
+  private getClass;
+  /**
+   * Get the custom style for the annotation
+   *
+   * @param {LinkAnnotation} linkAnnotation current link annotation which saved custom style, class and attribute.
+   * @param {RTERenderContext} options - options.
+   * @returns {AnnotationStyle} Link style
+   */
+  private getStyle;
+  /**
+   * Get the custom attribute for the annotation
+   *
+   * @param {LinkAnnotation} linkAnnotation current link annotation which saved custom style, class and attribute.
+   * @param {RTERenderContext} options - Render context options.
+   * @returns {Record<string, string>} Link attributes
+   */
+  private getAttribute;
+  /**
+   * Convert style to string which can be used to html string.
+   *
+   * @param {AnnotationStyle} style Style object.
+   * @returns {string} Style string
+   */
+  private formatStyleToString;
 }

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

@@ -0,0 +1,25 @@
+import { BlockAnnotation, BlockAnnotationTypeEnum } from './block-annotation.abstract';
+import { AnnotationStyle, RTERenderContext } from '../../interface';
+import { Nullable } from '../../../../types/general';
+/**
+ * List annotation
+ */
+export declare class ListAnnotation extends BlockAnnotation {
+  readonly type: BlockAnnotationTypeEnum;
+  /**
+   * @inheritDoc
+   */
+  renderStyle(options?: RTERenderContext): Nullable<AnnotationStyle>;
+  /**
+   * @inheritDoc
+   */
+  renderClass(options?: RTERenderContext): Nullable<string>;
+  /**
+   * @inheritDoc
+   */
+  clone(): BlockAnnotation;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): Nullable<Record<string, unknown>>;
+}

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

@@ -1,4 +1,4 @@
-import { AnnotationStyle } from '../../interface';
+import { AnnotationStyle, RTERenderContext } from '../../interface';
 import { Nullable } from '../../../../types/general';
 import { Annotation } from './annotation.abstract';
 export declare enum NodeAnnotationTypeEnum {
@@ -10,15 +10,29 @@ export declare enum NodeAnnotationTypeEnum {
   IMAGE = "IMAGE",
   CODE = "CODE",
   TEXT_COLOR = "TEXT_COLOR",
-  LINK = "LINK"
+  LINK = "LINK",
+  INLINE_HTML = "INLINE_HTML",
+  PLAIN_TEXT = "PLAIN_TEXT"
 }
 /**
  * Abstract class for all annotations
  */
 export declare abstract class NodeAnnotation extends Annotation {
   abstract readonly type: NodeAnnotationTypeEnum;
-  renderClass?(): Nullable<string>;
-  abstract render(): Nullable<AnnotationStyle>;
+  /**
+   * Generate the style for the annotation
+   *
+   * @param {RTERenderContext} [options] - Options for rendering the annotation style.
+   * @returns {Nullable<AnnotationStyle>} - Style for the annotation.
+   */
+  abstract renderStyle(options?: RTERenderContext): Nullable<AnnotationStyle>;
+  /**
+   * Generate the class for the annotation
+   *
+   * @param {RTERenderContext} [options] - Options for rendering the annotation class.
+   * @returns {Nullable<string>} - Class for the annotation.
+   */
+  abstract renderClass(options?: RTERenderContext): Nullable<string>;
   /**
    * Generate the JSON representation of the annotation
    *

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

@@ -0,0 +1,31 @@
+import { NodeAnnotation, NodeAnnotationTypeEnum } from './node-annotation.abstract';
+import { AnnotationStyle } from '../../interface';
+import { Nullable } from '../../../../types/general';
+/**
+ * Annotation to make text as plain text
+ */
+export declare class PlainTextAnnotation extends NodeAnnotation {
+  readonly type: NodeAnnotationTypeEnum;
+  plainText: boolean;
+  constructor(plainText: boolean);
+  /**
+   * @inheritDoc
+   */
+  static from(plainText: boolean): [NodeAnnotationTypeEnum.PLAIN_TEXT, PlainTextAnnotation];
+  /**
+   * @inheritDoc
+   */
+  clone(): NodeAnnotation;
+  /**
+   * @inheritDoc
+   */
+  renderClass(): Nullable<string>;
+  /**
+   * @inheritDoc
+   */
+  renderStyle(): Nullable<AnnotationStyle>;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): Nullable<Record<string, unknown>>;
+}

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

@@ -1,6 +1,6 @@
 import { NodeAnnotation, NodeAnnotationTypeEnum } from './node-annotation.abstract';
 import { Nullable } from '../../../../types/general';
-import { AnnotationStyle } from '../../interface';
+import { AnnotationStyle, RTERenderContext } from '../../interface';
 /**
  * Annotation to make text with strikethrough
  */
@@ -26,15 +26,11 @@ export declare class StrikethroughAnnotation extends NodeAnnotation {
    */
   clone(): StrikethroughAnnotation;
   /**
-   * Generate the class for the annotation
-   *
-   * @returns {Nullable<string>} - Annotation class
+   * @inheritDoc
    */
-  renderClass(): Nullable<string>;
+  renderClass(options?: RTERenderContext): Nullable<string>;
   /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} - Annotation style
+   * @inheritDoc
    */
-  render(): Nullable<AnnotationStyle>;
+  renderStyle(options?: RTERenderContext): Nullable<AnnotationStyle>;
 }

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

@@ -26,17 +26,13 @@ export declare class TextColorAnnotation extends NodeAnnotation {
    */
   clone(): TextColorAnnotation;
   /**
-   * Generate the class for the annotation
-   *
-   * @returns {Nullable<string>} - Annotation class
+   * @inheritDoc
    */
   renderClass(): Nullable<string>;
   /**
-   * Generate the style for the annotation
-   *
-   * @returns {Nullable<AnnotationStyle>} - Annotation style
+   * @inheritDoc
    */
-  render(): Nullable<AnnotationStyle>;
+  renderStyle(): Nullable<AnnotationStyle>;
   /**
    * format text color
    *