@qontinui/ui-bridge 0.3.0 → 0.3.1

package/dist/ai/index.d.ts

@@ -1,7 +1,8 @@
-import { S as SearchCriteria, n as SearchResponse, o as SearchResult, A as AIDiscoveredElement, P as PageContext, t as SemanticSnapshot, m as ParsedAction, N as NLActionRequest, l as NLActionResponse, b as AIErrorContext, d as AssertionRequest, e as AssertionResult, B as BatchAssertionRequest, g as BatchAssertionResult, p as SemanticDiff, R as RecoverySuggestion } from '../types-DfPqwU-i.js';
-export { a as AIElementRegistrationOptions, c as AIFindResponse, f as AssertionType, E as ElementChange, h as ElementModification, F as FormAnalysis, i as FormFieldAnalysis, j as FormFieldState, k as FormState, M as ModalState, q as SemanticSearchCriteria, r as SemanticSearchResponse, s as SemanticSearchResult } from '../types-DfPqwU-i.js';
-import { x as RegisteredElement, q as ElementState } from '../types-jKVgTI6_.js';
-import { D as DiscoveredElement, A as ActionExecutor, d as ControlSnapshot } from '../types-BkNRILUa.js';
+import { a8 as SearchCriteria, a9 as SearchResponse, aa as SearchResult, A as AIDiscoveredElement, $ as PageContext, af as SemanticSnapshot, a3 as ParsedAction, X as NLActionRequest, Y as NLActionResponse, b as AIErrorContext, ab as SemanticDiff, a6 as RecoverySuggestion, D as DataType, a0 as PageDataMap, a7 as RegionType, a2 as PageRegionMap, S as ListSchema, al as TableSchema, ai as StructuredDataExtraction, x as FormatDescriptor, y as FormatMismatch, n as CrossAppDiff, T as MatchedElementPair, P as InteractionParity, Z as NavigationMap, i as ComponentInfo, h as ComponentComparison, Q as LayoutComparison, z as GridStructure, l as ContentComparison, m as CrossAppComparisonReport } from '../types-CebMQj76.js';
+export { a as AIElementRegistrationOptions, c as AIFindResponse, d as AssertionRequest, e as AssertionResult, f as AssertionType, B as BatchAssertionRequest, g as BatchAssertionResult, C as ComparisonIssue, j as ComponentMatch, k as ContentChanges, o as CrossAppMetricChange, p as CrossAppStatusChange, q as DataValueComparison, r as DensityComparison, E as ElementChange, s as ElementModification, t as ExtractedDataValue, F as FormAnalysis, u as FormFieldAnalysis, v as FormFieldState, w as FormState, G as GridDiff, H as HeadingChange, I as HeadingLevelComparison, J as HeadingMatch, K as HierarchyDiff, L as Intent, M as IntentExecutionResult, N as IntentParam, O as IntentSearchResponse, R as ListItemField, U as MetricChange, V as MetricMatch, W as ModalState, _ as NavigationPair, a1 as PageRegion, a4 as RecoveryAttemptRequest, a5 as RecoveryAttemptResult, ac as SemanticSearchCriteria, ad as SemanticSearchResponse, ae as SemanticSearchResult, ag as StatusChange, ah as StatusMatch, aj as TableColumn, ak as TableComparison, am as TextChange } from '../types-CebMQj76.js';
+import { X as RegisteredElement, z as ElementState } from '../types-suaYwWWg.js';
+import { D as DiscoveredElement, A as ActionExecutor, d as ControlSnapshot } from '../types-C7gVYRnF.js';
+export { A as AssertionConfig, a as AssertionExecutor, D as DEFAULT_ASSERTION_CONFIG, c as createAssertionExecutor } from '../assertions-BSR3afVr.js';
 
 /**
  * Fuzzy Matcher
@@ -496,156 +497,6 @@ declare class NLActionExecutor {
  */
 declare function createNLActionExecutor(config?: Partial<NLActionExecutorConfig>): NLActionExecutor;
 
-/**
- * Assertions Module
- *
- * Provides verification/assertion API for AI agents to validate
- * page state without writing Playwright tests.
- */
-
-/**
- * Configuration for assertions
- */
-interface AssertionConfig {
-    /** Default timeout for wait-based assertions */
-    defaultTimeout: number;
-    /** Polling interval for wait-based assertions */
-    pollInterval: number;
-    /** Default fuzzy threshold for element search */
-    fuzzyThreshold: number;
-    /** Include suggestions in failure messages */
-    includeSuggestions: boolean;
-}
-/**
- * Default assertion configuration
- */
-declare const DEFAULT_ASSERTION_CONFIG: AssertionConfig;
-/**
- * Assertion executor class
- */
-declare class AssertionExecutor {
-    private config;
-    private searchEngine;
-    private elements;
-    constructor(config?: Partial<AssertionConfig>);
-    /**
-     * Update available elements for assertions
-     */
-    updateElements(elements: Array<DiscoveredElement | AIDiscoveredElement>): void;
-    /**
-     * Execute a single assertion
-     */
-    assert(request: AssertionRequest): Promise<AssertionResult>;
-    /**
-     * Execute multiple assertions
-     */
-    assertBatch(request: BatchAssertionRequest): Promise<BatchAssertionResult>;
-    /**
-     * Convenience method: assert element is visible
-     */
-    assertVisible(target: string | SearchCriteria, timeout?: number): Promise<AssertionResult>;
-    /**
-     * Convenience method: assert element is hidden
-     */
-    assertHidden(target: string | SearchCriteria, timeout?: number): Promise<AssertionResult>;
-    /**
-     * Convenience method: assert element is enabled
-     */
-    assertEnabled(target: string | SearchCriteria, timeout?: number): Promise<AssertionResult>;
-    /**
-     * Convenience method: assert element is disabled
-     */
-    assertDisabled(target: string | SearchCriteria, timeout?: number): Promise<AssertionResult>;
-    /**
-     * Convenience method: assert element has text
-     */
-    assertHasText(target: string | SearchCriteria, text: string, timeout?: number): Promise<AssertionResult>;
-    /**
-     * Convenience method: assert element contains text
-     */
-    assertContainsText(target: string | SearchCriteria, text: string, timeout?: number): Promise<AssertionResult>;
-    /**
-     * Convenience method: assert element has value
-     */
-    assertHasValue(target: string | SearchCriteria, value: string, timeout?: number): Promise<AssertionResult>;
-    /**
-     * Convenience method: assert element exists
-     */
-    assertExists(target: string | SearchCriteria, timeout?: number): Promise<AssertionResult>;
-    /**
-     * Convenience method: assert element does not exist
-     */
-    assertNotExists(target: string | SearchCriteria, timeout?: number): Promise<AssertionResult>;
-    /**
-     * Convenience method: assert checkbox is checked
-     */
-    assertChecked(target: string | SearchCriteria, timeout?: number): Promise<AssertionResult>;
-    /**
-     * Convenience method: assert checkbox is unchecked
-     */
-    assertUnchecked(target: string | SearchCriteria, timeout?: number): Promise<AssertionResult>;
-    /**
-     * Convenience method: assert element count
-     */
-    assertCount(target: SearchCriteria, expectedCount: number, timeout?: number): Promise<AssertionResult>;
-    /**
-     * Find element by target (string or criteria)
-     */
-    private findElement;
-    /**
-     * Execute the actual assertion
-     */
-    private executeAssertion;
-    /**
-     * Assert visibility state
-     */
-    private assertVisibility;
-    /**
-     * Assert enabled state
-     */
-    private assertEnabledState;
-    /**
-     * Assert focused state
-     */
-    private assertFocused;
-    /**
-     * Assert checked state
-     */
-    private assertCheckedState;
-    /**
-     * Assert text content
-     */
-    private assertTextMatch;
-    /**
-     * Assert input value
-     */
-    private assertValue;
-    /**
-     * Assert element count
-     */
-    private assertElementCount;
-    /**
-     * Assert attribute value (placeholder for DOM attribute assertions)
-     */
-    private assertAttribute;
-    /**
-     * Assert element has CSS class
-     */
-    private assertHasClass;
-    /**
-     * Assert CSS property value
-     */
-    private assertCssProperty;
-    /**
-     * Create an assertion result
-     */
-    private createResult;
-}
-/**
- * Create a default assertion executor
- */
-declare function createAssertionExecutor(config?: Partial<AssertionConfig>): AssertionExecutor;
-
 /**
  * Semantic Snapshot
  *
@@ -667,6 +518,8 @@ interface SemanticSnapshotConfig {
     generateDescriptions: boolean;
     /** Maximum elements to include */
     maxElements: number;
+    /** Merge annotations from the annotation store (default: true) */
+    useAnnotations: boolean;
 }
 /**
  * Default snapshot configuration
@@ -710,6 +563,10 @@ declare class SemanticSnapshotManager {
      * Convert a single element to AI element
      */
     private convertElement;
+    /**
+     * Generate a content-specific description
+     */
+    private generateContentDescription;
     /**
      * Build full page context
      */
@@ -832,6 +689,21 @@ declare function hasSignificantChanges(diff: SemanticDiff): boolean;
  * Utility: Get a brief description of what changed
  */
 declare function describeDiff(diff: SemanticDiff): string;
+/**
+ * Parse a numeric value from a string, handling common formats:
+ * - Plain numbers: "42", "1,234", "1234.56"
+ * - Percentages: "95%", "12.5%"
+ * - Currency: "$1,234", "$1,234.56", "-$50"
+ * - Duration: "2h 30m", "1.5s", "100ms"
+ * - Negative values: "-42", "($500)"
+ *
+ * Returns the numeric value or null if not parseable.
+ */
+declare function parseNumericValue(text: string): number | null;
+/**
+ * Classify whether a status change is an improvement, degradation, or neutral
+ */
+declare function classifyStatusDirection(oldStatus: string, newStatus: string): 'improved' | 'degraded' | 'neutral';
 
 /**
  * Error Context
@@ -890,4 +762,289 @@ declare function isRecoverableError(code: ErrorCode): boolean;
  */
 declare function getBestRecoverySuggestion(context: AIErrorContext): RecoverySuggestion | null;
 
-export { AIDiscoveredElement, AIErrorContext, type AliasGeneratorConfig, type AliasGeneratorInput, type AssertionConfig, AssertionExecutor, AssertionRequest, AssertionResult, BatchAssertionRequest, BatchAssertionResult, DEFAULT_ALIAS_CONFIG, DEFAULT_ASSERTION_CONFIG, DEFAULT_DIFF_CONFIG, DEFAULT_EXECUTOR_CONFIG, DEFAULT_FUZZY_CONFIG, DEFAULT_SEARCH_CONFIG, DEFAULT_SNAPSHOT_CONFIG, type ErrorCode, ErrorCodes, type FuzzyMatchConfig, type FuzzyMatchResult, NLActionExecutor, type NLActionExecutorConfig, NLActionRequest, NLActionResponse, PageContext, ParsedAction, RecoverySuggestion, SearchCriteria, SearchEngine, type SearchEngineConfig, SearchResponse, SearchResult, SemanticDiff, type SemanticDiffConfig, SemanticDiffManager, SemanticSnapshot, type SemanticSnapshotConfig, SemanticSnapshotManager, type SummaryConfig, areSynonyms, computeDiff, createAssertionExecutor, createDiffManager, createErrorContext, createNLActionExecutor, createSearchEngine, createSimpleError, createSnapshotManager, describeAction, describeDiff, extractModifiers, findAllMatches, findBestMatch, formatErrorContext, fuzzyContains, fuzzyMatch, generateAliases, generateDescription, generateDiffSummary, generateElementDescription, generateNgrams, generatePageSummary, generatePurpose, generateSnapshotSummary, generateSuggestedActions, getBestRecoverySuggestion, getSynonyms, hasSignificantChanges, inferPageType, isRecoverableError, jaroSimilarity, jaroWinklerSimilarity, levenshteinDistance, levenshteinSimilarity, ngramSimilarity, normalizeString, parseNLInstruction, parseNLInstructions, splitCompoundInstruction, tokenSimilarity, tokenize, validateParsedAction, wordSimilarity };
+/**
+ * Data Extraction
+ *
+ * Extracts labeled data values from page elements, classifies their types,
+ * and normalizes values for cross-app comparison.
+ */
+
+interface DataExtractionConfig {
+    /** Minimum confidence to include a value */
+    minConfidence: number;
+    /** Whether to normalize whitespace */
+    normalizeWhitespace: boolean;
+}
+declare const DEFAULT_DATA_EXTRACTION_CONFIG: DataExtractionConfig;
+/**
+ * Classify the data type of a raw string value.
+ */
+declare function classifyDataType(value: string): {
+    type: DataType;
+    confidence: number;
+};
+/**
+ * Normalize a value for comparison by stripping formatting differences.
+ */
+declare function normalizeValue(value: string, dataType: DataType): string;
+/**
+ * Extract labeled data values from all page elements.
+ */
+declare function extractPageData(elements: AIDiscoveredElement[], config?: DataExtractionConfig): PageDataMap;
+
+/**
+ * Region Segmentation
+ *
+ * Segments a page into semantic regions (header, nav, sidebar, main, footer, etc.)
+ * based on element positions, roles, and spatial clustering.
+ */
+
+interface RegionSegmentationConfig {
+    /** Minimum elements for a region to be valid */
+    minRegionElements: number;
+    /** Top portion of viewport considered "header" (fraction 0-1) */
+    headerFraction: number;
+    /** Bottom portion considered "footer" (fraction 0-1) */
+    footerFraction: number;
+    /** Left portion considered "sidebar" (fraction 0-1) */
+    sidebarFraction: number;
+}
+declare const DEFAULT_REGION_SEGMENTATION_CONFIG: RegionSegmentationConfig;
+/**
+ * Classify the region type of an element based on its role, position, and context.
+ */
+declare function classifyRegionType(el: AIDiscoveredElement, relativeY: number, relativeX: number, config?: RegionSegmentationConfig): {
+    type: RegionType;
+    confidence: number;
+};
+/**
+ * Segment all page elements into semantic regions.
+ */
+declare function segmentPageRegions(elements: AIDiscoveredElement[], config?: RegionSegmentationConfig): PageRegionMap;
+
+/**
+ * Table & List Extraction
+ *
+ * Detects and extracts structured data (tables and lists) from page elements
+ * based on spatial layout and semantic roles.
+ */
+
+interface TableExtractionConfig {
+    /** Minimum columns to consider a group a table */
+    minTableColumns: number;
+    /** Minimum rows to consider a group a table */
+    minTableRows: number;
+    /** Minimum items to consider a group a list */
+    minListItems: number;
+    /** Position tolerance for column alignment (px) */
+    columnTolerance: number;
+    /** Position tolerance for row alignment (px) */
+    rowTolerance: number;
+}
+declare const DEFAULT_TABLE_EXTRACTION_CONFIG: TableExtractionConfig;
+/**
+ * Detect a table structure from elements with grid-like spatial arrangement.
+ */
+declare function detectTable(elements: AIDiscoveredElement[], config?: TableExtractionConfig): TableSchema | null;
+/**
+ * Detect a list structure from repeating element patterns.
+ */
+declare function detectList(elements: AIDiscoveredElement[], config?: TableExtractionConfig): ListSchema | null;
+/**
+ * Extract all structured data (tables and lists) from page elements.
+ */
+declare function extractStructuredData(elements: AIDiscoveredElement[], config?: TableExtractionConfig): StructuredDataExtraction;
+
+/**
+ * Format Analysis
+ *
+ * Analyzes the display format of data values and detects
+ * format mismatches between source and target pages.
+ */
+
+interface FormatAnalysisConfig {
+    /** Treat minor format differences (e.g., comma vs period for thousands) as warnings rather than errors */
+    lenientFormatting: boolean;
+}
+declare const DEFAULT_FORMAT_ANALYSIS_CONFIG: FormatAnalysisConfig;
+/**
+ * Detect the format pattern of a value.
+ */
+declare function detectFormatPattern(value: string, dataType: DataType): string;
+/**
+ * Analyze format of a single element's value.
+ */
+declare function analyzeFormat(elementId: string, label: string, rawValue: string): FormatDescriptor;
+/**
+ * Analyze formats for all data-bearing elements on a page.
+ */
+declare function analyzePageFormats(elements: AIDiscoveredElement[]): FormatDescriptor[];
+/**
+ * Compare formats between source and target descriptors with matching labels.
+ */
+declare function compareFormats(sourceFormats: FormatDescriptor[], targetFormats: FormatDescriptor[], config?: FormatAnalysisConfig): FormatMismatch[];
+
+/**
+ * Cross-App Diff
+ *
+ * Matches elements between source and target pages and computes
+ * a structured diff of data values, formats, and unmatched elements.
+ */
+
+interface CrossAppDiffConfig {
+    /** Minimum confidence to consider a match */
+    matchThreshold: number;
+    /** Weight for accessible name matching */
+    accessibleNameWeight: number;
+    /** Weight for text matching */
+    textWeight: number;
+    /** Weight for role + position matching */
+    rolePositionWeight: number;
+}
+declare const DEFAULT_CROSS_APP_DIFF_CONFIG: CrossAppDiffConfig;
+/**
+ * Match elements between source and target using greedy assignment.
+ * Elements are matched by descending confidence.
+ */
+declare function matchElements(sourceElements: AIDiscoveredElement[], targetElements: AIDiscoveredElement[], config?: CrossAppDiffConfig): MatchedElementPair[];
+/**
+ * Compute a full cross-app diff between source and target element sets.
+ */
+declare function computeCrossAppDiff(sourceElements: AIDiscoveredElement[], targetElements: AIDiscoveredElement[], config?: CrossAppDiffConfig): CrossAppDiff;
+
+/**
+ * Action Parity
+ *
+ * Compares the interactive capabilities (available actions) of matched
+ * element pairs to detect missing functionality between source and target.
+ */
+
+interface ActionParityConfig {
+    /** Actions to ignore in comparison (e.g., framework-internal actions) */
+    ignoreActions: string[];
+}
+declare const DEFAULT_ACTION_PARITY_CONFIG: ActionParityConfig;
+/**
+ * Analyze action parity for all matched element pairs.
+ */
+declare function analyzeActionParity(matchedPairs: MatchedElementPair[], sourceElements: AIDiscoveredElement[], targetElements: AIDiscoveredElement[], config?: ActionParityConfig): InteractionParity[];
+
+/**
+ * Navigation Map
+ *
+ * Identifies navigation elements in both source and target pages
+ * and maps them to each other for parity analysis.
+ */
+
+interface NavigationMapConfig {
+    /** Minimum similarity for label matching */
+    labelMatchThreshold: number;
+}
+declare const DEFAULT_NAVIGATION_MAP_CONFIG: NavigationMapConfig;
+/**
+ * Determine whether an element is a navigation link/item.
+ */
+declare function isNavigationElement(el: AIDiscoveredElement): boolean;
+/**
+ * Build a navigation map comparing source and target pages.
+ */
+declare function buildNavigationMap(sourceElements: AIDiscoveredElement[], targetElements: AIDiscoveredElement[], config?: NavigationMapConfig): NavigationMap;
+
+/**
+ * Component Comparison
+ *
+ * Compares registered components between source and target apps,
+ * matching by name/type and diffing state keys and actions.
+ */
+
+interface ComponentComparisonConfig {
+    /** Minimum similarity for name matching */
+    nameMatchThreshold: number;
+}
+declare const DEFAULT_COMPONENT_COMPARISON_CONFIG: ComponentComparisonConfig;
+/**
+ * Compare components between source and target apps.
+ *
+ * Note: ComponentInfo is not part of SemanticSnapshot. The caller must
+ * fetch component lists separately from /control/components endpoint.
+ */
+declare function compareComponents(sourceComponents: ComponentInfo[], targetComponents: ComponentInfo[], config?: ComponentComparisonConfig): ComponentComparison;
+
+/**
+ * Layout Comparison
+ *
+ * Compares the spatial layout between two pages: grid structure,
+ * hierarchy depth, and information density.
+ */
+
+interface LayoutComparisonConfig {
+    /** Tolerance for column/row alignment detection (px) */
+    gridTolerance: number;
+}
+declare const DEFAULT_LAYOUT_COMPARISON_CONFIG: LayoutComparisonConfig;
+/**
+ * Detect the implicit grid structure from element positions.
+ */
+declare function detectGridStructure(elements: AIDiscoveredElement[], config?: LayoutComparisonConfig): GridStructure;
+/**
+ * Compute a prominence score for an element (0-1) based on size and position.
+ * Larger elements nearer the top are more prominent.
+ */
+declare function computeProminence(element: AIDiscoveredElement, pageWidth: number, pageHeight: number): number;
+/**
+ * Compare layouts between source and target element sets.
+ */
+declare function compareLayouts(sourceElements: AIDiscoveredElement[], targetElements: AIDiscoveredElement[], sourceRegions?: PageRegionMap, targetRegions?: PageRegionMap, config?: LayoutComparisonConfig): LayoutComparison;
+
+/**
+ * Content Comparison
+ *
+ * Compares content elements (headings, metrics, labels, statuses, table data)
+ * between source and target semantic snapshots. Produces a structured
+ * ContentComparison result alongside the existing interactive element comparison.
+ */
+
+interface ContentComparisonConfig {
+    /** Minimum fuzzy similarity to consider two labels as matching */
+    labelMatchThreshold: number;
+    /** Minimum fuzzy similarity to consider two headings as matching */
+    headingMatchThreshold: number;
+    /** Maximum cell differences to report per table */
+    maxCellDifferences: number;
+}
+declare const DEFAULT_CONTENT_COMPARISON_CONFIG: ContentComparisonConfig;
+/**
+ * Compare content elements between source and target.
+ *
+ * Analyzes headings, metrics, statuses, labels, and table data,
+ * producing a structured ContentComparison result.
+ */
+declare function compareContent(sourceElements: AIDiscoveredElement[], targetElements: AIDiscoveredElement[], config?: ContentComparisonConfig): ContentComparison;
+
+/**
+ * Comparison Report
+ *
+ * Orchestrates all cross-app analysis modules to produce a unified
+ * comparison report with scores, issues, and a summary.
+ */
+
+interface ComparisonReportConfig {
+    /** Include component comparison (requires separate ComponentInfo arrays) */
+    includeComponents: boolean;
+}
+declare const DEFAULT_COMPARISON_REPORT_CONFIG: ComparisonReportConfig;
+/**
+ * Generate a comprehensive cross-app comparison report.
+ *
+ * @param source - Source page semantic snapshot
+ * @param target - Target page semantic snapshot
+ * @param options - Optional configuration and component data
+ * @returns Full comparison report with scores, issues, and summary
+ */
+declare function generateComparisonReport(source: SemanticSnapshot, target: SemanticSnapshot, options?: {
+    config?: ComparisonReportConfig;
+    sourceComponents?: ComponentInfo[];
+    targetComponents?: ComponentInfo[];
+}): CrossAppComparisonReport;
+
+export { AIDiscoveredElement, AIErrorContext, type ActionParityConfig, type AliasGeneratorConfig, type AliasGeneratorInput, type ComparisonReportConfig, ComponentComparison, type ComponentComparisonConfig, ComponentInfo, ContentComparison, type ContentComparisonConfig, CrossAppComparisonReport, CrossAppDiff, type CrossAppDiffConfig, DEFAULT_ACTION_PARITY_CONFIG, DEFAULT_ALIAS_CONFIG, DEFAULT_COMPARISON_REPORT_CONFIG, DEFAULT_COMPONENT_COMPARISON_CONFIG, DEFAULT_CONTENT_COMPARISON_CONFIG, DEFAULT_CROSS_APP_DIFF_CONFIG, DEFAULT_DATA_EXTRACTION_CONFIG, DEFAULT_DIFF_CONFIG, DEFAULT_EXECUTOR_CONFIG, DEFAULT_FORMAT_ANALYSIS_CONFIG, DEFAULT_FUZZY_CONFIG, DEFAULT_LAYOUT_COMPARISON_CONFIG, DEFAULT_NAVIGATION_MAP_CONFIG, DEFAULT_REGION_SEGMENTATION_CONFIG, DEFAULT_SEARCH_CONFIG, DEFAULT_SNAPSHOT_CONFIG, DEFAULT_TABLE_EXTRACTION_CONFIG, type DataExtractionConfig, DataType, type ErrorCode, ErrorCodes, type FormatAnalysisConfig, FormatDescriptor, FormatMismatch, type FuzzyMatchConfig, type FuzzyMatchResult, GridStructure, InteractionParity, LayoutComparison, type LayoutComparisonConfig, ListSchema, MatchedElementPair, NLActionExecutor, type NLActionExecutorConfig, NLActionRequest, NLActionResponse, NavigationMap, type NavigationMapConfig, PageContext, PageDataMap, PageRegionMap, ParsedAction, RecoverySuggestion, type RegionSegmentationConfig, RegionType, SearchCriteria, SearchEngine, type SearchEngineConfig, SearchResponse, SearchResult, SemanticDiff, type SemanticDiffConfig, SemanticDiffManager, SemanticSnapshot, type SemanticSnapshotConfig, SemanticSnapshotManager, StructuredDataExtraction, type SummaryConfig, type TableExtractionConfig, TableSchema, analyzeActionParity, analyzeFormat, analyzePageFormats, areSynonyms, buildNavigationMap, classifyDataType, classifyRegionType, classifyStatusDirection, compareComponents, compareContent, compareFormats, compareLayouts, computeCrossAppDiff, computeDiff, computeProminence, createDiffManager, createErrorContext, createNLActionExecutor, createSearchEngine, createSimpleError, createSnapshotManager, describeAction, describeDiff, detectFormatPattern, detectGridStructure, detectList, detectTable, extractModifiers, extractPageData, extractStructuredData, findAllMatches, findBestMatch, formatErrorContext, fuzzyContains, fuzzyMatch, generateAliases, generateComparisonReport, generateDescription, generateDiffSummary, generateElementDescription, generateNgrams, generatePageSummary, generatePurpose, generateSnapshotSummary, generateSuggestedActions, getBestRecoverySuggestion, getSynonyms, hasSignificantChanges, inferPageType, isNavigationElement, isRecoverableError, jaroSimilarity, jaroWinklerSimilarity, levenshteinDistance, levenshteinSimilarity, matchElements, ngramSimilarity, normalizeString, normalizeValue, parseNLInstruction, parseNLInstructions, parseNumericValue, segmentPageRegions, splitCompoundInstruction, tokenSimilarity, tokenize, validateParsedAction, wordSimilarity };