@globalpayments/vega 2.87.0 → 2.89.0

package/dist/types/components/vega-input-passcode/vega-input-passcode.d.ts

@@ -106,6 +106,16 @@ export declare class VegaInputPasscode {
    * @vegaVersion 2.66.0
    */
   required: boolean;
+  /**
+   * Indicates whether the field should be presented as optional.
+   *
+   * This property only takes effect when `required` is `false`.
+   * When `true`, an "optional" label is displayed next to the field label.
+   *
+   * @default false
+   * @vegaVersion 2.88.0
+   */
+  optional: boolean;
   /**
    * An array of custom validation rules applied to the passcode input in
    * addition to the built-in `RequiredFieldRule`. Each rule must implement

package/dist/types/components/vega-input-phone-number/slimmers/renderers/vega-input-phone-number-renderer.d.ts

@@ -2,6 +2,7 @@ import { VegaSlimmer } from '../../../../vega-slimmer/vega-slimmer-core';
 import { VegaInputPhoneNumber } from '../../vega-input-phone-number';
 export declare class VegaInputPhoneNumberRenderer extends VegaSlimmer {
   protected required: VegaInputPhoneNumber['required'];
+  protected optional: VegaInputPhoneNumber['optional'];
   protected label: VegaInputPhoneNumber['label'];
   protected disabled: VegaInputPhoneNumber['disabled'];
   protected hint: VegaInputPhoneNumber['hint'];

package/dist/types/components/vega-input-phone-number/vega-input-phone-number.d.ts

@@ -60,6 +60,16 @@ export declare class VegaInputPhoneNumber {
    * @vegaVersion 2.18.0
    */
   required: boolean;
+  /**
+   * Indicates whether the field should be presented as optional.
+   *
+   * This property only takes effect when `required` is `false`.
+   * When `true`, an "optional" label is displayed next to the field label.
+   *
+   * @default false
+   * @vegaVersion 2.88.0
+   */
+  optional: boolean;
   /**
    * Specifies whether the phone number input field is disabled. When `true`,
    * both the country selector and the phone number text field become

package/dist/types/components/vega-input-range/slimmers/renderers/vega-input-range-renderer.d.ts

@@ -3,6 +3,7 @@ import { VegaInputRange } from '../../vega-input-range';
 /** The class VegaInputRangeRenderer is a TypeScript React component that renders an input range field with custom label, hint, and styling options. */
 export declare class VegaInputRangeRenderer extends VegaSlimmer {
   protected required: VegaInputRange['required'];
+  protected optional: VegaInputRange['optional'];
   protected disabled: VegaInputRange['disabled'];
   protected label: VegaInputRange['label'];
   protected hint: VegaInputRange['hint'];

package/dist/types/components/vega-input-range/vega-input-range.d.ts

@@ -95,6 +95,16 @@ export declare class VegaInputRange {
    * @vegaVersion 2.2.0
    */
   required: boolean;
+  /**
+   * Indicates whether the field should be presented as optional.
+   *
+   * This property only takes effect when `required` is `false`.
+   * When `true`, an "optional" label is displayed next to the field label.
+   *
+   * @default false
+   * @vegaVersion 2.89.0
+   */
+  optional: boolean;
   /**
    * Indicates whether the current value in the field is considered valid
    *    based on the defined validation rules.

package/dist/types/components/vega-input-select/slimmers/renderers/vega-input-select-renderer.d.ts

@@ -7,6 +7,7 @@ export declare class VegaInputSelectRenderer extends VegaSlimmer {
   private hint;
   private label;
   private required;
+  private optional;
   private labelSuffixButtonConfig;
   private labelButtonClickEventEmitter;
   private dropdownRenderer;

package/dist/types/components/vega-input-select/vega-input-select.d.ts

@@ -76,6 +76,16 @@ export declare class VegaInputSelect {
    * @vegaVersion 1.0.7
    */
   required: boolean;
+  /**
+   * Indicates whether the field should be presented as optional.
+   *
+   * This property only takes effect when `required` is `false`.
+   * When `true`, an "optional" label is displayed next to the field label.
+   *
+   * @default false
+   * @vegaVersion 2.89.0
+   */
+  optional: boolean;
   /**
    * Allows customization of the text displayed within the
    *    select field when single or multiple items are selected.

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

@@ -0,0 +1,3 @@
+import { IconPayload } from '../../../helpers/icon/interface';
+declare const _default: IconPayload;
+export default _default;

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

@@ -0,0 +1,3 @@
+import { IconPayload } from '../../../helpers/icon/interface';
+declare const _default: IconPayload;
+export default _default;

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

@@ -5,7 +5,7 @@ import { RTENode } from '../nodes/node.abstract';
  * Class to handle the style representation of annotations for RTE blocks and nodes.
  */
 export declare class RTEAnnotationStyle<T extends RTEBlock | RTENode> {
-  private dtoType;
+  private dtoName;
   private annotationMap;
   constructor(dto: T);
   /**

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

@@ -18,6 +18,11 @@ export declare type RTEBlockChildrenType = RTEBlock | RTENode;
 export declare abstract class RTEBlock<P = RTEBlockParentType, C = RTEBlockChildrenType> {
   id: string;
   annotationMap: BlockAnnotations;
+  /**
+   * Minimize-safe type discriminator. Each concrete sub-class declares its own
+   * `static readonly dtoName = 'ClassName'`.
+   */
+  readonly dtoName: string;
   abstract type: string;
   abstract parent: P;
   abstract children: C[];

package/dist/types/components/vega-rich-text-editor/dto/blocks/code-block.d.ts

@@ -11,6 +11,8 @@ import { RTEHtmlBlock } from './html-block';
  */
 export declare class RTECodeBlock extends RTEBlock<VegaRTEContent | RTEHtmlBlock, RTECodeBlockNode> {
   static CODE_BLOCK_PLACEHOLDER_CLASS_NAME: string;
+  static readonly dtoName: string;
+  readonly dtoName: string;
   type: RTEBlockType;
   parent: VegaRTEContent | RTEHtmlBlock;
   children: RTECodeBlockNode[];

package/dist/types/components/vega-rich-text-editor/dto/blocks/html-block.d.ts

@@ -6,6 +6,8 @@ import { RTENode } from '../nodes/node.abstract';
  * HTML Block
  */
 export declare class RTEHtmlBlock extends RTEBlock<VegaRTEContent | RTEHtmlBlock, RTEBlock> {
+  static readonly dtoName: string;
+  readonly dtoName: string;
   type: 'html-block';
   parent: VegaRTEContent | RTEHtmlBlock;
   htmlTag: string;

package/dist/types/components/vega-rich-text-editor/dto/blocks/image-block.d.ts

@@ -7,6 +7,8 @@ import { RTEHtmlBlock } from './html-block';
  * Image block
  */
 export declare class RTEImageBlock extends RTEBlock<VegaRTEContent | RTEHtmlBlock, RTEImageNode> {
+  static readonly dtoName: string;
+  readonly dtoName: string;
   readonly type: RTEBlockType;
   children: RTEImageNode[];
   parent: VegaRTEContent | RTEHtmlBlock;

package/dist/types/components/vega-rich-text-editor/dto/blocks/list-block.d.ts

@@ -10,6 +10,8 @@ export declare type RTEListBlockTagType = 'ol' | 'ul';
  * List block
  */
 export declare class RTEListBlock extends RTEBlock<VegaRTEContent | RTEListItemBlock | RTEHtmlBlock, RTEListItemBlock> {
+  static readonly dtoName: string;
+  readonly dtoName: string;
   type: VegaRTEListBlockType;
   children: RTEListItemBlock[];
   parent: RTEListItemBlock | VegaRTEContent | RTEHtmlBlock;

package/dist/types/components/vega-rich-text-editor/dto/blocks/list-item-block.d.ts

@@ -6,6 +6,8 @@ import { RTETextBlock } from './text-block';
  * List item block
  */
 export declare class RTEListItemBlock extends RTETextBlock {
+  static readonly dtoName: string;
+  readonly dtoName: string;
   /**
    * TODO: Refactor the list item properties children and nestList, merge two properties together.
    *

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

@@ -11,6 +11,8 @@ export declare type RTETextBlockTagType = 'div' | 'h1' | 'h2' | 'h3' | 'h4' | 'h
  * Text block
  */
 export declare class RTETextBlock extends RTEBlock<VegaRTEContent | RTEListBlock | RTEHtmlBlock, RTETextNode> {
+  static readonly dtoName: string;
+  readonly dtoName: string;
   type: VegaRTETextBlockType;
   children: RTETextNode[];
   parent: VegaRTEContent | RTEListBlock | RTEHtmlBlock;

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

@@ -10,6 +10,9 @@ import './setup';
  * Class representing the content state of the rich text editor.
  */
 export declare class VegaRTEContent {
+  /** Minimize-safe type discriminator for VegaRTEContent. */
+  static readonly dtoName: string;
+  readonly dtoName: string;
   children: RTEContentBlock[];
   constructor(blocks: RTEContentBlock[]);
   /**

package/dist/types/components/vega-rich-text-editor/dto/nodes/code-block-node.d.ts

@@ -18,6 +18,8 @@ declare type CodeBlockNodeAnnotationValue = SelectionRangeAnnotation | CustomSty
  * RTE code node DTO class.
  */
 export declare class RTECodeBlockNode extends RTEDecoratorNode<RTECodeBlock> {
+  static readonly dtoName: string;
+  readonly dtoName: string;
   type: NodeTypeEnum;
   parent: RTECodeBlock;
   text: string;

package/dist/types/components/vega-rich-text-editor/dto/nodes/image-node.d.ts

@@ -8,6 +8,8 @@ import { RTEDecoratorNode } from './decorator-node';
  * Image node
  */
 export declare class RTEImageNode extends RTEDecoratorNode<RTEImageBlock> {
+  static readonly dtoName: string;
+  readonly dtoName: string;
   readonly type: NodeTypeEnum;
   parent: RTEImageBlock;
   url: string;

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

@@ -18,6 +18,11 @@ export declare type NodeAnnotations = Map<RTENodeAnnotationMapKey, RTENodeAnnota
 export declare abstract class RTENode<P extends RTEBlock = RTEBlock> {
   id: string;
   annotationMap: NodeAnnotations;
+  /**
+   * Minimize-safe type discriminator. Each concrete sub-class declares its own
+   * `static readonly dtoName = 'ClassName'`.
+   */
+  readonly dtoName: string;
   abstract readonly type: string;
   abstract parent: P;
   protected constructor(id: string, annotationMap?: Map<RTENodeAnnotationMapKey, RTENodeAnnotationMapValue>);

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

@@ -20,6 +20,8 @@ export declare type InlineHtmlTagDescriptor = {
 export declare class RTETextNode extends RTENode<RTETextBlock> {
   static registerActionStrategyStatus: Record<string, boolean>;
   static readonly htmlTag: 'span';
+  static readonly dtoName: string;
+  readonly dtoName: string;
   readonly type: NodeTypeEnum | string;
   text: string;
   parent: RTETextBlock;

package/dist/types/components/vega-rich-text-editor/extensions/base-toolbar-button-renderer.d.ts

@@ -12,6 +12,9 @@ import { VegaRTECreateElementFunction, VegaRTEToolbarRenderContext, VegaRTERende
  * Override the methods to customize the rendering and behavior of the button.
  */
 export declare abstract class VegaRTEToolbarButtonRenderer {
+  private dropdownEl;
+  private itemsContainerEl;
+  private buttonEl;
   /**
    * Checks if the button should be hidden.
    *
@@ -116,6 +119,34 @@ export declare abstract class VegaRTEToolbarButtonRenderer {
    * @returns {Nullable<RTEDropdownListItem>} The dropdown list item if found, otherwise null.
    */
   protected getListItemByKey(itemList: (RTEDropdownListItem | RTEDropdownListGroup)[], key: string): Nullable<RTEDropdownListItem>;
+  /**
+   * Handles keyboard events on the toolbar button to support dropdown keyboard accessibility.
+   * - Enter / Space: Toggles the dropdown open/closed.
+   * - ArrowDown / ArrowUp: Opens the dropdown and focuses the first/last item.
+   *
+   * @param {KeyboardEvent} e The keyboard event.
+   */
+  private handleButtonKeyDown;
+  /**
+   * Handles keyboard navigation within the dropdown items container.
+   * - ArrowDown/ArrowUp: Moves focus to the next/previous non-disabled item.
+   * - Escape: Closes the dropdown and returns focus to the toolbar button.
+   *
+   * @param {KeyboardEvent} e The keyboard event.
+   */
+  private handleItemsKeyDown;
+  /**
+   * Focuses the first or last non-disabled dropdown item.
+   *
+   * @param {'first' | 'last'} position Whether to focus the first or last item.
+   */
+  private focusDropdownItem;
+  /**
+   * Gets all dropdown items from the items container.
+   *
+   * @returns {HTMLVegaDropdownItemElement[]} Array of dropdown item elements.
+   */
+  private getDropdownItems;
   /**
    * Handles the button click event.
    *

package/dist/types/components/vega-rich-text-editor/extensions/extension.abstract.d.ts

@@ -13,6 +13,11 @@ import { ActionHandlerInterceptor } from '../dto/action-handle-strategies/action
 import { AnnotationGeneratorStrategyAbstract } from '../slimmers/controllers/helper/element-to-dto-strategy/annotation-handler/annotation-generator-strategy.abstract';
 import { AnnotationAction } from '../dto/actions/annotation-action.abstract';
 import { RTEFilterStylesStrategy } from '../dto/filter-styles-strategies/filter-styles-strategy.abstract';
+import type { VegaRTEBlockBase, VegaRTETransformOptions } from '../interface';
+declare type BlockClassWithFrom = ClassType<RTEBlock> & {
+  from(block: VegaRTEBlockBase, options?: VegaRTETransformOptions): RTEBlock;
+};
+declare type AnnotationFromJsonHandler = (instance: RTEBlock, value: unknown, block: VegaRTEBlockBase, options?: VegaRTETransformOptions) => void;
 /**
  * Abstract class for Vega Rich Text Editor extensions.
  */
@@ -45,6 +50,19 @@ export declare abstract class VegaRTEExtension {
    * @param {RTEFilterStylesStrategy} strategy - The filter styles strategy to register.
    */
   static registerFilterStylesStrategy(blockOrNodeClassName: string, strategy: RTEFilterStylesStrategy): void;
+  /**
+   * Attach a custom JSON annotation handler to a block DTO class's static `from` flow.
+   *
+   * This is a reusable extension point: any extension can register a handler for an
+   * annotation key and transform the value into block annotations during JSON parsing.
+   *
+   * Safe to call multiple times per class/key/handler — duplicate registrations are no-ops.
+   *
+   * @param {BlockClassWithFrom} BlockClass - Block DTO class to patch.
+   * @param {string} annotationKey - JSON annotation key to read from `block.annotations`.
+   * @param {AnnotationFromJsonHandler} handler - Handler that applies annotation logic to the instance.
+   */
+  static attachAnnotationFromJson(BlockClass: BlockClassWithFrom, annotationKey: string, handler: AnnotationFromJsonHandler): void;
   /**
    * Lifecycle hook called by the rich text editor before the first render
    * (during `componentWillLoad`).  Override this method to perform per-host
@@ -152,3 +170,4 @@ export declare abstract class VegaRTEExtension {
    */
   protected registerAnnotationHandler(handler: AnnotationGeneratorStrategyAbstract): void;
 }
+export {};

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

@@ -14,6 +14,8 @@ export declare type RTEFunctionBlockChild = RTELogicControlBlock | RTETextBlock;
  * RTE Function Block
  */
 export declare class RTEFunctionBlock extends RTEBlock<VegaRTEContent | RTEHtmlBlock, RTEFunctionBlockChild> {
+  static dtoName: string;
+  readonly dtoName: string;
   type: string;
   parent: VegaRTEContent | RTEHtmlBlock;
   children: RTEFunctionBlockChild[];

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

@@ -9,6 +9,8 @@ export declare type VegaRTELogicControlBlock = VegaRTECustomBlock & {
  * Class representing a logic control block in the rich text editor.
  */
 export declare class RTELogicControlBlock extends RTEBlock {
+  static dtoName: string;
+  readonly dtoName: string;
   type: string;
   parent: RTEFunctionBlock;
   children: RTELogicControlNode[];

package/dist/types/components/vega-rich-text-editor/extensions/functions/dto/logic-control-node.d.ts

@@ -5,6 +5,8 @@ import { RTELogicControlBlock } from './logic-control-block';
  * Class representing a logic control node in the rich text editor.
  */
 export declare class RTELogicControlNode extends RTENode {
+  static dtoName: string;
+  readonly dtoName: string;
   type: string;
   text: string;
   parent: RTELogicControlBlock;

package/dist/types/components/vega-rich-text-editor/extensions/functions/function-extension.d.ts

@@ -3,8 +3,9 @@ import { VegaRTEExtension } from '../extension.abstract';
  * Function extension class for Vega Rich Text Editor.
  */
 export declare class VegaRTEFunctionExtension extends VegaRTEExtension {
-  private toolbarButtonRenderer;
   constructor();
+  /** @inheritDoc */
+  prepareBeforeLoad(host: HTMLVegaRichTextEditorElement): void;
   /**
    * Remove the appen children strategies to prevent default insert new paragraph logic in function block
    */

package/dist/types/components/vega-rich-text-editor/extensions/horizontal-line/action-handler-strategies/horizontal-line-block-insert-strategy.d.ts

@@ -0,0 +1,29 @@
+import type { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { InsertHorizontalLineBlockAction } from '../actions/insert-horizontal-line-block-action';
+/**
+ * Strategy to handle the insertion of a horizontal line block into the rich text editor.
+ * Follows the same pattern as BlockInsertImageIntoTextStrategy (before/after/split).
+ */
+export declare class InsertHorizontalLineBlockStrategy extends ActionHandleStrategy<InsertHorizontalLineBlockAction, RTEBlock> {
+  /**
+   * @inheritDoc
+   */
+  protected handleAction(action: InsertHorizontalLineBlockAction, target: RTEBlock): void;
+  /**
+   * Insert HR after target. If next sibling is focusable (has a text node), move cursor there;
+   * otherwise create an empty paragraph after HR.
+   *
+   * @param {InsertHorizontalLineBlockAction} action - The insert action whose `nextFocusNode` is updated.
+   * @param {RTEBlock} target - The block after which the HR is inserted.
+   * @param {RTEHorizontalLineBlock} hrBlock - The HR block to insert.
+   */
+  private insertAfterWithFocus;
+  /**
+   * Get the next sibling block of the given block.
+   *
+   * @param {RTEBlock} block - The current block.
+   * @returns {RTEBlock | undefined} The next sibling block, or undefined if none.
+   */
+  private getNextSiblingBlock;
+}

package/dist/types/components/vega-rich-text-editor/extensions/horizontal-line/action-handler-strategies/hr-to-horizontal-line-block-strategy.d.ts

@@ -0,0 +1,35 @@
+import { RTEContentBlock, VegaRTETransformOptions } from '../../../interface';
+import { Nullable } from '../../../../../types/general';
+import { ElementToDTOStrategy } from '../../../slimmers/controllers/helper/element-to-dto-strategy/element-to-dto-strategy.abstract';
+/**
+ * Strategy to convert `<hr>` HTML elements into RTEHorizontalLineBlock instances.
+ */
+export declare class HrToHorizontalLineBlockStrategy extends ElementToDTOStrategy {
+  /**
+   * Determines if this strategy can handle the current element.
+   *
+   * @param {HTMLElement[]} elementsArray - Array of elements to process.
+   * @param {number} currentIndex - The current index in the array.
+   * @returns {number} The number of elements this strategy can handle (1 for `<hr>`, 0 otherwise).
+   */
+  canHandle(elementsArray: HTMLElement[], currentIndex: number): number;
+  /**
+   * Converts the `<hr>` element to an RTEHorizontalLineBlock.
+   * Uses `htmlElementToAnnotationGenerator` to extract annotations (handles refill + filter).
+   *
+   * @param {HTMLElement[]} elementsArray - Array of elements.
+   * @param {VegaRTETransformOptions} [options] - Transformation options.
+   * @returns {Nullable<RTEContentBlock>} The created horizontal line block.
+   */
+  handle(elementsArray: HTMLElement[], options?: VegaRTETransformOptions): Nullable<RTEContentBlock>;
+  /**
+   * @inheritDoc
+   */
+  appendChildBlocks(): void;
+  /**
+   * `<hr>` is a void element — no children to process.
+   *
+   * @returns {boolean} Always false.
+   */
+  shouldProceedToElementChildren(): boolean;
+}

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

@@ -0,0 +1,15 @@
+import { ModifyContentAction } from '../../../dto/actions/modify-content-action.abstract';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+import { Nullable } from '../../../../../types/general';
+export declare const INSERT_HORIZONTAL_LINE_BLOCK: string;
+/**
+ * Action to insert a horizontal line block into the rich text editor.
+ * Carries cursor position info to support split-paragraph insertion (same pattern as InsertImageToBlockAction).
+ */
+export declare class InsertHorizontalLineBlockAction extends ModifyContentAction {
+  type: string;
+  nextFocusNode: Nullable<RTENode>;
+  splitPointNode: Nullable<RTENode>;
+  startOffsetOfNode: number;
+  constructor(splitPointNode?: Nullable<RTENode>, startOffsetOfNode?: number);
+}

package/dist/types/components/vega-rich-text-editor/extensions/horizontal-line/assets/horizontal-line.d.ts

@@ -0,0 +1,3 @@
+import { IconPayload } from '../../../../../helpers/icon/interface';
+declare const _default: IconPayload;
+export default _default;

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

@@ -0,0 +1,43 @@
+import { BlockAnnotation } from '../../../dto/annotations/block-annotation.abstract';
+import { AnnotationStyle, RTERenderContext } from '../../../interface';
+import { Nullable } from '../../../../../types/general';
+export declare enum RTEHorizontalLineExtensionAnnotationTypeEnum {
+  HORIZONTAL_LINE = "HORIZONTAL_LINE"
+}
+/**
+ * Horizontal line annotation.
+ * Mirrors {@link TextStyleAnnotation}: emits the HR default visual styles in
+ * standalone mode (source edit) and the corresponding class in normal mode.
+ * Only added to the block when `autoMatchFormat` is enabled.
+ */
+export declare class HorizontalLineAnnotation extends BlockAnnotation<RTEHorizontalLineExtensionAnnotationTypeEnum> {
+  readonly type: RTEHorizontalLineExtensionAnnotationTypeEnum;
+  /**
+   * Generate the map item for the annotation.
+   *
+   * @returns {[RTEHorizontalLineExtensionAnnotationTypeEnum.HORIZONTAL_LINE, HorizontalLineAnnotation]} Map item.
+   */
+  static from(): [RTEHorizontalLineExtensionAnnotationTypeEnum.HORIZONTAL_LINE, HorizontalLineAnnotation];
+  /**
+   * Get the default styles for the horizontal line element.
+   *
+   * @returns {AnnotationStyle} The default styles.
+   */
+  static getDefaultStyles(): AnnotationStyle;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): Nullable<Record<string, unknown>>;
+  /**
+   * @inheritDoc
+   */
+  clone(): HorizontalLineAnnotation;
+  /**
+   * @inheritDoc
+   */
+  renderClass(options?: RTERenderContext): Nullable<string>;
+  /**
+   * @inheritDoc
+   */
+  renderStyle(options?: RTERenderContext): Nullable<AnnotationStyle>;
+}

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

@@ -0,0 +1,53 @@
+import { VegaRTEBlockAnnotations, VegaRTECustomBlock, VegaRTETransformOptions } from '../../../interface';
+import { RTEBlock } from '../../../dto/blocks/block.abstract';
+import { VegaRTEContent } from '../../../dto/content-state';
+import { RTEHtmlBlock } from '../../../dto/blocks/html-block';
+import { RTEHorizontalLineNode } from './horizontal-line-node';
+import { RTENode } from '../../../dto/nodes/node.abstract';
+/**
+ * Horizontal line block — a block containing a single `<hr>` decorator node.
+ */
+export declare class RTEHorizontalLineBlock extends RTEBlock<VegaRTEContent | RTEHtmlBlock, RTEHorizontalLineNode> {
+  static readonly dtoName: string;
+  readonly dtoName: string;
+  readonly type: string;
+  children: RTEHorizontalLineNode[];
+  parent: VegaRTEContent | RTEHtmlBlock;
+  constructor(id: string, options?: VegaRTETransformOptions);
+  /**
+   * Creates an RTEHorizontalLineBlock from a JSON representation.
+   *
+   * @param {VegaRTECustomBlock} block - The block JSON to convert.
+   * @param {VegaRTETransformOptions} [options] - Transformation options.
+   * @returns {RTEHorizontalLineBlock} The created block instance.
+   */
+  static from(block: VegaRTECustomBlock, options?: VegaRTETransformOptions): RTEHorizontalLineBlock;
+  /**
+   * Creates a new RTEHorizontalLineBlock with a child node.
+   *
+   * @param {VegaRTEBlockAnnotations} [annotations] - Optional annotations (e.g. customStyle overrides).
+   * @param {VegaRTETransformOptions} [options] - Transformation options.
+   * @returns {RTEHorizontalLineBlock} A new block instance.
+   */
+  static create(annotations?: VegaRTEBlockAnnotations, options?: VegaRTETransformOptions): RTEHorizontalLineBlock;
+  /**
+   * @inheritDoc
+   */
+  toJSON(): VegaRTECustomBlock;
+  /**
+   * @inheritDoc
+   */
+  toHtml(options?: VegaRTETransformOptions): string;
+  /**
+   * @inheritDoc
+   */
+  isNotEmpty(): boolean;
+  /**
+   * @inheritDoc
+   */
+  getLastNode(): RTENode;
+  /**
+   * @inheritDoc
+   */
+  clone(parent: VegaRTEContent | RTEHtmlBlock): RTEHorizontalLineBlock;
+}

package/dist/types/components/vega-rich-text-editor/extensions/horizontal-line/dto/horizontal-line-node.d.ts

@@ -0,0 +1,26 @@
+import { RTEDecoratorNode } from '../../../dto/nodes/decorator-node';
+import { RTENodeAnnotationMapKey, RTENodeAnnotationMapValue } from '../../../interface';
+import type { RTEBlock } from '../../../dto/blocks/block.abstract';
+/**
+ * Horizontal line node — a decorator node representing `<hr>` in the editor.
+ */
+export declare class RTEHorizontalLineNode extends RTEDecoratorNode<RTEBlock> {
+  readonly type: string;
+  parent: RTEBlock;
+  constructor(id: string, parentBlock: RTEBlock, annotationMap?: Map<RTENodeAnnotationMapKey, RTENodeAnnotationMapValue>);
+  /**
+   * @inheritDoc
+   */
+  toJSON(): {
+    id: string;
+    type: string;
+  };
+  /**
+   * @inheritDoc
+   */
+  clone(parent: RTEBlock): RTEHorizontalLineNode;
+  /**
+   * @inheritDoc
+   */
+  toHtml(): string;
+}

package/dist/types/components/vega-rich-text-editor/extensions/horizontal-line/filter-styles-strategies/horizontal-line-block/horizontal-line-filter-styles-strategy.d.ts

@@ -0,0 +1,31 @@
+import { RTEBlock } from '../../../../dto/blocks/block.abstract';
+import { RTENode } from '../../../../dto/nodes/node.abstract';
+import { RTEFilterStyles, RTEFilterStylesStrategy } from '../../../../dto/filter-styles-strategies/filter-styles-strategy.abstract';
+/**
+ * Default visual styles for the `<hr>` element in the RTE.
+ * These styles match the CSS applied in `horizontal-line-block-styles.css`.
+ *
+ * @see {@link file://extensions/horizontal-line/renderers/horizontal-line-block-styles.css} — must stay in sync.
+ */
+export declare const HR_DEFAULT_STYLES: RTEFilterStyles;
+/**
+ * Filter styles strategy for horizontal line blocks.
+ * Strips default HR visual styles during output and refills them during input,
+ * ensuring source edit round-trips do not lose information.
+ */
+export declare class HorizontalLineFilterStylesStrategy extends RTEFilterStylesStrategy {
+  protected stylesToBeFiltered: RTEFilterStyles;
+  protected elementTagName: string;
+  /**
+   * @inheritDoc
+   */
+  canFilter(blockOrNodeInstance: RTEBlock | RTENode): boolean;
+  /**
+   * @inheritDoc
+   */
+  canRefill(_blockOrNodeClassName: string, element: HTMLElement): boolean;
+  /**
+   * @inheritDoc
+   */
+  toCssText(): string;
+}

package/dist/types/components/vega-rich-text-editor/extensions/horizontal-line/filter-styles-strategies/horizontal-line-block/predicate.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Predicate class provides static methods to check specific conditions on HTML elements or dto instances.
+ */
+export declare class Predicate {
+  /**
+   * Checks if the given class name corresponds to a horizontal line block.
+   *
+   * @param {string} className The class name to check.
+   * @returns {boolean} True if the class name corresponds to a horizontal line block, false otherwise.
+   */
+  static isHorizontalLineBlock(className: string): boolean;
+}

package/dist/types/components/vega-rich-text-editor/extensions/horizontal-line/horizontal-line-extension.d.ts

@@ -0,0 +1,9 @@
+import { VegaRTEExtension } from '../extension.abstract';
+/**
+ * Extension that adds horizontal line (`<hr>`) support to the Vega Rich Text Editor.
+ */
+export declare class VegaRTEHorizontalLineExtension extends VegaRTEExtension {
+  private blockRenderer;
+  private toolbarButtonRenderer;
+  constructor();
+}