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

Advanced AI-powered self-healing selectors for Playwright with 20+ healing types, neural networks, and machine learning models

/**
 * TypeScript interfaces for Advanced ML Self-Healing System
 */
export 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;
}
export 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;
    };
}
export interface NeuralNetworkModel {
    patterns: Record<string, number>;
    weights: Record<string, number>;
    biases: Record<string, number>;
    learningRate: number;
    activationFunction: (x: number) => number;
    layers: Array<{
        neurons: number;
        weights: number[][];
        biases: number[];
        activation: 'sigmoid' | 'relu' | 'tanh';
    }>;
    trainingData: Array<{
        input: number[];
        output: number[];
        success: boolean;
    }>;
    backpropagation: {
        momentum: number;
        batchSize: number;
        epochs: number;
    };
    deepLearning: {
        hiddenLayers: Array<{
            neurons: number;
            activation: 'sigmoid' | 'relu' | 'tanh' | 'leaky_relu';
            dropout: number;
        }>;
        optimizer: 'adam' | 'sgd' | 'rmsprop';
        lossFunction: 'binary_crossentropy' | 'mean_squared_error' | 'categorical_crossentropy';
        regularization: {
            l1: number;
            l2: number;
        };
    };
    convolutional: {
        filters: Array<{
            size: number;
            channels: number;
            stride: number;
        }>;
        pooling: 'max' | 'average';
        flatten: boolean;
    };
    recurrent: {
        type: 'lstm' | 'gru' | 'rnn';
        units: number;
        returnSequences: boolean;
        bidirectional: boolean;
    };
}
export 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;
    };
}
export 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 interface AdaptiveLearningSystem {
    successPatterns: Array<{
        pattern: string;
        successRate: number;
        confidence: number;
        usageCount: number;
        lastUsed: number;
    }>;
    failurePatterns: Array<{
        pattern: string;
        failureRate: number;
        attempts: number;
        lastAttempt: number;
        suggestedFix: string;
    }>;
    performanceMetrics: {
        averageResponseTime: number;
        successRate: number;
        confidenceThreshold: number;
        learningRate: number;
    };
    optimizationStrategies: Array<{
        name: string;
        description: string;
        successRate: number;
        implementation: string;
    }>;
}
export interface ParallelProcessingConfig {
    maxWorkers: number;
    chunkSize: number;
    timeout: number;
    retryAttempts: number;
    fallbackStrategy: string;
}
export interface AdvancedCachingSystem {
    memoryCache: Map<string, {
        result: AdvancedMLResult;
        timestamp: number;
        accessCount: number;
        ttl: number;
    }>;
    persistentCache: {
        storage: 'localStorage' | 'sessionStorage' | 'indexedDB';
        maxSize: number;
        compression: boolean;
    };
    cacheStrategies: {
        lru: boolean;
        ttl: number;
        maxEntries: number;
        compression: boolean;
    };
}
export interface MachineLearningModels {
    supportVectorMachine: {
        kernel: 'linear' | 'rbf' | 'poly' | 'sigmoid';
        C: number;
        gamma: 'scale' | 'auto' | number;
        degree: number;
        coef0: number;
        trained: boolean;
        supportVectors: number[][];
        dualCoefficients: number[][];
        intercept: number;
    };
    randomForest: {
        nEstimators: number;
        maxDepth: number;
        minSamplesSplit: number;
        minSamplesLeaf: number;
        maxFeatures: 'sqrt' | 'log2' | number;
        bootstrap: boolean;
        trained: boolean;
        trees: Array<{
            nodes: Array<{
                feature: number;
                threshold: number;
                left: number;
                right: number;
                value: number;
            }>;
        }>;
    };
    gradientBoosting: {
        nEstimators: number;
        learningRate: number;
        maxDepth: number;
        subsample: number;
        trained: boolean;
        estimators: Array<{
            features: number[];
            thresholds: number[];
            values: number[];
        }>;
    };
    naiveBayes: {
        type: 'gaussian' | 'multinomial' | 'bernoulli';
        trained: boolean;
        classCounts: Record<string, number>;
        featureCounts: Record<string, Record<string, number>>;
        classPriors: Record<string, number>;
    };
    kNearestNeighbors: {
        nNeighbors: number;
        weights: 'uniform' | 'distance';
        algorithm: 'auto' | 'ball_tree' | 'kd_tree' | 'brute';
        leafSize: number;
        trained: boolean;
        trainingData: Array<{
            features: number[];
            label: number;
        }>;
    };
}
export interface NaturalLanguageProcessing {
    tokenization: {
        method: 'word' | 'subword' | 'character';
        vocabulary: Set<string>;
        maxLength: number;
        padding: 'pre' | 'post';
        truncation: 'pre' | 'post';
    };
    embeddings: {
        type: 'word2vec' | 'glove' | 'fasttext' | 'bert';
        dimensions: number;
        vocabulary: Record<string, number[]>;
        unknownToken: string;
    };
    languageModel: {
        type: 'transformer' | 'lstm' | 'gru';
        layers: number;
        hiddenSize: number;
        attentionHeads: number;
        dropout: number;
        trained: boolean;
    };
    semanticAnalysis: {
        similarityMetrics: Array<'cosine' | 'euclidean' | 'manhattan' | 'jaccard'>;
        clustering: {
            method: 'kmeans' | 'dbscan' | 'hierarchical';
            nClusters: number;
            minSamples: number;
        };
        topicModeling: {
            method: 'lda' | 'nmf' | 'lsa';
            nTopics: number;
            maxIterations: number;
        };
    };
}
export interface ComputerVisionFeatures {
    imageProcessing: {
        filters: Array<{
            type: 'gaussian' | 'sobel' | 'canny' | 'laplacian';
            kernelSize: number;
            sigma: number;
        }>;
        transformations: Array<{
            type: 'resize' | 'rotate' | 'flip' | 'crop';
            parameters: Record<string, any>;
        }>;
        colorSpaces: Array<'rgb' | 'hsv' | 'lab' | 'grayscale'>;
    };
    featureExtraction: {
        methods: Array<'sift' | 'surf' | 'orb' | 'brisk'>;
        descriptors: Array<{
            type: 'hog' | 'lbp' | 'gabor';
            parameters: Record<string, any>;
        }>;
        keypoints: Array<{
            x: number;
            y: number;
            response: number;
            angle: number;
            octave: number;
        }>;
    };
    objectDetection: {
        model: 'yolo' | 'ssd' | 'faster_rcnn';
        confidence: number;
        nmsThreshold: number;
        anchors: number[][];
        classes: string[];
    };
    opticalCharacterRecognition: {
        engine: 'tesseract' | 'easyocr' | 'paddleocr';
        languages: string[];
        confidence: number;
        preprocessing: Array<{
            type: 'threshold' | 'morphology' | 'noise_removal';
            parameters: Record<string, any>;
        }>;
    };
}
export interface EnsembleMethods {
    voting: {
        type: 'hard' | 'soft';
        weights: number[];
        models: string[];
    };
    stacking: {
        baseModels: string[];
        metaModel: string;
        crossValidation: number;
    };
    bagging: {
        nEstimators: number;
        maxSamples: number;
        maxFeatures: number;
        bootstrap: boolean;
    };
    boosting: {
        type: 'adaboost' | 'gradient' | 'xgboost';
        nEstimators: number;
        learningRate: number;
        maxDepth: number;
    };
}
export interface RealTimeLearning {
    onlineLearning: {
        enabled: boolean;
        batchSize: number;
        updateFrequency: number;
        forgettingFactor: number;
    };
    incrementalLearning: {
        enabled: boolean;
        memorySize: number;
        importanceSampling: boolean;
        conceptDrift: {
            detection: boolean;
            threshold: number;
            windowSize: number;
        };
    };
    activeLearning: {
        enabled: boolean;
        queryStrategy: 'uncertainty' | 'diversity' | 'random';
        budget: number;
        uncertaintyMetrics: Array<'entropy' | 'margin' | 'least_confidence'>;
    };
    reinforcementLearning: {
        enabled: boolean;
        algorithm: 'q_learning' | 'sarsa' | 'actor_critic';
        stateSpace: number;
        actionSpace: number;
        learningRate: number;
        discountFactor: number;
        epsilon: number;
    };
}
export interface HealingAction {
    action: 'click' | 'fill' | 'type' | 'select' | 'hover' | 'focus' | 'scroll';
    value?: string;
    options?: {
        timeout?: number;
        force?: boolean;
        noWaitAfter?: boolean;
        trial?: boolean;
    };
}
export interface HealingOptions {
    timeout?: number;
    retries?: number;
    confidence?: number;
    fallback?: boolean;
    analytics?: boolean;
    caching?: boolean;
}
//# sourceMappingURL=types.d.ts.map