@arkyn/server 3.0.1-beta.142 → 3.0.1-beta.144

package/dist/utilities/schemaValidator.js

@@ -8,103 +8,51 @@ function formatErrorMessage(error) {
     return [title, ...lines].join("\n");
 }
 /**
- * A schema validator class that provides multiple validation methods for Zod schemas.
+ * Wraps a Zod schema with convenience validation methods suited for server-side use:
+ * - `isValid` — boolean check, no throws
+ * - `safeValidate` — raw Zod result, no throws
+ * - `validate` — throws `ServerError` on failure (for trusted/internal data)
+ * - `formValidate` / `formAsyncValidate` — throws `UnprocessableEntity` on failure (for user-submitted forms)
  *
  * @example
  * ```typescript
- * import { z } from "zod";
+ * const validator = new SchemaValidator(z.object({ email: z.string().email() }));
  *
- * const userSchema = z.object({
- *   name: z.string().min(1, "Name is required"),
- *   email: z.string().email("Invalid email"),
- *   age: z.number().min(18, "Must be at least 18")
- * });
- *
- * const validator = new SchemaValidator(userSchema);
- *
- * // Check if data is valid without throwing
- * const isValid = validator.isValid({ name: "John", email: "john@example.com", age: 25 });
- *
- * // Validate and throw ServerError on failure
- * try {
- *   const validData = validator.validate({ name: "John", email: "john@example.com", age: 25 });
- * } catch (error) {
- *   console.error(error.message);
- * }
- *
- * // Form validation with UnprocessableEntity error
- * try {
- *   const formData = validator.formValidate(requestBody);
- * } catch (error) {
- *   // Returns structured error with fieldErrors for forms
- * }
+ * // Inside a Remix action:
+ * const body = validator.formValidate(await decodeRequestBody(request));
  * ```
  */
 class SchemaValidator {
     schema;
     /**
-     * Creates a new SchemaValidator instance.
-     * @param {T} schema - The Zod schema to use for validation.
+     * @param schema - The Zod schema used for all validation methods on this instance.
      */
     constructor(schema) {
         this.schema = schema;
     }
     /**
-     * Checks if the provided data is valid according to the schema without throwing errors.
-     *
-     * @param {any} data - The data to validate.
-     *
-     * @returns {boolean} True if the data is valid, false otherwise.
+     * Returns `true` if the data satisfies the schema, `false` otherwise. Never throws.
      *
-     * @example
-     * ```typescript
-     * const validator = new SchemaValidator(userSchema);
-     * const isValid = validator.isValid({ name: "John", email: "invalid-email" });
-     * console.log(isValid); // false
-     * ```
+     * @param data - The value to check.
      */
     isValid(data) {
         return this.schema.safeParse(data).success;
     }
     /**
-     * Safely validates data and returns the complete parse result without throwing errors.
+     * Validates data and returns the raw Zod `safeParseResult` without throwing.
+     * Useful when you need access to the full error details.
      *
-     * @param {any} data - The data to validate.
-     * @returns {z.ZodSafeParseResult<z.infer<T>>} The Zod safe parse result containing success status and data or error.
-     *
-     * @example
-     * ```typescript
-     * const validator = new SchemaValidator(userSchema);
-     * const result = validator.safeValidate({ name: "", email: "john@example.com" });
-     *
-     * if (result.success) {
-     *   console.log(result.data); // Validated data
-     * } else {
-     *   console.log(result.error.issues); // Validation errors
-     * }
-     * ```
+     * @param data - The value to validate.
      */
     safeValidate(data) {
         return this.schema.safeParse(data);
     }
     /**
-     * Validates data and returns the parsed result, throwing a ServerError on validation failure.
-     *
-     * @param {any} data - The data to validate.
-     * @throws {ServerError} When validation fails, with a formatted error message.
-     * @returns {z.infer<T>} The validated and parsed data.
-     *
-     * @example
-     * ```typescript
-     * const validator = new SchemaValidator(userSchema);
+     * Validates data and returns the typed result, throwing `ServerError` on failure.
+     * Use for validating internal/trusted data (e.g. env vars, config objects).
      *
-     * try {
-     *   const validUser = validator.validate({ name: "John", email: "john@example.com", age: 25 });
-     *   console.log(validUser); // { name: "John", email: "john@example.com", age: 25 }
-     * } catch (error) {
-     *   console.error(error.message); // "Error validating:\n-> name: String must contain at least 1 character(s)"
-     * }
-     * ```
+     * @param data - The value to validate.
+     * @throws `ServerError` with a formatted field-by-field error message.
      */
     validate(data) {
         try {
@@ -115,26 +63,17 @@ class SchemaValidator {
         }
     }
     /**
-     * Validates form data and returns the parsed result, throwing an UnprocessableEntity error on validation failure.
-     * This method is specifically designed for form validation in web applications.
+     * Validates form data and returns the typed result, throwing `UnprocessableEntity` on failure.
+     * The error includes `fieldErrors`, `fields`, and `data.scrollTo` (first failing field name).
      *
-     * @param {any} data - The form data to validate.
-     * @param {string} [message] - Optional custom error message.
-     * @throws {UnprocessableEntity} When validation fails, with structured field errors for form handling.
-     * @returns {z.infer<T>} The validated and parsed form data.
+     * @param data - The raw form data to validate.
+     * @param message - Optional human-readable error message for the 422 response.
+     * @throws `UnprocessableEntity` with structured field errors for client-side form handling.
      *
      * @example
      * ```typescript
-     * const validator = new SchemaValidator(userSchema);
-     *
-     * try {
-     *   const validFormData = validator.formValidate(requestBody, "User data is invalid");
-     *   console.log(validFormData);
-     * } catch (error) {
-     *   // UnprocessableEntity with fieldErrors, fields, and scrollTo data
-     *   console.log(error.fieldErrors); // { name: "Name is required", email: "Invalid email" }
-     *   console.log(error.data.scrollTo); // "name" (first error field)
-     * }
+     * const validator = new SchemaValidator(registerSchema);
+     * const body = validator.formValidate(await decodeRequestBody(request));
      * ```
      */
     formValidate(data, message) {
@@ -151,26 +90,16 @@ class SchemaValidator {
         return formParsed.data;
     }
     /**
-     * Asynchronously validates form data and returns the parsed result, throwing an UnprocessableEntity error on validation failure.
-     * This method is the async version of formValidate, designed for form validation with async schemas.
+     * Async version of `formValidate` for schemas with async refinements (e.g. uniqueness checks).
      *
-     * @param {any} data - The form data to validate.
-     * @param {string} [message] - Optional custom error message.
-     * @throws {UnprocessableEntity} When validation fails, with structured field errors for form handling.
-     * @returns {Promise<z.infer<T>>} A promise that resolves to the validated and parsed form data.
+     * @param data - The raw form data to validate.
+     * @param message - Optional human-readable error message for the 422 response.
+     * @throws `UnprocessableEntity` with structured field errors for client-side form handling.
      *
      * @example
      * ```typescript
-     * const validator = new SchemaValidator(userSchemaWithAsyncValidation);
-     *
-     * try {
-     *   const validFormData = await validator.formAsyncValidate(requestBody, "User data is invalid");
-     *   console.log(validFormData);
-     * } catch (error) {
-     *   // UnprocessableEntity with fieldErrors, fields, and scrollTo data
-     *   console.log(error.fieldErrors); // { name: "Name is required", email: "Invalid email" }
-     *   console.log(error.data.scrollTo); // "name" (first error field)
-     * }
+     * const validator = new SchemaValidator(registerSchema);
+     * const body = await validator.formAsyncValidate(await decodeRequestBody(request));
      * ```
      */
     async formAsyncValidate(data, message) {

package/dist/validations/validateCep.d.ts

@@ -4,8 +4,8 @@
  * A valid CEP must contain exactly 8 numeric digits,
  * optionally formatted as "12345-678".
  *
- * @param {string} rawCep - CEP value, with or without formatting.
- * @returns {boolean} `true` if the CEP is valid, otherwise `false`.
+ * @param rawCep - CEP value, with or without formatting.
+ * @returns `true` if the CEP is valid, otherwise `false`.
  *
  * @example
  * ```typescript

package/dist/validations/validateCep.js

@@ -5,8 +5,8 @@ import { removeNonNumeric } from "@arkyn/shared";
  * A valid CEP must contain exactly 8 numeric digits,
  * optionally formatted as "12345-678".
  *
- * @param {string} rawCep - CEP value, with or without formatting.
- * @returns {boolean} `true` if the CEP is valid, otherwise `false`.
+ * @param rawCep - CEP value, with or without formatting.
+ * @returns `true` if the CEP is valid, otherwise `false`.
  *
  * @example
  * ```typescript

package/dist/validations/validateCnpj.d.ts

@@ -7,8 +7,8 @@
  * - Repeating digits check (invalid if all digits are the same).
  * - Verifies the two check digits with the proper weights.
  *
- * @param {string} rawCnpj - CNPJ string, possibly formatted.
- * @returns {boolean} `true` if valid, otherwise `false`.
+ * @param rawCnpj - CNPJ string, possibly formatted.
+ * @returns `true` if valid, otherwise `false`.
  *
  * @example
  * ```typescript

package/dist/validations/validateCnpj.js

@@ -27,8 +27,8 @@ function extractDigit(cnpj) {
  * - Repeating digits check (invalid if all digits are the same).
  * - Verifies the two check digits with the proper weights.
  *
- * @param {string} rawCnpj - CNPJ string, possibly formatted.
- * @returns {boolean} `true` if valid, otherwise `false`.
+ * @param rawCnpj - CNPJ string, possibly formatted.
+ * @returns `true` if valid, otherwise `false`.
  *
  * @example
  * ```typescript

package/dist/validations/validateCpf.d.ts

@@ -1,16 +1,9 @@
 /**
- * Validates a Brazilian CPF (Cadastro de Pessoas Físicas) number.
+ * Validates a Brazilian CPF number. Strips formatting, checks length, rejects
+ * repeated-digit sequences, and verifies both check digits with the CPF algorithm.
  *
- * The CPF is a unique identifier assigned to Brazilian citizens and residents.
- * This function checks if the provided CPF is valid by performing the following steps:
- * - Removes any non-digit characters from the input.
- * - Verifies if the CPF has the correct length (11 digits).
- * - Ensures that all digits are not the same (e.g., "111.111.111-11" is invalid).
- * - Calculates the first and second verification digits using the CPF algorithm.
- * - Compares the calculated verification digits with the ones provided in the CPF.
- *
- * @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`.
+ * @param rawCpf - CPF string, with or without formatting (dots and dashes).
+ * @returns `true` if the CPF is valid, otherwise `false`.
  *
  * @example
  * ```typescript

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"validateCpf.d.ts","sourceRoot":"","sources":["../../src/validations/validateCpf.ts"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;GAYG;AAEH,iBAAS,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAiB5C;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/validations/validateCpf.js

@@ -20,18 +20,11 @@ function extractDigit(cpf) {
     return cpf.slice(9);
 }
 /**
- * Validates a Brazilian CPF (Cadastro de Pessoas Físicas) number.
+ * Validates a Brazilian CPF number. Strips formatting, checks length, rejects
+ * repeated-digit sequences, and verifies both check digits with the CPF algorithm.
  *
- * The CPF is a unique identifier assigned to Brazilian citizens and residents.
- * This function checks if the provided CPF is valid by performing the following steps:
- * - Removes any non-digit characters from the input.
- * - Verifies if the CPF has the correct length (11 digits).
- * - Ensures that all digits are not the same (e.g., "111.111.111-11" is invalid).
- * - Calculates the first and second verification digits using the CPF algorithm.
- * - Compares the calculated verification digits with the ones provided in the CPF.
- *
- * @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`.
+ * @param rawCpf - CPF string, with or without formatting (dots and dashes).
+ * @returns `true` if the CPF is valid, otherwise `false`.
  *
  * @example
  * ```typescript

package/dist/validations/validateDate.d.ts

@@ -1,21 +1,17 @@
 /**
- * Validates a date string based on the provided format and configuration.
+ * Validates a date string against a format and optional year bounds.
  *
- * @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`.
+ * @param date - The date string to validate.
+ * @param config.inputFormat - Parsing format: `"brazilianDate"` (DD/MM/YYYY, default), `"isoDate"` (MM-DD-YYYY), or `"timestamp"` (YYYY-MM-DD).
+ * @param config.minYear - Minimum allowed year. Defaults to 1900.
+ * @param config.maxYear - Maximum allowed year. Defaults to 3000.
+ * @returns `true` if the date is valid according to the format and bounds, otherwise `false`.
  *
  * @example
  * ```typescript
  * validateDate("31/12/2023"); // true
- * 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)
+ * validateDate("29/02/2023"); // false (not a leap year)
  * ```
  */
 declare function validateDate(date: string, config?: {

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"validateDate.d.ts","sourceRoot":"","sources":["../../src/validations/validateDate.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;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,22 +1,18 @@
 import { ValidateDateService } from "@arkyn/shared";
 /**
- * Validates a date string based on the provided format and configuration.
+ * Validates a date string against a format and optional year bounds.
  *
- * @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`.
+ * @param date - The date string to validate.
+ * @param config.inputFormat - Parsing format: `"brazilianDate"` (DD/MM/YYYY, default), `"isoDate"` (MM-DD-YYYY), or `"timestamp"` (YYYY-MM-DD).
+ * @param config.minYear - Minimum allowed year. Defaults to 1900.
+ * @param config.maxYear - Maximum allowed year. Defaults to 3000.
+ * @returns `true` if the date is valid according to the format and bounds, otherwise `false`.
  *
  * @example
  * ```typescript
  * validateDate("31/12/2023"); // true
- * 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)
+ * validateDate("29/02/2023"); // false (not a leap year)
  * ```
  */
 function validateDate(date, config) {

package/dist/validations/validateEmail.d.ts

@@ -6,8 +6,8 @@
  * - Validating advanced RFC 5322 compliance rules
  * - Verifying that the domain has valid MX or A records in DNS
  *
- * @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`
+ * @param rawEmail - The email address to validate.
+ * @returns `true` if the email passes format checks and its domain resolves in DNS, otherwise `false`.
  *
  * @example
  * ```typescript

package/dist/validations/validateEmail.js

@@ -85,8 +85,8 @@ async function isValidDns(domain) {
  * - Validating advanced RFC 5322 compliance rules
  * - Verifying that the domain has valid MX or A records in DNS
  *
- * @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`
+ * @param rawEmail - The email address to validate.
+ * @returns `true` if the email passes format checks and its domain resolves in DNS, otherwise `false`.
  *
  * @example
  * ```typescript

package/dist/validations/validatePassword.d.ts

@@ -6,8 +6,8 @@
  * - At least 1 number
  * - At least 1 special character
  *
- * @param {string} rawPassword - The raw password string.
- * @returns {boolean} `true` if password is valid, otherwise `false`.
+ * @param rawPassword - The password string to validate.
+ * @returns `true` if the password meets all rules, otherwise `false`.
  *
  * @example
  * ```ts

package/dist/validations/validatePassword.js

@@ -6,8 +6,8 @@
  * - At least 1 number
  * - At least 1 special character
  *
- * @param {string} rawPassword - The raw password string.
- * @returns {boolean} `true` if password is valid, otherwise `false`.
+ * @param rawPassword - The password string to validate.
+ * @returns `true` if the password meets all rules, otherwise `false`.
  *
  * @example
  * ```ts

package/dist/validations/validatePhone.d.ts

@@ -1,26 +1,14 @@
 /**
- * Validates a phone number against a list of country-specific formats.
+ * Validates an international phone number using `libphonenumber-js`, then confirms
+ * the parsed country code is present in the supported countries list.
  *
- * The function iterates through a predefined list of countries and checks if the
- * provided phone number matches the format for any of the countries. It uses
- * regular expressions to validate the phone number based on the country's code,
- * prefix, and mask.
- *
- * Special handling is applied for Brazilian phone numbers (ISO code "BR"), which
- * allows for an optional ninth digit.
- *
- * @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`.
+ * @param rawPhone - Phone number in E.164 format (e.g. `"+5532912345678"`).
+ * @returns `true` if the number is valid and the country is supported, otherwise `false`.
  *
  * @example
  * ```typescript
- * import { validatePhone } from "./validatePhone";
- *
- * validatePhone("+5532912345678"); // true for a valid Brazilian phone number
- * validatePhone("+553212345678"); // true for a valid Brazilian phone number
- * validatePhone("+19706574614"); // true for a valid American Samoa phone number
- * validatePhone("+55329123456178"); // false for an invalid Brazilian phone number
- * validatePhone("+55123456789"); // false for an invalid Brazilian phone number
+ * validatePhone("+5532912345678"); // true (Brazil)
+ * validatePhone("+55329123456178"); // false (invalid)
  * ```
  */
 declare function validatePhone(rawPhone: string): boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"validatePhone.d.ts","sourceRoot":"","sources":["../../src/validations/validatePhone.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,iBAAS,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAYhD;AAED,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"validatePhone.d.ts","sourceRoot":"","sources":["../../src/validations/validatePhone.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;GAYG;AAEH,iBAAS,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAYhD;AAED,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/validations/validatePhone.js

@@ -1,28 +1,16 @@
 import { countries } from "@arkyn/templates";
 import { isValidPhoneNumber, parsePhoneNumberWithError, } from "libphonenumber-js";
 /**
- * Validates a phone number against a list of country-specific formats.
+ * Validates an international phone number using `libphonenumber-js`, then confirms
+ * the parsed country code is present in the supported countries list.
  *
- * The function iterates through a predefined list of countries and checks if the
- * provided phone number matches the format for any of the countries. It uses
- * regular expressions to validate the phone number based on the country's code,
- * prefix, and mask.
- *
- * Special handling is applied for Brazilian phone numbers (ISO code "BR"), which
- * allows for an optional ninth digit.
- *
- * @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`.
+ * @param rawPhone - Phone number in E.164 format (e.g. `"+5532912345678"`).
+ * @returns `true` if the number is valid and the country is supported, otherwise `false`.
  *
  * @example
  * ```typescript
- * import { validatePhone } from "./validatePhone";
- *
- * validatePhone("+5532912345678"); // true for a valid Brazilian phone number
- * validatePhone("+553212345678"); // true for a valid Brazilian phone number
- * validatePhone("+19706574614"); // true for a valid American Samoa phone number
- * validatePhone("+55329123456178"); // false for an invalid Brazilian phone number
- * validatePhone("+55123456789"); // false for an invalid Brazilian phone number
+ * validatePhone("+5532912345678"); // true (Brazil)
+ * validatePhone("+55329123456178"); // false (invalid)
  * ```
  */
 function validatePhone(rawPhone) {

package/dist/validations/validateRg.d.ts

@@ -6,8 +6,8 @@
  * - Ensures length is reasonable (7–9 digits).
  * - Optionally allows for a final letter (verifier).
  *
- * @param {string} rawRg - RG string, possibly formatted.
- * @returns {boolean} `true` if format seems valid, otherwise `false`.
+ * @param rawRg - RG string, possibly formatted.
+ * @returns `true` if format seems valid, otherwise `false`.
  *
  * @example
  * ```ts

package/dist/validations/validateRg.js

@@ -6,8 +6,8 @@
  * - Ensures length is reasonable (7–9 digits).
  * - Optionally allows for a final letter (verifier).
  *
- * @param {string} rawRg - RG string, possibly formatted.
- * @returns {boolean} `true` if format seems valid, otherwise `false`.
+ * @param rawRg - RG string, possibly formatted.
+ * @returns `true` if format seems valid, otherwise `false`.
  *
  * @example
  * ```ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkyn/server",
-  "version": "3.0.1-beta.142",
+  "version": "3.0.1-beta.144",
   "author": "Arkyn | Lucas Gonçalves",
   "main": "./dist/bundle.js",
   "module": "./dist/bundle.js",