@silasfmartins/testhub 1.0.0

package/dist/src/utils/DatabaseInterceptor.js

@@ -0,0 +1,295 @@
+import { StatementTracker } from '../hubdocs/StatementTracker.js';
+import { analyzeCurrentSpecFile } from './SpecFileAnalyzer.js';
+import { Logger } from './Logger.js';
+const interceptorsInstalled = new Set();
+// Regex constants para performance
+const SQL_PATTERN = /^(SELECT|INSERT|UPDATE|DELETE|CREATE|ALTER|DROP)/i;
+const FROM_PATTERN = /FROM\s+([^\s,]+)/i;
+const INSERT_PATTERN = /INSERT\s+INTO\s+([^\s,(]+)/i;
+const UPDATE_PATTERN = /UPDATE\s+([^\s,]+)/i;
+const DELETE_PATTERN = /DELETE\s+FROM\s+([^\s,]+)/i;
+/**
+ * 🎯 Detecta tipo de operação SQL automaticamente
+ */
+function detectSqlType(sql) {
+    const sqlUpper = sql.trim().toUpperCase();
+    if (sqlUpper.startsWith('SELECT')) {
+        return 'SELECT';
+    }
+    if (sqlUpper.startsWith('INSERT')) {
+        return 'INSERT';
+    }
+    if (sqlUpper.startsWith('UPDATE')) {
+        return 'UPDATE';
+    }
+    if (sqlUpper.startsWith('DELETE')) {
+        return 'DELETE';
+    }
+    if (sqlUpper.startsWith('CREATE')) {
+        return 'CREATE';
+    }
+    if (sqlUpper.startsWith('ALTER')) {
+        return 'ALTER';
+    }
+    if (sqlUpper.startsWith('DROP')) {
+        return 'DROP';
+    }
+    return 'SQL';
+}
+/**
+ * 🎯 Extrai descrição ou SQL da lista de argumentos
+ */
+function extractInfo(methodName, args) {
+    if (args.length === 0) {
+        return {};
+    }
+    // BancoActions.execute(description, sql)
+    if (methodName === 'execute' && args.length >= 2) {
+        return { description: String(args[0]), sql: String(args[1]) };
+    }
+    // BancoActions.executeQuery(sql) ou BancoHelper.executarQuery(sql)
+    if ((methodName === 'executeQuery' || methodName === 'executarQuery') &&
+        args.length >= 1) {
+        return { sql: String(args[0]) };
+    }
+    // BancoActions.update(description, sql)
+    if (methodName === 'update' && args.length >= 2) {
+        return { description: String(args[0]), sql: String(args[1]) };
+    }
+    // BancoActions.select(sql)
+    if (methodName === 'select' && args.length >= 1) {
+        return { sql: String(args[0]) };
+    }
+    // Fallback: primeiro argumento que é string
+    const firstStringArg = args.find((arg) => typeof arg === 'string');
+    if (firstStringArg) {
+        // Se parece com SQL, é SQL
+        if (String(firstStringArg).trim().toUpperCase().match(SQL_PATTERN)) {
+            return { sql: String(firstStringArg) };
+        }
+        return { description: String(firstStringArg) };
+    }
+    return {};
+}
+/**
+ * 🎯 Extrai nome da tabela do SQL
+ */
+function extractTableName(sql) {
+    const sqlUpper = sql.trim().toUpperCase();
+    // SELECT ... FROM table
+    let match = sqlUpper.match(FROM_PATTERN);
+    if (match) {
+        return match[1];
+    }
+    // INSERT INTO table
+    match = sqlUpper.match(INSERT_PATTERN);
+    if (match) {
+        return match[1];
+    }
+    // UPDATE table
+    match = sqlUpper.match(UPDATE_PATTERN);
+    if (match) {
+        return match[1];
+    }
+    // DELETE FROM table
+    match = sqlUpper.match(DELETE_PATTERN);
+    if (match) {
+        return match[1];
+    }
+    return null;
+}
+/**
+ * 🎯 Gera nome do CT automaticamente
+ */
+function generateCtName(info) {
+    const { className, methodName, sql, description } = info;
+    // 🆕 NOVO: Obter informações do CN/CT do arquivo .spec.ts atual
+    let ctPrefix = '';
+    try {
+        const specAnalysis = analyzeCurrentSpecFile();
+        const cnName = specAnalysis.cn;
+        const ctName = specAnalysis.ct;
+        if (cnName || ctName) {
+            const parts = [];
+            if (cnName)
+                parts.push(cnName);
+            if (ctName)
+                parts.push(ctName);
+            ctPrefix = `${parts.join(' → ')} → `;
+        }
+    }
+    catch {
+        // Silenciosamente ignorar erros na análise do spec
+    }
+    // Se tem descrição, usar ela
+    if (description) {
+        return `${ctPrefix}${className}.${methodName}() - ${description}`;
+    }
+    // Se tem SQL, detectar tipo e usar
+    if (sql) {
+        const sqlType = detectSqlType(sql);
+        const tableName = extractTableName(sql);
+        return `${ctPrefix}${className}.${methodName}() - ${sqlType}${tableName ? ` ${tableName}` : ''}`;
+    }
+    // Fallback: nome do método
+    return `${ctPrefix}${className}.${methodName}()`;
+}
+/**
+ * 🤖 Intercepta método automaticamente
+ */
+function interceptMethod(target, className, methodName, originalMethod) {
+    return async (...args) => {
+        // Extrair informações da chamada
+        const info = extractInfo(methodName, args);
+        const methodInfo = {
+            className,
+            methodName,
+            args,
+            ...info,
+        };
+        // 🔧 CORREÇÃO CRÍTICA: NÃO criar CTs para métodos de banco
+        // DatabaseInterceptor deve apenas REGISTRAR AÇÕES, não criar CTs
+        // CTs são criados apenas para métodos Statement (validateCep, processOrder, etc.)
+        Logger.info(`🗄️ [DatabaseInterceptor] Executando ${className}.${methodName}() - REGISTRANDO AÇÃO`);
+        // Gerar nome da ação (não CT)
+        const actionName = generateCtName(methodInfo);
+        const startTime = Date.now();
+        try {
+            // Executar método original
+            const result = await originalMethod.apply(target, args);
+            const duration = Date.now() - startTime;
+            // ✅ NOVO: Registrar como AÇÃO executada, não como CT
+            StatementTracker.recordAction('DB', `${className}.${methodName}() - ${actionName}`, true, duration, {
+                query: methodInfo.sql?.slice(0, 500) || 'N/A',
+            });
+            Logger.info(`✅ [DatabaseInterceptor] ${className}.${methodName}() executado com sucesso (${duration}ms)`);
+            return result;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            // ✅ NOVO: Registrar como AÇÃO falhada, não como CT falhado
+            StatementTracker.recordAction('DB', `${className}.${methodName}() - ${actionName}`, false, duration, {
+                query: methodInfo.sql?.slice(0, 500) || 'N/A',
+            });
+            Logger.error(`❌ [DatabaseInterceptor] ${className}.${methodName}() falhou (${duration}ms): ${error}`);
+            // Re-throw o erro
+            throw error;
+        }
+    };
+}
+/**
+ * 🎯 Métodos que devem ser interceptados por classe
+ * APENAS métodos de negócio - NÃO métodos internos do framework
+ */
+const METHODS_TO_INTERCEPT = {
+    // Banco de Dados - apenas métodos de execução SQL
+    BancoActions: ['execute', 'executeQuery', 'update', 'select', 'selectColumn'],
+    BancoHelper: ['executarQuery', 'validateEquals'],
+    // SSH - apenas métodos de comando e validação
+    SSHActions: [
+        'write',
+        'read',
+        'executeAndRead',
+        'validateContains',
+        'validateEquals',
+    ],
+    // 🚫 API REMOVIDO - ApiActions são métodos internos que não devem ser interceptados como CTs
+    // 'ApiActions': ['get', 'post', 'put', 'delete', 'patch', 'request'], // <- REMOVIDO
+    // Web (Playwright) - apenas ações de interação
+    WebActions: [
+        'navegarPara',
+        'click',
+        'doubleClick',
+        'rightClick',
+        'preencher',
+        'hover',
+        'mouseMove',
+        'selecionarOpcao',
+        'selecionarEmLista',
+        'selecionarOpcaoTabela',
+        'trocarFrame',
+        'esperarElemento',
+        'esperarTexto',
+        'obterTexto',
+        'obterValor',
+        'capturarPrint',
+        'verificarExistencia',
+        'validarTextoCampo',
+        'validarExistencia',
+        'executarJavaScript',
+    ],
+    // Mobile (Appium) - apenas ações de interação
+    MobileActions: [
+        'click',
+        'tap',
+        'setText',
+        'swipe',
+        'scroll',
+        'longPress',
+        'doubleClick',
+        'dragAndDrop',
+        'hideKeyboard',
+        'swipeLeft',
+        'swipeRight',
+        'swipeUp',
+        'swipeDown',
+        'pinch',
+        'zoom',
+        'waitForElement',
+        'back',
+        'switchToContext',
+    ],
+};
+/**
+ * 🚀 Instala interceptação automática em uma classe
+ */
+export function installDatabaseInterceptor(targetClass, className) {
+    const interceptorKey = `${className}`;
+    if (interceptorsInstalled.has(interceptorKey)) {
+        return; // Já instalado
+    }
+    // Obter lista de métodos permitidos para esta classe
+    const allowedMethods = METHODS_TO_INTERCEPT[className] || [];
+    if (allowedMethods.length === 0) {
+        // Se não tem métodos específicos, não interceptar nada
+        if (process.env.AUTOCORE_DEBUG_LOGS === 'true') {
+            process.stderr.write(`[DatabaseInterceptor] Nenhum método definido para interceptar em ${className}\n`);
+        }
+        return;
+    }
+    let interceptedCount = 0;
+    for (const methodName of allowedMethods) {
+        const target = targetClass;
+        const originalMethod = target[methodName];
+        // Interceptar apenas se método existir e for função
+        if (typeof originalMethod === 'function') {
+            target[methodName] = interceptMethod(targetClass, className, methodName, originalMethod);
+            interceptedCount++;
+        }
+    }
+    interceptorsInstalled.add(interceptorKey);
+    // Log interno do framework - silent mode disponível
+    if (process.env.AUTOCORE_DEBUG_LOGS === 'true') {
+        process.stdout.write(`🤖 [DatabaseInterceptor] Interceptação instalada em ${className} (${interceptedCount}/${allowedMethods.length} métodos)\n`);
+    }
+}
+/**
+ * 🚀 Instala interceptação automática em múltiplas classes
+ */
+export function installDatabaseInterceptors(classes) {
+    for (const { class: targetClass, name } of classes) {
+        installDatabaseInterceptor(targetClass, name);
+    }
+}
+/**
+ * 📋 Lista interceptadores instalados
+ */
+export function getInstalledDatabaseInterceptors() {
+    return Array.from(interceptorsInstalled);
+}
+/**
+ * 🧹 Remove todos os interceptadores
+ */
+export function clearDatabaseInterceptors() {
+    interceptorsInstalled.clear();
+}

package/dist/src/utils/DateHelper.d.ts

@@ -0,0 +1,16 @@
+export type DateFormat = "DD/MM/YYYY" | "MM/DD/YYYY" | "YYYY-MM-DD" | "DD-MM-YYYY" | "MM-DD-YYYY" | "DD.MM.YYYY" | "MM.DD.YYYY" | string;
+export type DateOptions = {
+    descricao?: string;
+    tirarPrint?: boolean;
+    delay?: number;
+    inputFormat?: DateFormat;
+    outputFormat?: DateFormat;
+    outputSeparator?: "/" | "-" | ".";
+    pressTab?: boolean;
+};
+export declare class DateHelper {
+    static convert(value: string, inputFormat?: DateFormat, outputFormat?: DateFormat): string;
+    static changeSeparator(value: string, separator: "/" | "-" | "."): string;
+    static toISO(value: string, inputFormat?: DateFormat): string;
+    static detectFormat(value: string): DateFormat;
+}

package/dist/src/utils/DateHelper.js

@@ -0,0 +1,120 @@
+const clamp = (value, min, max) => Math.min(max, Math.max(min, value));
+const pad2 = (value) => String(clamp(value, 0, 99)).padStart(2, "0");
+const pad4 = (value) => String(clamp(value, 0, 9999)).padStart(4, "0");
+const normalizeFormat = (format) => format
+    .trim()
+    .toUpperCase()
+    .replace(/D{2}/g, "DD")
+    .replace(/M{2}/g, "MM")
+    .replace(/Y{4}/g, "YYYY");
+const detectSeparator = (value) => {
+    if (value.includes("/"))
+        return "/";
+    if (value.includes("-"))
+        return "-";
+    if (value.includes("."))
+        return ".";
+    return "/";
+};
+const parseParts = (value) => value
+    .trim()
+    .split(/[^0-9]+/g)
+    .filter(Boolean)
+    .map((part) => Number.parseInt(part, 10))
+    .filter((part) => Number.isFinite(part));
+const parseWithFormat = (value, format) => {
+    const fmt = normalizeFormat(format);
+    const sep = detectSeparator(fmt);
+    const fmtParts = fmt.split(sep);
+    const values = parseParts(value);
+    if (fmtParts.length !== 3 || values.length < 3)
+        return null;
+    let day = 1;
+    let month = 1;
+    let year = 1970;
+    for (let i = 0; i < fmtParts.length; i++) {
+        const token = fmtParts[i];
+        const parsed = values[i];
+        if (!Number.isFinite(parsed))
+            return null;
+        if (token === "DD")
+            day = parsed;
+        if (token === "MM")
+            month = parsed;
+        if (token === "YYYY")
+            year = parsed;
+    }
+    if (year < 100 && year >= 0)
+        year += 2000;
+    if (month < 1 || month > 12)
+        return null;
+    if (day < 1 || day > 31)
+        return null;
+    return { day, month, year };
+};
+const parseAuto = (value) => {
+    const parts = parseParts(value);
+    if (parts.length < 3)
+        return null;
+    let day = parts[0];
+    let month = parts[1];
+    let year = parts[2];
+    if (String(parts[0]).length === 4) {
+        year = parts[0];
+        month = parts[1];
+        day = parts[2];
+    }
+    else if (parts[0] <= 12 && parts[1] > 12) {
+        month = parts[0];
+        day = parts[1];
+    }
+    if (year < 100 && year >= 0)
+        year += 2000;
+    if (month < 1 || month > 12)
+        return null;
+    if (day < 1 || day > 31)
+        return null;
+    return { day, month, year };
+};
+const formatParsedDate = (parsed, format) => {
+    const fmt = normalizeFormat(String(format || "DD/MM/YYYY"));
+    return fmt
+        .replace(/DD/g, pad2(parsed.day))
+        .replace(/MM/g, pad2(parsed.month))
+        .replace(/YYYY/g, pad4(parsed.year));
+};
+export class DateHelper {
+    static convert(value, inputFormat = "DD/MM/YYYY", outputFormat = "DD/MM/YYYY") {
+        const parsed = parseWithFormat(value, String(inputFormat)) || parseAuto(value);
+        if (!parsed)
+            return String(value || "").trim();
+        return formatParsedDate(parsed, outputFormat);
+    }
+    static changeSeparator(value, separator) {
+        return String(value || "").replace(/[\/\-.]/g, separator);
+    }
+    static toISO(value, inputFormat) {
+        const parsed = (inputFormat ? parseWithFormat(value, String(inputFormat)) : null) ||
+            parseAuto(value);
+        if (!parsed)
+            return String(value || "").trim();
+        return `${pad4(parsed.year)}-${pad2(parsed.month)}-${pad2(parsed.day)}`;
+    }
+    static detectFormat(value) {
+        const trimmed = String(value || "").trim();
+        if (!trimmed)
+            return "DD/MM/YYYY";
+        if (/^\d{4}[\/\-.]\d{1,2}[\/\-.]\d{1,2}$/.test(trimmed)) {
+            return "YYYY-MM-DD";
+        }
+        const parts = parseParts(trimmed);
+        if (parts.length >= 3) {
+            const [a, b] = parts;
+            if (a > 12)
+                return "DD/MM/YYYY";
+            if (b > 12)
+                return "MM/DD/YYYY";
+        }
+        return "DD/MM/YYYY";
+    }
+}

package/dist/src/utils/DateValidator.d.ts

@@ -0,0 +1,4 @@
+import type { ILocator } from "../interfaces.js";
+export declare class DateValidator {
+    static validateFilled(locator: ILocator, expectedValue: string, _context?: string): Promise<boolean>;
+}

package/dist/src/utils/DateValidator.js

@@ -0,0 +1,51 @@
+import { DateHelper } from "./DateHelper.js";
+const normalize = (value) => String(value || "")
+    .trim()
+    .replace(/\s+/g, "")
+    .toLowerCase();
+const normalizeDateLike = (value) => String(value || "").replace(/[^0-9]/g, "");
+export class DateValidator {
+    static async validateFilled(locator, expectedValue, _context) {
+        try {
+            const expected = String(expectedValue || "").trim();
+            if (!expected)
+                return false;
+            let actual = "";
+            try {
+                actual = await locator.inputValue();
+            }
+            catch { }
+            if (!actual) {
+                try {
+                    actual = (await locator.textContent()) || "";
+                }
+                catch { }
+            }
+            if (!actual) {
+                try {
+                    actual = (await locator.getAttribute("value")) || "";
+                }
+                catch { }
+            }
+            const expectedNorm = normalize(expected);
+            const actualNorm = normalize(actual);
+            if (expectedNorm && actualNorm && expectedNorm === actualNorm) {
+                return true;
+            }
+            const expectedDigits = normalizeDateLike(expected);
+            const actualDigits = normalizeDateLike(actual);
+            if (expectedDigits && actualDigits && expectedDigits === actualDigits) {
+                return true;
+            }
+            const expectedIso = DateHelper.toISO(expected);
+            const actualIso = DateHelper.toISO(actual);
+            if (expectedIso && actualIso && expectedIso === actualIso) {
+                return true;
+            }
+            return false;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/src/utils/DocumentGenerator.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Utility class to generate documents and IDs used in tests.
+ */
+export declare class DocumentGenerator {
+    private static readonly CPF_INITIAL_DIGITS;
+    private static readonly CPF_RANDOM_MULTIPLIER;
+    private static readonly CPF_MODULO_DIVISOR;
+    private static readonly CNPJ_RANDOM_MULTIPLIER;
+    private static readonly CNPJ_FIXED_PART;
+    private static readonly CNPJ_FIRST_MULTIPLIERS;
+    private static readonly CNPJ_SECOND_MULTIPLIERS;
+    private static readonly HEX_CHARS;
+    private static readonly ALPHANUMERIC_CHARS;
+    private static readonly EXTERNAL_ID_PART1_LENGTH;
+    private static readonly EXTERNAL_ID_PART2_LENGTH;
+    private static readonly EXTERNAL_ID_PART3_PREFIX_LENGTH;
+    private static readonly SERVICENOW_PART1_LENGTH;
+    private static readonly SERVICENOW_PART2_LENGTH;
+    /** Generate a valid CPF (returns digits only) and writes to DataStore key 'CPF' */
+    static generateCPF(): string;
+    private static computeCpfCheckDigits;
+    /** Generate a valid CNPJ (returns digits only) and writes to DataStore key 'CNPJ' */
+    static generateCNPJ(): string;
+    private static computeCheckDigit;
+    /** Generate a random alphanumeric string based on Node UUID (no hyphens) */
+    static generateRandomAlphanumericUUID(length: number): string;
+    /** Generate complex external id similar to example */
+    static generateComplexExternalId(): string;
+    static generateRandomAlphanumeric(length: number): string;
+    static generateRandomNumeric(length: number): string;
+    static generateServiceNowTaskId(): string;
+    /** Generate a random email and store in DataStore 'EMAIL' */
+    static generateRandomEmail(): string;
+}
+export default DocumentGenerator;

package/dist/src/utils/DocumentGenerator.js

@@ -0,0 +1,129 @@
+import { randomUUID } from 'node:crypto';
+import { DataStore } from '@silasfmartins/testhub';
+/**
+ * Utility class to generate documents and IDs used in tests.
+ */
+export class DocumentGenerator {
+    // CPF constants
+    static CPF_INITIAL_DIGITS = 9;
+    static CPF_RANDOM_MULTIPLIER = 10;
+    static CPF_MODULO_DIVISOR = 11;
+    // CNPJ constants
+    static CNPJ_RANDOM_MULTIPLIER = 10;
+    static CNPJ_FIXED_PART = [0, 0, 0, 1];
+    static CNPJ_FIRST_MULTIPLIERS = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
+    static CNPJ_SECOND_MULTIPLIERS = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
+    // Other generators
+    static HEX_CHARS = 'abcdef0123456789';
+    static ALPHANUMERIC_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    // ServiceNow / external id lengths
+    static EXTERNAL_ID_PART1_LENGTH = 32;
+    static EXTERNAL_ID_PART2_LENGTH = 32;
+    static EXTERNAL_ID_PART3_PREFIX_LENGTH = 30;
+    static SERVICENOW_PART1_LENGTH = 32;
+    static SERVICENOW_PART2_LENGTH = 31;
+    /** Generate a valid CPF (returns digits only) and writes to DataStore key 'CPF' */
+    static generateCPF() {
+        const initials = [];
+        for (let i = 0; i < this.CPF_INITIAL_DIGITS; i++) {
+            initials.push(Math.floor(Math.random() * this.CPF_RANDOM_MULTIPLIER));
+        }
+        const [d1, d2] = this.computeCpfCheckDigits(initials);
+        const cpf = [...initials, d1, d2].join('');
+        try {
+            DataStore.set('CPF', cpf);
+        }
+        catch {
+            // ignore if DataStore not available in environment
+        }
+        return cpf;
+    }
+    static computeCpfCheckDigits(digits) {
+        const firstMultipliers = [10, 9, 8, 7, 6, 5, 4, 3, 2];
+        const secondMultipliers = [11, 10, 9, 8, 7, 6, 5, 4, 3, 2];
+        const sum1 = digits.reduce((s, d, i) => s + d * firstMultipliers[i], 0);
+        const r1 = sum1 % this.CPF_MODULO_DIVISOR;
+        const dig1 = r1 < 2 ? 0 : this.CPF_MODULO_DIVISOR - r1;
+        const digitsWithFirst = [...digits, dig1];
+        const sum2 = digitsWithFirst.reduce((s, d, i) => s + d * secondMultipliers[i], 0);
+        const r2 = sum2 % this.CPF_MODULO_DIVISOR;
+        const dig2 = r2 < 2 ? 0 : this.CPF_MODULO_DIVISOR - r2;
+        return [dig1, dig2];
+    }
+    /** Generate a valid CNPJ (returns digits only) and writes to DataStore key 'CNPJ' */
+    static generateCNPJ() {
+        // generate first 8 random digits
+        const first8 = [];
+        for (let i = 0; i < 8; i++) {
+            first8.push(Math.floor(Math.random() * this.CNPJ_RANDOM_MULTIPLIER));
+        }
+        const base = [...first8, ...this.CNPJ_FIXED_PART]; // 12 digits
+        const dig1 = this.computeCheckDigit(base, this.CNPJ_FIRST_MULTIPLIERS);
+        const dig2 = this.computeCheckDigit([...base, dig1], this.CNPJ_SECOND_MULTIPLIERS);
+        const cnpj = [...base, dig1, dig2].join('');
+        try {
+            DataStore.set('CNPJ', cnpj);
+        }
+        catch {
+            // ignore
+        }
+        return cnpj;
+    }
+    static computeCheckDigit(digits, multipliers) {
+        const sum = digits.reduce((s, d, i) => s + d * multipliers[i], 0);
+        const r = sum % 11;
+        return r < 2 ? 0 : 11 - r;
+    }
+    /** Generate a random alphanumeric string based on Node UUID (no hyphens) */
+    static generateRandomAlphanumericUUID(length) {
+        let result = randomUUID().replace(/-/g, '');
+        while (result.length < length) {
+            result += randomUUID().replace(/-/g, '');
+        }
+        return result.substring(0, length);
+    }
+    /** Generate complex external id similar to example */
+    static generateComplexExternalId() {
+        const randomHex = (len) => Array.from({ length: len }, () => this.HEX_CHARS[Math.floor(Math.random() * this.HEX_CHARS.length)]).join('');
+        const part1 = randomHex(this.EXTERNAL_ID_PART1_LENGTH);
+        const part2 = randomHex(this.EXTERNAL_ID_PART2_LENGTH);
+        const part3 = '0x' +
+            randomHex(this.EXTERNAL_ID_PART3_PREFIX_LENGTH) +
+            String.fromCharCode(97 + Math.floor(Math.random() * 26));
+        return `${part1}-${part2}${part3}`;
+    }
+    static generateRandomAlphanumeric(length) {
+        let out = '';
+        for (let i = 0; i < length; i++) {
+            out += this.ALPHANUMERIC_CHARS.charAt(Math.floor(Math.random() * this.ALPHANUMERIC_CHARS.length));
+        }
+        return out;
+    }
+    static generateRandomNumeric(length) {
+        const digits = '0123456789';
+        let out = '';
+        for (let i = 0; i < length; i++) {
+            out += digits.charAt(Math.floor(Math.random() * digits.length));
+        }
+        return out;
+    }
+    static generateServiceNowTaskId() {
+        const randomHex = (len) => Array.from({ length: len }, () => this.HEX_CHARS[Math.floor(Math.random() * this.HEX_CHARS.length)]).join('');
+        const part1 = randomHex(this.SERVICENOW_PART1_LENGTH);
+        const part2 = randomHex(this.SERVICENOW_PART2_LENGTH);
+        return `${part1}x${part2}`;
+    }
+    /** Generate a random email and store in DataStore 'EMAIL' */
+    static generateRandomEmail() {
+        const randomString = Math.random().toString(36).substring(2, 10);
+        const email = `test_${randomString}@email.com`;
+        try {
+            DataStore.set('EMAIL', email);
+        }
+        catch {
+            // ignore
+        }
+        return email;
+    }
+}
+export default DocumentGenerator;