@silasfmartins/testhub 1.0.0

package/dist/src/testhub/SystemsManager.js

@@ -0,0 +1,365 @@
+/**
+ * SystemsManager: Gerenciador de sistemas com IntelliSense dinâmico
+ * Busca sistemas do backend e cria enum dinâmico para autocomplete
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { Logger } from '../utils/Logger.js';
+import { TestHubClient, } from './TestHubClient.js';
+/**
+ * Gerenciador de sistemas com suporte a IntelliSense
+ */
+export class SystemsManager {
+    static instance;
+    client;
+    selectedSystem = null;
+    systemsLoaded = false;
+    systems = [];
+    constructor() {
+        this.client = TestHubClient.getInstance();
+    }
+    /**
+     * Obtém instância singleton
+     */
+    static getInstance() {
+        if (!SystemsManager.instance) {
+            SystemsManager.instance = new SystemsManager();
+        }
+        return SystemsManager.instance;
+    }
+    /**
+     * 🚀 Inicializa o gerenciador e busca sistemas do backend
+     */
+    async initialize() {
+        if (this.systemsLoaded) {
+            return;
+        }
+        try {
+            this.systems = await this.client.getSystems();
+            this.systemsLoaded = true;
+            if (this.systems.length > 0) {
+                await this.generateSystemsEnum();
+            }
+            else {
+                Logger.warning('⚠️ Nenhum sistema encontrado no AutoCore Hub');
+            }
+        }
+        catch (error) {
+            Logger.error(`❌ Erro ao inicializar SystemsManager: ${error}`);
+            this.systemsLoaded = false;
+        }
+    }
+    /**
+     * 📝 Gera arquivo TypeScript com enum Systems para IntelliSense
+     *
+     * ESTRATÉGIA: Salva enum em .rbqa/SystemsEnum.ts no projeto consumidor
+     * para que possa ser importado sem modificar source files do framework
+     */
+    async generateSystemsEnum() {
+        try {
+            // Gerar conteúdo do enum
+            const enumContent = this.generateEnumContent();
+            // 🎯 Salvar em .rbqa/SystemsEnum.ts no projeto consumidor
+            const projectRoot = process.cwd();
+            const rbqaDir = path.join(projectRoot, '.rbqa');
+            const enumFilePath = path.join(rbqaDir, 'SystemsEnum.ts');
+            // Criar diretório .rbqa se não existir
+            if (!fs.existsSync(rbqaDir)) {
+                fs.mkdirSync(rbqaDir, { recursive: true });
+            }
+            // Salvar arquivo TypeScript
+            fs.writeFileSync(enumFilePath, enumContent.typescript);
+        }
+        catch (error) {
+            Logger.warning(`⚠️ Erro ao gerar enum de sistemas: ${error}`);
+        }
+    } /**
+     * Gera conteúdo do enum TypeScript
+     */
+    generateEnumContent() {
+        // Gerar lista de sistemas para documentação
+        const sistemasDisponiveis = this.systems.length > 0
+            ? this.systems
+                .map((s) => ` * - ${this.sanitizeEnumKey(s.name)}: ${s.description || s.name}`)
+                .join('\n')
+            : ' * (Nenhum sistema cadastrado ainda)';
+        const tsContent = `/**
+ * 🌐 Enum de Sistemas do AutoCore Hub
+ * 
+ * Este arquivo é gerado automaticamente quando você executa o teste pela primeira vez.
+ * NÃO EDITE MANUALMENTE - será sobrescrito na próxima execução.
+ * 
+ * 📅 Última atualização: ${new Date().toLocaleString('pt-BR')}
+ * 🔗 AutoCore Hub: http://brtlvlty0559pl:3333
+ * 📊 Total de sistemas: ${this.systems.length}
+ * 
+ * 💡 USO:
+ * \`\`\`typescript
+ * import { Systems } from "../.rbqa/SystemsEnum"
+ * import { TestAnnotations } from "@silasfmartins/testhub"
+ * 
+ * test("CT001", async ({}, testInfo) => {
+ *   TestAnnotations.Api.testInfo = testInfo
+ *   await TestAnnotations.setSystem(Systems.NOME_SISTEMA)
+ * })
+ * \`\`\`
+ * 
+ * 🎯 SISTEMAS DISPONÍVEIS:
+${sistemasDisponiveis}
+ */
+
+export enum Systems {
+${this.systems.length > 0
+            ? this.systems
+                .map((system) => {
+                const enumKey = this.sanitizeEnumKey(system.name);
+                const description = system.description || system.name;
+                return `  /**\n   * ${description}\n   * Nome original: "${system.name}"\n   */\n  ${enumKey} = "${system.name}"`;
+            })
+                .join(',\n\n')
+            : '  // Nenhum sistema cadastrado no AutoCore Hub ainda\n  // Execute o teste novamente após cadastrar sistemas'}
+}
+
+export default Systems
+`;
+        return { typescript: tsContent };
+    }
+    /**
+     * Sanitiza nome do sistema para usar como chave de enum
+     * IMPORTANTE: Preserva o formato original se já for válido (ex: AUTENTICA_IN_HML)
+     */
+    sanitizeEnumKey(systemName) {
+        // Se o nome já está em UPPERCASE com underscores válidos, mantém como está
+        if (/^[A-Z0-9_]+$/.test(systemName)) {
+            return systemName;
+        }
+        // Caso contrário, converte
+        return systemName
+            .toUpperCase()
+            .replace(/[^A-Z0-9_]/g, '_')
+            .replace(/_{2,}/g, '_')
+            .replace(/^_|_$/g, '');
+    }
+    /**
+     * 🎯 Seleciona um sistema para uso nos testes
+     * @param systemName Nome do sistema
+     * @param environmentName Nome do ambiente (ex: 'preprod', 'esteira1')
+     * @param projectType Tipo de projeto (API, Frontend, etc) para filtrar ambientes
+     */
+    async selectSystem(systemName, environmentName, projectType) {
+        if (!this.systemsLoaded) {
+            await this.initialize();
+        }
+        // Buscar sistema
+        const system = await this.client.getSystemByName(systemName);
+        if (!system) {
+            throw new Error(`❌ Sistema "${systemName}" não encontrado no TestHub. Sistemas disponíveis: ${this.systems.map((s) => s.name).join(', ')}`);
+        }
+        // Determinar ambiente (usar NODE_ENV ou ENV)
+        const envName = environmentName || process.env.NODE_ENV || process.env.ENV || 'preprod';
+        Logger.info(`🔍 Buscando ambiente: "${envName}" (NODE_ENV: ${process.env.NODE_ENV}, ENV: ${process.env.ENV})`);
+        // ⚠️ NOTA: O backend não retorna o tipo do sistema (API, WEB, SSH, etc.)
+        // Portanto, NÃO filtramos por tipo - todos os ambientes estão disponíveis
+        // O tipo é usado apenas para informação, não para validação
+        let availableEnvironments = system.environments;
+        if (projectType) {
+            // Log informativo apenas - não filtra mais por tipo
+            Logger.info(`   📌 Tipo de projeto: ${projectType}`);
+        }
+        availableEnvironments.forEach((env) => {
+            Logger.info(`   - ${env.name}: ${env.url ? '***' : '(sem URL)'}`);
+        });
+        // Buscar ambiente específico pelo NOME (case-insensitive)
+        let environment = availableEnvironments.find((env) => env.name.toLowerCase() === envName.toLowerCase());
+        // Se não encontrou, pegar o primeiro ambiente disponível
+        if (!environment) {
+            environment = availableEnvironments[0];
+            Logger.warning(`⚠️ Ambiente "${envName}" não encontrado. Usando: ${environment.name}`);
+        }
+        this.selectedSystem = {
+            name: systemName,
+            system,
+            environment,
+            environmentName: environment.name,
+        };
+        return this.selectedSystem;
+    }
+    /**
+     * Obtém sistema selecionado atual
+     */
+    getSelectedSystem() {
+        return this.selectedSystem;
+    }
+    /**
+     * Verifica se um sistema foi selecionado
+     */
+    hasSystemSelected() {
+        return this.selectedSystem !== null;
+    }
+    /**
+     * Valida se sistema foi selecionado (lança erro se não)
+     */
+    validateSystemSelected() {
+        if (!this.hasSystemSelected()) {
+            throw new Error(`
+❌ SISTEMA NÃO CONFIGURADO
+
+Você precisa selecionar um sistema antes de executar os testes.
+
+Adicione no início do seu teste:
+
+import { Systems, TestAnnotations } from '@silasfmartins/testhub'
+
+test.describe("Meu Cenário", () => {
+  test("Meu Teste", async ({}, testInfo) => {
+    TestAnnotations.Api.testInfo = testInfo
+    TestAnnotations.setSystem(Systems.NOME_DO_SISTEMA) // 👈 OBRIGATÓRIO
+    
+    // ... seu teste aqui
+  })
+})
+
+Sistemas disponíveis: ${this.systems.map((s) => s.name).join(', ')}
+      `);
+        }
+    }
+    /**
+     * Lista todos os sistemas disponíveis
+     */
+    async listSystems() {
+        if (!this.systemsLoaded) {
+            await this.initialize();
+        }
+        return this.systems;
+    }
+    /**
+     * Lista sistemas por tipo
+     */
+    async listSystemsByType(type) {
+        if (!this.systemsLoaded) {
+            await this.initialize();
+        }
+        return this.systems.filter((system) => system.environments.some((env) => env.type === type));
+    }
+    /**
+     * Limpa seleção atual
+     */
+    clearSelection() {
+        this.selectedSystem = null;
+    }
+    /**
+     * Recarrega sistemas do backend (força atualização)
+     */
+    async reload() {
+        this.client.clearCache();
+        this.systemsLoaded = false;
+        await this.initialize();
+    }
+    /**
+     * Obtém configuração do sistema selecionado (para injeção automática)
+     */
+    getSystemConfig() {
+        if (!this.selectedSystem) {
+            return null;
+        }
+        const env = this.selectedSystem.environment;
+        return {
+            baseUrl: env.url,
+            username: env.username,
+            password: env.password,
+            host: env.url.replace(/^https?:\/\//, ''), // Remove protocolo para SSH/Banco
+            port: env.port,
+            serviceName: env.serviceName,
+            privateKeyPath: env.privateKeyPath,
+        };
+    }
+}
+/**
+ * 🌐 Enum Systems com Lazy Loading
+ *
+ * Este enum é populado dinamicamente quando você usa TestAnnotations.setSystem()
+ * pela primeira vez. Ele carrega os sistemas do AutoCore Hub automaticamente.
+ *
+ * ✅ USO RECOMENDADO:
+ *
+ * import { TestAnnotations, Systems } from "@silasfmartins/testhub"
+ *
+ * test("Meu teste", async ({}, testInfo) => {
+ *   TestAnnotations.Api.testInfo = testInfo
+ *
+ *   // Opção 1: String direta (sempre funciona)
+ *   await TestAnnotations.setSystem("AUTENTICA_IN_HML")
+ *
+ *   // Opção 2: Enum (após primeira execução)
+ *   await TestAnnotations.setSystem(Systems.AUTENTICA_IN_HML)
+ * })
+ *
+ * 💡 O enum Systems é populado automaticamente na primeira chamada de setSystem()
+ */
+// Proxy que carrega sistemas dinamicamente
+export const Systems = new Proxy({}, {
+    get(target, prop) {
+        // Se já existe no cache, retorna
+        if (prop in target) {
+            return target[prop];
+        }
+        // Se é uma propriedade especial do JavaScript, retorna undefined
+        if (typeof prop === 'symbol' ||
+            prop === 'then' ||
+            prop === 'constructor' ||
+            prop === 'prototype') {
+            return undefined;
+        }
+        // Tentar carregar do enum gerado
+        try {
+            const projectRoot = process.cwd();
+            const enumFilePath = path.join(projectRoot, '.rbqa', 'SystemsEnum.ts');
+            if (fs.existsSync(enumFilePath)) {
+                const content = fs.readFileSync(enumFilePath, 'utf-8');
+                const match = content.match(new RegExp(`${prop}\\s*=\\s*"([^"]+)"`));
+                if (match) {
+                    target[prop] = match[1];
+                    return match[1];
+                }
+            }
+        }
+        catch (error) {
+            // Ignorar erro silenciosamente
+        }
+        // Retornar o próprio nome como valor (ex: Systems.AUTENTICA_IN_HML = "AUTENTICA_IN_HML")
+        target[prop] = prop;
+        return prop;
+    },
+    // Permitir iteração sobre as propriedades
+    ownKeys(target) {
+        try {
+            const projectRoot = process.cwd();
+            const enumFilePath = path.join(projectRoot, '.rbqa', 'SystemsEnum.ts');
+            if (fs.existsSync(enumFilePath)) {
+                const content = fs.readFileSync(enumFilePath, 'utf-8');
+                const matches = content.matchAll(/(\w+)\s*=\s*"([^"]+)"/g);
+                const keys = [];
+                for (const match of matches) {
+                    keys.push(match[1]);
+                    target[match[1]] = match[2];
+                }
+                return keys;
+            }
+        }
+        catch (error) {
+            // Ignorar erro
+        }
+        return Object.keys(target);
+    },
+    getOwnPropertyDescriptor(target, prop) {
+        if (typeof prop === 'symbol') {
+            return undefined;
+        }
+        return {
+            enumerable: true,
+            configurable: true,
+            value: target[prop] || prop,
+        };
+    },
+});
+export default SystemsManager;

package/dist/src/testhub/TestHubClient.d.ts

@@ -0,0 +1,335 @@
+/**
+ * TestHubClient: Cliente HTTP para comunicação com o backend TestHub
+ * Responsável por buscar sistemas e enviar resultados de execução
+ *
+ * NOTA: Usa fetch nativo do Node.js (sem axios) para evitar problemas com proxy corporativo
+ */
+/**
+ * Variável de ambiente do sistema
+ */
+export interface EnvironmentVariable {
+    id: string;
+    key: string;
+    value: string;
+}
+/**
+ * Sistema retornado pelo backend
+ */
+export interface TestHubSystem {
+    id: string;
+    name: string;
+    description: string;
+    url: string;
+    type?: string;
+    status?: string;
+    isActive?: boolean;
+    sidService?: string;
+    environments: TestHubEnvironment[];
+}
+/**
+ * Ambiente de um sistema (DEV, HML, PROD, etc)
+ */
+export interface TestHubEnvironment {
+    id: string;
+    name: string;
+    type: string;
+    url: string;
+    port?: string;
+    username?: string;
+    password?: string;
+    serviceName?: string;
+    privateKeyPath?: string;
+    variables?: EnvironmentVariable[];
+    frameworkVariables?: Record<string, string>;
+    requiredFrameworkVariables?: string[];
+    credentials?: {
+        id: string;
+        label: string;
+        suffix?: string | null;
+        description?: string | null;
+        url?: string | null;
+        port?: string | null;
+        service?: string | null;
+        username?: string | null;
+        password?: string | null;
+        isDefault?: boolean;
+        isActive?: boolean;
+        displayOrder?: number;
+    }[];
+    isPrivate?: boolean;
+    privateMembers?: {
+        userId: string;
+        canManage?: boolean;
+    }[];
+}
+/**
+ * Informações de um CT individual
+ */
+export interface CTInfo {
+    ctNome: string;
+    status: 'sucesso' | 'erro' | 'pulado';
+    tempoExecucao: number;
+    erro?: string;
+    logs?: string;
+    linhaErro?: number;
+    screenshots?: string[];
+}
+/**
+ * Payload de execução de CN com lista de CTs
+ * NOTA: matricula e email agora são enviados via headers (x-automation-user-matricula e x-automation-user-email)
+ */
+export interface TestExecutionPayload {
+    cenarioNome: string;
+    sistemaNome: string;
+    repositorio?: string;
+    ambiente: 'LOCAL' | 'AZURE';
+    status: 'sucesso' | 'erro' | 'pulado';
+    tempoExecucao: number;
+    totalCTs: number;
+    ctsPassados: number;
+    ctsFalhados: number;
+    ctsPulados: number;
+    cts: CTInfo[];
+    erro?: string;
+    logs?: string;
+}
+/**
+ * Payload para execução de cenário no AutoCore Hub
+ */
+export interface ScenarioExecutionPayload {
+    cenarioNome: string;
+    cenarioId?: string;
+    sistemaNome?: string;
+    repositorio?: string;
+    ambiente: 'LOCAL' | 'AZURE';
+    status?: 'executando' | 'sucesso' | 'erro' | 'cancelado';
+    tempoExecucao?: number;
+    sistemaId?: string;
+    parametros?: string;
+    resultado?: string;
+    erro?: string;
+    logs?: string;
+    linhaErro?: number;
+    ctErro?: string;
+    cnE1Erro?: string;
+    nomeCenarioCt?: string;
+    testeEspecificoErro?: string;
+    screenshots?: string[];
+    evidencias?: string;
+}
+/**
+ * Usuário retornado pelo AutoCore Hub
+ */
+export interface HubUser {
+    id: string;
+    name: string;
+    email: string;
+    matricula: string;
+    role: string;
+    diretoria?: string;
+    equipe?: string;
+}
+/**
+ * Configuração do cliente TestHub
+ */
+export interface TestHubConfig {
+    baseUrl: string;
+    timeout?: number;
+    retries?: number;
+    cacheEnabled?: boolean;
+    cacheDuration?: number;
+}
+/**
+ * Cliente para comunicação com backend TestHub
+ * Usa fetch nativo do Node.js para evitar problemas com proxy corporativo
+ */
+export declare class TestHubClient {
+    private static instance;
+    private config;
+    private systemsCache;
+    private cacheFilePath;
+    private cachedUserId;
+    private cachedAuthToken;
+    private cachedAuthTokenExpiry;
+    private hubApiUrl;
+    private constructor();
+    /**
+     * Obtém instância singleton do cliente
+     */
+    static getInstance(config?: Partial<TestHubConfig>): TestHubClient;
+    /**
+     * Constrói headers padrão para requisições ao AutoCore Hub
+     * - Windows local: x-automation-user-matricula (USERNAME)
+     * - Linux/Azure: x-automation-user-email (email do pipeline)
+     * REGRA: Cada ambiente manda apenas o que tem disponível
+     */
+    private buildHeaders;
+    /**
+     * Faz uma requisição GET com retry e fallback de URL
+     */
+    private fetchGet;
+    /**
+     * Faz uma requisição POST com retry
+     */
+    private fetchPost;
+    /**
+     * 📡 Busca lista de sistemas do backend
+     * @returns Lista de sistemas cadastrados
+     */
+    getSystems(): Promise<TestHubSystem[]>;
+    /**
+     * 📤 Envia resultado de execução em batch para o backend
+     * @param batchPayload Dados completos da execução (batch)
+     * @returns IDs das execuções criadas
+     */
+    sendBatchExecution(batchPayload: any): Promise<string[]>;
+    /**
+     * 📦 Envia artifacts (relatórios compactados em Base64) para o backend
+     * @param artifactsPayload Dados dos artifacts
+     */
+    sendArtifacts(artifactsPayload: any): Promise<void>;
+    /**
+     * 🔍 Busca sistema por nome
+     * @param systemName Nome do sistema
+     * @returns Sistema encontrado ou null
+     */
+    getSystemByName(systemName: string): Promise<TestHubSystem | null>;
+    /**
+     * 🔍 Busca sistemas por tipo de ambiente
+     * @param type Tipo de ambiente (API, WEB, SSH, BANCO)
+     * @returns Lista de sistemas filtrados
+     */
+    getSystemsByType(type: TestHubEnvironment['type']): Promise<TestHubSystem[]>;
+    /**
+     * 🔍 Busca ambiente específico de um sistema
+     * @param systemName Nome do sistema
+     * @param environmentName Nome do ambiente (ex: 'preprod', 'esteira1')
+     * @returns Ambiente encontrado ou null
+     */
+    getEnvironment(systemName: string, environmentName: string): Promise<TestHubEnvironment | null>;
+    /**
+     * 🔑 Busca todas as variáveis de ambiente de um sistema/ambiente específico
+     * Inclui automaticamente campos do ambiente como variáveis:
+     * - URL, USERNAME, PASSWORD, PORT
+     * @param systemName Nome do sistema
+     * @param environmentName Nome do ambiente (ex: 'Prod', 'Homolog')
+     * @returns Array de variáveis ou array vazio
+     */
+    getEnvironmentVariables(systemName: string, environmentName: string): Promise<EnvironmentVariable[]>;
+    /**
+     * Obtém token JWT do AutoCore Hub e faz cache com expiry simples.
+     */
+    private getAuthToken;
+    /**
+     * Retorna um mapa de variáveis final para execução escolhendo credencial com sufixo quando informado.
+     * - Sufixo nulo => usa chaves padrão (URL, USERNAME...)
+     * - Sufixo 'PARCEIRO' => prefere URL_PARCEIRO etc, mas faz fallback para padrão quando ausente
+     */
+    getFrameworkVariablesForExecution(systemName: string, environmentName: string, credentialSuffix?: string | null): Promise<Record<string, string>>;
+    /**
+     * Retorna os sufixos de credenciais disponíveis para um ambiente (inclui null/default)
+     */
+    getAvailableCredentialSuffixes(systemName: string, environmentName: string): Promise<(string | null)[]>;
+    /**
+     * Constrói um conjunto de credenciais (URL/PORT/SERVICE/USERNAME/PASSWORD) a partir do mapa de framework vars
+     */
+    getCredentialSetFromVars(vars: Record<string, string>, suffix?: string | null): {
+        url: string;
+        port: string;
+        service: string;
+        username: string;
+        password: string;
+    };
+    /**
+     * Retorna o conjunto de credenciais efetivo para execução, escolhendo por sufixo ou fallback
+     */
+    getCredentialSetForEnvironment(systemName: string, environmentName: string, requestedSuffix?: string | null): Promise<{
+        suffix: string | null;
+        credentialSet: {
+            url: string;
+            port: string;
+            service: string;
+            username: string;
+            password: string;
+        };
+    }>;
+    /**
+     * Resolve um valor possivelmente placeholder usando as frameworkVariables ou credentials do ambiente.
+     * - Se `input` for uma chave (ex: "USERNAME", "ADB_VENDA") tenta buscar em frameworkVariables
+     * - Se for uma das chaves base (USERNAME/PASSWORD/URL/PORT/SERVICE) e não existir como variável, usa o credentialSet
+     * - Caso contrário retorna `input` inalterado
+     */
+    resolveFrameworkValue(systemName: string, environmentName: string, input: string | undefined | null, credentialSuffix?: string | null): Promise<string | null>;
+    /**
+     * 🔍 Busca uma variável específica por chave
+     * @param systemName Nome do sistema
+     * @param environmentName Nome do ambiente
+     * @param variableKey Chave da variável (ex: 'BASE_URL', 'API_TOKEN')
+     * @returns Valor da variável ou null se não encontrada
+     */
+    getEnvironmentVariable(systemName: string, environmentName: string, variableKey: string): Promise<string | null>;
+    /**
+     * 🌍 Carrega todas as variáveis de um ambiente como variáveis de ambiente do processo
+     * @param systemName Nome do sistema
+     * @param environmentName Nome do ambiente
+     * @param prefix Prefixo opcional para as variáveis (ex: 'AUTOCORE_')
+     * @returns Número de variáveis carregadas
+     */
+    loadEnvironmentVariables(systemName: string, environmentName: string, prefix?: string): Promise<number>;
+    /**
+     * 📝 Retorna todas as variáveis como um objeto chave-valor
+     * @param systemName Nome do sistema
+     * @param environmentName Nome do ambiente
+     * @returns Objeto com chave-valor das variáveis
+     */
+    getVariablesAsObject(systemName: string, environmentName: string): Promise<Record<string, string>>;
+    /**
+     * Verifica se o cache é válido
+     */
+    private isCacheValid;
+    /**
+     * Salva sistemas no cache em memória e arquivo
+     */
+    private saveSystemsToCache;
+    /**
+     * Carrega sistemas do cache em arquivo
+     */
+    private loadSystemsFromFileCache;
+    /**
+     * Salva execução que falhou para retry posterior
+     */
+    private saveFailedBatchExecution;
+    /**
+     * Limpa cache de sistemas
+     */
+    clearCache(): void;
+    /**
+     * Testa conectividade com o backend
+     */
+    testConnection(): Promise<boolean>;
+    /**
+     * Converte sistemas do AutoCore Hub para formato TestHub
+     */
+    private convertHubSystemsToTestHub;
+    /**
+     * Obtém User ID do AutoCore Hub (com autenticação automática)
+     */
+    getUserId(): Promise<string>;
+    /**
+     * Detecta ambiente de execução e obtém identificador do usuário
+     */
+    private getUserIdentifier;
+    /**
+     * Obtém email do usuário via Azure DevOps REST API
+     */
+    private getAzureUserEmailFromAPI;
+    /**
+     * Envia execução de cenário para o AutoCore Hub
+     */
+    sendScenarioExecution(payload: ScenarioExecutionPayload): Promise<string>;
+    /**
+     * Salva execução de cenário falhada para retry posterior
+     */
+    private saveFailedScenarioExecution;
+}
+export default TestHubClient;