@heartlandone/vega 2.49.1 → 2.50.0-RTE-preview

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

@@ -1,18 +1,31 @@
-import { AnnotationStyle } from '../../interface';
+import { AnnotationStyle, RTERenderContext } from '../../interface';
 import { Annotation } from './annotation.abstract';
 import { Nullable } from '../../../../types/general';
 export declare enum BlockAnnotationTypeEnum {
   ALIGNMENT = "ALIGNMENT",
   TEXT_STYLE = "TEXT_STYLE",
-  INDENT = "INDENT"
+  INDENT = "INDENT",
+  LIST = "LIST"
 }
 /**
  * BlockAnnotation is an abstract class that represents a block annotation.
  */
 export declare abstract class BlockAnnotation extends Annotation {
   abstract readonly type: BlockAnnotationTypeEnum;
-  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 item of the annotation
    *

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
@@ -26,15 +26,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,43 @@
+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;
+  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,42 @@
+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;
+}

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,6 +1,6 @@
 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
@@ -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/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

@@ -33,9 +33,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,50 @@ 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.
+   * @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 {
@@ -17,8 +17,20 @@ export declare enum NodeAnnotationTypeEnum {
  */
 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/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
    *

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

@@ -1,5 +1,5 @@
 import { BlockAnnotation, BlockAnnotationTypeEnum } from './block-annotation.abstract';
-import { AnnotationStyle, VegaRTETextStyleType } from '../../interface';
+import { AnnotationStyle, RTERenderContext, VegaRTETextStyleType } from '../../interface';
 import { Nullable } from '../../../../types/general';
 /**
  * Text style annotation
@@ -26,9 +26,11 @@ export declare class TextStyleAnnotation extends BlockAnnotation {
    */
   clone(): TextStyleAnnotation;
   /**
-   * Render the styles by block type
-   *
-   * @returns {AnnotationStyle} the styles to apply
+   * @inheritDoc
+   */
+  renderClass(options?: RTERenderContext): Nullable<string>;
+  /**
+   * @inheritDoc
    */
-  render(): AnnotationStyle;
+  renderStyle(options?: RTERenderContext): Nullable<AnnotationStyle>;
 }

package/dist/types/components/vega-rich-text-editor/dto/annotations/underline-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 underline
  */
@@ -26,15 +26,11 @@ export declare class UnderlineAnnotation extends NodeAnnotation {
    */
   clone(): UnderlineAnnotation;
   /**
-   * 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/blocks/block.abstract.d.ts

@@ -1,4 +1,4 @@
-import { RTEBlockType, VegaRTEBlockAnnotations, VegaRTEBlockBase } from '../../interface';
+import { AnnotationStyle, RTEBlockAnnotationMapKey, RTEBlockAnnotationMapValue, RTEBlockType, RTERenderContext, VegaRTEBlockAnnotations, VegaRTEBlockBase } from '../../interface';
 import { BlockAnnotation, BlockAnnotationTypeEnum } from '../annotations/block-annotation.abstract';
 import { AnnotationAction } from '../actions/annotation-action.abstract';
 import { Nullable } from '../../../../types/general';
@@ -7,7 +7,9 @@ import { VegaRTEContent } from '../content-state';
 import { InternalAnnotationTypeEnum } from '../annotations/annotation.abstract';
 import { LinkGroupAnnotation } from '../annotations/link-group-annotation';
 import { RTENode } from '../nodes/node.abstract';
-export declare type BlockAnnotations = Map<keyof typeof BlockAnnotationTypeEnum | InternalAnnotationTypeEnum.LINK_GROUP, BlockAnnotation | LinkGroupAnnotation>;
+import { CustomAttributeAnnotation } from '../annotations/custom-attribute-annotation';
+export declare type BlockAnnotations = Map<RTEBlockAnnotationMapKey, RTEBlockAnnotationMapValue>;
+export declare type BlockAnnotationsEntity = [RTEBlockAnnotationMapKey, RTEBlockAnnotationMapValue];
 /**
  * Abstract class for block
  */
@@ -26,10 +28,10 @@ export declare abstract class RTEBlock {
    * @param {unknown} value - The `value` parameter in the `createAnnotationEntity` function is the value
    * that will be used to create the annotation entity. It can be of any type depending on the specific
    * annotation being created.
-   * @returns {Nullable<[BlockAnnotationTypeEnum, BlockAnnotation]>} The `createAnnotationEntity` function returns a nullable tuple containing a
+   * @returns {Nullable<BlockAnnotationsEntity>} The `createAnnotationEntity` function returns a nullable tuple containing a
    * `BlockAnnotationTypeEnum` and a `BlockAnnotation` object.
    */
-  protected static createAnnotationEntity(type: keyof VegaRTEBlockAnnotations, value: unknown): Nullable<[BlockAnnotationTypeEnum, BlockAnnotation]>;
+  protected static createAnnotationEntity(type: keyof VegaRTEBlockAnnotations, value: unknown): Nullable<BlockAnnotationsEntity>;
   /**
    * Class to JSON object
    *
@@ -50,6 +52,33 @@ export declare abstract class RTEBlock {
    * @param {AnnotationAction} action - Annotation action
    */
   apply(action: AnnotationAction | ModifyContentAction): void;
+  /**
+   * Get styles from annotations
+   *
+   * @param {RTERenderContext} [options={ standalone: false }] - Options to control style mode
+   * @returns {AnnotationStyle} - Annotation styles
+   */
+  getStyles(options?: RTERenderContext): AnnotationStyle;
+  /**
+   * Get classes from annotations
+   *
+   * @param {RTERenderContext} [options={ standalone: false }] - Options to control standalone mode
+   * @returns {string} - Annotation style
+   */
+  getClasses(options?: RTERenderContext): string;
+  /**
+   * Get custom attribute annotation, excluding "class" and "style"
+   *
+   * @returns {Nullable<CustomAttributeAnnotation>} - custom attribute annotation
+   */
+  getCustomAttributesAnnotation(): Nullable<CustomAttributeAnnotation>;
+  /**
+   * Generate attributes as string
+   *
+   * @param {...string} attrs - Additional attributes to include
+   * @returns {string} - Attributes as string
+   */
+  protected generateAttributeString(...attrs: string[]): string;
   /**
    * Apply action to block
    *
@@ -82,4 +111,10 @@ export declare abstract class RTEBlock {
   abstract isNotEmpty(): boolean;
   abstract getLastNode(): RTENode;
   abstract clone(): RTEBlock;
+  /**
+   * Converts the block to HTML.
+   *
+   * @returns {string} The HTML string representing the block.
+   */
+  abstract toHtml(): string;
 }