playwright-advanced-ml-healer/dist/advanced-ml-healing.d.ts

Advanced AI-powered self-healing selectors for Playwright with 19+ healing types, neural networks, machine learning models, and Global DOM Learning ML Model

import { Page } from 'playwright';
interface AdvancedElementFeatures {
    tagName: string;
    id: string;
    className: string;
    textContent: string;
    attributes: Record<string, string>;
    position: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    visibility: boolean;
    interactivity: boolean;
    role: string;
    ariaLabel: string;
    placeholder: string;
    semanticRole: string;
    accessibilityScore: number;
    visualHierarchy: number;
    interactionPattern: string;
    contextSimilarity: number;
    historicalSuccess: number;
    neuralScore: number;
    fuzzyMatchScore: number;
    temporalPattern: string;
    domainSpecificScore: number;
}
interface AdvancedMLResult {
    selector: string;
    confidence: number;
    reasoning: string;
    features: AdvancedElementFeatures;
    alternatives: Array<{
        selector: string;
        confidence: number;
        reasoning: string;
    }>;
    learningInsights: Array<string>;
    performanceMetrics: {
        responseTime: number;
        accuracyScore: number;
        reliabilityScore: number;
        neuralScore: number;
        fuzzyScore: number;
    };
    analytics: {
        patternType: string;
        successProbability: number;
        confidenceLevel: string;
        recommendedStrategy: string;
    };
}
interface MultiModalFeatures {
    visualFeatures: {
        color: string;
        backgroundColor: string;
        fontSize: string;
        fontWeight: string;
        borderStyle: string;
        borderRadius: string;
        boxShadow: string;
        opacity: number;
        zIndex: number;
        position: 'static' | 'relative' | 'absolute' | 'fixed';
    };
    accessibilityFeatures: {
        ariaLabel: string;
        ariaDescribedBy: string;
        ariaLabelledBy: string;
        ariaHidden: boolean;
        ariaDisabled: boolean;
        ariaRequired: boolean;
        ariaInvalid: boolean;
        tabIndex: number;
        role: string;
    };
    semanticFeatures: {
        tagName: string;
        textContent: string;
        placeholder: string;
        title: string;
        alt: string;
        href: string;
        type: string;
        value: string;
        checked: boolean;
        selected: boolean;
    };
    layoutFeatures: {
        x: number;
        y: number;
        width: number;
        height: number;
        offsetTop: number;
        offsetLeft: number;
        scrollTop: number;
        scrollLeft: number;
        clientWidth: number;
        clientHeight: number;
    };
    interactionFeatures: {
        clickable: boolean;
        focusable: boolean;
        editable: boolean;
        draggable: boolean;
        resizable: boolean;
        selectable: boolean;
        scrollable: boolean;
    };
}
interface ContextAwareFeatures {
    parentContext: {
        tagName: string;
        id: string;
        className: string;
        role: string;
        ariaLabel: string;
    };
    siblingContext: Array<{
        tagName: string;
        id: string;
        className: string;
        textContent: string;
        role: string;
    }>;
    formContext: {
        formId: string;
        formAction: string;
        formMethod: string;
        formEnctype: string;
    };
    pageContext: {
        title: string;
        url: string;
        domain: string;
        pathname: string;
        searchParams: Record<string, string>;
    };
    userContext: {
        action: string;
        intent: string;
        previousActions: Array<{
            action: string;
            selector: string;
            timestamp: number;
        }>;
    };
}
export declare class AdvancedMLHealing {
    private healingHistory;
    private typeMismatchLearningHistory;
    private neuralNetwork;
    private fuzzyStringMatch;
    private levenshteinDistance;
    private isAnagram;
    private calculateNeuralNetworkHealth;
    private processMultiModalAnalysis;
    private analyzeContextAwareFeatures;
    private calculateAdaptiveScore;
    private processParallelHealingStrategies;
    private processNeuralNetworkStrategy;
    private processFuzzyLogicStrategy;
    private processSemanticAnalysisStrategy;
    private processContextAwareStrategy;
    private processPatternRecognitionStrategy;
    private processMultiModalStrategy;
    private extractNeuralInputs;
    private calculateFuzzyScore;
    private trainSupportVectorMachine;
    private trainRandomForest;
    private trainGradientBoosting;
    private trainNaiveBayes;
    private trainKNearestNeighbors;
    private tokenizeText;
    private calculateWordEmbeddings;
    private calculateSemanticSimilarity;
    private processImageFeatures;
    private detectVisualElements;
    private ensemblePrediction;
    private updateOnlineLearning;
    private detectConceptDrift;
    private activeLearningQuery;
    private calculateAdvancedMetrics;
    private fuseMultiModalFeatures;
    private processWithCaching;
    private advancedCachingSystem;
    private analyticsSystem;
    private adaptiveLearningSystem;
    private machineLearningModels;
    private naturalLanguageProcessing;
    private computerVisionFeatures;
    private ensembleMethods;
    private realTimeLearning;
    private updateAdaptiveLearning;
    private extractPattern;
    private generateSuggestedFix;
    private recordStrategySuccess;
    private recordStrategyFailure;
    private recordResponseTime;
    private recordPatternType;
    private recordElementType;
    private getFromCache;
    private setCache;
    healWithAdvancedML(page: Page, originalSelector: string, context?: any): Promise<AdvancedMLResult | null>;
    getHealingAnalytics(): {
        totalRequests: number;
        successfulHealings: number;
        failedHealings: number;
        successRate: string;
        averageResponseTime: string;
        cacheMetrics: {
            hits: number;
            misses: number;
            hitRate: string;
            size: number;
        };
        strategySuccessRates: {
            [k: string]: {
                success: number;
                total: number;
            };
        };
        patternTypes: {
            [k: string]: number;
        };
        elementTypes: {
            [k: string]: number;
        };
    };
    private performOptimizedMLHealing;
    private performComprehensiveHealing;
    private executeComprehensiveHealing;
    getHealingStats(): {
        total: number;
        successful: number;
        successRate: number;
        averageResponseTime: number;
    };
    getAdvancedAnalytics(): any;
    generateAnalyticsReport(): string;
    getCachingStats(): {
        size: number;
        hitRate: number;
        avgAccessCount: number;
    };
    clearCache(): void;
    getAdaptiveLearningStats(): {
        successPatterns: number;
        failurePatterns: number;
        performanceMetrics: {
            averageResponseTime: number;
            successRate: number;
            confidenceThreshold: number;
            learningRate: number;
        };
        optimizationStrategies: {
            name: string;
            description: string;
            successRate: number;
            implementation: string;
        }[];
    };
    trainNeuralNetwork(trainingData: Array<{
        input: number[];
        output: number[];
        success: boolean;
    }>): void;
    trainNeuralNetworkForML(trainingData: Array<{
        features: number[];
        label: number;
    }>): void;
    processMultipleSelectors(selectors: string[], context: any): Promise<Array<{
        selector: string;
        result: AdvancedMLResult | null;
    }>>;
    analyzeElementMultiModal(element: Element): MultiModalFeatures;
    analyzeElementContext(element: Element): ContextAwareFeatures;
    recognizePattern(selector: string): string;
    optimizePerformance(): void;
    debugHealingProcess(selector: string, context: any): any;
    exportLearningData(): any;
    importLearningData(data: any): void;
    trainAllModels(trainingData: Array<{
        features: number[];
        label: number;
    }>): void;
    predictWithEnsemble(features: number[]): {
        prediction: number;
        confidence: number;
        method: string;
    };
    analyzeElementComprehensive(element: Element, selector: string): any;
    updateRealTimeLearning(features: number[], prediction: number, actual: number): void;
    private retrainModels;
    getComprehensiveStats(): any;
    optimizePerformanceComprehensive(): void;
    generateComprehensiveReport(): string;
    private createAdvancedMLResult;
    private healById;
    private healByText;
    private healByClass;
    private healByTag;
    private healByAttribute;
    private healByPosition;
    private healByXPath;
    private healComplexSelector;
    private healWithUniversalML;
    private healByPattern;
    private healBySemantic;
    private healByContext;
    private healByAnagram;
    private healByFuzzyLogic;
    private healByMultiModal;
    private healByNeuralNetwork;
    private healByEnhancedAbbreviation;
    private healByElementTypeMismatch;
    private analyzeSelector;
    private calculateTypeMismatchScore;
    private healByAttributeMismatch;
    private generateAttributeVariations;
    private calculateAttributeMismatchScore;
    private areAttributeValuesCompatible;
    private createHealedSelector;
    private areTypesCompatible;
    private getSemanticElementMapping;
    private generateSemanticSearchSelectors;
    private calculateEnhancedSemanticScore;
    private calculateAttributeSimilarity;
    private generateFastPrimarySelector;
    private getOptimizedElementInfo;
    private calculateFastSemanticScore;
    private generateOptimizedSemanticSelectors;
    private getFirstSuccessfulStrategy;
    private generateFallbackSelectors;
    private generateContextSearchSelectors;
    private recordTypeMismatchLearning;
    private calculateStringSimilarity;
    private calculateLevenshteinDistance;
    private calculateSemanticScore;
    private calculateAccessibilityScore;
    private calculateVisualScore;
    private calculateContextScore;
    private healingAnalytics;
    private healingCache;
    private executeParallelHealing;
}
export {};
//# sourceMappingURL=advanced-ml-healing.d.ts.map