@silasfmartins/testhub 1.0.0

package/dist/src/utils/testRecovery/TestRecoveryClient.d.ts

@@ -0,0 +1,801 @@
+export type ErrorType = "not_found" | "multiple_elements" | "timeout" | "wrong_navigation" | "stale_element";
+export type ActionType = "click" | "fill" | "select" | "hover" | "check" | "uncheck" | "press" | "wait" | "navigate" | "doubleClick";
+/** Origem da execução (v2.6.9) */
+export type ExecutionSource = "LOCAL" | "AZURE";
+/** Origem da correção (v2.6.9) */
+export type RecoverySource = "framework" | "manual" | "auto_code";
+/** Lista de actionTypes válidos para validação */
+export declare const VALID_ACTION_TYPES: ActionType[];
+/**
+ * Mapeamento de nomes de métodos WebActions para actionTypes do Test Recovery
+ * Usado para normalizar o actionType quando vem do wrapper automático
+ */
+export declare const METHOD_TO_ACTION_TYPE: Record<string, ActionType>;
+/**
+ * Converte nome de método WebActions para actionType do Test Recovery
+ * @param methodName Nome do método (ex: 'setText', 'click', 'waitForVisible')
+ * @returns ActionType normalizado
+ */
+export declare function methodToActionType(methodName: string): ActionType;
+/** Lista de errorTypes válidos para validação */
+export declare const VALID_ERROR_TYPES: ErrorType[];
+/**
+ * Valida se um actionType é válido
+ */
+export declare function isValidActionType(action: string | undefined | null): action is ActionType;
+/**
+ * Valida se um errorType é válido
+ */
+export declare function isValidErrorType(error: string | undefined | null): error is ErrorType;
+/**
+ * Infere o actionType baseado no contexto do XPath ou elemento
+ * Útil quando o actionType não é fornecido explicitamente
+ */
+export declare function inferActionType(xpath: string, context?: Record<string, unknown>): ActionType;
+/** Elemento de página capturado */
+export interface PageElement {
+    tag?: string;
+    text?: string;
+    id?: string;
+    className?: string;
+    name?: string;
+    type?: string;
+    href?: string;
+    placeholder?: string;
+    ariaLabel?: string;
+    dataTestId?: string;
+    role?: string;
+    xpath?: string;
+    title?: string;
+}
+/**
+ * Contexto adicional para análise de falha (v2.6.0+)
+ * Usado para melhorar a sugestão de XPath em formulários sequenciais
+ */
+export interface RecoveryContext {
+    /** Valor que estava tentando preencher (para fill) */
+    value?: string;
+    /** Método original que foi chamado (ex: fill, click) */
+    originalMethod?: string;
+    /** Lista de XPaths de inputs que JÁ FORAM PREENCHIDOS COM SUCESSO */
+    filledInputs?: string[];
+    /** Lista de IDs/names de campos que JÁ FORAM PREENCHIDOS COM SUCESSO */
+    filledFields?: string[];
+    /** Texto visível do elemento */
+    text?: string;
+    /** Papel ARIA do elemento */
+    role?: string;
+    /** Label ARIA */
+    ariaLabel?: string;
+    /** Tipo do elemento (text, password, etc) */
+    type?: string;
+    /** Elementos próximos (para contexto) */
+    nearbyElements?: string[];
+    /**
+     * Aliases do seletor original (v2.7.44 - item 14)
+     * Permite preservar o XPath original para fill de username/login.
+     * Backend usa para heurística de alias (ex: user -> username).
+     */
+    selectorAliases?: {
+        selector?: string;
+        ref?: string;
+        xpath?: string;
+    };
+    /** Nome do arquivo Page Object do chamador (item 20 v2.7.44) */
+    pageFileName?: string;
+    /** Nome legível da página (item 20 v2.7.44) */
+    pageName?: string;
+    /** Nome da classe Page Object (item 20 v2.7.44) */
+    pageObjectName?: string;
+}
+export interface RecoveryRequest {
+    url: string;
+    failedXPath: string;
+    errorType: ErrorType;
+    actionType: ActionType;
+    sessionId?: string;
+    systemName?: string;
+    environment?: string;
+    expectedUrl?: string;
+    actualUrl?: string;
+    /** Origem da execução (v2.6.9) - LOCAL ou AZURE */
+    executionSource?: ExecutionSource;
+    /** Origem da correção (v2.6.9) - framework, manual ou auto_code */
+    recoverySource?: RecoverySource;
+    /** Nome do teste/cenário - CN (v2.6.9) */
+    testCaseName?: string;
+    /** ID do caso de teste - CT (v2.6.9) */
+    testCaseId?: string;
+    /** Nome do método que falhou (v2.6.9) */
+    testMethodName?: string;
+    /** Contexto adicional para análise (v2.6.0+) */
+    context?: RecoveryContext;
+    /** Estrutura capturada localmente via MCP (extract_page_structure/playwright_execute) */
+    pageStructure?: {
+        title?: string;
+        url?: string;
+        buttons?: PageElement[];
+        inputs?: PageElement[];
+        links?: PageElement[];
+        elements?: PageElement[];
+        headings?: PageElement[];
+    };
+    /** HTML capturado localmente se preferir enviar HTML bruto */
+    pageHtml?: string;
+    screenshot?: string;
+    /**
+     * Objeto estruturado do ator/executor real (item 23 v2.7.44).
+     * Permite dashboard exibir nome real (não PlaywrightFrame).
+     * Valores vêm de UserHeaders ou de env vars.
+     */
+    actor?: {
+        id?: string;
+        name?: string;
+        email?: string;
+        matricula?: string;
+    };
+}
+export interface RecoveryResponse {
+    success: boolean;
+    /** ID do log de recovery (v2.7.43) - priorizar no report-result */
+    logId?: string;
+    analysis: {
+        suggestedXPath: string;
+        confidence: number;
+        reason?: string;
+        alternatives?: string[];
+        pageChanged?: boolean;
+        elementCount?: number;
+        /** Indica se auto-fix local está disponível (v2.7.1) - true quando confidence >= 0.7 E executionSource=LOCAL */
+        autoFixAvailable?: boolean;
+    };
+    actions?: Array<{
+        type: "wait" | "click_other" | "navigate" | "refresh" | "switch_frame";
+        selector?: string;
+        url?: string;
+        waitMs?: number;
+        reason?: string;
+    }>;
+    /** Indica resposta enfileirada (202) - v2.7.43 */
+    queued?: boolean;
+    requestId?: string;
+    position?: number;
+    metadata?: {
+        pageTitle?: string;
+        pageStructureHash?: string;
+        timestamp?: string;
+        systemId?: string;
+        environmentId?: string;
+    };
+}
+export interface FixInCodeRequest {
+    url?: string;
+    failedXPath: string;
+    newXPath: string;
+    errorType?: ErrorType;
+    actionType?: ActionType;
+    projectRoot: string;
+    attributesFile?: string;
+    locatorProperty?: string;
+    systemName?: string;
+    autoConfirm?: boolean;
+}
+export interface FixInCodeResponse {
+    success: boolean;
+    fileUpdated: boolean;
+    filePath?: string;
+    changes?: {
+        oldXPath: string;
+        newXPath: string;
+        property?: string;
+        lineNumber?: number;
+    };
+}
+/**
+ * Request para Auto-Fix Local (v2.7.1)
+ * Permite aplicar correção de XPath diretamente nos arquivos do projeto
+ */
+export interface AutoFixLocalRequest {
+    /** Raiz do projeto (caminho absoluto) */
+    projectRoot: string;
+    /** XPath antigo que falhou */
+    oldXPath: string;
+    /** Novo XPath sugerido pelo Test Recovery */
+    newXPath: string;
+    /** Confiança do novo XPath (0-1) */
+    confidence: number;
+    /** Arquivo de teste (ex: LoginTest.spec.ts) - usado para inferir Attributes automaticamente */
+    testFilePath?: string;
+    /** Arquivo de Attributes específico (opcional) */
+    attributesFile?: string;
+    /** Nome da classe/Page onde o XPath está (opcional) */
+    className?: string;
+    /** Nome da propriedade/getter do locator (opcional) */
+    locatorProperty?: string;
+    /** Nome do método que falhou (para audit) */
+    methodName?: string;
+    /** Número da linha onde ocorreu a falha (para audit) */
+    lineNumber?: number;
+    /** Session ID do recovery (para correlacionar com logs) */
+    recoverySessionId?: string;
+    /** Nome do sistema (opcional, para contexto) */
+    systemName?: string;
+    /** Ambiente onde ocorreu a falha (opcional) */
+    environmentType?: string;
+    /** Se true, aplica a correção sem confirmação */
+    autoConfirm?: boolean;
+    /** Origem da execução - sempre 'Local' para auto-fix */
+    executionSource?: "Local";
+}
+/**
+ * Response do Auto-Fix Local (v2.7.1)
+ */
+export interface AutoFixLocalResponse {
+    success: boolean;
+    message: string;
+    fix?: {
+        /** Arquivo que foi modificado */
+        filePath: string;
+        /** XPath antigo substituído */
+        oldXPath: string;
+        /** Novo XPath aplicado */
+        newXPath: string;
+        /** Número da linha onde a alteração foi feita */
+        lineNumber?: number;
+        /** Nome da propriedade/getter modificado */
+        property?: string;
+        /** Backup do arquivo original criado? */
+        backupCreated?: boolean;
+    };
+    /** Motivo da falha (quando success=false) */
+    error?: string;
+}
+/**
+ * Metadados de recovery obtidos do ambiente/contexto (v2.7.43)
+ * Usado para enriquecer payloads de analyzeFailure, reportResult e autoFixLocal
+ */
+export interface RecoveryMetadata {
+    executionSource: ExecutionSource;
+    testCaseName?: string;
+    testCaseId?: string;
+    testMethodName?: string;
+}
+/**
+ * Obtém metadados de recovery a partir de variáveis de ambiente e TestContext (v2.7.43)
+ * - executionSource: detecta automaticamente LOCAL vs AZURE
+ * - testCaseName/testCaseId/testMethodName: obtém do TestContext.testInfo quando disponível
+ */
+export declare function getRecoveryMetadata(): RecoveryMetadata;
+/** Problema detectado em um XPath */
+export interface XPathProblem {
+    type: "dynamic_id" | "deep_xpath" | "index_based" | "shallow_attributes" | "literal_text" | "dynamic_classes";
+    weight: number;
+    description: string;
+}
+/** Falha recorrente detectada pelo Auto-Healing */
+export interface RecurringFailure {
+    xpath: string;
+    occurrences: number;
+    failureRate: number;
+    riskScore: number;
+    problems: XPathProblem[];
+    lastFailure?: string;
+    firstFailure?: string;
+    affectedTests: number;
+}
+/** Resposta de falhas recorrentes */
+export interface RecurringFailuresResponse {
+    failures: RecurringFailure[];
+    total: number;
+}
+/** Sugestão de refatoração */
+export interface RefactorSuggestion {
+    newXPath: string;
+    confidence: number;
+    effort: "low" | "medium" | "high";
+    justification: string;
+    affectedElements: number;
+}
+/** Resposta de sugestão de refatoração */
+export interface SuggestRefactorResponse {
+    xpath: string;
+    suggestions: RefactorSuggestion[];
+}
+/** Análise de impacto */
+export interface ImpactAnalysisResponse {
+    xpath: string;
+    impactAnalysis: {
+        affectedTests: number;
+        successRateHistorical: number;
+        lastSuccessAt?: string;
+        lastFailureAt?: string;
+        recommendation: "refactor_now" | "monitor" | "ignore";
+        confidence: number;
+        estimatedRecoveryTime?: number;
+    };
+}
+export declare function getRecurringFailures(params?: {
+    days?: number;
+    minOccurrences?: number;
+    limit?: number;
+}): Promise<RecurringFailuresResponse | null>;
+export declare function suggestRefactor(xpath: string): Promise<SuggestRefactorResponse | null>;
+export declare function impactAnalysis(xpath: string): Promise<ImpactAnalysisResponse | null>;
+export declare function analyzeFailure(body: RecoveryRequest): Promise<RecoveryResponse | null>;
+export declare function fixInCode(payload: FixInCodeRequest): Promise<FixInCodeResponse | null>;
+export declare function markSuccess(sessionId: string, attemptNumber: number): Promise<boolean>;
+/**
+ * Requisição para reportar resultado de tentativa de recovery
+ * OBRIGATÓRIO chamar após testar XPath sugerido (v2.6.9)
+ */
+export interface ReportResultRequest {
+    /** ID do log (preferencial quando disponível) */
+    logId?: string;
+    /** ID da sessão (alternativa ao logId) */
+    sessionId?: string;
+    /** Número da tentativa (alternativa ao logId) */
+    attemptNumber?: number;
+    /** XPath testado (alternativa ao logId) */
+    xpath?: string;
+    /** Resultado da tentativa */
+    success: boolean;
+    /** Se foi corrigido automaticamente no código */
+    autoFixed?: boolean;
+    /** Origem da execução - LOCAL ou AZURE */
+    executionSource?: ExecutionSource;
+    /** Origem da correção - framework, manual ou auto_code */
+    recoverySource?: RecoverySource;
+    /** Nome do teste/cenário - CN */
+    testCaseName?: string;
+    /** ID do caso de teste - CT */
+    testCaseId?: string;
+    /** Nome do método que falhou */
+    testMethodName?: string;
+    /**
+     * Ator/executor real (item 23 v2.7.44).
+     * Enviado no body para rastreio no dashboard.
+     */
+    actor?: {
+        id?: string;
+        name?: string;
+        email?: string;
+        matricula?: string;
+    };
+}
+/**
+ * Resposta do report-result
+ */
+export interface ReportResultResponse {
+    success: boolean;
+    updated: boolean;
+    logId?: string;
+}
+/**
+ * Headers opcionais de identificação do usuário (v2.7.44)
+ * Suporta múltiplos aliases aceitos pelo backend
+ */
+export interface UserHeaders {
+    userEmail?: string;
+    userMatricula?: string;
+    userId?: string;
+    userName?: string;
+}
+/**
+ * Reporta resultado de tentativa de recovery
+ *
+ * ⚠️ OBRIGATÓRIO chamar após testar XPath sugerido (v2.6.9)
+ * Sem report-result, a tentativa fica como "pendente" no dashboard
+ *
+ * @param params Parâmetros do resultado
+ * @param user Headers opcionais de identificação do usuário
+ * @returns Resposta do servidor
+ *
+ * @example
+ * ```typescript
+ * // Após testar XPath sugerido
+ * await reportResult({
+ *   logId: result.logId,
+ *   success: true,
+ *   autoFixed: true,
+ *   executionSource: 'AZURE',
+ *   recoverySource: 'framework',
+ *   testCaseName: 'Login Test',
+ *   testCaseId: 'CT-001',
+ *   testMethodName: 'testLogin'
+ * });
+ * ```
+ */
+export declare function reportResult(params: ReportResultRequest, user?: UserHeaders): Promise<ReportResultResponse | null>;
+/**
+ * Obtém estatísticas de recuperação (Dashboard)
+ * GET /api/test-recovery/stats
+ */
+export interface RecoveryStats {
+    totalAttempts: number;
+    successfulRecoveries: number;
+    failedRecoveries: number;
+    successRate: number;
+    avgConfidence: number;
+    errorTypeDistribution: Record<ErrorType | string, number>;
+    actionTypeDistribution: Record<ActionType | string, number>;
+}
+export declare function getRecoveryStats(params?: {
+    userId?: string;
+    startDate?: string;
+    endDate?: string;
+}): Promise<RecoveryStats | null>;
+/**
+ * Verifica status da fila de processamento
+ * GET /api/test-recovery/queue/status/{requestId}
+ */
+export interface QueueStatus {
+    requestId: string;
+    status: "pending" | "processing" | "completed" | "failed" | "timeout";
+    position?: number;
+    result?: RecoveryResponse;
+    error?: string;
+}
+export declare function getQueueStatus(requestId: string): Promise<QueueStatus | null>;
+/**
+ * Log de recuperação
+ */
+export interface RecoveryLog {
+    id: string;
+    sessionId: string;
+    xpath: string;
+    suggestedXPath?: string;
+    confidence?: number;
+    success: boolean;
+    timestamp: string;
+    errorType?: ErrorType;
+    actionType?: ActionType;
+}
+/** CT individual no batch */
+export interface BatchCT {
+    name: string;
+    systemName?: string;
+    systemId?: string;
+    status: "passed" | "failed" | "skipped";
+    startTime: number;
+    startTimeFormatted?: string;
+    endTime: number;
+    endTimeFormatted?: string;
+    duration: number;
+    durationFormatted?: string;
+    error?: string;
+}
+/** Teste (CN) no batch */
+export interface BatchTest {
+    testName: string;
+    startTime: number;
+    startTimeFormatted?: string;
+    endTime: number;
+    endTimeFormatted?: string;
+    totalCTs: number;
+    passedCTs: number;
+    failedCTs: number;
+    duration: number;
+    durationFormatted?: string;
+    cts: BatchCT[];
+}
+/** Payload completo do batch de execuções */
+export interface BatchExecutionPayload {
+    systemName: string;
+    systemId?: string;
+    timestamp: string;
+    totalCTs: number;
+    passedCTs: number;
+    failedCTs: number;
+    totalDuration: number;
+    totalDurationFormatted?: string;
+    ambiente: "LOCAL" | "AZURE";
+    tests: BatchTest[];
+}
+/** Artifacts para upload */
+export interface ArtifactsPayload {
+    timestamp: string;
+    execucaoCenarioId?: string;
+    systemName?: string;
+    systemId?: string;
+    artifacts: {
+        htmlReport?: string;
+        testResults?: string;
+        traces?: string[];
+        screenshots?: string[];
+        size?: {
+            htmlReportBytes?: number;
+            testResultsBytes?: number;
+            totalBytes?: number;
+        };
+    };
+}
+/**
+ * Obtém logs de recuperação (histórico)
+ * GET /api/test-recovery/recovery-logs
+ */
+export declare function getRecoveryLogs(params?: {
+    sessionId?: string;
+    limit?: number;
+}): Promise<RecoveryLog[] | null>;
+/**
+ * Classe helper para integração com Test Recovery
+ * Gerencia o estado de campos preenchidos e facilita a análise de falhas
+ *
+ * @example
+ * ```typescript
+ * const recovery = new TestRecoveryHelper();
+ *
+ * try {
+ *   await page.locator(xpath).fill(value);
+ *   recovery.markFieldFilled(xpath, 'fieldId');
+ * } catch (error) {
+ *   const pageStructure = await recovery.extractPageStructure(page);
+ *   const result = await recovery.analyzeFailure({
+ *     url: page.url(),
+ *     failedXPath: xpath,
+ *     errorType: 'timeout',
+ *     actionType: 'fill',
+ *     pageStructure,
+ *     value,
+ *   });
+ *
+ *   if (result?.analysis.confidence >= 0.5) {
+ *     await page.locator(result.analysis.suggestedXPath).fill(value);
+ *     recovery.markFieldFilled(result.analysis.suggestedXPath);
+ *   }
+ * }
+ * ```
+ */
+export declare class TestRecoveryHelper {
+    private filledFields;
+    private filledInputs;
+    private sessionId;
+    private userHeaders;
+    private projectRoot;
+    /**
+     * Cria uma instância do TestRecoveryHelper
+     *
+     * @param sessionId ID da sessão para correlacionar requisições
+     * @param user Headers de identificação do usuário
+     * @param projectRoot Caminho absoluto do projeto (para auto-fix local)
+     */
+    constructor(sessionId?: string, user?: UserHeaders, projectRoot?: string);
+    /**
+     * Define o projectRoot para auto-fix local (v2.7.1)
+     */
+    setProjectRoot(projectRoot: string): void;
+    /**
+     * Obtém o projectRoot atual
+     */
+    getProjectRoot(): string | undefined;
+    /**
+     * Define o sessionId para manter contexto entre requisições
+     */
+    setSessionId(sessionId: string): void;
+    /**
+     * Obtém o sessionId atual
+     */
+    getSessionId(): string | undefined;
+    /**
+     * Define headers de identificação do usuário (v2.6.9)
+     * Também atualiza headers globais para chamadas do framework
+     */
+    setUserHeaders(user: UserHeaders): void;
+    /**
+     * Analisa falha e retorna XPath corrigido
+     * Envia automaticamente o contexto de campos já preenchidos
+     *
+     * @param params Parâmetros da análise (v2.6.9: inclui executionSource, recoverySource, testCase*)
+     */
+    analyzeFailure(params: {
+        url: string;
+        failedXPath: string;
+        errorType: ErrorType;
+        actionType: ActionType;
+        pageStructure?: RecoveryRequest["pageStructure"];
+        pageHtml?: string;
+        value?: string;
+        systemName?: string;
+        environment?: string;
+        /** Origem da execução (v2.6.9) - LOCAL ou AZURE */
+        executionSource?: ExecutionSource;
+        /** Origem da correção (v2.6.9) - framework, manual ou auto_code */
+        recoverySource?: RecoverySource;
+        /** Nome do teste/cenário - CN (v2.6.9) */
+        testCaseName?: string;
+        /** ID do caso de teste - CT (v2.6.9) */
+        testCaseId?: string;
+        /** Nome do método que falhou (v2.6.9) */
+        testMethodName?: string;
+    }): Promise<RecoveryResponse | null>;
+    /**
+     * Reporta resultado de tentativa de recovery
+     *
+     * ⚠️ OBRIGATÓRIO chamar após testar XPath sugerido (v2.6.9)
+     * Sem report-result, a tentativa fica como "pendente" no dashboard
+     *
+     * @param params Parâmetros do resultado
+     * @returns Resposta do servidor
+     */
+    reportResult(params: {
+        /** ID do log (preferencial) */
+        logId?: string;
+        /** Número da tentativa (alternativa ao logId) */
+        attemptNumber?: number;
+        /** XPath testado (alternativa ao logId) */
+        xpath?: string;
+        /** Resultado da tentativa */
+        success: boolean;
+        /** Se foi corrigido automaticamente no código */
+        autoFixed?: boolean;
+        /** Origem da execução - LOCAL ou AZURE */
+        executionSource?: ExecutionSource;
+        /** Origem da correção - framework, manual ou auto_code */
+        recoverySource?: RecoverySource;
+        /** Nome do teste/cenário - CN */
+        testCaseName?: string;
+        /** ID do caso de teste - CT */
+        testCaseId?: string;
+        /** Nome do método que falhou */
+        testMethodName?: string;
+    }): Promise<ReportResultResponse | null>;
+    /**
+     * Marca campo como preenchido com sucesso
+     * Deve ser chamado após cada preenchimento bem-sucedido
+     *
+     * @param xpath XPath do elemento preenchido
+     * @param fieldId ID ou name do campo (opcional, melhora a análise)
+     */
+    markFieldFilled(xpath: string, fieldId?: string): void;
+    /**
+     * Remove um campo da lista de preenchidos
+     * Útil quando um campo é limpo ou precisa ser repreenchido
+     */
+    unmarkFieldFilled(xpath: string, fieldId?: string): void;
+    /**
+     * Limpa histórico de campos preenchidos
+     * Deve ser chamado no início de cada novo teste ou ao mudar de página
+     */
+    clearFilledFields(): void;
+    /**
+     * Obtém lista de XPaths preenchidos
+     */
+    getFilledInputs(): string[];
+    /**
+     * Obtém lista de IDs/names preenchidos
+     */
+    getFilledFields(): string[];
+    /**
+     * Extrai estrutura da página usando Playwright Page
+     * Retorna objeto pronto para enviar ao Test Recovery
+     *
+     * @param page Instância de Page do Playwright
+     * @returns Estrutura da página com inputs, buttons, links e headings
+     */
+    extractPageStructure(page: {
+        evaluate: <T>(fn: () => T) => Promise<T>;
+        url: () => string;
+        title: () => Promise<string>;
+    }): Promise<RecoveryRequest["pageStructure"]>;
+    /**
+     * Extrai ID ou name de um XPath sugerido
+     * Útil para marcar campo como preenchido após recovery
+     *
+     * @param xpath XPath para extrair o identificador
+     * @returns ID ou name encontrado, ou undefined
+     */
+    extractFieldIdFromXPath(xpath: string): string | undefined;
+    /**
+     * Helper para executar ação com recovery automático
+     * Se a ação falhar, tenta recuperar usando Test Recovery
+     *
+     * @param params Parâmetros da ação (v2.6.9: inclui executionSource, testCase*)
+     * @returns Resultado da ação com informações de recovery
+     */
+    executeWithRecovery(params: {
+        page: {
+            locator: (selector: string) => {
+                fill: (value: string, options?: {
+                    timeout?: number;
+                }) => Promise<void>;
+                click: (options?: {
+                    timeout?: number;
+                }) => Promise<void>;
+            };
+            url: () => string;
+            evaluate: <T>(fn: () => T) => Promise<T>;
+            title: () => Promise<string>;
+        };
+        xpath: string;
+        actionType: "fill" | "click";
+        value?: string;
+        timeout?: number;
+        minConfidence?: number;
+        systemName?: string;
+        environment?: string;
+        /** Origem da execução (v2.6.9) - LOCAL ou AZURE */
+        executionSource?: ExecutionSource;
+        /** Nome do teste/cenário - CN (v2.6.9) */
+        testCaseName?: string;
+        /** ID do caso de teste - CT (v2.6.9) */
+        testCaseId?: string;
+        /** Nome do método que falhou (v2.6.9) */
+        testMethodName?: string;
+    }): Promise<{
+        success: boolean;
+        usedXPath: string;
+        wasRecovered: boolean;
+    }>;
+    /**
+     * Aplica correção de XPath automaticamente nos arquivos do projeto (v2.7.1)
+     *
+     * ⚠️ Requisitos:
+     * - executionSource deve ser 'LOCAL' (não funciona em Azure/CI)
+     * - confidence deve ser >= 0.7 (segurança)
+     * - projectRoot deve ser válido e acessível
+     *
+     * @param params Parâmetros para auto-fix local
+     * @returns Resultado da operação com detalhes da correção
+     *
+     * @example
+     * ```typescript
+     * const recovery = new TestRecoveryHelper();
+     *
+     * // Após analyzeFailure retornar autoFixAvailable=true
+     * const result = await recovery.autoFixLocal({
+     *   projectRoot: '/home/user/projeto',
+     *   oldXPath: '//input[@id="email"]',
+     *   newXPath: '//input[@data-testid="email-input"]',
+     *   confidence: 0.85,
+     *   attributesFile: 'AttributesLogin.ts'
+     * });
+     *
+     * if (result.success) {
+     *   console.log(`Arquivo corrigido: ${result.fix?.filePath}`);
+     * }
+     * ```
+     */
+    autoFixLocal(params: {
+        /** Raiz do projeto (caminho absoluto) - usa this.projectRoot se não informado */
+        projectRoot?: string;
+        /** XPath antigo que falhou */
+        oldXPath: string;
+        /** Novo XPath sugerido pelo Test Recovery */
+        newXPath: string;
+        /** Confiança do novo XPath (0-1) - mínimo 0.7 */
+        confidence: number;
+        /** Arquivo de teste (ex: LoginTest.spec.ts) - usado para inferir Attributes */
+        testFilePath?: string;
+        /** Arquivo de Attributes específico (opcional) */
+        attributesFile?: string;
+        /** Nome da classe onde o XPath está (opcional) */
+        className?: string;
+        /** Nome da propriedade/getter do locator (opcional) */
+        locatorProperty?: string;
+        /** Nome do método que falhou (para audit) */
+        methodName?: string;
+        /** Número da linha onde ocorreu a falha (para audit) */
+        lineNumber?: number;
+        /** Nome do sistema (opcional) */
+        systemName?: string;
+        /** Ambiente (opcional) */
+        environmentType?: string;
+        /** Se true, aplica sem confirmação (default: true em framework) */
+        autoConfirm?: boolean;
+        /** Origem da execução - 'Local' para auto-fix (v2.7.44) */
+        executionSource?: "Local";
+    }): Promise<AutoFixLocalResponse>;
+}
+/**
+ * Instância singleton do TestRecoveryHelper
+ * Use para casos simples sem necessidade de múltiplas instâncias
+ *
+ * @example
+ * ```typescript
+ * import { testRecoveryHelper } from '@silasfmartins/testhub';
+ *
+ * testRecoveryHelper.markFieldFilled(xpath, 'username');
+ * const result = await testRecoveryHelper.analyzeFailure({ ... });
+ * ```
+ */
+export declare const testRecoveryHelper: TestRecoveryHelper;