@arkyn/server 3.0.1-beta.117 → 3.0.1-beta.119

package/dist/validations/validateCep.js

@@ -1,33 +1,27 @@
 import { removeNonNumeric } from "@arkyn/shared";
 /**
- * Removes all non-digit characters from the CEP.
- * @param cep - Raw CEP string.
- * @returns Only numeric characters.
- */
-/**
- * Validates a Brazilian CEP (Código de Endereçamento Postal).
+ * Validates a Brazilian CEP (postal code).
  *
- * A valid CEP has 8 numeric digits.
+ * A valid CEP must contain exactly 8 numeric digits,
+ * optionally formatted as "12345-678".
  *
- * @param rawCep - CEP string, may include formatting (e.g., "12345-678").
- * @returns `true` if the CEP is valid, otherwise `false`.
+ * @param {string} rawCep - CEP value, with or without formatting.
+ * @returns {boolean} `true` if the CEP is valid, otherwise `false`.
  *
  * @example
- * ```ts
+ * ```typescript
  * validateCep("12345-678"); // true
  * validateCep("12345678");  // true
  * validateCep("ABCDE-123"); // false
  * ```
  */
-const validateCep = (rawCep) => {
-    if (!rawCep)
-        return false;
-    const validFormat = /^[0-9-]+$/.test(rawCep);
+function validateCep(rawCep) {
+    const validFormat = /^\d{5}-\d{3}$/.test(rawCep) || /^\d{8}$/.test(rawCep);
     if (!validFormat)
         return false;
     const cep = removeNonNumeric(rawCep);
     const CEP_LENGTH = 8;
     const isOnlyDigits = /^\d{8}$/.test(cep);
     return cep.length === CEP_LENGTH && isOnlyDigits;
-};
+}
 export { validateCep };

package/dist/validations/validateCnpj.d.ts

@@ -1,4 +1,3 @@
-type ValidateCnpjFunction = (rawCnpj: string) => boolean;
 /**
  * Validates a Brazilian CNPJ (Cadastro Nacional da Pessoa Jurídica) number.
  *
@@ -8,15 +7,15 @@ type ValidateCnpjFunction = (rawCnpj: string) => boolean;
  * - Repeating digits check (invalid if all digits are the same).
  * - Verifies the two check digits with the proper weights.
  *
- * @param rawCnpj - CNPJ string, possibly formatted.
- * @returns `true` if valid, otherwise `false`.
+ * @param {string} rawCnpj - CNPJ string, possibly formatted.
+ * @returns {boolean} `true` if valid, otherwise `false`.
  *
  * @example
- * ```ts
+ * ```typescript
  * validateCnpj("12.345.678/0001-95"); // false
  * validateCnpj("11.444.777/0001-61"); // true
  * ```
  */
-declare const validateCnpj: ValidateCnpjFunction;
+declare function validateCnpj(rawCnpj: string): boolean;
 export { validateCnpj };
 //# sourceMappingURL=validateCnpj.d.ts.map

package/dist/validations/validateCnpj.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validateCnpj.d.ts","sourceRoot":"","sources":["../../src/validations/validateCnpj.ts"],"names":[],"mappings":"AAEA,KAAK,oBAAoB,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;AAyBzD;;;;;;;;;;;;;;;;;GAiBG;AAEH,QAAA,MAAM,YAAY,EAAE,oBAgBnB,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,CAAC"}
+{"version":3,"file":"validateCnpj.d.ts","sourceRoot":"","sources":["../../src/validations/validateCnpj.ts"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;GAiBG;AAEH,iBAAS,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAqB9C;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/validations/validateCnpj.js

@@ -27,18 +27,25 @@ function extractDigit(cnpj) {
  * - Repeating digits check (invalid if all digits are the same).
  * - Verifies the two check digits with the proper weights.
  *
- * @param rawCnpj - CNPJ string, possibly formatted.
- * @returns `true` if valid, otherwise `false`.
+ * @param {string} rawCnpj - CNPJ string, possibly formatted.
+ * @returns {boolean} `true` if valid, otherwise `false`.
  *
  * @example
- * ```ts
+ * ```typescript
  * validateCnpj("12.345.678/0001-95"); // false
  * validateCnpj("11.444.777/0001-61"); // true
  * ```
  */
-const validateCnpj = (rawCnpj) => {
+function validateCnpj(rawCnpj) {
     if (!rawCnpj)
         return false;
+    if (rawCnpj.length > 18)
+        return false;
+    if (rawCnpj.length < 14)
+        return false;
+    const hasSpaces = /\s/.test(rawCnpj);
+    if (hasSpaces)
+        return false;
     const cnpj = removeNonNumeric(rawCnpj);
     if (isInvalidLength(cnpj))
         return false;
@@ -48,5 +55,5 @@ const validateCnpj = (rawCnpj) => {
     const digit1 = calculateDigit(base, [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]);
     const digit2 = calculateDigit(base + digit1, [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]);
     return extractDigit(cnpj) === `${digit1}${digit2}`;
-};
+}
 export { validateCnpj };

package/dist/validations/validateCpf.d.ts

@@ -1,4 +1,3 @@
-type ValidateCpfFunction = (rawCpf: string) => boolean;
 /**
  * Validates a Brazilian CPF (Cadastro de Pessoas Físicas) number.
  *
@@ -10,8 +9,8 @@ type ValidateCpfFunction = (rawCpf: string) => boolean;
  * - Calculates the first and second verification digits using the CPF algorithm.
  * - Compares the calculated verification digits with the ones provided in the CPF.
  *
- * @param rawCpf - The raw CPF string, which may include formatting characters (e.g., dots or dashes).
- * @returns `true` if the CPF is valid, otherwise `false`.
+ * @param {string} rawCpf - The raw CPF string, which may include formatting characters (e.g., dots or dashes).
+ * @returns {boolean} `true` if the CPF is valid, otherwise `false`.
  *
  * @example
  * ```typescript
@@ -19,6 +18,6 @@ type ValidateCpfFunction = (rawCpf: string) => boolean;
  * validateCpf("111.444.777-35"); // true
  * ```
  */
-declare const validateCpf: ValidateCpfFunction;
+declare function validateCpf(rawCpf: string): boolean;
 export { validateCpf };
 //# sourceMappingURL=validateCpf.d.ts.map

package/dist/validations/validateCpf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validateCpf.d.ts","sourceRoot":"","sources":["../../src/validations/validateCpf.ts"],"names":[],"mappings":"AAEA,KAAK,mBAAmB,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC;AAyBvD;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,QAAA,MAAM,WAAW,EAAE,mBAWlB,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"validateCpf.d.ts","sourceRoot":"","sources":["../../src/validations/validateCpf.ts"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,iBAAS,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAiB5C;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/validations/validateCpf.js

@@ -30,8 +30,8 @@ function extractDigit(cpf) {
  * - Calculates the first and second verification digits using the CPF algorithm.
  * - Compares the calculated verification digits with the ones provided in the CPF.
  *
- * @param rawCpf - The raw CPF string, which may include formatting characters (e.g., dots or dashes).
- * @returns `true` if the CPF is valid, otherwise `false`.
+ * @param {string} rawCpf - The raw CPF string, which may include formatting characters (e.g., dots or dashes).
+ * @returns {boolean} `true` if the CPF is valid, otherwise `false`.
  *
  * @example
  * ```typescript
@@ -39,9 +39,16 @@ function extractDigit(cpf) {
  * validateCpf("111.444.777-35"); // true
  * ```
  */
-const validateCpf = (rawCpf) => {
+function validateCpf(rawCpf) {
     if (!rawCpf)
         return false;
+    if (rawCpf.length > 14)
+        return false;
+    if (rawCpf.length < 11)
+        return false;
+    const hasSpaces = /\s/.test(rawCpf);
+    if (hasSpaces)
+        return false;
     const cpf = removeNonNumeric(rawCpf);
     if (isInvalidLength(cpf))
         return false;
@@ -50,5 +57,5 @@ const validateCpf = (rawCpf) => {
     const digit1 = calculateDigit(cpf, 10);
     const digit2 = calculateDigit(cpf, 11);
     return extractDigit(cpf) === `${digit1}${digit2}`;
-};
+}
 export { validateCpf };

package/dist/validations/validateDate.d.ts

@@ -1,34 +1,27 @@
-type ValidateDateConfig = {
-    inputFormat?: "DD/MM/YYYY" | "MM-DD-YYYY" | "YYYY-MM-DD";
-    minYear?: number;
-    maxYear?: number;
-};
-type ValidateDateFunction = (rawDate: string, config?: ValidateDateConfig) => boolean;
 /**
  * Validates a date string based on the provided format and configuration.
  *
- * @param rawDate - The date string to validate.
- * @param config - Optional configuration object to customize validation.
- * @param config.inputFormat - The expected format of the input date.
- *                            Supported formats are "DD/MM/YYYY", "MM-DD-YYYY", and "YYYY-MM-DD".
- *                            Defaults to "DD/MM/YYYY".
- * @param config.minYear - The minimum allowed year for the date. Defaults to 1900.
- * @param config.maxYear - The maximum allowed year for the date. Defaults to 3000.
- *
- * @returns `true` if the date is valid according to the specified format and configuration, otherwise `false`.
- *
- * @throws {Error} If an invalid date format is provided in the configuration.
+ * @param {string} date - The date string to validate.
+ * @param {object} config - Optional configuration object to customize validation.
+ * @param {number} config.minYear - The minimum allowed year for the date. Defaults to 1900.
+ * @param {number} config.maxYear - The maximum allowed year for the date. Defaults to 3000.
+ * @throws {Error} If an invalid input format is provided.
+ * @returns {boolean} `true` if the date is valid according to the specified format and configuration, otherwise `false`.
  *
  * @example
  * ```typescript
  * validateDate("31/12/2023"); // true
- * validateDate("12-31-2023", { inputFormat: "MM-DD-YYYY" }); // true
- * validateDate("2023-12-31", { inputFormat: "YYYY-MM-DD", minYear: 2000, maxYear: 2100 }); // true
- * validateDate("29/02/2024", { inputFormat: "DD/MM/YYYY" }); // true (leap year)
- * validateDate("29/02/2023", { inputFormat: "DD/MM/YYYY" }); // false (not a leap year)
- * validateDate("31/04/2023", { inputFormat: "DD/MM/YYYY" }); // false (April has 30 days)
+ * validateDate("12-31-2023", { inputFormat: "isoDate" }); // true
+ * validateDate("2023-12-31", { inputFormat: "timestamp", minYear: 2000, maxYear: 2100 }); // true
+ * validateDate("29/02/2024", { inputFormat: "brazilianDate" }); // true (leap year)
+ * validateDate("29/02/2023", { inputFormat: "brazilianDate" }); // false (not a leap year)
+ * validateDate("31/04/2023", { inputFormat: "brazilianDate" }); // false (April has 30 days)
  * ```
  */
-declare const validateDate: ValidateDateFunction;
+declare function validateDate(date: string, config?: {
+    inputFormat?: "brazilianDate" | "isoDate" | "timestamp";
+    minYear?: number;
+    maxYear?: number;
+}): boolean;
 export { validateDate };
 //# sourceMappingURL=validateDate.d.ts.map

package/dist/validations/validateDate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validateDate.d.ts","sourceRoot":"","sources":["../../src/validations/validateDate.ts"],"names":[],"mappings":"AAAA,KAAK,kBAAkB,GAAG;IACxB,WAAW,CAAC,EAAE,YAAY,GAAG,YAAY,GAAG,YAAY,CAAC;IACzD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,KAAK,oBAAoB,GAAG,CAC1B,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,kBAAkB,KACxB,OAAO,CAAC;AAEb;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,QAAA,MAAM,YAAY,EAAE,oBA8CnB,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,CAAC"}
+{"version":3,"file":"validateDate.d.ts","sourceRoot":"","sources":["../../src/validations/validateDate.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,iBAAS,YAAY,CACnB,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE;IACP,WAAW,CAAC,EAAE,eAAe,GAAG,SAAS,GAAG,WAAW,CAAC;IACxD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GACA,OAAO,CAiCT;AAED,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/validations/validateDate.js

@@ -1,73 +1,55 @@
+import { ValidateDateService } from "@arkyn/shared";
 /**
  * Validates a date string based on the provided format and configuration.
  *
- * @param rawDate - The date string to validate.
- * @param config - Optional configuration object to customize validation.
- * @param config.inputFormat - The expected format of the input date.
- *                            Supported formats are "DD/MM/YYYY", "MM-DD-YYYY", and "YYYY-MM-DD".
- *                            Defaults to "DD/MM/YYYY".
- * @param config.minYear - The minimum allowed year for the date. Defaults to 1900.
- * @param config.maxYear - The maximum allowed year for the date. Defaults to 3000.
- *
- * @returns `true` if the date is valid according to the specified format and configuration, otherwise `false`.
- *
- * @throws {Error} If an invalid date format is provided in the configuration.
+ * @param {string} date - The date string to validate.
+ * @param {object} config - Optional configuration object to customize validation.
+ * @param {number} config.minYear - The minimum allowed year for the date. Defaults to 1900.
+ * @param {number} config.maxYear - The maximum allowed year for the date. Defaults to 3000.
+ * @throws {Error} If an invalid input format is provided.
+ * @returns {boolean} `true` if the date is valid according to the specified format and configuration, otherwise `false`.
  *
  * @example
  * ```typescript
  * validateDate("31/12/2023"); // true
- * validateDate("12-31-2023", { inputFormat: "MM-DD-YYYY" }); // true
- * validateDate("2023-12-31", { inputFormat: "YYYY-MM-DD", minYear: 2000, maxYear: 2100 }); // true
- * validateDate("29/02/2024", { inputFormat: "DD/MM/YYYY" }); // true (leap year)
- * validateDate("29/02/2023", { inputFormat: "DD/MM/YYYY" }); // false (not a leap year)
- * validateDate("31/04/2023", { inputFormat: "DD/MM/YYYY" }); // false (April has 30 days)
+ * validateDate("12-31-2023", { inputFormat: "isoDate" }); // true
+ * validateDate("2023-12-31", { inputFormat: "timestamp", minYear: 2000, maxYear: 2100 }); // true
+ * validateDate("29/02/2024", { inputFormat: "brazilianDate" }); // true (leap year)
+ * validateDate("29/02/2023", { inputFormat: "brazilianDate" }); // false (not a leap year)
+ * validateDate("31/04/2023", { inputFormat: "brazilianDate" }); // false (April has 30 days)
  * ```
  */
-const validateDate = (rawDate, config) => {
-    let day, month, year;
-    const inputFormat = config?.inputFormat || "DD/MM/YYYY";
+function validateDate(date, config) {
+    const inputFormat = config?.inputFormat || "brazilianDate";
     const minYear = config?.minYear || 1900;
     const maxYear = config?.maxYear || 3000;
-    if (inputFormat === "DD/MM/YYYY") {
-        const dateRegex = /^(\d{2})\/(\d{2})\/(\d{4})$/;
-        if (!dateRegex.test(rawDate))
-            return false;
-        [, day, month, year] = rawDate.match(dateRegex) || [];
-    }
-    else if (inputFormat === "MM-DD-YYYY") {
-        const dateRegex = /^(\d{2})-(\d{2})-(\d{4})$/;
-        if (!dateRegex.test(rawDate))
-            return false;
-        [, month, day, year] = rawDate.match(dateRegex) || [];
-    }
-    else if (inputFormat === "YYYY-MM-DD") {
-        const dateRegex = /^(\d{4})-(\d{2})-(\d{2})$/;
-        if (!dateRegex.test(rawDate))
-            return false;
-        [, year, month, day] = rawDate.match(dateRegex) || [];
-    }
-    else {
-        throw new Error("Invalid date format");
-    }
-    const dayNum = parseInt(day, 10);
-    const monthNum = parseInt(month, 10);
-    const yearNum = parseInt(year, 10);
-    if (dayNum < 1 || dayNum > 31)
-        return false;
-    if (monthNum < 1 || monthNum > 12)
+    const validateDateService = new ValidateDateService();
+    validateDateService.validateInputFormat(inputFormat);
+    let day, month, year;
+    const dateParts = date.split(/[-/]/).map(Number);
+    if (dateParts.length !== 3)
         return false;
-    const daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-    if (monthNum === 2) {
-        const isLeapYear = (yearNum % 4 === 0 && yearNum % 100 !== 0) || yearNum % 400 === 0;
-        if (dayNum > (isLeapYear ? 29 : 28))
+    try {
+        switch (inputFormat) {
+            case "brazilianDate":
+                [day, month, year] = dateParts;
+                validateDateService.validateDateParts(year, month, day);
+                break;
+            case "isoDate":
+                [month, day, year] = dateParts;
+                validateDateService.validateDateParts(year, month, day);
+                break;
+            case "timestamp":
+                [year, month, day] = dateParts;
+                validateDateService.validateDateParts(year, month, day);
+                break;
+        }
+        if (year < minYear || year > maxYear)
             return false;
+        return true;
     }
-    else if (dayNum > daysInMonth[monthNum - 1]) {
+    catch {
         return false;
     }
-    if (yearNum < minYear || yearNum > maxYear)
-        return false;
-    const isValidDate = new Date(yearNum, monthNum - 1, dayNum).getDate() === dayNum;
-    return isValidDate;
-};
+}
 export { validateDate };

package/dist/validations/validateEmail.d.ts

@@ -1,4 +1,3 @@
-type ValidateEmailFunction = (rawEmail: string) => Promise<boolean>;
 /**
  * Validates if an email address is valid in all possible ways, including DNS validation.
  *
@@ -7,8 +6,8 @@ type ValidateEmailFunction = (rawEmail: string) => Promise<boolean>;
  * - Validating advanced RFC 5322 compliance rules
  * - Verifying that the domain has valid MX or A records in DNS
  *
- * @param rawEmail - The email address string to validate
- * @returns A promise that resolves to `true` if the email is valid (including DNS), otherwise `false`
+ * @param {string} rawEmail - The email address string to validate
+ * @returns {Promise<boolean>} A promise that resolves to `true` if the email is valid (including DNS), otherwise `false`
  *
  * @example
  * ```typescript
@@ -17,6 +16,6 @@ type ValidateEmailFunction = (rawEmail: string) => Promise<boolean>;
  * await validateEmail("invalid-email"); // false (invalid format)
  * ```
  */
-declare const validateEmail: ValidateEmailFunction;
+declare function validateEmail(rawEmail: string): Promise<boolean>;
 export { validateEmail };
 //# sourceMappingURL=validateEmail.d.ts.map

package/dist/validations/validateEmail.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validateEmail.d.ts","sourceRoot":"","sources":["../../src/validations/validateEmail.ts"],"names":[],"mappings":"AAEA,KAAK,qBAAqB,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAmGpE;;;;;;;;;;;;;;;;;GAiBG;AAEH,QAAA,MAAM,aAAa,EAAE,qBAYpB,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"validateEmail.d.ts","sourceRoot":"","sources":["../../src/validations/validateEmail.ts"],"names":[],"mappings":"AAwFA;;;;;;;;;;;;;;;;;GAiBG;AAEH,iBAAe,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAW/D;AAED,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/validations/validateEmail.js

@@ -1,11 +1,8 @@
 import dns from "node:dns";
-// const resolveDns = dns.promises.resolve;
-// Validates basic email format using a comprehensive regex pattern
 function isValidBasicFormat(email) {
-    const emailRegex = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+    const emailRegex = /^[a-zA-Z0-9.!$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
     return emailRegex.test(email);
 }
-// Validates the local part of email (before @)
 function isValidLocalPart(localPart) {
     if (localPart.length === 0 || localPart.length > 64)
         return false;
@@ -18,7 +15,6 @@ function isValidLocalPart(localPart) {
         return false;
     return true;
 }
-// Validates a single domain label
 function isValidDomainLabel(label) {
     if (label.length === 0 || label.length > 63)
         return false;
@@ -28,7 +24,6 @@ function isValidDomainLabel(label) {
         return false;
     return true;
 }
-// Validates the domain part of email (after @)
 function isValidDomainPart(domainPart) {
     if (domainPart.length === 0 || domainPart.length > 253)
         return false;
@@ -49,7 +44,6 @@ function isValidDomainPart(domainPart) {
         return false;
     return true;
 }
-// Performs advanced syntax validation beyond basic regex
 function isValidAdvancedSyntax(email) {
     const parts = email.split("@");
     if (parts.length !== 2)
@@ -61,33 +55,28 @@ function isValidAdvancedSyntax(email) {
         return false;
     return true;
 }
-// Extracts the domain from email address
 function extractDomain(email) {
     const parts = email.split("@");
     return parts.length === 2 ? parts[1].toLowerCase() : null;
 }
-// DNS record types to check for domain validation
 const DNS_RECORD_TYPES = ["MX", "A", "AAAA"];
-// Attempts to resolve a specific DNS record type for a domain
-// async function tryResolveDnsRecord(
-//   domain: string,
-//   recordType: string
-// ): Promise<boolean> {
-//   try {
-//     await resolveDns(domain, recordType);
-//     return true;
-//   } catch {
-//     return false;
-//   }
-// }
-// Validates if domain has valid DNS records (MX, A, or AAAA records)
-// async function isValidDns(domain: string): Promise<boolean> {
-//   for (const recordType of DNS_RECORD_TYPES) {
-//     const hasRecord = await tryResolveDnsRecord(domain, recordType);
-//     if (hasRecord) return true;
-//   }
-//   return false;
-// }
+async function tryResolveDnsRecord(domain, recordType) {
+    try {
+        await dns?.promises?.resolve(domain, recordType);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function isValidDns(domain) {
+    for (const recordType of DNS_RECORD_TYPES) {
+        const hasRecord = await tryResolveDnsRecord(domain, recordType);
+        if (hasRecord)
+            return true;
+    }
+    return false;
+}
 /**
  * Validates if an email address is valid in all possible ways, including DNS validation.
  *
@@ -96,8 +85,8 @@ const DNS_RECORD_TYPES = ["MX", "A", "AAAA"];
  * - Validating advanced RFC 5322 compliance rules
  * - Verifying that the domain has valid MX or A records in DNS
  *
- * @param rawEmail - The email address string to validate
- * @returns A promise that resolves to `true` if the email is valid (including DNS), otherwise `false`
+ * @param {string} rawEmail - The email address string to validate
+ * @returns {Promise<boolean>} A promise that resolves to `true` if the email is valid (including DNS), otherwise `false`
  *
  * @example
  * ```typescript
@@ -106,7 +95,7 @@ const DNS_RECORD_TYPES = ["MX", "A", "AAAA"];
  * await validateEmail("invalid-email"); // false (invalid format)
  * ```
  */
-const validateEmail = async (rawEmail) => {
+async function validateEmail(rawEmail) {
     if (!rawEmail || typeof rawEmail !== "string")
         return false;
     const email = rawEmail.trim();
@@ -117,7 +106,6 @@ const validateEmail = async (rawEmail) => {
     const domain = extractDomain(email);
     if (!domain)
         return false;
-    // return await isValidDns(domain);
-    return true;
-};
+    return await isValidDns(domain);
+}
 export { validateEmail };

package/dist/validations/validatePassword.d.ts

@@ -1,4 +1,3 @@
-type ValidatePasswordFunction = (rawPassword: string) => boolean;
 /**
  * Validates a password based on the following rules:
  * - At least 8 characters
@@ -7,8 +6,8 @@ type ValidatePasswordFunction = (rawPassword: string) => boolean;
  * - At least 1 number
  * - At least 1 special character
  *
- * @param rawPassword - The raw password string.
- * @returns `true` if password is valid, otherwise `false`.
+ * @param {string} rawPassword - The raw password string.
+ * @returns {boolean} `true` if password is valid, otherwise `false`.
  *
  * @example
  * ```ts
@@ -16,6 +15,6 @@ type ValidatePasswordFunction = (rawPassword: string) => boolean;
  * validatePassword("senha123");  // false (no uppercase, no special char)
  * ```
  */
-declare const validatePassword: ValidatePasswordFunction;
+declare function validatePassword(rawPassword: string): boolean;
 export { validatePassword };
 //# sourceMappingURL=validatePassword.d.ts.map

package/dist/validations/validatePassword.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validatePassword.d.ts","sourceRoot":"","sources":["../../src/validations/validatePassword.ts"],"names":[],"mappings":"AAAA,KAAK,wBAAwB,GAAG,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC;AAEjE;;;;;;;;;;;;;;;;GAgBG;AAEH,QAAA,MAAM,gBAAgB,EAAE,wBAkBvB,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,CAAC"}
+{"version":3,"file":"validatePassword.d.ts","sourceRoot":"","sources":["../../src/validations/validatePassword.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,iBAAS,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAkBtD;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/validations/validatePassword.js

@@ -6,8 +6,8 @@
  * - At least 1 number
  * - At least 1 special character
  *
- * @param rawPassword - The raw password string.
- * @returns `true` if password is valid, otherwise `false`.
+ * @param {string} rawPassword - The raw password string.
+ * @returns {boolean} `true` if password is valid, otherwise `false`.
  *
  * @example
  * ```ts
@@ -15,14 +15,14 @@
  * validatePassword("senha123");  // false (no uppercase, no special char)
  * ```
  */
-const validatePassword = (rawPassword) => {
+function validatePassword(rawPassword) {
     if (!rawPassword)
         return false;
     const hasMinLength = rawPassword.length >= 8;
     const hasUppercase = /[A-Z]/.test(rawPassword);
     const hasLetter = /[a-z]/.test(rawPassword);
     const hasNumber = /\d/.test(rawPassword);
-    const hasSpecialChar = /[!@#$%^&*(),.?":{}|<>_\-+=~`[\]\\\/]/.test(rawPassword);
+    const hasSpecialChar = /[!@#$%^&*(),.?":;{}|<>_\-+=~`[\]\\\/]/.test(rawPassword);
     return [
         hasMinLength,
         hasUppercase,
@@ -30,5 +30,5 @@ const validatePassword = (rawPassword) => {
         hasNumber,
         hasSpecialChar,
     ].every((condition) => condition);
-};
+}
 export { validatePassword };

package/dist/validations/validatePhone.d.ts

@@ -1,4 +1,3 @@
-type ValidatePhoneFunction = (rawPhone: string) => boolean;
 /**
  * Validates a phone number against a list of country-specific formats.
  *
@@ -10,8 +9,8 @@ type ValidatePhoneFunction = (rawPhone: string) => boolean;
  * Special handling is applied for Brazilian phone numbers (ISO code "BR"), which
  * allows for an optional ninth digit.
  *
- * @param rawPhone - The phone number to validate as a string.
- * @returns `true` if the phone number matches any country's format, otherwise `false`.
+ * @param {string} rawPhone - The phone number to validate as a string.
+ * @returns {boolean} `true` if the phone number matches any country's format, otherwise `false`.
  *
  * @example
  * ```typescript
@@ -24,6 +23,6 @@ type ValidatePhoneFunction = (rawPhone: string) => boolean;
  * validatePhone("+55 1234567890"); // false for an invalid Brazilian phone number
  * ```
  */
-declare const validatePhone: ValidatePhoneFunction;
+declare function validatePhone(rawPhone: string): boolean;
 export { validatePhone };
 //# sourceMappingURL=validatePhone.d.ts.map

package/dist/validations/validatePhone.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validatePhone.d.ts","sourceRoot":"","sources":["../../src/validations/validatePhone.ts"],"names":[],"mappings":"AAEA,KAAK,qBAAqB,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,QAAA,MAAM,aAAa,EAAE,qBAiBpB,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"validatePhone.d.ts","sourceRoot":"","sources":["../../src/validations/validatePhone.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,iBAAS,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAiBhD;AAED,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/validations/validatePhone.js

@@ -10,8 +10,8 @@ import { countries } from "@arkyn/templates";
  * Special handling is applied for Brazilian phone numbers (ISO code "BR"), which
  * allows for an optional ninth digit.
  *
- * @param rawPhone - The phone number to validate as a string.
- * @returns `true` if the phone number matches any country's format, otherwise `false`.
+ * @param {string} rawPhone - The phone number to validate as a string.
+ * @returns {boolean} `true` if the phone number matches any country's format, otherwise `false`.
  *
  * @example
  * ```typescript
@@ -24,7 +24,7 @@ import { countries } from "@arkyn/templates";
  * validatePhone("+55 1234567890"); // false for an invalid Brazilian phone number
  * ```
  */
-const validatePhone = (rawPhone) => {
+function validatePhone(rawPhone) {
     for (const country of countries) {
         const countryCode = country.code;
         const prefix = country.prefix ? `-${country.prefix}` : "";
@@ -40,5 +40,5 @@ const validatePhone = (rawPhone) => {
             return true;
     }
     return false;
-};
+}
 export { validatePhone };

package/dist/validations/validateRg.d.ts

@@ -1,4 +1,3 @@
-type ValidateRgFunction = (rawRg: string) => boolean;
 /**
  * Validates a Brazilian RG (Registro Geral) in a generic way.
  *
@@ -7,8 +6,8 @@ type ValidateRgFunction = (rawRg: string) => boolean;
  * - Ensures length is reasonable (7–9 digits).
  * - Optionally allows for a final letter (verifier).
  *
- * @param rawRg - RG string, possibly formatted.
- * @returns `true` if format seems valid, otherwise `false`.
+ * @param {string} rawRg - RG string, possibly formatted.
+ * @returns {boolean} `true` if format seems valid, otherwise `false`.
  *
  * @example
  * ```ts
@@ -17,6 +16,6 @@ type ValidateRgFunction = (rawRg: string) => boolean;
  * validateRg("12345678X"); // true
  * ```
  */
-declare const validateRg: ValidateRgFunction;
+declare function validateRg(rawRg: string): boolean;
 export { validateRg };
 //# sourceMappingURL=validateRg.d.ts.map

package/dist/validations/validateRg.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validateRg.d.ts","sourceRoot":"","sources":["../../src/validations/validateRg.ts"],"names":[],"mappings":"AAAA,KAAK,kBAAkB,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;AAErD;;;;;;;;;;;;;;;;;GAiBG;AAEH,QAAA,MAAM,UAAU,EAAE,kBAajB,CAAC;AAEF,OAAO,EAAE,UAAU,EAAE,CAAC"}
+{"version":3,"file":"validateRg.d.ts","sourceRoot":"","sources":["../../src/validations/validateRg.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,iBAAS,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAa1C;AAED,OAAO,EAAE,UAAU,EAAE,CAAC"}