@heartlandone/vega 2.72.0 → 2.74.0-RTE-table-preview

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-strategies/toggle-header-table-column-strategy.d.ts

@@ -0,0 +1,45 @@
+import { RTETableBlock } from '../dto/table-block';
+import { RTETableCellBlock } from '../dto/table-cell-block';
+import { RTETableHeadCellBlock } from '../dto/table-head-cell-block';
+import { ToggleHeaderTableColumnAction } from '../actions/toggle-header-table-column-action';
+import { TableColumnStrategy } from './table-column-strategy.abstract';
+/**
+ * Strategy to handle the toggle of header state of a table column.
+ */
+export declare class ToggleHeaderTableColumnStrategy extends TableColumnStrategy<ToggleHeaderTableColumnAction> {
+  /**
+   * Check if all selected cells are header cells.
+   *
+   * @param {(RTETableCellBlock | RTETableHeadCellBlock)[]} selectedCellRange - The range of selected table cell blocks.
+   * @returns {boolean} True if all selected cells are header cells, false otherwise.
+   */
+  static isFullHeaderSelection(selectedCellRange: (RTETableCellBlock | RTETableHeadCellBlock)[]): boolean;
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: ToggleHeaderTableColumnAction, target: RTETableBlock): void;
+  /**
+   * Toggles the specified header cells in a row to cells.
+   *
+   * @param {number} firstTableCellIndex - The index of the first table cell in the row.
+   * @param {RTETableRowBlock} row - The table row block containing the cells to toggle.
+   * @param {number} startCellIndex - The index of the first cell to toggle.
+   */
+  private toggleHeaderCellsToCells;
+  /**
+   * Toggles the specified cells in a row to header cells.
+   *
+   * @param {number} firstTableCellIndex - The index of the first table cell in the row.
+   * @param {number} endCellIndex - The index of the last cell to toggle.
+   * @param {RTETableRowBlock} row - The table row block containing the cells to toggle.
+   */
+  private toggleCellsToHeader;
+  /**
+   * Replaces a cell in a given row at the specified index with a new cell.
+   *
+   * @param {RTETableRowBlock} row - The table row block containing the cell to replace.
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} oldCell - The cell to replace.
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} newCell - The new cell to insert.
+   */
+  private replaceCellInRow;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-strategies/update-table-cell-properties-strategy.d.ts

@@ -0,0 +1,13 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { RTETableCellAnnotationsAction } from '../actions/table-cell-annotations-action';
+import { RTETableHeadCellAnnotationsAction } from '../actions/table-head-cell-annotations-action';
+import { RTETableCellBlock } from '../dto/table-cell-block';
+/**
+ * Update table cell properties action handler strategy
+ */
+export declare class UpdateTableCellPropertiesStrategy extends ActionHandleStrategy<RTETableCellAnnotationsAction | RTETableHeadCellAnnotationsAction, RTETableCellBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: RTETableCellAnnotationsAction | RTETableHeadCellAnnotationsAction, target: RTETableCellBlock): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/action-handler-strategies/update-table-properties-strategy.d.ts

@@ -0,0 +1,12 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { UpdateTablePropertiesAction } from '../actions/update-table-properties-action';
+import { RTETableBlock } from '../dto/table-block';
+/**
+ * Update table properties action handler strategy
+ */
+export declare class UpdateTablePropertiesStrategy extends ActionHandleStrategy<UpdateTablePropertiesAction, RTETableBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: UpdateTablePropertiesAction, target: RTETableBlock): void;
+}

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

@@ -0,0 +1,12 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import type { RTETableBlock } from '../dto/table-block';
+export declare const DELETE_TABLE_BLOCK: string;
+/**
+ * Action to delete a table block
+ */
+export declare class DeleteTableBlockAction extends ModifyContentAction {
+  isFlushable: boolean;
+  type: string;
+  tableBlock: RTETableBlock;
+  constructor(target: RTETableBlock);
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/actions/delete-table-column-action.d.ts

@@ -0,0 +1,15 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { RTETableCellBlock } from '../dto/table-cell-block';
+export declare const DELETE_TABLE_COLUMN: string;
+/**
+ * Action to delete a table column
+ */
+export declare class DeleteTableColumnAction extends ModifyContentAction {
+  isFlushable: boolean;
+  type: string;
+  /**
+   * The table cell delete range that determines which column to delete.
+   */
+  tableCellDeleteRange: RTETableCellBlock[];
+  constructor(target: RTETableCellBlock[]);
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/actions/delete-table-row-action.d.ts

@@ -0,0 +1,17 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { RTETableRowBlock } from '../dto/table-row-block';
+export declare const DELETE_TABLE_ROW: string;
+/**
+ * Action class for deleting a specific table row.
+ */
+export declare class DeleteTableRowAction extends ModifyContentAction {
+  isFlushable: boolean;
+  type: string;
+  rowsToBeRemoved: RTETableRowBlock[];
+  /**
+   * Constructs an InsertTableRowAction.
+   *
+   * @param {RTETableRowBlock[]} rowsToBeRemoved - The rows to be removed from the table.
+   */
+  constructor(rowsToBeRemoved: RTETableRowBlock[]);
+}

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

@@ -0,0 +1,20 @@
+import { Nullable } from '../../../../../types/general';
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+export declare const INSERT_TABLE_BLOCK: string;
+/**
+ * Action to insert a table block into the rich text editor.
+ */
+export declare class InsertTableBlockAction extends ModifyContentAction {
+  type: string;
+  nextFocusNode: Nullable<RTENode>;
+  /**
+   * Number of rows in the table.
+   */
+  rowCount: number;
+  /**
+   * Number of columns in the table.
+   */
+  columnCount: number;
+  constructor(rowCount: number, columnCount: number);
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/actions/insert-table-column-action.d.ts

@@ -0,0 +1,23 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { RTETableCellBlock } from '../dto/table-cell-block';
+export declare const INSERT_TABLE_COLUMN: string;
+export declare enum InsertTableColumnDirection {
+  LEFT = "LEFT",
+  RIGHT = "RIGHT"
+}
+/**
+ * Action to insert a table column into the RTETable.
+ */
+export declare class InsertTableColumnAction extends ModifyContentAction {
+  isFlushable: boolean;
+  type: string;
+  /**
+   * The table cell insert range that determines where to insert the new column.
+   */
+  tableCellInsertRange: RTETableCellBlock[];
+  /**
+   * Specifies whether to insert the column to the left or right of the given cell range.
+   */
+  insertDirection: InsertTableColumnDirection;
+  constructor(insertDirection: InsertTableColumnDirection, tableCellInsertRange: RTETableCellBlock[]);
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/actions/insert-table-row-action.d.ts

@@ -0,0 +1,23 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { RTETableRowBlock } from '../dto/table-row-block';
+export declare const INSERT_TABLE_ROW: string;
+export declare enum InsertTableRowDirection {
+  ABOVE = "ABOVE",
+  BELOW = "BELOW"
+}
+/**
+ * Action class for inserting a new row into a table within the rich text editor.
+ */
+export declare class InsertTableRowAction extends ModifyContentAction {
+  isFlushable: boolean;
+  type: string;
+  insertDirection: InsertTableRowDirection;
+  selectedRows: RTETableRowBlock[];
+  /**
+   * Constructs an InsertTableRowAction.
+   *
+   * @param {InsertTableRowDirection} insertDirection - The direction to insert the new row (above or below the current row).
+   * @param {RTETableRowBlock[]} selectedRows - The currently selected rows in the table.
+   */
+  constructor(insertDirection: InsertTableRowDirection, selectedRows?: RTETableRowBlock[]);
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/actions/select-table-column-action.d.ts

@@ -0,0 +1,18 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { RTETableCellBlock } from '../dto/table-cell-block';
+export declare const SELECT_TABLE_COLUMN: string;
+/**
+ * Action to select a table column into the RTETable.
+ */
+export declare class SelectTableColumnAction extends ModifyContentAction {
+  type: string;
+  /**
+   * The table cell that determines where to select the column.
+   */
+  tableCellSelectRange: RTETableCellBlock[];
+  /**
+   * Callback function to be called for each selected cell.
+   */
+  selectCellCallback: (cell: RTETableCellBlock[]) => void;
+  constructor(tableCellSelectRange: RTETableCellBlock[], selectCellCallback: (cell: RTETableCellBlock[]) => void);
+}

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

@@ -0,0 +1,16 @@
+import { AnnotationAction } from '../../../dto/actions/annotation-action.abstract';
+import { Annotation } from '../../../dto/annotations/annotation.abstract';
+import { Nullable } from '../../../../../types/general';
+import { VegaRTETableAnnotation } from '../annotations/table-annotation';
+/**
+ * Action to apply annotations to a table.
+ */
+export declare class RTETableAnnotationsAction extends AnnotationAction {
+  isFlushable: boolean;
+  table: VegaRTETableAnnotation;
+  constructor(table: VegaRTETableAnnotation);
+  /**
+   * @inheritDoc
+   */
+  toAnnotation(): Nullable<Annotation>;
+}

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

@@ -0,0 +1,14 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { Nullable } from '../../../../../types/general';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+export declare const TOGGLE_TABLE_CAPTION: string;
+/**
+ * Action payload for toggling the optional table caption block.
+ */
+export declare class TableCaptionAction extends ModifyContentAction {
+  type: string;
+  isFlushable: boolean;
+  shouldEnable: boolean;
+  nextFocusNode: Nullable<RTENode>;
+  constructor(shouldEnable: boolean);
+}

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

@@ -0,0 +1,14 @@
+import { AnnotationAction } from '../../../dto/actions/annotation-action.abstract';
+import { RTETableCellAnnotation, VegaRTETableCellAnnotation } from '../annotations/table-cell-annotation';
+/**
+ * Action to apply annotations to a table cell.
+ */
+export declare class RTETableCellAnnotationsAction extends AnnotationAction {
+  isFlushable: boolean;
+  cellAnnotation: VegaRTETableCellAnnotation;
+  constructor(cellAnnotation: VegaRTETableCellAnnotation);
+  /**
+   * @inheritDoc
+   */
+  toAnnotation(): RTETableCellAnnotation;
+}

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

@@ -0,0 +1,15 @@
+import { AnnotationAction } from '../../../dto/actions/annotation-action.abstract';
+import { VegaRTETableCellAnnotation } from '../annotations/table-cell-annotation';
+import { RTETableHeadCellAnnotation } from '../annotations/table-head-cell-annotation';
+/**
+ * Action to apply annotations to a table head cell.
+ */
+export declare class RTETableHeadCellAnnotationsAction extends AnnotationAction {
+  isFlushable: boolean;
+  tableCell: VegaRTETableCellAnnotation;
+  constructor(tableCell: VegaRTETableCellAnnotation);
+  /**
+   * @inheritDoc
+   */
+  toAnnotation(): RTETableHeadCellAnnotation;
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/actions/toggle-header-row-action.d.ts

@@ -0,0 +1,12 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { RTETableRowBlock } from '../dto/table-row-block';
+export declare const TOGGLE_HEADER_ROW: string;
+/**
+ * Action to convert selected rows to header rows or revert them back to normal rows.
+ */
+export declare class ToggleHeaderRowAction extends ModifyContentAction {
+  isFlushable: boolean;
+  type: string;
+  selectedRows: RTETableRowBlock[];
+  constructor(selectedRows: RTETableRowBlock[]);
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/actions/toggle-header-table-column-action.d.ts

@@ -0,0 +1,16 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { RTETableCellBlock } from '../dto/table-cell-block';
+export declare const TOGGLE_HEADER_TABLE_COLUMN: string;
+/**
+ * Action to toggle header state of a table column in the RTETable.
+ */
+export declare class ToggleHeaderTableColumnAction extends ModifyContentAction {
+  isFlushable: boolean;
+  type: string;
+  headerOn: boolean;
+  /**
+   * The table cell that determines where to header the column.
+   */
+  tableCellHeaderRange: RTETableCellBlock[];
+  constructor(tableCellHeaderRange: RTETableCellBlock[], headerOn: boolean);
+}

package/dist/types/components/vega-rich-text-editor/extensions/table/actions/update-table-properties-action.d.ts

@@ -0,0 +1,18 @@
+import { AnnotationAction } from '../../../dto/actions/annotation-action.abstract';
+import { RTETablePropertiesType } from '../../../interface';
+import { RTETableAnnotation } from '../annotations/table-annotation';
+export declare const UPDATE_TABLE_PROPERTIES: string;
+/**
+ * Action to update table properties
+ */
+export declare class UpdateTablePropertiesAction extends AnnotationAction {
+  isFlushable: boolean;
+  private tableProperties;
+  constructor(tableProperties: RTETablePropertiesType);
+  /**
+   * Generate annotation from action data
+   *
+   * @returns {RTETableAnnotation} The generated annotation
+   */
+  toAnnotation(): RTETableAnnotation;
+}

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

@@ -0,0 +1,43 @@
+import { Nullable } from '../../../../../types/general';
+import { AnnotationGeneratorStrategyAbstract } from '../../../slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/annotation-generator-strategy.abstract';
+import { VegaRTETableBorderType } from '../annotations/table-annotation';
+/**
+ * Base class for table annotation handlers with common extraction methods.
+ */
+export declare abstract class TableAnnotationHandlerBase extends AnnotationGeneratorStrategyAbstract {
+  /**
+   * Extract background color from element.
+   *
+   * @param {HTMLElement} element - Table element.
+   * @returns {Nullable<string>} Background color value.
+   */
+  protected getBackgroundColor(element: HTMLElement): Nullable<string>;
+  /**
+   * Extract border properties from element.
+   *
+   * @param {HTMLElement} element - Table element.
+   * @returns {Nullable<VegaRTETableBorderType>} Border properties.
+   */
+  protected getBorder(element: HTMLElement): Nullable<VegaRTETableBorderType>;
+  /**
+   * Parse border string into structured border type.
+   *
+   * @param {string} borderStr - Border CSS string.
+   * @returns {Nullable<VegaRTETableBorderType>} Parsed border properties.
+   */
+  protected parseBorderString(borderStr: string): Nullable<VegaRTETableBorderType>;
+  /**
+   * Extract width from element.
+   *
+   * @param {HTMLElement} element - Table element.
+   * @returns {Nullable<string>} Width value.
+   */
+  protected getWidth(element: HTMLElement): Nullable<string>;
+  /**
+   * Extract height from element.
+   *
+   * @param {HTMLElement} element - Table element.
+   * @returns {Nullable<string>} Height value.
+   */
+  protected getHeight(element: HTMLElement): Nullable<string>;
+}

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

@@ -0,0 +1,26 @@
+import { VegaRTEAnnotations } from '../../../interface';
+import { RTEDtoClassPrototype } from '../../../slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/html-element-to-annotation-generator';
+import { TableAnnotationHandlerBase } from './table-annotation-handler-base';
+/**
+ * Handler for table annotation parsing from HTML elements.
+ */
+export declare class TableAnnotationHandler extends TableAnnotationHandlerBase {
+  /**
+   * @inheritDoc
+   */
+  canHandle<T extends RTEDtoClassPrototype>(targetDto: T): boolean;
+  /**
+   * Handle annotation extraction from table element.
+   *
+   * @param {HTMLElement} element - Current table element.
+   * @returns {VegaRTEAnnotations} - Extracted table annotation.
+   */
+  handle(element: HTMLElement): VegaRTEAnnotations;
+  /**
+   * Extract alignment from element.
+   *
+   * @param {HTMLElement} element - Table element.
+   * @returns {Nullable<VegaRTETableAlignment>} Alignment value.
+   */
+  private getAlignment;
+}

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

@@ -0,0 +1,42 @@
+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 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,64 @@
+import { Nullable } from '../../../../../types/general';
+import { BlockAnnotation } from '../../../dto/annotations/block-annotation.abstract';
+export declare type VegaRTETableAnnotation = {
+  backgroundColor?: Nullable<string>;
+  border?: Nullable<VegaRTETableBorderType>;
+  width?: Nullable<string>;
+  height?: Nullable<string>;
+  alignment?: Nullable<VegaRTETableAlignment>;
+};
+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"
+}
+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> {
+  readonly type: RTETableExtensionAnnotationTypeEnum.TABLE;
+  backgroundColor?: Nullable<string>;
+  border?: Nullable<VegaRTETableBorderType>;
+  width?: Nullable<string>;
+  height?: Nullable<string>;
+  alignment?: Nullable<VegaRTETableAlignment>;
+  constructor({ backgroundColor, border, width, height, alignment, }?: VegaRTETableAnnotation);
+  /**
+   * @inheritDoc
+   */
+  static from(value: VegaRTETableAnnotation): [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,26 @@
+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>>;
+}

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

@@ -0,0 +1,67 @@
+import { Nullable } from '../../../../../types/general';
+import { RTETableExtensionAnnotationTypeEnum, VegaRTETableBorderType } from './table-annotation';
+import { BlockAnnotation } from '../../../dto/annotations/block-annotation.abstract';
+import { RTERenderContext } from '../../../interface';
+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>;
+};
+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;
+  readonly type: RTETableExtensionAnnotationTypeEnum.CELL;
+  backgroundColor?: Nullable<string>;
+  padding?: Nullable<string>;
+  border?: Nullable<VegaRTETableBorderType>;
+  width?: Nullable<string>;
+  height?: Nullable<string>;
+  textAlign?: Nullable<VegaRTETableTextAlignType>;
+  verticalAlign?: Nullable<VegaRTETableVerticalAlignType>;
+  constructor({ backgroundColor, padding, border, width, height, textAlign, verticalAlign, }?: VegaRTETableCellAnnotation);
+  /**
+   * @inheritDoc
+   */
+  static from(cellAnnotation: VegaRTETableCellAnnotation): [RTETableExtensionAnnotationTypeEnum.CELL, RTETableCellAnnotation];
+  /**
+   * Generates the CSS border string from the border properties.
+   *
+   * @returns {Nullable<string>} The CSS border string.
+   */
+  get borderStr(): Nullable<string>;
+  /**
+   * @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-head-cell-annotation.d.ts

@@ -0,0 +1,22 @@
+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 {
+  static readonly DEFAULT_BACKGROUND_COLOR: string;
+  constructor(annotation?: VegaRTETableCellAnnotation);
+  /**
+   * @inheritDoc
+   */
+  static from(cellAnnotation: VegaRTETableCellAnnotation): [RTETableExtensionAnnotationTypeEnum.CELL, RTETableHeadCellAnnotation];
+  /**
+   * @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,3 @@
+import { RTETableColorSchema } from '../../../interface';
+export declare const RTE_TABLE_BORDER_STYLES: string[];
+export declare const RTE_TABLE_DEFAULT_COLORS: RTETableColorSchema[];