@globalpayments/vega 2.90.0 → 2.92.0

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

@@ -0,0 +1,10 @@
+import { VegaRTEExtension } from '../extension.abstract';
+/**
+ * Vega Rich Text Editor Copy Extension.
+ * Adds a toolbar button that copies the currently selected editor content to the clipboard.
+ */
+export declare class VegaRTECopyExtension extends VegaRTEExtension {
+  static TOOLBAR_BUTTON_KEY: string;
+  /** @inheritDoc */
+  prepareBeforeLoad(host: HTMLVegaRichTextEditorElement): void;
+}

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

@@ -0,0 +1,36 @@
+import { VegaRTECreateElementFunction, VegaRTERenderResult, VegaRTEToolbarRenderContext } from '../../interface';
+import { VegaRTEToolbarButtonRenderer } from '../base-toolbar-button-renderer';
+/**
+ * Toolbar button renderer for the Copy extension.
+ * Renders a toolbar button that copies the currently selected editor text to the clipboard.
+ */
+export declare class RTECopyToolbarButtonRenderer extends VegaRTEToolbarButtonRenderer {
+  /**
+   * Renders the copy toolbar button.
+   *
+   * @param {VegaRTECreateElementFunction} h - Create element function.
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   * @returns {VegaRTERenderResult} - The toolbar button render result.
+   */
+  render(h: VegaRTECreateElementFunction, editorContext: VegaRTEToolbarRenderContext): VegaRTERenderResult;
+  /**
+   * Determines if the copy button should be disabled.
+   * Disabled when the editor is disabled or when no content is selected.
+   *
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   * @returns {boolean} - True if the button should be disabled.
+   */
+  protected isDisabled(editorContext: VegaRTEToolbarRenderContext): boolean;
+  /**
+   * Handles the copy button click event.
+   * Dispatches a copy action through `host.value`; the action handler extracts the current selection
+   * and writes the resulting HTML and plain text content to the clipboard.
+   *
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   */
+  protected handleButtonClick(editorContext: VegaRTEToolbarRenderContext): void;
+  /**
+   * Handles dropdown click event. Not applicable for the copy button, so it's left empty.
+   */
+  protected handleDropdownClick(): void;
+}

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

@@ -0,0 +1,11 @@
+import { VegaRTEExtension } from '../extension.abstract';
+/**
+ * Vega Rich Text Editor Cut Extension.
+ * Adds a toolbar button that copies the currently selected editor content to the clipboard
+ * and removes it from the editor.
+ */
+export declare class VegaRTECutExtension extends VegaRTEExtension {
+  static TOOLBAR_BUTTON_KEY: string;
+  /** @inheritDoc */
+  prepareBeforeLoad(host: HTMLVegaRichTextEditorElement): void;
+}

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

@@ -0,0 +1,24 @@
+import { VegaRTECreateElementFunction, VegaRTERenderResult, VegaRTEToolbarRenderContext } from '../../interface';
+import { RTECopyToolbarButtonRenderer } from '../copy/copy-toolbar-button-renderer';
+/**
+ * Toolbar button renderer for the Cut extension.
+ * Reuses the Copy renderer to write the selected editor content to the clipboard,
+ * then removes the selected content from the editor.
+ */
+export declare class RTECutToolbarButtonRenderer extends RTECopyToolbarButtonRenderer {
+  /**
+   * Renders the cut toolbar button.
+   *
+   * @param {VegaRTECreateElementFunction} h - Create element function.
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   * @returns {VegaRTERenderResult} - The toolbar button render result.
+   */
+  render(h: VegaRTECreateElementFunction, editorContext: VegaRTEToolbarRenderContext): VegaRTERenderResult;
+  /**
+   * Handles the cut button click event.
+   * Copies the current editor selection to the clipboard and then deletes it from the editor.
+   *
+   * @param {VegaRTEToolbarRenderContext} editorContext - The render context for the editor.
+   */
+  protected handleButtonClick(editorContext: VegaRTEToolbarRenderContext): Promise<void>;
+}

package/dist/types/components/vega-rich-text-editor/extensions/find-replace/assets/find-and-replace.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/find-replace/find-replace-extension.d.ts

@@ -0,0 +1,15 @@
+import { VegaRTEExtension } from '../extension.abstract';
+/**
+ * Find & Replace extension for Vega Rich Text Editor.
+ *
+ * Registers a toolbar button (magnifying-glass icon) that toggles the find-replace panel.
+ * Each editor host gets its own isolated FindReplaceState and toolbar renderer instance,
+ * created during the per-host prepareBeforeLoad lifecycle hook.
+ *
+ * Toolbar key: 'findReplace'
+ */
+export declare class VegaRTEFindReplaceExtension extends VegaRTEExtension {
+  static readonly TOOLBAR_BUTTON_KEY: string;
+  /** @inheritDoc */
+  prepareBeforeLoad(host: HTMLVegaRichTextEditorElement): void;
+}

package/dist/types/components/vega-rich-text-editor/extensions/find-replace/slimmer/controllers/find-controller.d.ts

@@ -0,0 +1,65 @@
+import { FindReplaceControllerAbstract, FindReplaceControllerContext } from './find-replace-controller.abstract';
+import type { FindReplaceResult } from './find-replace-controller.abstract';
+/**
+ * Concrete find controller.
+ *
+ * Provides search, navigation, highlight, and lifecycle capabilities.
+ * Shares state with {@link ReplaceController} via the injected
+ * {@link FindReplaceControllerContext}.
+ */
+export declare class FindController extends FindReplaceControllerAbstract {
+  constructor(context: FindReplaceControllerContext);
+  /**
+   * Runs a search with the current keyword on the host's content.
+   * Applies highlights and returns the result for panel display.
+   *
+   * @returns {FindReplaceResult} The match count and current position.
+   */
+  find(): FindReplaceResult;
+  /**
+   * Navigates to the next match.
+   *
+   * @returns {FindReplaceResult} Updated position.
+   */
+  next(): FindReplaceResult;
+  /**
+   * Navigates to the previous match.
+   *
+   * @returns {FindReplaceResult} Updated position.
+   */
+  prev(): FindReplaceResult;
+  /**
+   * Clears all search state and removes highlight overlays.
+   */
+  clear(): void;
+  /**
+   * Re-runs the search after content has changed (e.g. user typed while
+   * panel is open). Attempts to preserve the previous navigation position.
+   *
+   * @param {boolean} scrollToActive - Whether to scroll the active highlight into view.
+   * @returns {FindReplaceResult | null} Updated result, or null if no search is active.
+   */
+  refresh(scrollToActive?: boolean): FindReplaceResult | null;
+  /**
+   * Toggles the match-case search option, clears previous results,
+   * and re-runs the search if a keyword is set.
+   *
+   * @param {boolean} enabled - Whether match-case should be enabled.
+   * @returns {FindReplaceResult} The updated search result.
+   */
+  setMatchCase(enabled: boolean): FindReplaceResult;
+  /**
+   * Toggles the whole-words search option, clears previous results,
+   * and re-runs the search if a keyword is set.
+   *
+   * @param {boolean} enabled - Whether whole-words should be enabled.
+   * @returns {FindReplaceResult} The updated search result.
+   */
+  setWholeWords(enabled: boolean): FindReplaceResult;
+  /**
+   * Clears previous results and re-runs the search with the current keyword and options.
+   *
+   * @returns {FindReplaceResult} The updated search result.
+   */
+  private updateFindResults;
+}

package/dist/types/components/vega-rich-text-editor/extensions/find-replace/slimmer/controllers/find-replace-controller.abstract.d.ts

@@ -0,0 +1,65 @@
+import { FindReplaceState } from './helper/find-replace-state';
+import { FindReplaceHighlightManager } from './helper/find-replace-highlight-manager';
+import type { Nullable } from '../../../../../../types/general';
+/**
+ * Result returned after a search or navigation operation,
+ * used by the renderer to update the panel display.
+ */
+export declare type FindReplaceResult = {
+  /** 1-based current position (0 when no matches). */
+  current: number;
+  /** Total number of matches. */
+  total: number;
+};
+/**
+ * Shared mutable context injected into both {@link FindController} and
+ * {@link ReplaceController} so they operate on the same search state,
+ * highlights, host reference, and keyword.
+ */
+export declare type FindReplaceControllerContext = {
+  readonly state: FindReplaceState;
+  readonly highlightManager: FindReplaceHighlightManager;
+  hostRef: Nullable<HTMLVegaRichTextEditorElement>;
+  keyword: string;
+};
+/**
+ * Creates a new shared controller context with default (empty) state.
+ *
+ * @returns {FindReplaceControllerContext} A fresh context instance.
+ */
+export declare function createFindReplaceControllerContext(): FindReplaceControllerContext;
+/**
+ * Abstract base controller for the Find & Replace extension.
+ *
+ * Holds shared operations ({@link setHost}, {@link setKeyword}) and the
+ * common helper {@link applyAndGetResult}. Concrete implementations
+ * ({@link FindController}, {@link ReplaceController}) add the respective
+ * search/navigation and mutation capabilities.
+ */
+export declare abstract class FindReplaceControllerAbstract {
+  protected readonly context: FindReplaceControllerContext;
+  protected constructor(context: FindReplaceControllerContext);
+  /**
+   * Updates the cached host reference. Called on each render cycle.
+   *
+   * @typedef HTMLVegaRichTextEditorElement - The type of the host rich text editor element.
+   * @param {HTMLVegaRichTextEditorElement} host - The RTE host element.
+   */
+  setHost(host: HTMLVegaRichTextEditorElement): void;
+  /**
+   * Updates the keyword. Clears previous match results and highlights,
+   * but preserves the flat-text cache so the next find() on the same
+   * document does not re-flatten every block.
+   *
+   * @param {string} keyword - The new search keyword.
+   * @returns {FindReplaceResult} Reset result (0/0).
+   */
+  setKeyword(keyword: string): FindReplaceResult;
+  /**
+   * Applies highlight overlays and returns the current result for the panel.
+   *
+   * @param {boolean} scrollToActive - Whether to scroll the active highlight into view.
+   * @returns {FindReplaceResult} The current match position and total count.
+   */
+  protected applyAndGetResult(scrollToActive?: boolean): FindReplaceResult;
+}

package/dist/types/components/vega-rich-text-editor/extensions/find-replace/slimmer/controllers/helper/block-search-strategies/block-search-strategy.abstract.d.ts

@@ -0,0 +1,29 @@
+import type { RTEBlock } from '../../../../../../dto/blocks/block.abstract';
+import type { RTETextBlock } from '../../../../../../dto/blocks/text-block';
+import type { RTECodeBlock } from '../../../../../../dto/blocks/code-block';
+/**
+ * Defines how a specific type of RTEBlock contributes searchable leaf blocks.
+ *
+ * Implementations are registered on FindReplaceState in priority order.
+ * The first strategy whose `canHandle` returns true is used.
+ */
+export declare abstract class BlockSearchStrategy {
+  /**
+   * Returns true if this strategy handles the given block.
+   *
+   * @param {RTEBlock} block - The block to test.
+   * @returns {boolean}
+   */
+  abstract canHandle(block: RTEBlock): boolean;
+  /**
+   * Collects searchable leaf blocks from the given block.
+   *
+   * The `recurse` callback allows strategies to delegate child traversal
+   * back to the caller without creating a circular dependency.
+   *
+   * @param {RTEBlock} block - The block to collect from.
+   * @param {(blocks: RTEBlock[]) => (RTETextBlock | RTECodeBlock)[]} recurse - Callback to recurse into child block arrays.
+   * @returns {(RTETextBlock | RTECodeBlock)[]}
+   */
+  abstract collect(block: RTEBlock, recurse: (blocks: RTEBlock[]) => (RTETextBlock | RTECodeBlock)[]): (RTETextBlock | RTECodeBlock)[];
+}

package/dist/types/components/vega-rich-text-editor/extensions/find-replace/slimmer/controllers/helper/block-search-strategies/code-block-search-strategy.d.ts

@@ -0,0 +1,17 @@
+import { RTECodeBlock } from '../../../../../../dto/blocks/code-block';
+import type { RTEBlock } from '../../../../../../dto/blocks/block.abstract';
+import type { RTETextBlock } from '../../../../../../dto/blocks/text-block';
+import { BlockSearchStrategy } from './block-search-strategy.abstract';
+/**
+ * Handles RTECodeBlock — a searchable leaf block whose text lives in children[0].text.
+ */
+export declare class CodeBlockSearchStrategy extends BlockSearchStrategy {
+  /**
+   * @inheritDoc
+   */
+  canHandle(block: RTEBlock): boolean;
+  /**
+   * @inheritDoc
+   */
+  collect(block: RTEBlock): (RTETextBlock | RTECodeBlock)[];
+}

package/dist/types/components/vega-rich-text-editor/extensions/find-replace/slimmer/controllers/helper/block-search-strategies/container-block-search-strategy.d.ts

@@ -0,0 +1,21 @@
+import type { RTEBlock } from '../../../../../../dto/blocks/block.abstract';
+import type { RTETextBlock } from '../../../../../../dto/blocks/text-block';
+import type { RTECodeBlock } from '../../../../../../dto/blocks/code-block';
+import { BlockSearchStrategy } from './block-search-strategy.abstract';
+/**
+ * Fallback strategy for generic container blocks whose concrete type is not
+ * known at compile time (RTEHtmlBlock, table blocks, extension-defined blocks, …).
+ *
+ * A block is treated as a container when its children array is non-empty and
+ * the first child is not an RTETextNode (i.e. children are blocks, not nodes).
+ */
+export declare class ContainerBlockSearchStrategy extends BlockSearchStrategy {
+  /**
+   * @inheritDoc
+   */
+  canHandle(block: RTEBlock): boolean;
+  /**
+   * @inheritDoc
+   */
+  collect(block: RTEBlock, recurse: (blocks: RTEBlock[]) => (RTETextBlock | RTECodeBlock)[]): (RTETextBlock | RTECodeBlock)[];
+}

package/dist/types/components/vega-rich-text-editor/extensions/find-replace/slimmer/controllers/helper/block-search-strategies/list-item-block-search-strategy.d.ts

@@ -0,0 +1,21 @@
+import type { RTEBlock } from '../../../../../../dto/blocks/block.abstract';
+import type { RTETextBlock } from '../../../../../../dto/blocks/text-block';
+import type { RTECodeBlock } from '../../../../../../dto/blocks/code-block';
+import { BlockSearchStrategy } from './block-search-strategy.abstract';
+/**
+ * Handles RTEListItemBlock — a searchable leaf block that may also carry
+ * nested RTEListBlocks via its `nestList` property.
+ *
+ * Must be registered before TextBlockSearchStrategy because RTEListItemBlock
+ * extends RTETextBlock and would otherwise be matched by the parent class check.
+ */
+export declare class ListItemBlockSearchStrategy extends BlockSearchStrategy {
+  /**
+   * @inheritDoc
+   */
+  canHandle(block: RTEBlock): boolean;
+  /**
+   * @inheritDoc
+   */
+  collect(block: RTEBlock, recurse: (blocks: RTEBlock[]) => (RTETextBlock | RTECodeBlock)[]): (RTETextBlock | RTECodeBlock)[];
+}

package/dist/types/components/vega-rich-text-editor/extensions/find-replace/slimmer/controllers/helper/block-search-strategies/text-block-search-strategy.d.ts

@@ -0,0 +1,18 @@
+import { RTETextBlock } from '../../../../../../dto/blocks/text-block';
+import type { RTEBlock } from '../../../../../../dto/blocks/block.abstract';
+import type { RTECodeBlock } from '../../../../../../dto/blocks/code-block';
+import { BlockSearchStrategy } from './block-search-strategy.abstract';
+/**
+ * Handles plain RTETextBlock (paragraph, heading, etc.) — a searchable leaf
+ * block whose text lives in its RTETextNode children.
+ */
+export declare class TextBlockSearchStrategy extends BlockSearchStrategy {
+  /**
+   * @inheritDoc
+   */
+  canHandle(block: RTEBlock): boolean;
+  /**
+   * @inheritDoc
+   */
+  collect(block: RTEBlock): (RTETextBlock | RTECodeBlock)[];
+}

package/dist/types/components/vega-rich-text-editor/extensions/find-replace/slimmer/controllers/helper/find-replace-highlight-manager.d.ts

@@ -0,0 +1,88 @@
+import type { FindMatch } from './find-replace-state';
+/**
+ * Manages highlights for the Find & Replace extension using a DOM overlay.
+ *
+ * Instead of modifying the RTE content tree (which causes re-renders, cursor
+ * jumping, and VegaChange events), this manager renders semi-transparent
+ * highlight rectangles in an absolutely-positioned overlay container.
+ *
+ * The overlay lives inside `.rich-text-editor-container` (the RTE's scroll
+ * container) so highlight divs scroll naturally with the text content.
+ * `pointer-events: none` ensures highlights don't interfere with user
+ * interaction (selection, typing, clicking).
+ *
+ * Position computation uses `Range.getClientRects()` on the actual text DOM
+ * nodes (resolved via `stateEntityRenderingRegistry.getDOMByEntity`).
+ */
+export declare class FindReplaceHighlightManager {
+  private overlayContainer;
+  constructor();
+  /**
+   * Renders highlight overlays for all matches, with the active match
+   * visually distinct. Clears any existing highlights before applying.
+   *
+   * @typedef HTMLVegaRichTextEditorElement - The type of the host rich text editor element.
+   * @param {ReadonlyArray<FindMatch>} matches - All search results.
+   * @param {number} currentIndex - 0-based index of the active match (-1 = none).
+   * @param {HTMLVegaRichTextEditorElement} host - The RTE host element.
+   * @param {boolean} scrollToActive - Whether to scroll the active highlight into view.
+   */
+  apply(matches: ReadonlyArray<FindMatch>, currentIndex: number, host: HTMLVegaRichTextEditorElement, scrollToActive?: boolean): void;
+  /**
+   * Removes all highlight overlay elements.
+   * Safe to call multiple times or when no highlights are active.
+   */
+  clear(): void;
+  /**
+   * Gets the existing overlay container or creates one inside the RTE's
+   * scroll container (`.rich-text-editor-container`).
+   *
+   * @typedef HTMLVegaRichTextEditorElement - The type of the host rich text editor element.
+   * @param {HTMLVegaRichTextEditorElement} host - The RTE host element.
+   * @returns {HTMLDivElement | null} The overlay container, or null in SSR environments.
+   */
+  private getOrCreateOverlay;
+  /**
+   * Creates absolutely-positioned highlight rectangles for a single node
+   * position within a match.
+   *
+   * Uses client rectangle extraction from `Range` to handle multi-line matches (where a
+   * single text range may produce multiple rectangles due to line wrapping).
+   *
+   * @param {HTMLDivElement} overlay - The overlay container.
+   * @param {DOMRect} overlayRect - The overlay's bounding client rect (for coordinate conversion).
+   * @param {NodePosition} nodePosition - The node and character offsets for this segment.
+   * @param {string} bg - The background color to apply.
+   * @returns {Nullable<HTMLDivElement>} The first created highlight div for this node segment.
+   */
+  private createHighlightRectangles;
+  /**
+   * Builds a DOM Range for the given node position.
+   *
+   * For standard text nodes (RTETextNode rendered as `<span>`), the first
+   * child is a Text node and offsets apply directly.
+   *
+   * For code block nodes (`<vega-code-block>` with shadow DOM), we traverse
+   * the shadow root's `<code>` element child spans to locate the correct
+   * text positions by accumulated character offset.
+   *
+   * @param {HTMLElement} domElement - The registered DOM element for the node.
+   * @param {NodePosition} nodePosition - The character offsets within the node.
+   * @returns {Nullable<Range>} A Range if successfully built, or null on failure.
+   */
+  private buildRange;
+  /**
+   * Builds a Range inside a `<vega-code-block>` shadow DOM element.
+   *
+   * `<vega-code-block>` renders its content inside a shadow root with a `<code>`
+   * element containing multiple child `<span>` nodes (one per syntax token).
+   * This method walks all Text nodes within that `<code>` element, accumulating
+   * character length until the positions corresponding to startOffset / endOffset
+   * are found.
+   *
+   * @param {HTMLElement} domElement - The `<vega-code-block>` host element.
+   * @param {NodePosition} nodePosition - The character offsets within the node.
+   * @returns {Range | null} A Range if successfully built, or null on failure.
+   */
+  private buildCodeBlockRange;
+}

package/dist/types/components/vega-rich-text-editor/extensions/find-replace/slimmer/controllers/helper/find-replace-state.d.ts

@@ -0,0 +1,200 @@
+import { RTETextBlock } from '../../../../../dto/blocks/text-block';
+import { RTECodeBlock } from '../../../../../dto/blocks/code-block';
+import type { VegaRTEContent } from '../../../../../dto/content-state';
+import type { RTETextNode } from '../../../../../dto/nodes/text-node';
+import type { RTECodeBlockNode } from '../../../../../dto/nodes/code-block-node';
+/**
+ * The position of a match within a specific node, expressed as node-local offsets.
+ */
+export declare type NodePosition = {
+  node: RTETextNode | RTECodeBlockNode;
+  startOffset: number;
+  endOffset: number;
+};
+/**
+ * A single find result representing one regex match within a document block.
+ */
+export declare type FindMatch = {
+  /** The block containing the match. */
+  block: RTETextBlock | RTECodeBlock;
+  /** Ordered list of node-level positions that together compose this match. */
+  nodes: NodePosition[];
+  /** The matched text string as it appears in the document. */
+  matchText: string;
+};
+/**
+ * Options controlling the search behavior.
+ */
+export declare type FindOptions = {
+  /** When true, the search is case-sensitive. Defaults to false. */
+  matchCase?: boolean;
+  /** When true, only whole-word occurrences are matched. Defaults to false. */
+  wholeWords?: boolean;
+};
+/**
+ * Manages the in-memory state for a single Find & Replace session.
+ *
+ * One instance is created per editor host inside VegaRTEFindReplaceExtension
+ * during `initialExtensionAfterLoad`. It holds all search results, the
+ * current navigation index, and a per-block flat-text cache.
+ *
+ * Public API:
+ * - `search(content, keyword)` — run a search, replace current state using current options
+ * - `next()` / `prev()` — navigate through results
+ * - `getCurrentMatch()` / `getMatches()` / `getTotal()` / `getCurrentIndex()` — read state
+ * - `clear()` — reset everything
+ */
+export declare class FindReplaceState {
+  private matches;
+  private currentIndex;
+  private flatCache;
+  private cachedContent;
+  private matchCase;
+  private wholeWords;
+  /**
+   * Ordered strategy chain used to classify and traverse each block type.
+   * More specific types (RTEListItemBlock) must precede their parent class (RTETextBlock).
+   */
+  private readonly blockSearchStrategies;
+  /**
+   * Runs a fresh search over the given content and replaces all previous results.
+   *
+   * The flat-text cache is invalidated whenever the content reference changes
+   * (i.e. after the user edits the document). When only the keyword or options
+   * change (user typing in the find input), the cache is reused.
+   *
+   * @param {VegaRTEContent} content - The root content DTO to search.
+   * @param {string} keyword - The search keyword entered by the user.
+   * Uses the currently stored `matchCase` and `wholeWords` options.
+   */
+  search(content: VegaRTEContent, keyword: string): void;
+  /**
+   * Advances to the next match, wrapping around to the first.
+   */
+  next(): void;
+  /**
+   * Moves to the previous match, wrapping around to the last.
+   */
+  prev(): void;
+  /**
+   * Sets the current index directly. Clamps to valid range.
+   *
+   * @param {number} index - The desired index.
+   */
+  setCurrentIndex(index: number): void;
+  /**
+   * Returns the currently active match, or null if there are no results.
+   *
+   * @returns {FindMatch | null} The currently active match, or null if there are no results.
+   */
+  getCurrentMatch(): FindMatch | null;
+  /**
+   * Returns all matches from the last search.
+   *
+   * @returns {ReadonlyArray<FindMatch>} All matches from the last search.
+   */
+  getMatches(): ReadonlyArray<FindMatch>;
+  /**
+   * Returns the total number of matches from the last search.
+   *
+   * @returns {number} The total number of matches.
+   */
+  getTotal(): number;
+  /**
+   * Returns the 0-based index of the current match, or -1 when there are no results.
+   *
+   * @returns {number} The 0-based index, or -1 when there are no results.
+   */
+  getCurrentIndex(): number;
+  /**
+   * Resets only match results and navigation index.
+   * The flat-text cache and cached content reference are preserved so that
+   * a subsequent search on the same document (e.g. after a keyword change)
+   * can reuse the already-computed block flat texts.
+   */
+  clearResults(): void;
+  /**
+   * Resets all search state, including results, navigation index, and flat-text cache.
+   * Use this when the session ends (e.g. panel closed) or the host changes.
+   */
+  clear(): void;
+  /**
+   * Sets the matchCase search option.
+   *
+   * @param {boolean} enabled - Whether to enable case-sensitive matching.
+   */
+  setMatchCase(enabled: boolean): void;
+  /**
+   * Sets the wholeWords search option.
+   *
+   * @param {boolean} enabled - Whether to enable whole-word matching.
+   */
+  setWholeWords(enabled: boolean): void;
+  /**
+   * Invalidates the flat-text cache when the content reference has changed.
+   * Since flushChanges always produces a new VegaRTEContent via clone(), a
+   * changed reference reliably indicates the document has been edited.
+   *
+   * @param {VegaRTEContent} content - The incoming content reference.
+   */
+  private invalidateCacheIfNeeded;
+  /**
+   * Builds a RegExp from the keyword and search options.
+   *
+   * @param {string} keyword - The raw user input.
+   * @param {FindOptions} options - Search options.
+   * @returns {RegExp} The compiled regular expression.
+   */
+  private buildRegExp;
+  /**
+   * Escapes all regex special characters so the keyword is treated as literal text.
+   *
+   * @param {string} text - The raw input string.
+   * @returns {string} The escaped string safe for use in a RegExp constructor.
+   */
+  private escapeRegExp;
+  /**
+   * Recursively collects all searchable leaf blocks (RTETextBlock and RTECodeBlock)
+   * from a block tree in document order.
+   *
+   * Each block is dispatched to the first matching BlockSearchStrategy.
+   *
+   * @param {RTEBlock[]} blocks - The block array to traverse.
+   * @returns {(RTETextBlock | RTECodeBlock)[]} Ordered list of searchable leaf blocks.
+   */
+  private collectSearchableBlocks;
+  /**
+   * Builds the flat text and segment table for a RTETextBlock.
+   *
+   * Non-editable child nodes (e.g. tokens, which render as read-only chips)
+   * are excluded from the searchable flat text. Each is replaced by a single
+   * sentinel character so that adjacent editable segments cannot bridge across
+   * the token to form a false match, while keeping segment offsets aligned.
+   *
+   * @param {RTETextBlock} block - The text block to flatten.
+   * @returns {BlockFlatCache} The flat text string and segment mapping.
+   */
+  private buildTextBlockFlat;
+  /**
+   * Builds the flat text and segment table for a RTECodeBlock.
+   *
+   * @param {RTECodeBlock} block - The code block to flatten.
+   * @returns {BlockFlatCache} The flat text string and segment mapping.
+   */
+  private buildCodeBlockFlat;
+  /**
+   * Maps a flat [matchStart, matchEnd) range back to individual node positions.
+   *
+   * @param {(TextSegment | CodeSegment)[]} segments - The segment table.
+   * @param {number} matchStart - Inclusive start in the flat text.
+   * @param {number} matchEnd - Exclusive end in the flat text.
+   * @returns {NodePosition[]} Ordered list of node-local positions spanning the match.
+   */
+  private flatOffsetToNodePositions;
+  /**
+   * Builds the current find options from the shared context.
+   *
+   * @returns {FindOptions} The options for the search engine.
+   */
+  private getFindOptions;
+}