@silasfmartins/testhub 1.0.0

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

@@ -0,0 +1,281 @@
+/**
+ * GlobalErrorHandler: Sistema global de captura e tratamento de erros
+ * Gerencia erros não capturados e fornece logging e observabilidade
+ */
+import { BaseError } from './BaseError.js';
+import { IntegrationError } from './IntegrationError.js';
+import { SecurityError } from './SecurityError.js';
+import { SystemError } from './SystemError.js';
+import { Logger } from '../../utils/Logger.js';
+export class GlobalErrorHandler {
+    static instance;
+    config;
+    errors = [];
+    metrics;
+    originalConsoleError;
+    originalProcessListeners = {};
+    constructor(config = {}) {
+        this.config = {
+            enableConsoleLogging: true,
+            enableFileLogging: false,
+            maxErrorsInMemory: 100,
+            enableStackTrace: true,
+            enableUserFriendlyMessages: true,
+            enableObservability: false,
+            ...config,
+        };
+        this.metrics = {
+            totalErrors: 0,
+            errorsByCategory: {},
+            errorsBySeverity: {},
+            recentErrors: [],
+            startTime: Date.now(),
+        };
+        this.originalConsoleError = console.error;
+        this.setupGlobalHandlers();
+    }
+    /**
+     * Obtém instância singleton do GlobalErrorHandler
+     */
+    static getInstance(config) {
+        if (!GlobalErrorHandler.instance) {
+            GlobalErrorHandler.instance = new GlobalErrorHandler(config);
+        }
+        return GlobalErrorHandler.instance;
+    }
+    /**
+     * Configura handlers globais para captura de erros
+     */
+    setupGlobalHandlers() {
+        // Capturar erros não tratados
+        process.on('uncaughtException', (error) => {
+            this.handleUncaughtError(error, 'uncaughtException');
+        });
+        process.on('unhandledRejection', (reason, promise) => {
+            this.handleUnhandledRejection(reason, promise);
+        });
+        // Interceptar console.error para capturar logs de erro
+        console.error = (...args) => {
+            this.handleConsoleError(args);
+            this.originalConsoleError.apply(console, args);
+        };
+    }
+    /**
+     * Manuseia erro principal do sistema
+     */
+    handleError(error, context) {
+        let processedError;
+        if (error instanceof BaseError) {
+            processedError = error;
+        }
+        else {
+            // Converter erro genérico para BaseError
+            processedError = this.convertToBaseError(error, context);
+        }
+        // Adicionar contexto adicional se fornecido
+        if (context) {
+            processedError.context.metadata = {
+                ...processedError.context.metadata,
+                ...context,
+            };
+        }
+        this.logError(processedError);
+        this.updateMetrics(processedError);
+        this.storeError(processedError);
+        this.sendToObservability(processedError);
+    }
+    /**
+     * Manuseia erros não capturados
+     */
+    handleUncaughtError(error, type) {
+        const baseError = new SecurityError('SYS_UNCAUGHT_EXCEPTION', `Uncaught exception (${type}): ${error.message}`, 'Erro não tratado detectado no sistema.', error, { metadata: { type, timestamp: Date.now() } });
+        this.handleError(baseError);
+        // Em ambiente de produção, evitar crash
+        if (process.env.NODE_ENV === 'production') {
+            Logger.error('💥 Sistema em modo degradado devido a erro crítico');
+            process.env.AUTOCORE_DEGRADED_MODE = 'true';
+            process.env.AUTOCORE_DEGRADED_REASON = 'uncaught_exception';
+        }
+    }
+    /**
+     * Manuseia rejeições não tratadas
+     */
+    handleUnhandledRejection(reason, promise) {
+        const error = reason instanceof Error ? reason : new Error(String(reason));
+        const baseError = new IntegrationError('SYS_UNHANDLED_REJECTION', `Unhandled promise rejection: ${error.message}`, 'Promise rejeitada não tratada.', error, { metadata: { promise: promise.toString(), timestamp: Date.now() } });
+        this.handleError(baseError);
+    }
+    /**
+     * Manuseia logs de erro do console
+     */
+    handleConsoleError(args) {
+        const message = args
+            .map((arg) => (typeof arg === 'string' ? arg : JSON.stringify(arg)))
+            .join(' ');
+        if (message.includes('AutoCore') || message.includes('⚠️')) {
+            // Este é provavelmente um erro do nosso sistema
+            const error = SystemError.consoleError(message);
+            this.storeError(error);
+            this.updateMetrics(error);
+        }
+    }
+    /**
+     * Converte erro genérico para BaseError
+     */
+    convertToBaseError(error, context) {
+        // Tentar determinar tipo de erro baseado na mensagem
+        if (error.message.includes('ECONNREFUSED') ||
+            error.message.includes('network')) {
+            return IntegrationError.networkError('unknown', error, context);
+        }
+        if (error.message.includes('ENOENT') || error.message.includes('file')) {
+            return IntegrationError.fileSystemError('access', 'unknown', error, context);
+        }
+        if (error.message.includes('timeout')) {
+            return IntegrationError.timeoutError('unknown', 30_000, context);
+        }
+        // Erro genérico
+        return SystemError.genericError(error.message, error, context);
+    }
+    /**
+     * Registra erro nos logs
+     */
+    logError(error) {
+        if (this.config.enableConsoleLogging) {
+            if (this.config.enableUserFriendlyMessages) {
+                console.error(error.getUserFriendlyMessage());
+            }
+            else {
+                console.error(`[${error.severity.toUpperCase()}] ${error.code}: ${error.message}`);
+            }
+            if (this.config.enableStackTrace && error.stack) {
+                console.error(error.stack);
+            }
+        }
+        if (this.config.enableFileLogging && this.config.logFilePath) {
+            this.writeToLogFile(error);
+        }
+    }
+    /**
+     * Escreve erro em arquivo de log
+     */
+    async writeToLogFile(error) {
+        try {
+            const fs = await import('node:fs/promises');
+            const logEntry = `${new Date().toISOString()} - ${error.getTechnicalReport()}\n\n`;
+            await fs.appendFile(this.config.logFilePath, logEntry);
+        }
+        catch (writeError) {
+            Logger.error('Falha ao escrever no arquivo de log', writeError);
+        }
+    }
+    /**
+     * Atualiza métricas de erro
+     */
+    updateMetrics(error) {
+        this.metrics.totalErrors++;
+        this.metrics.errorsByCategory[error.category] =
+            (this.metrics.errorsByCategory[error.category] || 0) + 1;
+        this.metrics.errorsBySeverity[error.severity] =
+            (this.metrics.errorsBySeverity[error.severity] || 0) + 1;
+        this.metrics.recentErrors.unshift(error);
+        if (this.metrics.recentErrors.length > 10) {
+            this.metrics.recentErrors.pop();
+        }
+    }
+    /**
+     * Armazena erro na memória
+     */
+    storeError(error) {
+        this.errors.unshift(error);
+        // Limitar número de erros em memória
+        if (this.errors.length > this.config.maxErrorsInMemory) {
+            this.errors = this.errors.slice(0, this.config.maxErrorsInMemory);
+        }
+    }
+    /**
+     * Envia erro para sistema de observabilidade
+     */
+    async sendToObservability(error) {
+        if (!(this.config.enableObservability && this.config.observabilityEndpoint)) {
+            return;
+        }
+        try {
+            // Implementar envio para Axiom, Jaeger, etc.
+            const payload = {
+                timestamp: error.timestamp,
+                level: error.severity,
+                message: error.message,
+                error: error.toJSON(),
+                context: error.context,
+            };
+            // Aqui seria implementado o envio real
+            console.debug('Sending error to observability:', payload);
+        }
+        catch (observabilityError) {
+            Logger.error('Falha ao enviar erro para observabilidade', observabilityError);
+        }
+    }
+    /**
+     * Obtém métricas atuais
+     */
+    getMetrics() {
+        return { ...this.metrics };
+    }
+    /**
+     * Obtém erros recentes
+     */
+    getRecentErrors(limit = 10) {
+        return this.errors.slice(0, limit);
+    }
+    /**
+     * Gera relatório de status
+     */
+    generateStatusReport() {
+        const uptime = Date.now() - this.metrics.startTime;
+        const uptimeHours = Math.floor(uptime / (1000 * 60 * 60));
+        const uptimeMinutes = Math.floor((uptime % (1000 * 60 * 60)) / (1000 * 60));
+        const report = [
+            '=== RELATÓRIO DE STATUS AUTOCORE ===',
+            `Uptime: ${uptimeHours}h ${uptimeMinutes}m`,
+            `Total de Erros: ${this.metrics.totalErrors}`,
+            '',
+            'Erros por Categoria:',
+            ...Object.entries(this.metrics.errorsByCategory).map(([cat, count]) => `  ${cat}: ${count}`),
+            '',
+            'Erros por Severidade:',
+            ...Object.entries(this.metrics.errorsBySeverity).map(([sev, count]) => `  ${sev}: ${count}`),
+            '',
+            `Erros Recentes (${this.metrics.recentErrors.length}):`,
+            ...this.metrics.recentErrors
+                .slice(0, 5)
+                .map((err) => `  ${err.code}: ${err.userMessage}`),
+        ];
+        return report.join('\n');
+    }
+    /**
+     * Limpa erros armazenados
+     */
+    clearErrors() {
+        this.errors = [];
+        this.metrics.recentErrors = [];
+    }
+    /**
+     * Desativa handlers globais
+     */
+    dispose() {
+        console.error = this.originalConsoleError;
+        // Remover listeners se possível
+        // Note: não é possível remover completamente os listeners de uncaughtException
+        // mas podemos restaurar comportamentos originais
+    }
+}
+// Inicializar handler global automaticamente
+export const globalErrorHandler = GlobalErrorHandler.getInstance({
+    enableConsoleLogging: process.env.NODE_ENV !== 'test',
+    enableFileLogging: process.env.AUTOCORE_LOG_FILE === 'true',
+    logFilePath: process.env.AUTOCORE_LOG_PATH || './autocore-errors.log',
+    enableObservability: process.env.AUTOCORE_OBSERVABILITY === 'true',
+    observabilityEndpoint: process.env.AUTOCORE_OBSERVABILITY_ENDPOINT,
+});
+export default GlobalErrorHandler;

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

@@ -0,0 +1,17 @@
+/**
+ * IntegrationError: Erros de integração com sistemas externos
+ */
+import { BaseError, type ErrorContext } from './BaseError.js';
+export declare class IntegrationError extends BaseError {
+    constructor(code: string, message: string, userMessage: string, originalError?: Error, context?: Partial<ErrorContext>);
+    static browserLaunchFailed(browserType: string, error: Error, context?: Partial<ErrorContext>): IntegrationError;
+    static databaseConnectionFailed(database: string, error: Error, context?: Partial<ErrorContext>): IntegrationError;
+    static apiRequestFailed(url: string, statusCode: number, responseText: string, context?: Partial<ErrorContext>): IntegrationError;
+    static sshConnectionFailed(host: string, error: Error, context?: Partial<ErrorContext>): IntegrationError;
+    static fileSystemError(operation: string, path: string, error: Error, context?: Partial<ErrorContext>): IntegrationError;
+    static mobileDeviceConnectionFailed(deviceId: string, error: Error, context?: Partial<ErrorContext>): IntegrationError;
+    static timeoutError(operation: string, timeoutMs: number, context?: Partial<ErrorContext>): IntegrationError;
+    static networkError(host: string, error: Error, context?: Partial<ErrorContext>): IntegrationError;
+    static webOperationFailed(operation: string, details: string, error?: Error, context?: Partial<ErrorContext>): IntegrationError;
+}
+export default IntegrationError;

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

@@ -0,0 +1,51 @@
+/**
+ * IntegrationError: Erros de integração com sistemas externos
+ */
+import { BaseError } from './BaseError.js';
+export class IntegrationError extends BaseError {
+    constructor(code, message, userMessage, originalError, context) {
+        const details = {
+            code,
+            message,
+            userMessage,
+            category: 'integration',
+            severity: 'high',
+            recoverable: true,
+            suggestions: [
+                'Verifique a conectividade com o sistema externo',
+                'Confirme se as credenciais estão corretas',
+                'Tente novamente após alguns minutos',
+            ],
+            documentation: 'https://docs.autocore.rbqa/integration',
+        };
+        super(details, originalError, context);
+    }
+    static browserLaunchFailed(browserType, error, context) {
+        return new IntegrationError('INT_BROWSER_LAUNCH_FAILED', `Failed to launch ${browserType} browser: ${error.message}`, `Falha ao iniciar navegador ${browserType}. Verifique se está instalado corretamente.`, error, { ...context, metadata: { browserType } });
+    }
+    static databaseConnectionFailed(database, error, context) {
+        return new IntegrationError('INT_DATABASE_CONNECTION_FAILED', `Database connection failed for ${database}: ${error.message}`, `Falha na conexão com o banco de dados ${database}.`, error, { ...context, metadata: { database } });
+    }
+    static apiRequestFailed(url, statusCode, responseText, context) {
+        return new IntegrationError('INT_API_REQUEST_FAILED', `API request failed: ${statusCode} - ${responseText}`, `Falha na requisição para ${url}. Código: ${statusCode}`, undefined, { ...context, metadata: { url, statusCode, responseText } });
+    }
+    static sshConnectionFailed(host, error, context) {
+        return new IntegrationError('INT_SSH_CONNECTION_FAILED', `SSH connection failed to ${host}: ${error.message}`, `Falha na conexão SSH com ${host}.`, error, { ...context, metadata: { host } });
+    }
+    static fileSystemError(operation, path, error, context) {
+        return new IntegrationError('INT_FILESYSTEM_ERROR', `File system error during ${operation} on ${path}: ${error.message}`, `Erro no sistema de arquivos ao ${operation} ${path}.`, error, { ...context, metadata: { operation, path } });
+    }
+    static mobileDeviceConnectionFailed(deviceId, error, context) {
+        return new IntegrationError('INT_MOBILE_DEVICE_CONNECTION_FAILED', `Failed to connect to mobile device ${deviceId}: ${error.message}`, `Falha na conexão com dispositivo móvel ${deviceId}.`, error, { ...context, metadata: { deviceId } });
+    }
+    static timeoutError(operation, timeoutMs, context) {
+        return new IntegrationError('INT_TIMEOUT_ERROR', `Operation '${operation}' timed out after ${timeoutMs}ms`, `Timeout na operação '${operation}' após ${timeoutMs}ms.`, undefined, { ...context, metadata: { operation, timeoutMs } });
+    }
+    static networkError(host, error, context) {
+        return new IntegrationError('INT_NETWORK_ERROR', `Network error connecting to ${host}: ${error.message}`, `Erro de rede ao conectar com ${host}.`, error, { ...context, metadata: { host } });
+    }
+    static webOperationFailed(operation, details, error, context) {
+        return new IntegrationError('INT_WEB_OPERATION_FAILED', `Web operation '${operation}' failed: ${details}`, `Falha na operação web '${operation}': ${details}`, error, { ...context, metadata: { operation, details } });
+    }
+}
+export default IntegrationError;

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

@@ -0,0 +1,14 @@
+/**
+ * SecurityError: Erros relacionados à segurança e proteção
+ */
+import { BaseError, type ErrorContext } from './BaseError.js';
+export declare class SecurityError extends BaseError {
+    constructor(code: string, message: string, userMessage: string, originalError?: Error, context?: Partial<ErrorContext>);
+    static honeypotTriggered(source: string, context?: Partial<ErrorContext>): SecurityError;
+    static integrityCheckFailed(file: string, context?: Partial<ErrorContext>): SecurityError;
+    static eulaNotAccepted(context?: Partial<ErrorContext>): SecurityError;
+    static proofOfWorkFailed(method: string, context?: Partial<ErrorContext>): SecurityError;
+    static unauthorizedAccess(resource: string, context?: Partial<ErrorContext>): SecurityError;
+    static keyGenerationFailed(reason: string, context?: Partial<ErrorContext>): SecurityError;
+}
+export default SecurityError;

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

@@ -0,0 +1,42 @@
+/**
+ * SecurityError: Erros relacionados à segurança e proteção
+ */
+import { BaseError } from './BaseError.js';
+export class SecurityError extends BaseError {
+    constructor(code, message, userMessage, originalError, context) {
+        const details = {
+            code,
+            message,
+            userMessage,
+            category: 'security',
+            severity: 'high',
+            recoverable: false,
+            suggestions: [
+                'Verifique se o ambiente não está sendo monitorado por automação',
+                'Execute em modo degradado se necessário',
+                'Consulte a documentação de segurança',
+            ],
+            documentation: 'https://docs.autocore.rbqa/security',
+        };
+        super(details, originalError, context);
+    }
+    static honeypotTriggered(source, context) {
+        return new SecurityError('SEC_HONEYPOT_TRIGGERED', `Honeypot triggered from source: ${source}`, 'Sistema de proteção ativado. Detecção de uso automatizado.', undefined, { ...context, metadata: { source } });
+    }
+    static integrityCheckFailed(file, context) {
+        return new SecurityError('SEC_INTEGRITY_FAILED', `Integrity check failed for file: ${file}`, `Arquivo ${file} pode ter sido modificado ou corrompido.`, undefined, { ...context, metadata: { file } });
+    }
+    static eulaNotAccepted(context) {
+        return new SecurityError('SEC_EULA_NOT_ACCEPTED', 'EULA not accepted', 'Termos de uso não aceitos. O sistema funcionará em modo degradado.', undefined, context);
+    }
+    static proofOfWorkFailed(method, context) {
+        return new SecurityError('SEC_POW_FAILED', `Proof of work failed for method: ${method}`, `Validação de proof-of-work falhou para ${method}. Possível automação detectada.`, undefined, { ...context, metadata: { method } });
+    }
+    static unauthorizedAccess(resource, context) {
+        return new SecurityError('SEC_UNAUTHORIZED_ACCESS', `Unauthorized access attempt to: ${resource}`, `Acesso não autorizado detectado para ${resource}.`, undefined, { ...context, metadata: { resource } });
+    }
+    static keyGenerationFailed(reason, context) {
+        return new SecurityError('SEC_KEY_GENERATION_FAILED', `Key generation failed: ${reason}`, 'Falha na geração de chaves de segurança.', undefined, { ...context, metadata: { reason } });
+    }
+}
+export default SecurityError;

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

@@ -0,0 +1,12 @@
+/**
+ * SystemError: Erros internos do sistema AutoCore
+ */
+import { BaseError, type ErrorContext } from './BaseError.js';
+export declare class SystemError extends BaseError {
+    constructor(code: string, message: string, userMessage: string, originalError?: Error, context?: Partial<ErrorContext>);
+    static consoleError(message: string, context?: Partial<ErrorContext>): SystemError;
+    static genericError(message: string, originalError?: Error, context?: Partial<ErrorContext>): SystemError;
+    static initializationError(component: string, error: Error, context?: Partial<ErrorContext>): SystemError;
+    static resourceExhausted(resource: string, limit: number, context?: Partial<ErrorContext>): SystemError;
+}
+export default SystemError;

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

@@ -0,0 +1,36 @@
+/**
+ * SystemError: Erros internos do sistema AutoCore
+ */
+import { BaseError } from './BaseError.js';
+export class SystemError extends BaseError {
+    constructor(code, message, userMessage, originalError, context) {
+        const details = {
+            code,
+            message,
+            userMessage,
+            category: 'system',
+            severity: 'medium',
+            recoverable: true,
+            suggestions: [
+                'Reinicie a aplicação se o problema persistir',
+                'Verifique os logs para mais detalhes',
+                'Contate o suporte se necessário',
+            ],
+            documentation: 'https://docs.autocore.rbqa/system',
+        };
+        super(details, originalError, context);
+    }
+    static consoleError(message, context) {
+        return new SystemError('SYS_CONSOLE_ERROR', `Console error: ${message}`, 'Erro detectado no console do sistema.', undefined, context);
+    }
+    static genericError(message, originalError, context) {
+        return new SystemError('SYS_GENERIC_ERROR', message, 'Erro inesperado no sistema.', originalError, context);
+    }
+    static initializationError(component, error, context) {
+        return new SystemError('SYS_INITIALIZATION_ERROR', `Failed to initialize ${component}: ${error.message}`, `Falha na inicialização do componente ${component}.`, error, { ...context, metadata: { component } });
+    }
+    static resourceExhausted(resource, limit, context) {
+        return new SystemError('SYS_RESOURCE_EXHAUSTED', `Resource ${resource} exhausted, limit: ${limit}`, `Recurso ${resource} esgotado. Limite: ${limit}`, undefined, { ...context, metadata: { resource, limit } });
+    }
+}
+export default SystemError;

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

@@ -0,0 +1,14 @@
+/**
+ * ValidationError: Erros de validação de parâmetros e configurações
+ */
+import { BaseError, type ErrorContext } from './BaseError.js';
+export declare class ValidationError extends BaseError {
+    constructor(code: string, message: string, userMessage: string, originalError?: Error, context?: Partial<ErrorContext>);
+    static invalidParameter(paramName: string, expectedType: string, actualValue: unknown, context?: Partial<ErrorContext>): ValidationError;
+    static missingRequiredParameter(paramName: string, context?: Partial<ErrorContext>): ValidationError;
+    static invalidConfiguration(configKey: string, reason: string, context?: Partial<ErrorContext>): ValidationError;
+    static invalidSelector(selector: string, context?: Partial<ErrorContext>): ValidationError;
+    static invalidUrl(url: string, reason: string, context?: Partial<ErrorContext>): ValidationError;
+    static valueOutOfRange(paramName: string, value: number, min?: number, max?: number, context?: Partial<ErrorContext>): ValidationError;
+}
+export default ValidationError;

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

@@ -0,0 +1,61 @@
+/**
+ * ValidationError: Erros de validação de parâmetros e configurações
+ */
+import { BaseError } from './BaseError.js';
+export class ValidationError extends BaseError {
+    constructor(code, message, userMessage, originalError, context) {
+        const details = {
+            code,
+            message,
+            userMessage,
+            category: 'validation',
+            severity: 'medium',
+            recoverable: true,
+            suggestions: [
+                'Verifique os parâmetros informados',
+                'Consulte a documentação da API',
+                'Valide a configuração do projeto',
+            ],
+            documentation: 'https://docs.autocore.rbqa/validation',
+        };
+        super(details, originalError, context);
+    }
+    static invalidParameter(paramName, expectedType, actualValue, context) {
+        return new ValidationError('VAL_INVALID_PARAMETER', `Invalid parameter '${paramName}': expected ${expectedType}, got ${typeof actualValue}`, `Parâmetro '${paramName}' inválido. Esperado: ${expectedType}`, undefined, {
+            ...context,
+            metadata: {
+                paramName,
+                expectedType,
+                actualType: typeof actualValue,
+                actualValue,
+            },
+        });
+    }
+    static missingRequiredParameter(paramName, context) {
+        return new ValidationError('VAL_MISSING_PARAMETER', `Missing required parameter: ${paramName}`, `Parâmetro obrigatório '${paramName}' não informado.`, undefined, { ...context, metadata: { paramName } });
+    }
+    static invalidConfiguration(configKey, reason, context) {
+        return new ValidationError('VAL_INVALID_CONFIG', `Invalid configuration for '${configKey}': ${reason}`, `Configuração inválida para '${configKey}': ${reason}`, undefined, { ...context, metadata: { configKey, reason } });
+    }
+    static invalidSelector(selector, context) {
+        const error = new ValidationError('VAL_INVALID_SELECTOR', `Invalid selector: ${selector}`, `Seletor CSS/XPath inválido: ${selector}`, undefined, { ...context, metadata: { selector } });
+        error.suggestions.push('Verifique a sintaxe do seletor CSS ou XPath', 'Use ferramentas de desenvolvedor do navegador para testar', 'Consulte a documentação de seletores');
+        return error;
+    }
+    static invalidUrl(url, reason, context) {
+        const error = new ValidationError('VAL_INVALID_URL', `Invalid URL: ${url} - ${reason}`, `URL inválida: ${url}`, undefined, { ...context, metadata: { url, reason } });
+        error.suggestions.push('Verifique se a URL está correta', 'Inclua protocolo (http:// ou https://)', 'Verifique se o servidor está acessível');
+        return error;
+    }
+    static valueOutOfRange(paramName, value, min, max, context) {
+        const range = min !== undefined && max !== undefined
+            ? `entre ${min} e ${max}`
+            : min !== undefined
+                ? `maior ou igual a ${min}`
+                : max !== undefined
+                    ? `menor ou igual a ${max}`
+                    : 'no intervalo permitido';
+        return new ValidationError('VAL_VALUE_OUT_OF_RANGE', `Value ${value} for parameter '${paramName}' is out of range`, `Valor ${value} para '${paramName}' deve estar ${range}.`, undefined, { ...context, metadata: { paramName, value, min, max } });
+    }
+}
+export default ValidationError;

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

@@ -0,0 +1,12 @@
+/**
+ * Index de todas as classes de erro do AutoCore
+ * Facilita importação e uso das classes de erro
+ */
+export { BaseError, default as AutoCoreErrors, type ErrorContext, type ErrorDetails, } from './BaseError.js';
+export { ConfigurationError } from './ConfigurationError.js';
+export { type ErrorHandlerConfig, type ErrorMetrics, GlobalErrorHandler, globalErrorHandler, } from './GlobalErrorHandler.js';
+export { IntegrationError } from './IntegrationError.js';
+export { SecurityError } from './SecurityError.js';
+export { SystemError } from './SystemError.js';
+export { ValidationError } from './ValidationError.js';
+export { ErrorCatalog, formatError, getErrorHint, type ErrorCode, type ErrorEntry, type ErrorSeverity, } from './ErrorCatalog.js';

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

@@ -0,0 +1,13 @@
+/**
+ * Index de todas as classes de erro do AutoCore
+ * Facilita importação e uso das classes de erro
+ */
+// Re-export default
+export { BaseError, default as AutoCoreErrors, } from './BaseError.js';
+export { ConfigurationError } from './ConfigurationError.js';
+export { GlobalErrorHandler, globalErrorHandler, } from './GlobalErrorHandler.js';
+export { IntegrationError } from './IntegrationError.js';
+export { SecurityError } from './SecurityError.js';
+export { SystemError } from './SystemError.js';
+export { ValidationError } from './ValidationError.js';
+export { ErrorCatalog, formatError, getErrorHint, } from './ErrorCatalog.js';

package/dist/src/global-setup.d.ts

@@ -0,0 +1 @@
+export default function globalSetup(): Promise<void>;