@leanix/components 0.4.818 → 0.4.819

package/lib/forms-ui/components/option/option.component.d.ts

@@ -1,12 +1,32 @@
 import { ElementRef, EventEmitter } from '@angular/core';
 import { OptionGroupComponent } from '../option-group/option-group.component';
 import * as i0 from "@angular/core";
+/**
+ * Individual option used inside OptionsDropdownComponent, SingleSelectComponent, or MultiSelectComponent.
+ * Can be used standalone or grouped within an OptionGroupComponent for organized selections.
+ */
 export declare class OptionComponent {
     private group;
     elementRef: ElementRef<HTMLElement>;
+    /**
+     * Whether the option is currently selected.
+     * @default false
+     */
     selected: boolean;
+    /**
+     * Whether the option is currently highlighted (e.g., via keyboard navigation).
+     * @default false
+     */
     isHighlighted: boolean;
+    /**
+     * Whether the option is disabled and cannot be interacted with.
+     * @default false
+     */
     disabled: boolean;
+    /**
+     * The value associated with this option.
+     * Emitted when the option is selected.
+     */
     value: any;
     /**
      * Is true when option has a selection nature like sorting.
@@ -14,16 +34,37 @@ export declare class OptionComponent {
      *
      * Is false when option represents a one time action like printing.
      * Cannot have selectedState when Option has dropdown
+     * @default true
      */
     hasSelectedState: boolean;
     /**
+     * The icon used to indicate selection state.
+     * @default 'check'
      * @deprecated Use the default `'check'` value. The `'circle'` option is deprecated and will be removed in a future release.
      */
     selectIcon: 'check' | 'circle';
+    /**
+     * Event emitted when the option is selected.
+     * Emits the option's value.
+     */
     select: EventEmitter<any>;
+    /**
+     * Event emitted when the option's highlight state changes.
+     * Emits a boolean indicating the new highlight state.
+     */
     highlight: EventEmitter<boolean>;
+    /**
+     * Event emitted when an already selected option is clicked.
+     */
     selectedClick: EventEmitter<any>;
+    /**
+     * Event emitted when a keyboard event occurs on the option.
+     * Emits the KeyboardEvent for parent handling.
+     */
     keyDownAction: EventEmitter<KeyboardEvent>;
+    /**
+     * Event emitted when the mouse enters the option area.
+     */
     mouseEnter: EventEmitter<number>;
     option?: ElementRef<HTMLElement>;
     hasSubdropdown: boolean;

package/lib/forms-ui/components/option-group/option-group.component.d.ts

@@ -1,12 +1,34 @@
 import { EventEmitter } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Groups options under a labeled section inside dropdowns.
+ * Used to organize related options within OptionsDropdownComponent, SingleSelectComponent, or MultiSelectComponent.
+ *
+ * ### Projection slots
+ * - Default slot: Option components (`lx-option`) to group together.
+ *
+ * ### Example
+ * @example
+ * ```html
+ * <lx-option-group label="Recent Items" [hasSelectedState]="true">
+ *   <lx-option [value]="1">Item 1</lx-option>
+ *   <lx-option [value]="2">Item 2</lx-option>
+ * </lx-option-group>
+ * ```
+ */
 export declare class OptionGroupComponent {
     /**
-     * Is true when option children have a selected state.
-     * In this case we want to align the padding of the group label with the lx-options'.
+     * Whether option children have a selected state.
+     * When true, aligns the padding of the group label with the options.
+     * @default true
      */
     hasSelectedState: boolean;
+    /** The label text displayed for the option group. */
     label: string;
+    /**
+     * Event emitted when an option within the group is selected.
+     * Emits the selected option's value.
+     */
     select: EventEmitter<any>;
     selectOption(value: any): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<OptionGroupComponent, never>;

package/lib/forms-ui/components/option-group-dropdown/option-group-dropdown.component.d.ts

@@ -14,27 +14,74 @@ export type SingleSelectOptionGroup<T = any> = {
     options: (OptionGroupOption | T)[];
 };
 /**
- * `OptionGroupDropdownComponent` is a dropdown component that displays a list of options grouped by categories.
- * By itself it is only used to display a list of options, to be used in an input dropdown it can be used in
- * combination with the `SingleSelectComponent` or `MultiSelectComponent`.
+ * Dropdown component that displays options grouped by categories.
+ * Supports keyboard navigation, infinite scroll, custom templates, and creating new options.
+ * Used standalone or with SingleSelectComponent/MultiSelectComponent.
+ *
+ * ### Projection slots
+ * - `optionTemplate`: Template for custom option rendering (context: `$implicit`, `index`, `groupIndex`).
+ * - `noResultsOptionTemplateRef`: Template for custom "no results" message (context: `group`, `groupIndex`).
+ *
+ * ### Example
+ * @example
+ * ```html
+ * <lx-option-group-dropdown
+ *   [optionGroups]="groups"
+ *   [highlightTerm]="searchTerm"
+ *   (onItemSelected)="handleSelection($event)">
+ *   <ng-template #optionTemplate let-option>
+ *     <span>{{ option.label }}</span>
+ *   </ng-template>
+ * </lx-option-group-dropdown>
+ * ```
  */
 export declare class OptionGroupDropdownComponent extends KeyboardSelectDirective {
     /** @internal */
     readonly NAME = "OptionGroupDropdownComponent";
+    /**
+     * Array of option groups to display in the dropdown.
+     * @default []
+     */
     optionGroups: SingleSelectOptionGroup[];
     /**
-     * Usually a stream of the current input value of the parent select.
+     * Label for the "create new option" entry.
+     * Typically the current input value from a parent select component.
      */
     newOptionLabel?: string;
+    /** Term to highlight in option labels. */
     highlightTerm?: string;
+    /**
+     * Whether to show a "create new option" entry at the top of the dropdown.
+     * @default false
+     */
     showCreateNewOption: boolean;
+    /**
+     * Property name to use as the label for each option.
+     * @default 'label'
+     */
     labelKey: string;
+    /**
+     * Whether the dropdown is in a loading state.
+     * @default false
+     */
     loading: boolean;
+    /** Property name to use for tracking options. */
     trackByProperty?: string;
+    /**
+     * Whether to show "no results" message when a group has no options.
+     * @default false
+     */
     showNoResultsIfGroupIsEmpty: boolean;
+    /**
+     * Whether to use CDK overlay positioning for the dropdown.
+     * @default false
+     */
     overlayPositioning: boolean;
+    /** Event emitted when an option is selected. */
     onItemSelected: EventEmitter<any>;
+    /** Event emitted when the dropdown container is scrolled (for infinite scroll). */
     containerScrolled: EventEmitter<any>;
+    /** Event emitted when the user requests to create a new option. */
     createNewOption: EventEmitter<string>;
     /** @internal */
     optionTemplateRef?: TemplateRef<any>;

package/lib/forms-ui/components/options-dropdown/options-dropdown.component.d.ts

@@ -4,19 +4,83 @@ import { Subject } from 'rxjs';
 import { KeyboardActionSourceDirective } from '../../directives/keyboard-action-source.directive';
 import { OptionComponent } from '../option/option.component';
 import * as i0 from "@angular/core";
+/**
+ * A dropdown component that displays a list of selectable options.
+ * The dropdown opens when triggered and provides keyboard navigation support for accessible option selection.
+ * It supports nested option groups and sub-dropdowns with full ARIA compliance.
+ *
+ * ### Projection slots
+ * - Default (trigger): The button or element that triggers the dropdown (must have `lxKeyboardActionSource` directive)
+ * - `lx-option`: Individual selectable options within the dropdown
+ * - `lx-option-group`: Optional groups of options with labels
+ *
+ * ### Example
+ * @example
+ * ```html
+ * <lx-options-dropdown [disabled]="disabled" [maxHeight]="maxHeight">
+ *   <button lxKeyboardActionSource lx-button [disabled]="disabled" endIcon="slim-arrow-down">
+ *     <span>{{ activeView?.label }}</span>
+ *   </button>
+ *   @for (viewGroup of viewGroups; track viewGroup.groupKey) {
+ *     <lx-option-group [label]="'viewGroups.' + viewGroup.groupKey | translate">
+ *       @for (view of viewGroup.views; track view.key) {
+ *         <lx-option
+ *           [selected]="view === activeView"
+ *           (select)="applyView.emit(view.key)"
+ *         >{{ view.label }}</lx-option>
+ *       }
+ *     </lx-option-group>
+ *   }
+ * </lx-options-dropdown>
+ * ```
+ */
 export declare class OptionsDropdownComponent implements AfterViewInit, OnDestroy {
     private changeDetection;
     private readonly scrollStrategies;
     private renderer;
     /** @internal */
     readonly NAME = "OptionsDropdownComponent";
+    /**
+     * The alignment of the dropdown relative to the trigger element.
+     * @default 'right'
+     */
     align: 'right' | 'left';
+    /**
+     * Whether the dropdown should close when the page is scrolled.
+     * @default false
+     */
     closeOnScroll: boolean;
+    /**
+     * Whether the dropdown is disabled and cannot be opened.
+     * @default false
+     */
     disabled: boolean;
+    /**
+     * The maximum height of the dropdown. Can be any valid CSS height value.
+     * @default 'none'
+     */
     maxHeight: string;
+    /**
+     * Whether the dropdown should close automatically when an option is selected.
+     * @default true
+     */
     closeOnSelect: boolean;
+    /**
+     * Whether to enable advanced overlay positioning using CDK overlay.
+     * Use when the dropdown is wider than its trigger or positioned near a viewport edge —
+     * enables CDK overlay positioning with automatic boundary detection to prevent off-screen clipping
+     * @default false
+     */
     overlayPositioning: boolean;
+    /**
+     * Additional CSS class to apply to the dropdown overlay.
+     * @default ''
+     */
     dropdownClass: string;
+    /**
+     * Whether the trigger container should use display flex instead of inline-block.
+     * @default false
+     */
     isFlexEnabledTriggerContainer: boolean;
     /** @internal */
     trigger: KeyboardActionSourceDirective;
@@ -25,8 +89,17 @@ export declare class OptionsDropdownComponent implements AfterViewInit, OnDestro
     _options: QueryList<OptionComponent>;
     /** @internal */
     overlayScrollStrategy: ScrollStrategy;
+    /**
+     * Event emitted when the dropdown is opened.
+     */
     opened: EventEmitter<void>;
+    /**
+     * Event emitted when the dropdown is closed for any reason.
+     */
     closed: EventEmitter<void>;
+    /**
+     * Event emitted when the dropdown is closed without an option being selected (e.g., by pressing Escape or clicking outside).
+     */
     closedWithoutSelection: EventEmitter<void>;
     /** @internal */
     get displayStyle(): "inline-block" | "block";

package/lib/forms-ui/components/options-sub-dropdown/options-sub-dropdown.component.d.ts

@@ -2,9 +2,31 @@ import { AfterViewInit, ChangeDetectorRef, DestroyRef, OnDestroy, QueryList } fr
 import { BehaviorSubject, Subject } from 'rxjs';
 import { OptionComponent } from '../option/option.component';
 import * as i0 from "@angular/core";
+/**
+ * A nested sub-dropdown that appears next to a parent option.
+ * Opens on hover or keyboard navigation with debounced interactions.
+ * Automatically adjusts max height to fit viewport.
+ *
+ * ### Projection slots
+ * - Default slot: Nested dropdown options (`lx-option` components).
+ *
+ * ### Example
+ * @example
+ * ```html
+ * <lx-options-sub-dropdown [trigger]="parentOption" align="left">
+ *   <lx-option [value]="1">Sub-option 1</lx-option>
+ *   <lx-option [value]="2">Sub-option 2</lx-option>
+ * </lx-options-sub-dropdown>
+ * ```
+ */
 export declare class OptionsSubDropdownComponent implements AfterViewInit, OnDestroy {
     private changeDetection;
+    /** The parent option component that triggers this sub-dropdown. */
     trigger: OptionComponent;
+    /**
+     * Horizontal alignment of the sub-dropdown relative to the trigger option.
+     * @default 'right'
+     */
     align: 'right' | 'left';
     options: QueryList<OptionComponent>;
     hidden: boolean;

package/lib/forms-ui/components/picker/picker.component.d.ts

@@ -6,22 +6,26 @@ import { Subject } from 'rxjs';
 import { PickerOptionComponent } from '../picker-option/picker-option.component';
 import * as i0 from "@angular/core";
 /**
- * How to use:
- * Provide the lx-picker with two kinds of ContentChildren:
- * 1. A lxPickerTrigger, preferably a button element, which we use to open the dropdown on click or enter.
- * 2. A list of `<li>` elements with an lx-picker-option attribute that own the option template as content children.
+ * A dropdown picker for selecting a value from a list of options.
+ * Supports keyboard navigation, `ControlValueAccessor` for reactive forms, and custom trigger elements.
  *
- * You can use this component as part of a FormGroup or wire it up yourself by listening on the (select) output of the options.
+ * ### Projection slots
+ * - `lxPickerTrigger`: A button element used to open the dropdown on click or Enter
+ * - `li[lx-picker-option]`: List items representing selectable options
  *
- * Example usage (non FormGroup style):
- * ```
- * <lx-picker listBoxAriaLabel="Awesome picker">
- *   <button lxPickerTrigger lx-button mode="outline" size="large" [square]="true" aria-label="Awesome picker" title="Awesome picker">
- *       <lx-icon [name]="selection.label" [color]="selection.value" fontAwsomeStyle="solid"></lx-icon>
- *    </button>
- *    <li *ngFor="let option of options" lx-picker-option [value]="option.value" [selected]="selection === option" (select)="selection = option" [optionId]="option.id">
- *       <lx-icon lx-picker-option [name]="option.label" [color]="option.value" fontAwsomeStyle="solid"></lx-icon>
- *    </li>
+ * ### Example
+ * @example
+ * ```html
+ * <lx-picker listBoxAriaLabel="Color picker">
+ *   <button lxPickerTrigger lx-button mode="outline" size="large" [square]="true">
+ *     {{ selection.label }}
+ *   </button>
+ *   @for (option of options; track option.id) {
+ *     <li lx-picker-option [value]="option.value" [selected]="selection === option"
+ *         (select)="selection = option" [optionId]="option.id">
+ *       {{ option.label }}
+ *     </li>
+ *   }
  * </lx-picker>
  * ```
  */
@@ -30,14 +34,18 @@ export declare class PickerComponent implements AfterViewInit, ControlValueAcces
     private cdRef;
     /**
      * A human-readable string value which identifies the listbox.
-     * If there's a visible label, then aria-labelledby should be used instead to refer to that label.
+     * Use this when there's no visible label. Otherwise use listBoxAriaLabelledBy.
      */
     listBoxAriaLabel?: string;
     /**
-     * Identifies the visible element which identifies the listbox.
-     * If there's no visible label, then aria-label should be used instead to include a label.
+     * ID of the visible element which labels the listbox.
+     * Use this when there's a visible label. Otherwise use listBoxAriaLabel.
      */
     listBoxAriaLabelledBy?: string;
+    /**
+     * Direction the picker options dropdown opens.
+     * @default 'right'
+     */
     openDirection: 'left' | 'right';
     /** @internal */
     get activeDescendantsId(): string | undefined;

package/lib/forms-ui/components/picker-option/picker-option.component.d.ts

@@ -2,6 +2,28 @@ import { Highlightable } from '@angular/cdk/a11y';
 import { ChangeDetectorRef, EventEmitter, OnInit } from '@angular/core';
 import { TranslateService } from '@ngx-translate/core';
 import * as i0 from "@angular/core";
+/**
+ * Individual option within a picker dropdown.
+ *
+ * Must be a direct child of lx-picker.
+ *
+ * ### Projection slots
+ * - Default slot: Option content (text, icons, or custom elements). Hidden when `isClearOption` is true.
+ *
+ * ### Example
+ * @example
+ * ```html
+ * <lx-picker>
+ *   <button lxPickerTrigger>Select</button>
+ *   <li lx-picker-option [optionId]="'opt1'" [value]="'option1'" [ariaLabel]="'Option 1'">
+ *     Option 1
+ *   </li>
+ *   <li lx-picker-option [optionId]="'opt2'" [value]="'option2'" [ariaLabel]="'Option 2'">
+ *     Option 2
+ *   </li>
+ * </lx-picker>
+ * ```
+ */
 export declare class PickerOptionComponent implements Highlightable, OnInit {
     private cdRef;
     private translateService;
@@ -12,18 +34,25 @@ export declare class PickerOptionComponent implements Highlightable, OnInit {
     get titleValue(): string | undefined;
     get id(): string;
     /**
-     * The optionId must be set to a unique value. It's used as value for the id property of an option.
-     * As the user navigates through the list via arrow keys, the aria-activedescendant property for the
-     * button in the PickerComponent is adjusted to reflect the id attribute of the active option.
+     * Unique ID for the option. Must be unique within the picker.
+     * Used for aria-activedescendant tracking during keyboard navigation.
      */
     optionId: string;
+    /** Accessible label for the option. */
     ariaLabel?: string;
+    /** The value to emit when this option is selected. */
     value: any;
+    /**
+     * Whether this option is currently selected.
+     * @default false
+     */
     selected: boolean;
-    isClearOption: boolean;
     /**
-     * Emits the value.
+     * Whether this is a special "clear selection" option.
+     * @default false
      */
+    isClearOption: boolean;
+    /** Emitted when the option is selected. */
     select: EventEmitter<any>;
     /**
      * This property is true, when the option was selected by mouse click or by the

package/lib/forms-ui/components/pill-item/pill-item.component.d.ts

@@ -1,11 +1,36 @@
 import { EventEmitter } from '@angular/core';
 import { MultiSelectRemoveItemEvent } from '../multi-select/multi-select.component';
 import * as i0 from "@angular/core";
+/**
+ * An individual pill/tag item with a remove button.
+ * Typically used within `lx-pill-list` to display selected items.
+ *
+ * ### Example
+ * @example
+ * ```html
+ * <lx-pill-item [item]="selectedItem"
+ *               [label]="'Option A'"
+ *               (remove)="onRemove($event)">
+ * </lx-pill-item>
+ * ```
+ */
 export declare class PillItemComponent {
     readonly NAME = "PillItemComponent";
+    /**
+     * The data item associated with this pill.
+     */
     item: any;
+    /**
+     * The text label to display on the pill.
+     */
     label: string;
+    /**
+     * When set to true, disables the pill and prevents removal.
+     */
     disabled: boolean;
+    /**
+     * Event emitted when the pill is removed.
+     */
     remove: EventEmitter<MultiSelectRemoveItemEvent>;
     removePill(item: any, isMouse?: boolean): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<PillItemComponent, never>;

package/lib/forms-ui/components/pill-list/pill-list.component.d.ts

@@ -3,15 +3,71 @@ import { KeyboardSelectDirective } from '../keyboard-select.directive';
 import { MultiSelectRemoveItemEvent } from '../multi-select/multi-select.component';
 import { PillItemComponent } from '../pill-item/pill-item.component';
 import * as i0 from "@angular/core";
+/**
+ * A container for displaying a list of removable pill/tag items.
+ * Commonly used inside `lx-multi-select` to show selected items.
+ *
+ * When used inside `lx-multi-select`, apply `class="pills"` for proper projection
+ * and wire up `[keyboardSelectAction]` for keyboard navigation.
+ *
+ * ### Projection slots
+ * - `#pillTemplate`: Optional custom template for rendering individual pills.
+ *   Receives each pill as implicit context. Use when you need custom styling
+ *   or attributes on individual pills.
+ *
+ * ### Example — Basic usage inside multi-select
+ * @example
+ * ```html
+ * <lx-pill-list
+ *   class="pills"
+ *   [keyboardSelectAction]="multiSelect.selectionKeyboardSelectAction$"
+ *   [pills]="selectedItems"
+ *   labelKey="name"
+ *   itemKey="id"
+ *   (remove)="multiSelect.removeItem($event)">
+ * </lx-pill-list>
+ * ```
+ *
+ * ### Example — Custom pill template
+ * @example
+ * ```html
+ * <lx-pill-list
+ *   class="pills"
+ *   [keyboardSelectAction]="multiSelect.selectionKeyboardSelectAction$"
+ *   [pills]="selectedItems"
+ *   itemKey="id"
+ *   (remove)="multiSelect.removeItem($event)">
+ *   <ng-template #pillTemplate let-pill>
+ *     <lx-pill-item
+ *       [label]="pill.name"
+ *       [item]="pill"
+ *       [class.readOnly]="pill.readOnly">
+ *     </lx-pill-item>
+ *   </ng-template>
+ * </lx-pill-list>
+ * ```
+ */
 export declare class PillListComponent extends KeyboardSelectDirective implements AfterViewInit {
+    /**
+     * Array of items to display as pills.
+     */
     pills: any[];
+    /**
+     * Property name to use as the pill label from each item object.
+     */
     labelKey?: string;
     /**
-     * Provide an itemKey which contains the property name in each object to uniquely identify it.
-     * This will be used in the trackBy function.
+     * Property name to use as unique identifier for each item.
+     * Used in the trackBy function for better performance.
      */
     itemKey?: string;
+    /**
+     * When set to true, disables removal of pills.
+     */
     disabled: boolean;
+    /**
+     * Event emitted when a pill is removed.
+     */
     remove: EventEmitter<MultiSelectRemoveItemEvent>;
     /**
      * If you provide an <ng-template #pillTemplate>, it will be used to render the individual pills inside of the lx-multi-select.

package/lib/forms-ui/components/responsive-input/responsive-input.component.d.ts

@@ -2,10 +2,30 @@ import { AfterViewInit, ElementRef, EventEmitter, OnDestroy } from '@angular/cor
 import { ControlValueAccessor, UntypedFormControl } from '@angular/forms';
 import { BehaviorSubject, Subject } from 'rxjs';
 import * as i0 from "@angular/core";
+/**
+ * Input that dynamically adjusts its width based on content length.
+ *
+ * Useful for inline editing or space-constrained layouts.
+ *
+ * ### Example
+ * @example
+ * ```html
+ * <lx-responsive-input
+ *   [(ngModel)]="searchTerm"
+ *   [inputId]="'search'"
+ *   (focus)="onFocus()"
+ *   (blur)="onBlur()"
+ * ></lx-responsive-input>
+ * ```
+ */
 export declare class ResponsiveInputComponent implements AfterViewInit, OnDestroy, ControlValueAccessor {
+    /** Optional ID attribute for the input element. */
     inputId?: string;
+    /** Emitted when the input receives focus. */
     focus: EventEmitter<void>;
+    /** Emitted when the input receives focus via Tab key. */
     focusViaTab: EventEmitter<void>;
+    /** Emitted when the input loses focus. */
     blur: EventEmitter<void>;
     responsiveInput: ElementRef<HTMLInputElement>;
     inputWidth: ElementRef<HTMLSpanElement>;

package/lib/forms-ui/components/rich-text-editor/components/rich-text-editor-toolbar/rich-text-editor-toolbar.component.d.ts

@@ -3,9 +3,35 @@ import { Editor } from '@tiptap/core';
 import type { Level } from '@tiptap/extension-heading';
 import { Transaction } from '@tiptap/pm/state';
 import * as i0 from "@angular/core";
+/**
+ * Toolbar component for the rich text editor providing formatting controls.
+ *
+ * Displays formatting buttons based on enabled Tiptap extensions, including text styles,
+ * bold/italic/underline, lists, alignment, links, code blocks, and table insertion.
+ * The toolbar visibility is controlled by the `isVisible` input and link modal state.
+ *
+ * ### Projection slots
+ * - `.diagram-btn`: Custom diagram button when `lxDiagram` extension is enabled
+ *
+ * ### Example
+ * @example
+ * ```html
+ * <lx-rich-text-editor-toolbar [editor]="editor" [isVisible]="true">
+ *   <button class="diagram-btn" lx-button>Insert Diagram</button>
+ * </lx-rich-text-editor-toolbar>
+ * ```
+ */
 export declare class RichTextEditorToolbarComponent implements OnInit, OnDestroy {
     NAME: string;
+    /**
+     * The Tiptap editor instance to control with this toolbar.
+     */
     editor: Editor;
+    /**
+     * Controls the visibility of the toolbar.
+     *
+     * @default true
+     */
     readonly isVisible: import("@angular/core").InputSignal<boolean>;
     headingLevels: Level[];
     private readonly isLinkModalOpen;

package/lib/forms-ui/components/rich-text-editor/extensions/link/components/link-modal/link-modal.component.d.ts

@@ -2,8 +2,23 @@ import { ChangeDetectorRef } from '@angular/core';
 import { NgForm } from '@angular/forms';
 import { Editor } from '@tiptap/core';
 import * as i0 from "@angular/core";
+/**
+ * Modal dialog for creating and editing hyperlinks in the rich text editor.
+ *
+ * Provides a form to input link text and URL with validation. Supports creating new links
+ * and editing existing ones. The modal state is managed by the link plugin.
+ *
+ * ### Example
+ * @example
+ * ```html
+ * <lx-link-modal [editor]="editor" />
+ * ```
+ */
 export declare class LinkModalComponent {
     readonly NAME = "LinkModalComponent";
+    /**
+     * The Tiptap editor instance to insert or modify links in.
+     */
     editor: Editor;
     readonly ngForm: import("@angular/core").Signal<NgForm>;
     readonly cd: ChangeDetectorRef;