@silasfmartins/testhub 1.0.0

package/dist/src/domain/schemas/ValidationSchemas.d.ts

@@ -0,0 +1,159 @@
+/**
+ * @fileoverview Schemas de validação usando Zod para os componentes do AutoCore
+ * @module Domain/Schemas
+ */
+import { z } from 'zod';
+/**
+ * Schema para validação de URLs
+ */
+export declare const UrlSchema: z.ZodString;
+/**
+ * Schema para validação de seletores CSS/XPath
+ */
+export declare const SelectorSchema: z.ZodString;
+/**
+ * Schema para validação de tempo limite
+ */
+export declare const TimeoutSchema: z.ZodNumber;
+/**
+ * Schema para validação de credenciais SSH
+ */
+export declare const SSHCredentialsSchema: z.ZodObject<{
+    host: z.ZodString;
+    port: z.ZodDefault<z.ZodNumber>;
+    username: z.ZodString;
+    password: z.ZodOptional<z.ZodString>;
+    privateKey: z.ZodOptional<z.ZodString>;
+    passphrase: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Schema para validação de comandos SSH
+ */
+export declare const SSHCommandSchema: z.ZodString;
+/**
+ * Schema para validação de configuração de banco
+ */
+export declare const DatabaseConfigSchema: z.ZodObject<{
+    host: z.ZodString;
+    port: z.ZodNumber;
+    database: z.ZodString;
+    username: z.ZodString;
+    password: z.ZodString;
+    connectionTimeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    queryTimeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+/**
+ * Schema para validação de queries SQL
+ */
+export declare const SQLQuerySchema: z.ZodString;
+/**
+ * Schema para validação de dados de API Request
+ */
+export declare const ApiRequestSchema: z.ZodObject<{
+    url: z.ZodString;
+    method: z.ZodEnum<{
+        POST: "POST";
+        GET: "GET";
+        DELETE: "DELETE";
+        PUT: "PUT";
+        PATCH: "PATCH";
+    }>;
+    headers: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    body: z.ZodOptional<z.ZodUnknown>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    retries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+/**
+ * Schema para validação de configuração de device mobile
+ */
+export declare const MobileDeviceSchema: z.ZodObject<{
+    platformName: z.ZodEnum<{
+        Android: "Android";
+        iOS: "iOS";
+    }>;
+    deviceName: z.ZodString;
+    platformVersion: z.ZodString;
+    app: z.ZodOptional<z.ZodString>;
+    appPackage: z.ZodOptional<z.ZodString>;
+    appActivity: z.ZodOptional<z.ZodString>;
+    udid: z.ZodOptional<z.ZodString>;
+    orientation: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        PORTRAIT: "PORTRAIT";
+        LANDSCAPE: "LANDSCAPE";
+    }>>>;
+}, z.core.$strip>;
+/**
+ * Schema para validação de coordenadas mobile
+ */
+export declare const MobileCoordinatesSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Schema para validação de configuração de teste
+ */
+export declare const TestConfigurationSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    retries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    environment: z.ZodOptional<z.ZodString>;
+    parallel: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+/**
+ * Schema para validação de evidências/screenshots
+ */
+export declare const EvidenceConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    onFailure: z.ZodDefault<z.ZodBoolean>;
+    onSuccess: z.ZodDefault<z.ZodBoolean>;
+    quality: z.ZodDefault<z.ZodNumber>;
+    fullPage: z.ZodDefault<z.ZodBoolean>;
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Schema para validação de paths de arquivos
+ */
+export declare const FilePathSchema: z.ZodString;
+/**
+ * Schema para validação de viewport/dimensões de tela
+ */
+export declare const ViewportSchema: z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Utility functions para validação
+ */
+export declare class SchemaValidator {
+    /**
+     * Valida dados usando schema e retorna resultado tipado
+     */
+    static validate<T>(schema: z.ZodSchema<T>, data: unknown): T;
+    /**
+     * Valida dados de forma assíncrona
+     */
+    static validateAsync<T>(schema: z.ZodSchema<T>, data: unknown): Promise<T>;
+    /**
+     * Cria um schema opcional com valor padrão
+     */
+    static optional<T>(schema: z.ZodSchema<T>, defaultValue: T): z.ZodDefault<z.ZodOptional<z.ZodType<T, unknown, z.core.$ZodTypeInternals<T, unknown>>>>;
+}
+/**
+ * Tipos TypeScript derivados dos schemas
+ */
+export type UrlType = z.infer<typeof UrlSchema>;
+export type SelectorType = z.infer<typeof SelectorSchema>;
+export type TimeoutType = z.infer<typeof TimeoutSchema>;
+export type SSHCredentialsType = z.infer<typeof SSHCredentialsSchema>;
+export type SSHCommandType = z.infer<typeof SSHCommandSchema>;
+export type DatabaseConfigType = z.infer<typeof DatabaseConfigSchema>;
+export type SQLQueryType = z.infer<typeof SQLQuerySchema>;
+export type ApiRequestType = z.infer<typeof ApiRequestSchema>;
+export type MobileDeviceType = z.infer<typeof MobileDeviceSchema>;
+export type MobileCoordinatesType = z.infer<typeof MobileCoordinatesSchema>;
+export type TestConfigurationType = z.infer<typeof TestConfigurationSchema>;
+export type EvidenceConfigType = z.infer<typeof EvidenceConfigSchema>;
+export type FilePathType = z.infer<typeof FilePathSchema>;
+export type ViewportType = z.infer<typeof ViewportSchema>;

package/dist/src/domain/schemas/ValidationSchemas.js

@@ -0,0 +1,181 @@
+/**
+ * @fileoverview Schemas de validação usando Zod para os componentes do AutoCore
+ * @module Domain/Schemas
+ */
+import { z } from 'zod';
+/**
+ * Schema para validação de URLs
+ */
+export const UrlSchema = z
+    .string()
+    .url('URL deve ser válida e incluir protocolo (http:// ou https://)');
+/**
+ * Schema para validação de seletores CSS/XPath
+ */
+export const SelectorSchema = z
+    .string()
+    .min(1, 'Seletor não pode estar vazio')
+    .refine((selector) => {
+    // Validação básica de seletores CSS e XPath
+    const cssPattern = /^[a-zA-Z0-9\-_#.[\]():*+~>\s,"'=^$|]+$/;
+    const xpathPattern = /^\/\/|^\/|\.|@|\[|\]/;
+    return cssPattern.test(selector) || xpathPattern.test(selector);
+}, 'Seletor deve ser um CSS selector ou XPath válido');
+/**
+ * Schema para validação de tempo limite
+ */
+export const TimeoutSchema = z
+    .number()
+    .min(100, 'Timeout deve ser pelo menos 100ms')
+    .max(300_000, 'Timeout não pode exceder 5 minutos');
+/**
+ * Schema para validação de credenciais SSH
+ */
+export const SSHCredentialsSchema = z
+    .object({
+    host: z.string().min(1, 'Host é obrigatório'),
+    port: z.number().min(1).max(65_535).default(22),
+    username: z.string().min(1, 'Username é obrigatório'),
+    password: z.string().optional(),
+    privateKey: z.string().optional(),
+    passphrase: z.string().optional(),
+})
+    .refine((data) => data.password || data.privateKey, 'Deve fornecer password ou privateKey');
+/**
+ * Schema para validação de comandos SSH
+ */
+export const SSHCommandSchema = z
+    .string()
+    .min(1, 'Comando não pode estar vazio')
+    .max(8192, 'Comando muito longo (máximo 8KB)');
+/**
+ * Schema para validação de configuração de banco
+ */
+export const DatabaseConfigSchema = z.object({
+    host: z.string().min(1, 'Host é obrigatório'),
+    port: z.number().min(1).max(65_535),
+    database: z.string().min(1, 'Nome do banco é obrigatório'),
+    username: z.string().min(1, 'Username é obrigatório'),
+    password: z.string().min(1, 'Password é obrigatório'),
+    connectionTimeout: TimeoutSchema.optional().default(30_000),
+    queryTimeout: TimeoutSchema.optional().default(60_000),
+});
+/**
+ * Schema para validação de queries SQL
+ */
+export const SQLQuerySchema = z
+    .string()
+    .min(1, 'Query SQL não pode estar vazia')
+    .max(100_000, 'Query SQL muito longa (máximo 100KB)')
+    .refine((query) => {
+    const trimmed = query.trim().toLowerCase();
+    // Validações básicas de segurança SQL
+    const dangerousPatterns = [
+        /;\s*drop\s+/i,
+        /;\s*delete\s+.*\s+where\s+1\s*=\s*1/i,
+        /;\s*truncate\s+/i,
+        /;\s*alter\s+/i,
+    ];
+    return !dangerousPatterns.some((pattern) => pattern.test(query));
+}, 'Query contém padrões potencialmente perigosos');
+/**
+ * Schema para validação de dados de API Request
+ */
+export const ApiRequestSchema = z.object({
+    url: UrlSchema,
+    method: z.enum(['GET', 'POST', 'PUT', 'PATCH', 'DELETE']),
+    headers: z.record(z.string(), z.string()).optional().default({}),
+    body: z.unknown().optional(),
+    timeout: TimeoutSchema.optional().default(30_000),
+    retries: z.number().min(0).max(10).optional().default(0),
+});
+/**
+ * Schema para validação de configuração de device mobile
+ */
+export const MobileDeviceSchema = z.object({
+    platformName: z.enum(['iOS', 'Android']),
+    deviceName: z.string().min(1, 'Nome do device é obrigatório'),
+    platformVersion: z.string().min(1, 'Versão da plataforma é obrigatória'),
+    app: z.string().optional(),
+    appPackage: z.string().optional(),
+    appActivity: z.string().optional(),
+    udid: z.string().optional(),
+    orientation: z.enum(['PORTRAIT', 'LANDSCAPE']).optional().default('PORTRAIT'),
+});
+/**
+ * Schema para validação de coordenadas mobile
+ */
+export const MobileCoordinatesSchema = z.object({
+    x: z.number().min(0, 'Coordenada X deve ser positiva'),
+    y: z.number().min(0, 'Coordenada Y deve ser positiva'),
+});
+/**
+ * Schema para validação de configuração de teste
+ */
+export const TestConfigurationSchema = z.object({
+    name: z.string().min(1, 'Nome do teste é obrigatório'),
+    description: z.string().optional(),
+    timeout: TimeoutSchema.optional().default(60_000),
+    retries: z.number().min(0).max(10).optional().default(0),
+    tags: z.array(z.string()).optional().default([]),
+    environment: z.string().optional(),
+    parallel: z.boolean().optional().default(false),
+});
+/**
+ * Schema para validação de evidências/screenshots
+ */
+export const EvidenceConfigSchema = z.object({
+    enabled: z.boolean().default(true),
+    onFailure: z.boolean().default(true),
+    onSuccess: z.boolean().default(false),
+    quality: z.number().min(10).max(100).default(90),
+    fullPage: z.boolean().default(true),
+    path: z.string().optional(),
+});
+/**
+ * Schema para validação de paths de arquivos
+ */
+export const FilePathSchema = z
+    .string()
+    .min(1, 'Caminho do arquivo não pode estar vazio')
+    .refine((path) => {
+    // Validação básica de path - evitar path traversal
+    return !(path.includes('../') || path.includes('..\\'));
+}, 'Caminho de arquivo contém caracteres perigosos');
+/**
+ * Schema para validação de viewport/dimensões de tela
+ */
+export const ViewportSchema = z.object({
+    width: z.number().min(100).max(4000),
+    height: z.number().min(100).max(4000),
+});
+/**
+ * Utility functions para validação
+ */
+export class SchemaValidator {
+    /**
+     * Valida dados usando schema e retorna resultado tipado
+     */
+    static validate(schema, data) {
+        const result = schema.safeParse(data);
+        if (!result.success) {
+            const errors = result.error.issues
+                .map((err) => `${err.path.join('.')}: ${err.message}`)
+                .join('; ');
+            throw new Error(`Validação falhou: ${errors}`);
+        }
+        return result.data;
+    }
+    /**
+     * Valida dados de forma assíncrona
+     */
+    static async validateAsync(schema, data) {
+        return SchemaValidator.validate(schema, data);
+    }
+    /**
+     * Cria um schema opcional com valor padrão
+     */
+    static optional(schema, defaultValue) {
+        return schema.optional().default(defaultValue);
+    }
+}

package/dist/src/functions/errors/BaseError.d.ts

@@ -0,0 +1,78 @@
+/**
+ * BaseError: Classe base para todos os erros do AutoCore
+ * Fornece funcionalidades comuns como logging, categorização e context
+ */
+export interface ErrorContext {
+    userId?: string;
+    sessionId?: string;
+    timestamp: number;
+    environment: 'development' | 'testing' | 'production' | 'unknown';
+    framework: string;
+    version: string;
+    metadata?: Record<string, unknown>;
+    ctErro?: string;
+    cnErro?: string;
+    linhaErro?: number;
+    nomeCenarioCt?: string;
+}
+export interface ErrorDetails {
+    code: string;
+    message: string;
+    userMessage: string;
+    category: 'security' | 'validation' | 'integration' | 'configuration' | 'network' | 'system';
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    recoverable: boolean;
+    suggestions?: string[];
+    documentation?: string;
+}
+export declare class BaseError extends Error {
+    readonly id: string;
+    readonly code: string;
+    readonly userMessage: string;
+    readonly category: ErrorDetails['category'];
+    readonly severity: ErrorDetails['severity'];
+    readonly recoverable: boolean;
+    readonly suggestions: string[];
+    readonly documentation?: string;
+    readonly context: ErrorContext;
+    readonly timestamp: number;
+    readonly originalError?: Error;
+    constructor(detailsOrMessage: ErrorDetails | string, originalError?: Error, context?: Partial<ErrorContext>);
+    /**
+     * Converte erro para formato JSON serializável
+     */
+    toJSON(): Record<string, unknown>;
+    /**
+     * Gera mensagem formatada para o usuário
+     */
+    getUserFriendlyMessage(): string;
+    /**
+     * Gera relatório técnico completo
+     */
+    getTechnicalReport(): string;
+    /**
+     * Detecta ambiente de execução
+     */
+    private detectEnvironment;
+    /**
+     * Obtém versão do framework
+     */
+    private getFrameworkVersion;
+    /**
+     * Melhora stack trace com informações úteis
+     */
+    private enhanceStackTrace;
+    /**
+     * 🆕 Extrai informações de CT/CN automaticamente do stack trace
+     */
+    private extractTestInfoFromStack;
+    /**
+     * 🆕 Define manualmente informações de CT/CN (sobrescreve auto-extração)
+     */
+    setTestInfo(ctErro?: string, cnErro?: string, nomeCenarioCt?: string): void;
+    /**
+     * 🆕 Define linha de erro manualmente
+     */
+    setLineNumber(line: number): void;
+}
+export default BaseError;

package/dist/src/functions/errors/BaseError.js

@@ -0,0 +1,245 @@
+/**
+ * BaseError: Classe base para todos os erros do AutoCore
+ * Fornece funcionalidades comuns como logging, categorização e context
+ */
+import { randomUUID } from 'node:crypto';
+export class BaseError extends Error {
+    id;
+    code;
+    userMessage;
+    category;
+    severity;
+    recoverable;
+    suggestions;
+    documentation;
+    context;
+    timestamp;
+    originalError;
+    constructor(detailsOrMessage, originalError, context) {
+        const details = typeof detailsOrMessage === 'string'
+            ? {
+                code: 'GENERIC_ERROR',
+                message: detailsOrMessage,
+                userMessage: detailsOrMessage,
+                category: 'system',
+                severity: 'medium',
+                recoverable: false,
+            }
+            : detailsOrMessage;
+        super(details.message);
+        this.id = randomUUID();
+        this.code = details.code;
+        this.userMessage = details.userMessage;
+        this.category = details.category;
+        this.severity = details.severity;
+        this.recoverable = details.recoverable;
+        this.suggestions = details.suggestions || [];
+        this.documentation = details.documentation;
+        this.originalError = originalError;
+        this.timestamp = Date.now();
+        // 🆕 Auto-extrair informações de CT/CN do stack trace
+        const autoExtractedInfo = this.extractTestInfoFromStack();
+        this.context = {
+            timestamp: this.timestamp,
+            environment: this.detectEnvironment(),
+            framework: 'AutoCore',
+            version: this.getFrameworkVersion(),
+            ...autoExtractedInfo,
+            ...context,
+        };
+        // Manter stack trace original se disponível
+        if (originalError?.stack) {
+            this.stack = this.enhanceStackTrace(originalError.stack);
+        }
+        Error.captureStackTrace(this, this.constructor);
+    }
+    /**
+     * Converte erro para formato JSON serializável
+     */
+    toJSON() {
+        return {
+            id: this.id,
+            code: this.code,
+            message: this.message,
+            userMessage: this.userMessage,
+            category: this.category,
+            severity: this.severity,
+            recoverable: this.recoverable,
+            suggestions: this.suggestions,
+            documentation: this.documentation,
+            context: this.context,
+            timestamp: this.timestamp,
+            stack: this.stack,
+            originalError: this.originalError
+                ? {
+                    message: this.originalError.message,
+                    stack: this.originalError.stack,
+                }
+                : undefined,
+        };
+    }
+    /**
+     * Gera mensagem formatada para o usuário
+     */
+    getUserFriendlyMessage() {
+        let message = `❌ ${this.userMessage}\n`;
+        if (this.suggestions.length > 0) {
+            message += '\n💡 Sugestões:\n';
+            this.suggestions.forEach((suggestion, index) => {
+                message += `  ${index + 1}. ${suggestion}\n`;
+            });
+        }
+        if (this.documentation) {
+            message += `\n📚 Documentação: ${this.documentation}\n`;
+        }
+        message += `\n🔍 Código do erro: ${this.code}`;
+        message += `\n🆔 ID do erro: ${this.id}`;
+        return message;
+    }
+    /**
+     * Gera relatório técnico completo
+     */
+    getTechnicalReport() {
+        const report = [
+            '=== RELATÓRIO DE ERRO AUTOCORE ===',
+            `ID: ${this.id}`,
+            `Código: ${this.code}`,
+            `Categoria: ${this.category}`,
+            `Severidade: ${this.severity}`,
+            `Recuperável: ${this.recoverable ? 'Sim' : 'Não'}`,
+            `Timestamp: ${new Date(this.timestamp).toISOString()}`,
+            '',
+            'Contexto:',
+            `- Ambiente: ${this.context.environment}`,
+            `- Framework: ${this.context.framework} v${this.context.version}`,
+            `- Session ID: ${this.context.sessionId || 'N/A'}`,
+            '',
+            'Mensagem Técnica:',
+            this.message,
+            '',
+            'Mensagem do Usuário:',
+            this.userMessage,
+            '',
+        ];
+        if (this.suggestions.length > 0) {
+            report.push('Sugestões:');
+            this.suggestions.forEach((suggestion, index) => {
+                report.push(`${index + 1}. ${suggestion}`);
+            });
+            report.push('');
+        }
+        if (this.stack) {
+            report.push('Stack Trace:');
+            report.push(this.stack);
+            report.push('');
+        }
+        if (this.originalError) {
+            report.push('Erro Original:');
+            report.push(`Mensagem: ${this.originalError.message}`);
+            if (this.originalError.stack) {
+                report.push(`Stack: ${this.originalError.stack}`);
+            }
+            report.push('');
+        }
+        if (this.context.metadata) {
+            report.push('Metadados:');
+            report.push(JSON.stringify(this.context.metadata, null, 2));
+        }
+        return report.join('\n');
+    }
+    /**
+     * Detecta ambiente de execução
+     */
+    detectEnvironment() {
+        if (process.env.NODE_ENV === 'test' || process.env.VITEST) {
+            return 'testing';
+        }
+        if (process.env.NODE_ENV === 'production') {
+            return 'production';
+        }
+        if (process.env.NODE_ENV === 'development') {
+            return 'development';
+        }
+        return 'unknown';
+    }
+    /**
+     * Obtém versão do framework
+     */
+    getFrameworkVersion() {
+        try {
+            const pkg = require('../../../package.json');
+            return pkg.version || 'unknown';
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+    /**
+     * Melhora stack trace com informações úteis
+     */
+    enhanceStackTrace(originalStack) {
+        const lines = originalStack.split('\n');
+        const enhanced = [
+            `AutoCore Error [${this.code}]: ${this.message}`,
+            `  at ${this.constructor.name} (autocore:${this.category}:${this.severity})`,
+            ...lines.slice(1),
+        ];
+        return enhanced.join('\n');
+    }
+    /**
+     * 🆕 Extrai informações de CT/CN automaticamente do stack trace
+     */
+    extractTestInfoFromStack() {
+        const extractedInfo = {};
+        try {
+            // Capturar stack trace atual
+            const stack = new Error().stack || '';
+            // Extrair linha de erro (primeira linha após o construtor)
+            const lineMatch = stack.match(/:(\d+):\d+/);
+            if (lineMatch) {
+                extractedInfo.linhaErro = Number.parseInt(lineMatch[1], 10);
+            }
+            // Tentar extrair CT e CN do stack trace
+            // Procurar por padrões como "CT001", "CN001" nos nomes de arquivo
+            const ctMatch = stack.match(/[/\\](CT\d+[^/\\\s.]*)/i);
+            if (ctMatch) {
+                extractedInfo.ctErro = ctMatch[1];
+            }
+            const cnMatch = stack.match(/[/\\](CN\d+[^/\\\s.]*)/i);
+            if (cnMatch) {
+                extractedInfo.cnErro = cnMatch[1];
+            }
+            // Se encontrou CT ou CN, criar nome completo do cenário
+            if (extractedInfo.cnErro || extractedInfo.ctErro) {
+                extractedInfo.nomeCenarioCt = [
+                    extractedInfo.cnErro,
+                    extractedInfo.ctErro,
+                ]
+                    .filter(Boolean)
+                    .join(' / ');
+            }
+        }
+        catch {
+            // Ignorar erros na extração
+        }
+        return extractedInfo;
+    }
+    /**
+     * 🆕 Define manualmente informações de CT/CN (sobrescreve auto-extração)
+     */
+    setTestInfo(ctErro, cnErro, nomeCenarioCt) {
+        if (ctErro)
+            this.context.ctErro = ctErro;
+        if (cnErro)
+            this.context.cnErro = cnErro;
+        if (nomeCenarioCt)
+            this.context.nomeCenarioCt = nomeCenarioCt;
+    }
+    /**
+     * 🆕 Define linha de erro manualmente
+     */
+    setLineNumber(line) {
+        this.context.linhaErro = line;
+    }
+}
+export default BaseError;

package/dist/src/functions/errors/ConfigurationError.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ConfigurationError: Erros relacionados à configuração do framework
+ */
+import { BaseError, type ErrorContext } from './BaseError.js';
+export declare class ConfigurationError extends BaseError {
+    constructor(code: string, message: string, userMessage: string, originalError?: Error, context?: Partial<ErrorContext>);
+    static missingConfigFile(filePath: string, context?: Partial<ErrorContext>): ConfigurationError;
+    static invalidConfigFormat(filePath: string, error: Error, context?: Partial<ErrorContext>): ConfigurationError;
+    static missingEnvironmentVariable(varName: string, context?: Partial<ErrorContext>): ConfigurationError;
+    static invalidEnvironmentValue(varName: string, expectedFormat: string, context?: Partial<ErrorContext>): ConfigurationError;
+    static conflictingConfiguration(config1: string, config2: string, context?: Partial<ErrorContext>): ConfigurationError;
+    static unsupportedBrowserConfig(browser: string, context?: Partial<ErrorContext>): ConfigurationError;
+    static invalidTestConfiguration(configKey: string, reason: string, context?: Partial<ErrorContext>): ConfigurationError;
+    static missingDependency(dependency: string, context?: Partial<ErrorContext>): ConfigurationError;
+}
+export default ConfigurationError;