@heartlandone/vega 2.77.1 → 2.79.0

package/dist/types/components/vega-rich-text-editor/extensions/table/annotation-handler/table-cell-annotation-handler.d.ts

@@ -0,0 +1,56 @@
+import { Nullable } from '../../../../../types/general';
+import { VegaRTEAnnotations } from '../../../interface';
+import { RTEDtoClassPrototype } from '../../../slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/html-element-to-annotation-generator';
+import { VegaRTETableTextAlignType, VegaRTETableVerticalAlignType } from '../annotations/table-cell-annotation';
+import { TableAnnotationHandlerBase } from './table-annotation-handler-base';
+/**
+ * Handler for table cell annotation parsing from HTML elements.
+ */
+export declare class TableCellAnnotationHandler extends TableAnnotationHandlerBase {
+  /**
+   * @inheritDoc
+   */
+  canHandle<T extends RTEDtoClassPrototype>(targetDto: T): boolean;
+  /**
+   * Handle annotation extraction from table cell element.
+   *
+   * @param {HTMLElement} element - Current table cell element.
+   * @returns {VegaRTEAnnotations} - Extracted table cell annotation.
+   */
+  handle(element: HTMLElement): VegaRTEAnnotations;
+  /**
+   * Extract minimum width from element.
+   *
+   * @param {HTMLElement} element - Table cell element.
+   * @returns {Nullable<string>} Minimum width value.
+   */
+  protected getMinWidth(element: HTMLElement): Nullable<string>;
+  /**
+   * Extract box sizing from element.
+   *
+   * @param {HTMLElement} element - Table cell element.
+   * @returns {Nullable<string>} Box sizing value.
+   */
+  protected getBoxSizing(element: HTMLElement): Nullable<string>;
+  /**
+   * Extract padding from element.
+   *
+   * @param {HTMLElement} element - Table cell element.
+   * @returns {Nullable<string>} Padding value.
+   */
+  protected getPadding(element: HTMLElement): Nullable<string>;
+  /**
+   * Extract text alignment from element.
+   *
+   * @param {HTMLElement} element - Table cell element.
+   * @returns {Nullable<VegaRTETableTextAlignType>} Text alignment value.
+   */
+  protected getTextAlign(element: HTMLElement): Nullable<VegaRTETableTextAlignType>;
+  /**
+   * Extract vertical alignment from element.
+   *
+   * @param {HTMLElement} element - Table cell element.
+   * @returns {Nullable<VegaRTETableVerticalAlignType>} Vertical alignment value.
+   */
+  protected getVerticalAlign(element: HTMLElement): Nullable<VegaRTETableVerticalAlignType>;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/annotation-handler/table-head-cell-annotation-handler.d.ts

@@ -0,0 +1,13 @@
+import { RTEDtoClassPrototype } from '../../../slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/html-element-to-annotation-generator';
+import { TableCellAnnotationHandler } from './table-cell-annotation-handler';
+/**
+ * Handler for table head cell annotation parsing from HTML elements.
+ * Extends TableCellAnnotationHandler as the extraction logic is identical,
+ * only differing in the target DTO type (th vs td elements).
+ */
+export declare class TableHeadCellAnnotationHandler extends TableCellAnnotationHandler {
+  /**
+   * @inheritDoc
+   */
+  canHandle<T extends RTEDtoClassPrototype>(targetDto: T): boolean;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/annotations/table-annotation.d.ts

@@ -0,0 +1,73 @@
+import { Nullable } from '../../../../../types/general';
+import { BlockAnnotation } from '../../../dto/annotations/block-annotation.abstract';
+import { RTETableColorAnnotation } from './table-color-annotation';
+export declare type VegaRTETableAnnotation = {
+  backgroundColor?: Nullable<string>;
+  border?: Nullable<VegaRTETableBorderType>;
+  width?: Nullable<string>;
+  height?: Nullable<string>;
+  alignment?: Nullable<VegaRTETableAlignment>;
+  borderCollapse?: Nullable<string>;
+};
+export declare type VegaRTETableBorderType = {
+  style?: string;
+  width?: string;
+  color?: string;
+};
+export declare enum RTETableExtensionAnnotationTypeEnum {
+  TABLE = "EXTENSION_TABLE",
+  CELL = "EXTENSION_TABLE_CELL",
+  CAPTION = "EXTENSION_TABLE_CAPTION",
+  COLOR = "EXTENSION_TABLE_COLOR"
+}
+export declare type VegaRTETableAlignment = 'left' | 'center' | 'right';
+/**
+ * Class representing a table annotation in the rich text editor.
+ */
+export declare class RTETableAnnotation extends BlockAnnotation<RTETableExtensionAnnotationTypeEnum.TABLE> {
+  static readonly DEFAULT_BORDER_COLLAPSE: string;
+  static readonly DEFAULT_ALIGNMENT: VegaRTETableAlignment;
+  readonly type: RTETableExtensionAnnotationTypeEnum.TABLE;
+  backgroundColor?: Nullable<string>;
+  border?: Nullable<VegaRTETableBorderType>;
+  backgroundColorAnnotation: RTETableColorAnnotation;
+  borderColorAnnotation: RTETableColorAnnotation;
+  width?: Nullable<string>;
+  height?: Nullable<string>;
+  alignment?: Nullable<VegaRTETableAlignment>;
+  borderCollapse?: Nullable<string>;
+  useInternalStyle: boolean;
+  constructor({ backgroundColor, border, width, height, alignment, borderCollapse }?: VegaRTETableAnnotation, useInternalStyle?: boolean);
+  /**
+   * @inheritDoc
+   */
+  static from(value: VegaRTETableAnnotation, useInternalStyle?: boolean): [RTETableExtensionAnnotationTypeEnum.TABLE, RTETableAnnotation];
+  /**
+   * Generates the CSS border string from the border properties.
+   *
+   * @returns {Nullable<string>} The CSS border string.
+   */
+  get borderStr(): Nullable<string>;
+  /**
+   * @inheritDoc
+   */
+  clone(): RTETableAnnotation;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): Record<'table', VegaRTETableAnnotation>;
+  /**
+   * @inheritDoc
+   */
+  renderStyle(): Record<string, string>;
+  /**
+   * @inheritDoc
+   */
+  renderClass(): Nullable<string>;
+  /**
+   * Generates the alignment styles for the table.
+   *
+   * @returns {Record<string, string>} The alignment styles.
+   */
+  renderAlignmentStyle(): Record<string, string>;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/annotations/table-caption-annotation.d.ts

@@ -0,0 +1,32 @@
+import { BlockAnnotation } from '../../../dto/annotations/block-annotation.abstract';
+import { RTETableExtensionAnnotationTypeEnum } from './table-annotation';
+import { AnnotationStyle, RTERenderContext } from '../../../interface';
+import { Nullable } from '../../../../../types/general';
+/**
+ * Class representing a table caption annotation in the rich text editor.
+ */
+export declare class RTETableCaptionAnnotation extends BlockAnnotation<RTETableExtensionAnnotationTypeEnum.CAPTION> {
+  readonly type: RTETableExtensionAnnotationTypeEnum.CAPTION;
+  /**
+   * @inheritDoc
+   */
+  clone(): BlockAnnotation<RTETableExtensionAnnotationTypeEnum.CAPTION>;
+  /**
+   * @inheritDoc
+   */
+  renderClass(options?: RTERenderContext): Nullable<string>;
+  /**
+   * @inheritDoc
+   */
+  renderStyle(options?: RTERenderContext): Nullable<AnnotationStyle>;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): Nullable<Record<'caption', unknown>>;
+  /**
+   * Get the background color for the caption based on the current theme mode.
+   *
+   * @returns {string} The background color for the caption.
+   */
+  private getCaptionBackgroundColor;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/annotations/table-cell-annotation.d.ts

@@ -0,0 +1,100 @@
+import { Nullable } from '../../../../../types/general';
+import { RTETableExtensionAnnotationTypeEnum, VegaRTETableBorderType } from './table-annotation';
+import { BlockAnnotation } from '../../../dto/annotations/block-annotation.abstract';
+import { RTERenderContext } from '../../../interface';
+import { RTETableColorAnnotation } from './table-color-annotation';
+export declare type VegaRTETableCellAnnotation = {
+  backgroundColor?: Nullable<string>;
+  padding?: Nullable<string>;
+  border?: Nullable<VegaRTETableBorderType>;
+  width?: Nullable<string>;
+  height?: Nullable<string>;
+  textAlign?: Nullable<VegaRTETableTextAlignType>;
+  verticalAlign?: Nullable<VegaRTETableVerticalAlignType>;
+  minWidth?: Nullable<string>;
+  boxSizing?: Nullable<string>;
+};
+export declare type VegaRTETableTextAlignType = 'left' | 'center' | 'right' | 'justify';
+export declare type VegaRTETableVerticalAlignType = 'top' | 'middle' | 'bottom';
+/**
+ * Class representing a table cell annotation in the rich text editor.
+ */
+export declare class RTETableCellAnnotation extends BlockAnnotation<RTETableExtensionAnnotationTypeEnum.CELL> {
+  static readonly DEFAULT_PADDING: string;
+  static readonly DEFAULT_BORDER: VegaRTETableBorderType;
+  static readonly DEFAULT_HORIZONTAL_TEXT_ALIGN: VegaRTETableTextAlignType;
+  static readonly DEFAULT_VERTICAL_TEXT_ALIGN: VegaRTETableVerticalAlignType;
+  static readonly DEFAULT_CELL_MIN_WIDTH: string;
+  static readonly DEFAULT_BOX_SIZING: string;
+  readonly type: RTETableExtensionAnnotationTypeEnum.CELL;
+  padding?: Nullable<string>;
+  width?: Nullable<string>;
+  height?: Nullable<string>;
+  textAlign?: Nullable<VegaRTETableTextAlignType>;
+  verticalAlign?: Nullable<VegaRTETableVerticalAlignType>;
+  backgroundColorAnnotation: RTETableColorAnnotation;
+  borderColorAnnotation: RTETableColorAnnotation;
+  minWidth?: Nullable<string>;
+  boxSizing?: Nullable<string>;
+  useInternalStyle: boolean;
+  private _backgroundColor?;
+  private _border?;
+  constructor({ backgroundColor, padding, border, width, height, textAlign, verticalAlign, minWidth, boxSizing, }?: VegaRTETableCellAnnotation, useInternalStyle?: boolean);
+  /**
+   * @inheritDoc
+   */
+  static from(cellAnnotation: VegaRTETableCellAnnotation, useInternalStyle?: boolean): [RTETableExtensionAnnotationTypeEnum.CELL, RTETableCellAnnotation];
+  /**
+   * Generates the CSS border string from the border properties.
+   *
+   * @returns {Nullable<string>} The CSS border string.
+   */
+  get borderStr(): Nullable<string>;
+  /**
+   * Sets the background color using a color key.
+   *
+   * @param {Nullable<string>} colorKey - The key representing the background color.
+   */
+  set backgroundColor(colorKey: Nullable<string>);
+  /**
+   * Gets the background color value.
+   *
+   * @returns {Nullable<string>} The background color value.
+   */
+  get backgroundColor(): Nullable<string>;
+  /**
+   * Sets the border properties and updates the border color annotation accordingly.
+   *
+   * @param {Nullable<VegaRTETableBorderType>} border - The border properties to set.
+   */
+  set border(border: Nullable<VegaRTETableBorderType>);
+  /**
+   * Gets the border properties.
+   *
+   * @returns {Nullable<VegaRTETableBorderType>} The border properties.
+   */
+  get border(): Nullable<VegaRTETableBorderType>;
+  /**
+   * @inheritDoc
+   */
+  clone(): RTETableCellAnnotation;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): Record<'tableCell', VegaRTETableCellAnnotation>;
+  /**
+   * @inheritDoc
+   */
+  renderStyle(options?: RTERenderContext): Record<string, string>;
+  /**
+   * @inheritDoc
+   */
+  renderClass(): Nullable<string>;
+  /**
+   * Removes default values from the style object to avoid redundancy.
+   *
+   * @param {Record<string, Nullable<string>>} style - The style object to clean.
+   * @returns {Record<string, Nullable<string>>} The cleaned style object.
+   */
+  private removeDefaultValues;
+}

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

@@ -0,0 +1,44 @@
+import { Nullable } from '../../../../../types/general';
+import { BlockAnnotation } from '../../../dto/annotations/block-annotation.abstract';
+import { AnnotationStyle } from '../../../interface';
+import { RTETableExtensionAnnotationTypeEnum } from './table-annotation';
+/**
+ * Class representing a table color annotation in the rich text editor.
+ */
+export declare class RTETableColorAnnotation extends BlockAnnotation<RTETableExtensionAnnotationTypeEnum.COLOR> {
+  type: RTETableExtensionAnnotationTypeEnum.COLOR;
+  private color;
+  private colorKey?;
+  constructor(colorKey?: string);
+  /**
+   * Render the style for the annotation
+   *
+   * @returns {AnnotationStyle} The style object containing the color
+   */
+  renderStyle(): AnnotationStyle;
+  /**
+   * Render the CSS class for the annotation
+   *
+   * @returns {Nullable<string>} Always returns null as no CSS class is used
+   */
+  renderClass(): Nullable<string>;
+  /**
+   * Convert the annotation to a JSON representation
+   *
+   * @returns {Record<string, string>} A JSON object containing the color key
+   */
+  toJSON(): Record<string, string>;
+  /**
+   * Clone the current annotation
+   *
+   * @returns {BlockAnnotation<RTETableExtensionAnnotationTypeEnum.COLOR>} A new instance of RTETableColorAnnotation with the same color key
+   */
+  clone(): BlockAnnotation<RTETableExtensionAnnotationTypeEnum.COLOR>;
+  /**
+   * format table color
+   *
+   * @param {string} colorKey - table color
+   * @returns {Nullable<VegaRTEColorSchema>} - VegaRTEColorSchema
+   */
+  private formatColor;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/annotations/table-head-cell-annotation.d.ts

@@ -0,0 +1,27 @@
+import { RTETableExtensionAnnotationTypeEnum } from './table-annotation';
+import { RTERenderContext } from '../../../interface';
+import { RTETableCellAnnotation, VegaRTETableCellAnnotation } from './table-cell-annotation';
+/**
+ * Class representing a table head cell annotation in the rich text editor.
+ */
+export declare class RTETableHeadCellAnnotation extends RTETableCellAnnotation {
+  constructor(annotation?: VegaRTETableCellAnnotation, useInternalStyle?: boolean);
+  /**
+   * @inheritDoc
+   */
+  static from(cellAnnotation: VegaRTETableCellAnnotation, useInternalStyle?: boolean): [RTETableExtensionAnnotationTypeEnum.CELL, RTETableHeadCellAnnotation];
+  /**
+   * Gets the default background color for table head cells based on the current theme mode.
+   *
+   * @returns {string} The default background color for table head cells.
+   */
+  static getDefaultBackgroundColor(): string;
+  /**
+   * @inheritDoc
+   */
+  clone(): RTETableHeadCellAnnotation;
+  /**
+   * @inheritDoc
+   */
+  renderStyle(options?: RTERenderContext): Record<string, string>;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/constants/styles.constants.d.ts

@@ -0,0 +1,4 @@
+import { VegaRTEColorSchema } from '../../../interface';
+export declare const RTE_TABLE_BORDER_STYLES: string[];
+export declare const RTE_TABLE_DEFAULT_COLORS: VegaRTEColorSchema[];
+export declare const RTE_TABLE_HEAD_DEFAULT_BACKGROUND_COLOR: VegaRTEColorSchema;

package/dist/types/components/vega-rich-text-editor/extensions/table/dto/table-block.d.ts

@@ -0,0 +1,79 @@
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { VegaRTEContent } from '../../../dto/content-state';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+import { RTEHtmlBlock } from '../../../dto/blocks/html-block';
+import { VegaRTEBlockAnnotations, VegaRTEBlockBase, VegaRTETransformOptions } from '../../../interface';
+import { RTETableBodyBlock, VegaRTETableBodyBlock } from './table-body-block';
+import { RTETableHeadBlock, VegaRTETableHeadBlock } from './table-head-block';
+import { VegaRTETableAnnotation } from '../annotations/table-annotation';
+import { RTETableCaptionBlock, VegaRTETableCaptionBlock } from './table-caption-block';
+import { Nullable } from '../../../../../types/general';
+export declare type VegaRTETableBlock = VegaRTEBlockBase & {
+  type: string;
+  /**
+   * Children of the table block. May include an optional `table-caption` block
+   * alongside structural blocks like `table-head` and `table-body`.
+   */
+  children: (VegaRTETableHeadBlock | VegaRTETableBodyBlock | VegaRTETableCaptionBlock)[];
+  annotations?: VegaRTEBlockAnnotations & {
+    table?: VegaRTETableAnnotation;
+  };
+};
+export declare type VegaRTETableChildType = RTETableHeadBlock | RTETableBodyBlock | RTETableCaptionBlock;
+/**
+ * Class representing a table block in the rich text editor.
+ */
+export declare class RTETableBlock extends RTEBlock<VegaRTEContent | RTEHtmlBlock, VegaRTETableChildType> {
+  type: string;
+  parent: VegaRTEContent | RTEHtmlBlock;
+  children: VegaRTETableChildType[];
+  constructor(id: string, options?: VegaRTETransformOptions);
+  /**
+   * @inheritDoc
+   */
+  static from(block: VegaRTETableBlock, options?: VegaRTETransformOptions): RTETableBlock;
+  /**
+   * @inheritDoc
+   */
+  clone(parent: VegaRTEContent | RTEHtmlBlock): RTETableBlock;
+  /**
+   * @inheritDoc
+   */
+  getLastNode(): RTENode;
+  /**
+   * Get the first node of the table block.
+   *
+   * @returns {RTENode} The first node of the table block.
+   */
+  getFirstNode(): RTENode;
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): VegaRTETableBlock;
+  /**
+   * Retrieves the caption block from the children collection, if present.
+   *
+   * @returns {Nullable<RTETableCaptionBlock>} The caption block or `null`.
+   */
+  getCaption(): Nullable<RTETableCaptionBlock>;
+  /**
+   * Inserts, replaces, or removes the caption block within the children.
+   *
+   * @param {Nullable<RTETableCaptionBlock>} caption - The caption block to set, or `null` to remove.
+   */
+  setCaption(caption: Nullable<RTETableCaptionBlock>): void;
+  /**
+   * Checks whether the table currently stores a caption block reference.
+   *
+   * @returns {boolean} `true` when a caption DTO is attached; otherwise `false`.
+   */
+  hasCaption(): boolean;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/dto/table-body-block.d.ts

@@ -0,0 +1,42 @@
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+import { VegaRTEBlockBase, VegaRTETransformOptions } from '../../../interface';
+import { RTETableBlock } from './table-block';
+import { RTETableRowBlock, VegaRTETableRowBlock } from './table-row-block';
+export declare type VegaRTETableBodyBlock = VegaRTEBlockBase & {
+  type: string;
+  children: VegaRTETableRowBlock[];
+};
+/**
+ * Class representing a table body block in the rich text editor.
+ */
+export declare class RTETableBodyBlock extends RTEBlock<RTETableBlock, RTETableRowBlock> {
+  type: string;
+  parent: RTETableBlock;
+  children: RTETableRowBlock[];
+  constructor(id: string);
+  /**
+   * @inheritDoc
+   */
+  static from(block: VegaRTETableBodyBlock, options?: VegaRTETransformOptions): RTETableBodyBlock;
+  /**
+   * @inheritDoc
+   */
+  clone(parent: RTETableBlock): RTETableBodyBlock;
+  /**
+   * @inheritDoc
+   */
+  getLastNode(): RTENode;
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): VegaRTETableBodyBlock;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/dto/table-caption-block.d.ts

@@ -0,0 +1,41 @@
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { VegaRTEBlockBase, VegaRTETextBlock, VegaRTETransformOptions } from '../../../interface';
+import { RTETableBlock } from './table-block';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+export declare type VegaRTETableCaptionBlock = VegaRTEBlockBase & {
+  type: string;
+  children: VegaRTETextBlock[];
+};
+/**
+ * Represents the optional caption block for a table.
+ */
+export declare class RTETableCaptionBlock extends RTEBlock<RTETableBlock, RTEBlock> {
+  type: string;
+  parent: RTETableBlock;
+  children: RTEBlock[];
+  constructor(id: string, options?: VegaRTETransformOptions);
+  /**
+   * @inheritDoc
+   */
+  static from(block: VegaRTETableCaptionBlock, options?: VegaRTETransformOptions): RTETableCaptionBlock;
+  /**
+   * @inheritDoc
+   */
+  clone(parent: RTETableBlock): RTETableCaptionBlock;
+  /**
+   * @inheritDoc
+   */
+  getLastNode(): RTENode;
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): VegaRTETableCaptionBlock;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/dto/table-cell-block.d.ts

@@ -0,0 +1,64 @@
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+import { VegaRTEBlockAnnotations, VegaRTEBlockBase, VegaRTEContentBlock, VegaRTETransformOptions } from '../../../interface';
+import { RTETableRowBlock } from './table-row-block';
+import { VegaRTETableCellAnnotation } from '../annotations/table-cell-annotation';
+export declare type VegaRTETableCellBlock = VegaRTEBlockBase & {
+  type: string;
+  children: VegaRTEContentBlock[];
+  annotations?: VegaRTEBlockAnnotations & {
+    tableCell?: VegaRTETableCellAnnotation;
+  };
+};
+/**
+ * Class representing a table cell block in the rich text editor.
+ */
+export declare class RTETableCellBlock extends RTEBlock<RTETableRowBlock, RTEBlock> {
+  type: string;
+  parent: RTETableRowBlock;
+  children: RTEBlock[];
+  constructor(id: string, options?: VegaRTETransformOptions);
+  /**
+   * @inheritDoc
+   */
+  static from(block: VegaRTETableCellBlock, options?: VegaRTETransformOptions): RTETableCellBlock;
+  /**
+   * @inheritDoc
+   */
+  clone(parent: RTETableRowBlock): RTETableCellBlock;
+  /**
+   * @inheritDoc
+   */
+  getLastNode(): RTENode;
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty(): boolean;
+  /**
+   * Get the rowSpan of the table cell
+   *
+   * @returns {number} - rowSpan value
+   */
+  get rowSpan(): number;
+  /**
+   * Get the colSpan of the table cell
+   *
+   * @returns {number} - colSpan value
+   */
+  get colSpan(): number;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): VegaRTETableCellBlock;
+  /**
+   * Get custom attribute by name
+   *
+   * @param {string} attrName - attribute name
+   * @returns {Nullable<string>} - attribute value
+   */
+  private getCustomAttributeByName;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/dto/table-head-block.d.ts

@@ -0,0 +1,42 @@
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+import { VegaRTEBlockBase, VegaRTEContentBlock, VegaRTETransformOptions } from '../../../interface';
+import { RTETableBlock } from './table-block';
+import { RTETableRowBlock } from './table-row-block';
+export declare type VegaRTETableHeadBlock = VegaRTEBlockBase & {
+  type: string;
+  children: VegaRTEContentBlock[];
+};
+/**
+ * Class representing a table head block in the rich text editor.
+ */
+export declare class RTETableHeadBlock extends RTEBlock<RTETableBlock, RTETableRowBlock> {
+  type: string;
+  parent: RTETableBlock;
+  children: RTETableRowBlock[];
+  constructor(id: string);
+  /**
+   * @inheritDoc
+   */
+  static from(block: VegaRTETableHeadBlock, options?: VegaRTETransformOptions): RTETableHeadBlock;
+  /**
+   * @inheritDoc
+   */
+  clone(parent: RTETableBlock): RTETableHeadBlock;
+  /**
+   * @inheritDoc
+   */
+  getLastNode(): RTENode;
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): VegaRTETableHeadBlock;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/dto/table-head-cell-block.d.ts

@@ -0,0 +1,34 @@
+import { VegaRTEBlockAnnotations, VegaRTEBlockBase, VegaRTEContentBlock, VegaRTETransformOptions } from '../../../interface';
+import { RTETableRowBlock } from './table-row-block';
+import { RTETableCellBlock } from './table-cell-block';
+import { VegaRTETableCellAnnotation } from '../annotations/table-cell-annotation';
+export declare type VegaRTETableHeadCellBlock = VegaRTEBlockBase & {
+  type: string;
+  children: VegaRTEContentBlock[];
+  annotations?: VegaRTEBlockAnnotations & {
+    tableCell?: VegaRTETableCellAnnotation;
+  };
+};
+/**
+ * Class representing a table head block in the rich text editor.
+ */
+export declare class RTETableHeadCellBlock extends RTETableCellBlock {
+  type: string;
+  constructor(id: string, options?: VegaRTETransformOptions);
+  /**
+   * @inheritDoc
+   */
+  static from(block: VegaRTETableHeadCellBlock, options?: VegaRTETransformOptions): RTETableHeadCellBlock;
+  /**
+   * @inheritDoc
+   */
+  clone(parent: RTETableRowBlock): RTETableHeadCellBlock;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): VegaRTETableHeadCellBlock;
+}