@decaf-ts/decorator-validation 1.6.1 → 1.6.3

package/lib/validation/Validators/DateValidator.cjs

@@ -14,26 +14,58 @@ const Validator_1 = require("./Validator.cjs");
 const constants_1 = require("./constants.cjs");
 const decorators_1 = require("./decorators.cjs");
 /**
- * @summary Date Validator
- *
- * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#DATE}
- *
+ * @description Validator for checking if a value is a valid date
+ * @summary The DateValidator checks if a value is a valid date object or a string that can be converted to a valid date.
+ * It validates that the value represents a real date and not an invalid date like "2023-02-31".
+ * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#DATE}
  * @class DateValidator
  * @extends Validator
  *
  * @category Validators
+ * @example
+ * ```typescript
+ * // Create a date validator with default error message
+ * const dateValidator = new DateValidator();
+ *
+ * // Create a date validator with custom error message
+ * const customDateValidator = new DateValidator("Please enter a valid date");
+ *
+ * // Validate a date
+ * const result = dateValidator.hasErrors(new Date()); // undefined (valid)
+ * const invalidResult = dateValidator.hasErrors("not a date"); // Returns error message (invalid)
+ * ```
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant V as DateValidator
+ *
+ *   C->>V: new DateValidator(message)
+ *   C->>V: hasErrors(value, options)
+ *   alt value is undefined
+ *     V-->>C: undefined (valid)
+ *   else value is string
+ *     V->>V: Convert to Date
+ *   end
+ *   alt Date is invalid (NaN)
+ *     V-->>C: Error message
+ *   else Date is valid
+ *     V-->>C: undefined (valid)
+ *   end
  */
 let DateValidator = class DateValidator extends Validator_1.Validator {
     constructor(message = constants_1.DEFAULT_ERROR_MESSAGES.DATE) {
         super(message, Number.name, Date.name, String.name);
     }
     /**
-     * @summary Validates a model
+     * @description Checks if the provided value is a valid date
+     * @summary Validates that the given value is a valid date. If the value is a string,
+     * it attempts to convert it to a Date object. Returns an error message if the date is invalid,
+     * or undefined if the date is valid or if the value is undefined.
      *
-     * @param {Date | string} value
-     * @param {DateValidatorOptions} [options]
+     * @param {Date | string} value - The value to validate, can be a Date object or a string
+     * @param {DateValidatorOptions} [options={}] - Optional configuration options for the validator
      *
-     * @return {string | undefined}
+     * @return {string | undefined} Error message if validation fails, undefined if validation passes
      *
      * @override
      *
@@ -55,4 +87,4 @@ exports.DateValidator = DateValidator = __decorate([
     (0, decorators_1.validator)(constants_1.ValidationKeys.DATE),
     __metadata("design:paramtypes", [String])
 ], DateValidator);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGF0ZVZhbGlkYXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy92YWxpZGF0aW9uL1ZhbGlkYXRvcnMvRGF0ZVZhbGlkYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSwyQ0FBd0M7QUFDeEMsMkNBQXFFO0FBQ3JFLDZDQUF5QztBQUd6Qzs7Ozs7Ozs7O0dBU0c7QUFFSSxJQUFNLGFBQWEsR0FBbkIsTUFBTSxhQUFjLFNBQVEscUJBQStCO0lBQ2hFLFlBQVksVUFBa0Isa0NBQXNCLENBQUMsSUFBSTtRQUN2RCxLQUFLLENBQUMsT0FBTyxFQUFFLE1BQU0sQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLElBQUksRUFBRSxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDdEQsQ0FBQztJQUVEOzs7Ozs7Ozs7OztPQVdHO0lBQ0ksU0FBUyxDQUNkLEtBQW9CLEVBQ3BCLFVBQWdDLEVBQUU7UUFFbEMsSUFBSSxLQUFLLEtBQUssU0FBUztZQUFFLE9BQU87UUFFaEMsSUFBSSxPQUFPLEtBQUssS0FBSyxRQUFRO1lBQUUsS0FBSyxHQUFHLElBQUksSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBRXZELElBQUksTUFBTSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsT0FBTyxFQUFFLENBQUMsRUFBRSxDQUFDO1lBQ2xDLE1BQU0sRUFBRSxPQUFPLEdBQUcsRUFBRSxFQUFFLEdBQUcsT0FBTyxDQUFDO1lBQ2pDLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQyxPQUFPLElBQUksSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ2xELENBQUM7SUFDSCxDQUFDO0NBQ0YsQ0FBQTtBQTlCWSxzQ0FBYTt3QkFBYixhQUFhO0lBRHpCLElBQUEsc0JBQVMsRUFBQywwQkFBYyxDQUFDLElBQUksQ0FBQzs7R0FDbEIsYUFBYSxDQThCekIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBWYWxpZGF0b3IgfSBmcm9tIFwiLi9WYWxpZGF0b3JcIjtcbmltcG9ydCB7IERFRkFVTFRfRVJST1JfTUVTU0FHRVMsIFZhbGlkYXRpb25LZXlzIH0gZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5pbXBvcnQgeyB2YWxpZGF0b3IgfSBmcm9tIFwiLi9kZWNvcmF0b3JzXCI7XG5pbXBvcnQgeyBEYXRlVmFsaWRhdG9yT3B0aW9ucyB9IGZyb20gXCIuLi90eXBlc1wiO1xuXG4vKipcbiAqIEBzdW1tYXJ5IERhdGUgVmFsaWRhdG9yXG4gKlxuICogQHBhcmFtIHtzdHJpbmd9IFttZXNzYWdlXSBkZWZhdWx0cyB0byB7QGxpbmsgREVGQVVMVF9FUlJPUl9NRVNTQUdFUyNEQVRFfVxuICpcbiAqIEBjbGFzcyBEYXRlVmFsaWRhdG9yXG4gKiBAZXh0ZW5kcyBWYWxpZGF0b3JcbiAqXG4gKiBAY2F0ZWdvcnkgVmFsaWRhdG9yc1xuICovXG5AdmFsaWRhdG9yKFZhbGlkYXRpb25LZXlzLkRBVEUpXG5leHBvcnQgY2xhc3MgRGF0ZVZhbGlkYXRvciBleHRlbmRzIFZhbGlkYXRvcjxEYXRlVmFsaWRhdG9yT3B0aW9ucz4ge1xuICBjb25zdHJ1Y3RvcihtZXNzYWdlOiBzdHJpbmcgPSBERUZBVUxUX0VSUk9SX01FU1NBR0VTLkRBVEUpIHtcbiAgICBzdXBlcihtZXNzYWdlLCBOdW1iZXIubmFtZSwgRGF0ZS5uYW1lLCBTdHJpbmcubmFtZSk7XG4gIH1cblxuICAvKipcbiAgICogQHN1bW1hcnkgVmFsaWRhdGVzIGEgbW9kZWxcbiAgICpcbiAgICogQHBhcmFtIHtEYXRlIHwgc3RyaW5nfSB2YWx1ZVxuICAgKiBAcGFyYW0ge0RhdGVWYWxpZGF0b3JPcHRpb25zfSBbb3B0aW9uc11cbiAgICpcbiAgICogQHJldHVybiB7c3RyaW5nIHwgdW5kZWZpbmVkfVxuICAgKlxuICAgKiBAb3ZlcnJpZGVcbiAgICpcbiAgICogQHNlZSBWYWxpZGF0b3IjaGFzRXJyb3JzXG4gICAqL1xuICBwdWJsaWMgaGFzRXJyb3JzKFxuICAgIHZhbHVlOiBEYXRlIHwgc3RyaW5nLFxuICAgIG9wdGlvbnM6IERhdGVWYWxpZGF0b3JPcHRpb25zID0ge31cbiAgKTogc3RyaW5nIHwgdW5kZWZpbmVkIHtcbiAgICBpZiAodmFsdWUgPT09IHVuZGVmaW5lZCkgcmV0dXJuO1xuXG4gICAgaWYgKHR5cGVvZiB2YWx1ZSA9PT0gXCJzdHJpbmdcIikgdmFsdWUgPSBuZXcgRGF0ZSh2YWx1ZSk7XG5cbiAgICBpZiAoTnVtYmVyLmlzTmFOKHZhbHVlLmdldERhdGUoKSkpIHtcbiAgICAgIGNvbnN0IHsgbWVzc2FnZSA9IFwiXCIgfSA9IG9wdGlvbnM7XG4gICAgICByZXR1cm4gdGhpcy5nZXRNZXNzYWdlKG1lc3NhZ2UgfHwgdGhpcy5tZXNzYWdlKTtcbiAgICB9XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/lib/validation/Validators/DateValidator.d.ts

@@ -1,24 +1,56 @@
 import { Validator } from "./Validator";
 import { DateValidatorOptions } from "../types";
 /**
- * @summary Date Validator
- *
- * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#DATE}
- *
+ * @description Validator for checking if a value is a valid date
+ * @summary The DateValidator checks if a value is a valid date object or a string that can be converted to a valid date.
+ * It validates that the value represents a real date and not an invalid date like "2023-02-31".
+ * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#DATE}
  * @class DateValidator
  * @extends Validator
  *
  * @category Validators
+ * @example
+ * ```typescript
+ * // Create a date validator with default error message
+ * const dateValidator = new DateValidator();
+ *
+ * // Create a date validator with custom error message
+ * const customDateValidator = new DateValidator("Please enter a valid date");
+ *
+ * // Validate a date
+ * const result = dateValidator.hasErrors(new Date()); // undefined (valid)
+ * const invalidResult = dateValidator.hasErrors("not a date"); // Returns error message (invalid)
+ * ```
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant V as DateValidator
+ *
+ *   C->>V: new DateValidator(message)
+ *   C->>V: hasErrors(value, options)
+ *   alt value is undefined
+ *     V-->>C: undefined (valid)
+ *   else value is string
+ *     V->>V: Convert to Date
+ *   end
+ *   alt Date is invalid (NaN)
+ *     V-->>C: Error message
+ *   else Date is valid
+ *     V-->>C: undefined (valid)
+ *   end
  */
 export declare class DateValidator extends Validator<DateValidatorOptions> {
     constructor(message?: string);
     /**
-     * @summary Validates a model
+     * @description Checks if the provided value is a valid date
+     * @summary Validates that the given value is a valid date. If the value is a string,
+     * it attempts to convert it to a Date object. Returns an error message if the date is invalid,
+     * or undefined if the date is valid or if the value is undefined.
      *
-     * @param {Date | string} value
-     * @param {DateValidatorOptions} [options]
+     * @param {Date | string} value - The value to validate, can be a Date object or a string
+     * @param {DateValidatorOptions} [options={}] - Optional configuration options for the validator
      *
-     * @return {string | undefined}
+     * @return {string | undefined} Error message if validation fails, undefined if validation passes
      *
      * @override
      *

package/lib/validation/Validators/EmailValidator.cjs

@@ -14,13 +14,42 @@ const constants_1 = require("./constants.cjs");
 const PatternValidator_1 = require("./PatternValidator.cjs");
 const decorators_1 = require("./decorators.cjs");
 /**
- * @summary Email Validator
+ * @description Validator for checking if a string is a valid email address
+ * @summary The EmailValidator checks if a string matches a standard email address pattern.
+ * It extends the PatternValidator and uses a predefined email regex pattern to validate email addresses.
+ * This validator is typically used with the @email decorator.
  *
- * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#EMAIL}
+ * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#EMAIL}
  *
  * @class EmailValidator
  * @extends PatternValidator
  *
+ * @example
+ * ```typescript
+ * // Create an email validator with default error message
+ * const emailValidator = new EmailValidator();
+ *
+ * // Create an email validator with custom error message
+ * const customEmailValidator = new EmailValidator("Please enter a valid email address");
+ *
+ * // Validate an email
+ * const result = emailValidator.hasErrors("user@example.com"); // undefined (valid)
+ * const invalidResult = emailValidator.hasErrors("invalid-email"); // Returns error message (invalid)
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant E as EmailValidator
+ *   participant P as PatternValidator
+ *
+ *   C->>E: new EmailValidator(message)
+ *   E->>P: super(message)
+ *   C->>E: hasErrors(value, options)
+ *   E->>P: super.hasErrors(value, options with EMAIL pattern)
+ *   P-->>E: validation result
+ *   E-->>C: validation result
+ *
  * @category Validators
  */
 let EmailValidator = class EmailValidator extends PatternValidator_1.PatternValidator {
@@ -28,16 +57,19 @@ let EmailValidator = class EmailValidator extends PatternValidator_1.PatternVali
         super(message);
     }
     /**
-     * @summary Validates a model
+     * @description Checks if a string is a valid email address
+     * @summary Validates that the provided string matches the email pattern.
+     * This method extends the PatternValidator's hasErrors method by ensuring
+     * the email pattern is used, even if not explicitly provided in the options.
      *
-     * @param {string} value
-     * @param {PatternValidatorOptions} [options]
+     * @param {string} value - The string to validate as an email address
+     * @param {PatternValidatorOptions} [options={}] - Optional configuration options
      *
-     * @return {string | undefined}
+     * @return {string | undefined} Error message if validation fails, undefined if validation passes
      *
      * @override
      *
-     * @see Validator#hasErrors
+     * @see PatternValidator#hasErrors
      */
     hasErrors(value, options = {}) {
         return super.hasErrors(value, {
@@ -51,4 +83,4 @@ exports.EmailValidator = EmailValidator = __decorate([
     (0, decorators_1.validator)(constants_1.ValidationKeys.EMAIL),
     __metadata("design:paramtypes", [String])
 ], EmailValidator);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRW1haWxWYWxpZGF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdmFsaWRhdGlvbi9WYWxpZGF0b3JzL0VtYWlsVmFsaWRhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7OztBQUFBLDJDQUlxQjtBQUNyQix5REFBc0Q7QUFDdEQsNkNBQXlDO0FBR3pDOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXNDRztBQUVJLElBQU0sY0FBYyxHQUFwQixNQUFNLGNBQWUsU0FBUSxtQ0FBZ0I7SUFDbEQsWUFBWSxVQUFrQixrQ0FBc0IsQ0FBQyxLQUFLO1FBQ3hELEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUNqQixDQUFDO0lBRUQ7Ozs7Ozs7Ozs7Ozs7O09BY0c7SUFDSSxTQUFTLENBQ2QsS0FBYSxFQUNiLFVBQW1DLEVBQUU7UUFFckMsT0FBTyxLQUFLLENBQUMsU0FBUyxDQUFDLEtBQUssRUFBRTtZQUM1QixHQUFHLE9BQU87WUFDVixPQUFPLEVBQUUsT0FBTyxFQUFFLE9BQU8sSUFBSSw0QkFBZ0IsQ0FBQyxLQUFLO1NBQ3BELENBQUMsQ0FBQztJQUNMLENBQUM7Q0FDRixDQUFBO0FBN0JZLHdDQUFjO3lCQUFkLGNBQWM7SUFEMUIsSUFBQSxzQkFBUyxFQUFDLDBCQUFjLENBQUMsS0FBSyxDQUFDOztHQUNuQixjQUFjLENBNkIxQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIERFRkFVTFRfRVJST1JfTUVTU0FHRVMsXG4gIERFRkFVTFRfUEFUVEVSTlMsXG4gIFZhbGlkYXRpb25LZXlzLFxufSBmcm9tIFwiLi9jb25zdGFudHNcIjtcbmltcG9ydCB7IFBhdHRlcm5WYWxpZGF0b3IgfSBmcm9tIFwiLi9QYXR0ZXJuVmFsaWRhdG9yXCI7XG5pbXBvcnQgeyB2YWxpZGF0b3IgfSBmcm9tIFwiLi9kZWNvcmF0b3JzXCI7XG5pbXBvcnQgeyBQYXR0ZXJuVmFsaWRhdG9yT3B0aW9ucyB9IGZyb20gXCIuLi90eXBlc1wiO1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBWYWxpZGF0b3IgZm9yIGNoZWNraW5nIGlmIGEgc3RyaW5nIGlzIGEgdmFsaWQgZW1haWwgYWRkcmVzc1xuICogQHN1bW1hcnkgVGhlIEVtYWlsVmFsaWRhdG9yIGNoZWNrcyBpZiBhIHN0cmluZyBtYXRjaGVzIGEgc3RhbmRhcmQgZW1haWwgYWRkcmVzcyBwYXR0ZXJuLlxuICogSXQgZXh0ZW5kcyB0aGUgUGF0dGVyblZhbGlkYXRvciBhbmQgdXNlcyBhIHByZWRlZmluZWQgZW1haWwgcmVnZXggcGF0dGVybiB0byB2YWxpZGF0ZSBlbWFpbCBhZGRyZXNzZXMuXG4gKiBUaGlzIHZhbGlkYXRvciBpcyB0eXBpY2FsbHkgdXNlZCB3aXRoIHRoZSBAZW1haWwgZGVjb3JhdG9yLlxuICogXG4gKiBAcGFyYW0ge3N0cmluZ30gW21lc3NhZ2VdIC0gQ3VzdG9tIGVycm9yIG1lc3NhZ2UgdG8gZGlzcGxheSB3aGVuIHZhbGlkYXRpb24gZmFpbHMsIGRlZmF1bHRzIHRvIHtAbGluayBERUZBVUxUX0VSUk9SX01FU1NBR0VTI0VNQUlMfVxuICogXG4gKiBAY2xhc3MgRW1haWxWYWxpZGF0b3JcbiAqIEBleHRlbmRzIFBhdHRlcm5WYWxpZGF0b3JcbiAqIFxuICogQGV4YW1wbGVcbiAqIGBgYHR5cGVzY3JpcHRcbiAqIC8vIENyZWF0ZSBhbiBlbWFpbCB2YWxpZGF0b3Igd2l0aCBkZWZhdWx0IGVycm9yIG1lc3NhZ2VcbiAqIGNvbnN0IGVtYWlsVmFsaWRhdG9yID0gbmV3IEVtYWlsVmFsaWRhdG9yKCk7XG4gKiBcbiAqIC8vIENyZWF0ZSBhbiBlbWFpbCB2YWxpZGF0b3Igd2l0aCBjdXN0b20gZXJyb3IgbWVzc2FnZVxuICogY29uc3QgY3VzdG9tRW1haWxWYWxpZGF0b3IgPSBuZXcgRW1haWxWYWxpZGF0b3IoXCJQbGVhc2UgZW50ZXIgYSB2YWxpZCBlbWFpbCBhZGRyZXNzXCIpO1xuICogXG4gKiAvLyBWYWxpZGF0ZSBhbiBlbWFpbFxuICogY29uc3QgcmVzdWx0ID0gZW1haWxWYWxpZGF0b3IuaGFzRXJyb3JzKFwidXNlckBleGFtcGxlLmNvbVwiKTsgLy8gdW5kZWZpbmVkICh2YWxpZClcbiAqIGNvbnN0IGludmFsaWRSZXN1bHQgPSBlbWFpbFZhbGlkYXRvci5oYXNFcnJvcnMoXCJpbnZhbGlkLWVtYWlsXCIpOyAvLyBSZXR1cm5zIGVycm9yIG1lc3NhZ2UgKGludmFsaWQpXG4gKiBgYGBcbiAqIFxuICogQG1lcm1haWRcbiAqIHNlcXVlbmNlRGlhZ3JhbVxuICogICBwYXJ0aWNpcGFudCBDIGFzIENsaWVudFxuICogICBwYXJ0aWNpcGFudCBFIGFzIEVtYWlsVmFsaWRhdG9yXG4gKiAgIHBhcnRpY2lwYW50IFAgYXMgUGF0dGVyblZhbGlkYXRvclxuICogICBcbiAqICAgQy0+PkU6IG5ldyBFbWFpbFZhbGlkYXRvcihtZXNzYWdlKVxuICogICBFLT4+UDogc3VwZXIobWVzc2FnZSlcbiAqICAgQy0+PkU6IGhhc0Vycm9ycyh2YWx1ZSwgb3B0aW9ucylcbiAqICAgRS0+PlA6IHN1cGVyLmhhc0Vycm9ycyh2YWx1ZSwgb3B0aW9ucyB3aXRoIEVNQUlMIHBhdHRlcm4pXG4gKiAgIFAtLT4+RTogdmFsaWRhdGlvbiByZXN1bHRcbiAqICAgRS0tPj5DOiB2YWxpZGF0aW9uIHJlc3VsdFxuICogXG4gKiBAY2F0ZWdvcnkgVmFsaWRhdG9yc1xuICovXG5AdmFsaWRhdG9yKFZhbGlkYXRpb25LZXlzLkVNQUlMKVxuZXhwb3J0IGNsYXNzIEVtYWlsVmFsaWRhdG9yIGV4dGVuZHMgUGF0dGVyblZhbGlkYXRvciB7XG4gIGNvbnN0cnVjdG9yKG1lc3NhZ2U6IHN0cmluZyA9IERFRkFVTFRfRVJST1JfTUVTU0FHRVMuRU1BSUwpIHtcbiAgICBzdXBlcihtZXNzYWdlKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBAZGVzY3JpcHRpb24gQ2hlY2tzIGlmIGEgc3RyaW5nIGlzIGEgdmFsaWQgZW1haWwgYWRkcmVzc1xuICAgKiBAc3VtbWFyeSBWYWxpZGF0ZXMgdGhhdCB0aGUgcHJvdmlkZWQgc3RyaW5nIG1hdGNoZXMgdGhlIGVtYWlsIHBhdHRlcm4uXG4gICAqIFRoaXMgbWV0aG9kIGV4dGVuZHMgdGhlIFBhdHRlcm5WYWxpZGF0b3IncyBoYXNFcnJvcnMgbWV0aG9kIGJ5IGVuc3VyaW5nXG4gICAqIHRoZSBlbWFpbCBwYXR0ZXJuIGlzIHVzZWQsIGV2ZW4gaWYgbm90IGV4cGxpY2l0bHkgcHJvdmlkZWQgaW4gdGhlIG9wdGlvbnMuXG4gICAqXG4gICAqIEBwYXJhbSB7c3RyaW5nfSB2YWx1ZSAtIFRoZSBzdHJpbmcgdG8gdmFsaWRhdGUgYXMgYW4gZW1haWwgYWRkcmVzc1xuICAgKiBAcGFyYW0ge1BhdHRlcm5WYWxpZGF0b3JPcHRpb25zfSBbb3B0aW9ucz17fV0gLSBPcHRpb25hbCBjb25maWd1cmF0aW9uIG9wdGlvbnNcbiAgICpcbiAgICogQHJldHVybiB7c3RyaW5nIHwgdW5kZWZpbmVkfSBFcnJvciBtZXNzYWdlIGlmIHZhbGlkYXRpb24gZmFpbHMsIHVuZGVmaW5lZCBpZiB2YWxpZGF0aW9uIHBhc3Nlc1xuICAgKlxuICAgKiBAb3ZlcnJpZGVcbiAgICpcbiAgICogQHNlZSBQYXR0ZXJuVmFsaWRhdG9yI2hhc0Vycm9yc1xuICAgKi9cbiAgcHVibGljIGhhc0Vycm9ycyhcbiAgICB2YWx1ZTogc3RyaW5nLFxuICAgIG9wdGlvbnM6IFBhdHRlcm5WYWxpZGF0b3JPcHRpb25zID0ge31cbiAgKTogc3RyaW5nIHwgdW5kZWZpbmVkIHtcbiAgICByZXR1cm4gc3VwZXIuaGFzRXJyb3JzKHZhbHVlLCB7XG4gICAgICAuLi5vcHRpb25zLFxuICAgICAgcGF0dGVybjogb3B0aW9ucz8ucGF0dGVybiB8fCBERUZBVUxUX1BBVFRFUk5TLkVNQUlMLFxuICAgIH0pO1xuICB9XG59XG4iXX0=

package/lib/validation/Validators/EmailValidator.d.ts

@@ -1,28 +1,60 @@
 import { PatternValidator } from "./PatternValidator";
 import { PatternValidatorOptions } from "../types";
 /**
- * @summary Email Validator
+ * @description Validator for checking if a string is a valid email address
+ * @summary The EmailValidator checks if a string matches a standard email address pattern.
+ * It extends the PatternValidator and uses a predefined email regex pattern to validate email addresses.
+ * This validator is typically used with the @email decorator.
  *
- * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#EMAIL}
+ * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#EMAIL}
  *
  * @class EmailValidator
  * @extends PatternValidator
  *
+ * @example
+ * ```typescript
+ * // Create an email validator with default error message
+ * const emailValidator = new EmailValidator();
+ *
+ * // Create an email validator with custom error message
+ * const customEmailValidator = new EmailValidator("Please enter a valid email address");
+ *
+ * // Validate an email
+ * const result = emailValidator.hasErrors("user@example.com"); // undefined (valid)
+ * const invalidResult = emailValidator.hasErrors("invalid-email"); // Returns error message (invalid)
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant E as EmailValidator
+ *   participant P as PatternValidator
+ *
+ *   C->>E: new EmailValidator(message)
+ *   E->>P: super(message)
+ *   C->>E: hasErrors(value, options)
+ *   E->>P: super.hasErrors(value, options with EMAIL pattern)
+ *   P-->>E: validation result
+ *   E-->>C: validation result
+ *
  * @category Validators
  */
 export declare class EmailValidator extends PatternValidator {
     constructor(message?: string);
     /**
-     * @summary Validates a model
+     * @description Checks if a string is a valid email address
+     * @summary Validates that the provided string matches the email pattern.
+     * This method extends the PatternValidator's hasErrors method by ensuring
+     * the email pattern is used, even if not explicitly provided in the options.
      *
-     * @param {string} value
-     * @param {PatternValidatorOptions} [options]
+     * @param {string} value - The string to validate as an email address
+     * @param {PatternValidatorOptions} [options={}] - Optional configuration options
      *
-     * @return {string | undefined}
+     * @return {string | undefined} Error message if validation fails, undefined if validation passes
      *
      * @override
      *
-     * @see Validator#hasErrors
+     * @see PatternValidator#hasErrors
      */
     hasErrors(value: string, options?: PatternValidatorOptions): string | undefined;
 }

package/lib/validation/Validators/ListValidator.cjs

@@ -14,13 +14,48 @@ const Validator_1 = require("./Validator.cjs");
 const constants_1 = require("./constants.cjs");
 const decorators_1 = require("./decorators.cjs");
 /**
- * @summary List Validator
+ * @description Validator for checking if elements in a list or set match expected types
+ * @summary The ListValidator validates that all elements in an array or Set match the expected types.
+ * It checks each element against a list of allowed class types and ensures type consistency.
+ * This validator is typically used with the @list decorator.
  *
- * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LIST}
+ * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#LIST}
  *
  * @class ListValidator
  * @extends Validator
  *
+ * @example
+ * ```typescript
+ * // Create a list validator with default error message
+ * const listValidator = new ListValidator();
+ *
+ * // Create a list validator with custom error message
+ * const customListValidator = new ListValidator("All items must be of the specified type");
+ *
+ * // Validate a list
+ * const options = { clazz: ["String", "Number"] };
+ * const result = listValidator.hasErrors(["test", 123], options); // undefined (valid)
+ * const invalidResult = listValidator.hasErrors([new Date()], options); // Returns error message (invalid)
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant V as ListValidator
+ *
+ *   C->>V: new ListValidator(message)
+ *   C->>V: hasErrors(value, options)
+ *   alt value is empty
+ *     V-->>C: undefined (valid)
+ *   else value has elements
+ *     V->>V: Check each element's type
+ *     alt All elements match allowed types
+ *       V-->>C: undefined (valid)
+ *     else Some elements don't match
+ *       V-->>C: Error message
+ *     end
+ *   end
+ *
  * @category Validators
  */
 let ListValidator = class ListValidator extends Validator_1.Validator {
@@ -28,12 +63,15 @@ let ListValidator = class ListValidator extends Validator_1.Validator {
         super(message, Array.name, Set.name);
     }
     /**
-     * @summary Validates a model
+     * @description Checks if all elements in a list or set match the expected types
+     * @summary Validates that each element in the provided array or Set matches one of the
+     * class types specified in the options. For object types, it checks the constructor name,
+     * and for primitive types, it compares against the lowercase type name.
      *
-     * @param {any[] | Set<any>} value
-     * @param {ListValidatorOptions} options
+     * @param {any[] | Set<any>} value - The array or Set to validate
+     * @param {ListValidatorOptions} options - Configuration options containing the allowed class types
      *
-     * @return {string | undefined}
+     * @return {string | undefined} Error message if validation fails, undefined if validation passes
      *
      * @override
      *
@@ -68,4 +106,4 @@ exports.ListValidator = ListValidator = __decorate([
     (0, decorators_1.validator)(constants_1.ValidationKeys.LIST),
     __metadata("design:paramtypes", [String])
 ], ListValidator);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTGlzdFZhbGlkYXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy92YWxpZGF0aW9uL1ZhbGlkYXRvcnMvTGlzdFZhbGlkYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFBQSwyQ0FBd0M7QUFDeEMsMkNBQXFFO0FBQ3JFLDZDQUF5QztBQUd6Qzs7Ozs7Ozs7O0dBU0c7QUFFSSxJQUFNLGFBQWEsR0FBbkIsTUFBTSxhQUFjLFNBQVEscUJBQStCO0lBQ2hFLFlBQVksVUFBa0Isa0NBQXNCLENBQUMsSUFBSTtRQUN2RCxLQUFLLENBQUMsT0FBTyxFQUFFLEtBQUssQ0FBQyxJQUFJLEVBQUUsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ3ZDLENBQUM7SUFFRDs7Ozs7Ozs7Ozs7T0FXRztJQUNILFNBQVMsQ0FDUCxLQUF1QixFQUN2QixPQUE2QjtRQUU3QixJQUFJLENBQUMsS0FBSyxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUM7WUFBRSxPQUFPO1FBRTNFLE1BQU0sS0FBSyxHQUFHLEtBQUssQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQztZQUN4QyxDQUFDLENBQUMsT0FBTyxDQUFDLEtBQUs7WUFDZixDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDcEIsSUFBSSxHQUFRLEVBQ1YsT0FBTyxHQUFHLElBQUksQ0FBQztRQUNqQixLQUNFLElBQUksQ0FBQyxHQUFHLENBQUMsRUFDVCxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLEVBQ3RELENBQUMsRUFBRSxFQUNILENBQUM7WUFDRCxHQUFHLEdBQUksS0FBYSxDQUFDLENBQUMsQ0FBQyxDQUFDO1lBQ3hCLFFBQVEsT0FBTyxHQUFHLEVBQUUsQ0FBQztnQkFDbkIsS0FBSyxRQUFRLENBQUM7Z0JBQ2QsS0FBSyxVQUFVO29CQUNiLE9BQU8sR0FBRyxLQUFLLENBQUMsUUFBUSxDQUFFLEdBQWMsQ0FBQyxXQUFXLEVBQUUsSUFBSSxDQUFDLENBQUM7b0JBQzVELE1BQU07Z0JBQ1I7b0JBQ0UsT0FBTyxHQUFHLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFTLEVBQUUsRUFBRSxDQUFDLE9BQU8sR0FBRyxLQUFLLENBQUMsQ0FBQyxXQUFXLEVBQUUsQ0FBQyxDQUFDO29CQUNwRSxNQUFNO1lBQ1YsQ0FBQztRQUNILENBQUM7UUFFRCxPQUFPLE9BQU87WUFDWixDQUFDLENBQUMsU0FBUztZQUNYLENBQUMsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQyxPQUFPLElBQUksSUFBSSxDQUFDLE9BQU8sRUFBRSxLQUFLLENBQUMsQ0FBQztJQUM5RCxDQUFDO0NBQ0YsQ0FBQTtBQWpEWSxzQ0FBYTt3QkFBYixhQUFhO0lBRHpCLElBQUEsc0JBQVMsRUFBQywwQkFBYyxDQUFDLElBQUksQ0FBQzs7R0FDbEIsYUFBYSxDQWlEekIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBWYWxpZGF0b3IgfSBmcm9tIFwiLi9WYWxpZGF0b3JcIjtcbmltcG9ydCB7IERFRkFVTFRfRVJST1JfTUVTU0FHRVMsIFZhbGlkYXRpb25LZXlzIH0gZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5pbXBvcnQgeyB2YWxpZGF0b3IgfSBmcm9tIFwiLi9kZWNvcmF0b3JzXCI7XG5pbXBvcnQgeyBMaXN0VmFsaWRhdG9yT3B0aW9ucyB9IGZyb20gXCIuLi90eXBlc1wiO1xuXG4vKipcbiAqIEBzdW1tYXJ5IExpc3QgVmFsaWRhdG9yXG4gKlxuICogQHBhcmFtIHtzdHJpbmd9IFttZXNzYWdlXSBkZWZhdWx0cyB0byB7QGxpbmsgREVGQVVMVF9FUlJPUl9NRVNTQUdFUyNMSVNUfVxuICpcbiAqIEBjbGFzcyBMaXN0VmFsaWRhdG9yXG4gKiBAZXh0ZW5kcyBWYWxpZGF0b3JcbiAqXG4gKiBAY2F0ZWdvcnkgVmFsaWRhdG9yc1xuICovXG5AdmFsaWRhdG9yKFZhbGlkYXRpb25LZXlzLkxJU1QpXG5leHBvcnQgY2xhc3MgTGlzdFZhbGlkYXRvciBleHRlbmRzIFZhbGlkYXRvcjxMaXN0VmFsaWRhdG9yT3B0aW9ucz4ge1xuICBjb25zdHJ1Y3RvcihtZXNzYWdlOiBzdHJpbmcgPSBERUZBVUxUX0VSUk9SX01FU1NBR0VTLkxJU1QpIHtcbiAgICBzdXBlcihtZXNzYWdlLCBBcnJheS5uYW1lLCBTZXQubmFtZSk7XG4gIH1cblxuICAvKipcbiAgICogQHN1bW1hcnkgVmFsaWRhdGVzIGEgbW9kZWxcbiAgICpcbiAgICogQHBhcmFtIHthbnlbXSB8IFNldDxhbnk+fSB2YWx1ZVxuICAgKiBAcGFyYW0ge0xpc3RWYWxpZGF0b3JPcHRpb25zfSBvcHRpb25zXG4gICAqXG4gICAqIEByZXR1cm4ge3N0cmluZyB8IHVuZGVmaW5lZH1cbiAgICpcbiAgICogQG92ZXJyaWRlXG4gICAqXG4gICAqIEBzZWUgVmFsaWRhdG9yI2hhc0Vycm9yc1xuICAgKi9cbiAgaGFzRXJyb3JzKFxuICAgIHZhbHVlOiBhbnlbXSB8IFNldDxhbnk+LFxuICAgIG9wdGlvbnM6IExpc3RWYWxpZGF0b3JPcHRpb25zXG4gICk6IHN0cmluZyB8IHVuZGVmaW5lZCB7XG4gICAgaWYgKCF2YWx1ZSB8fCAoQXJyYXkuaXNBcnJheSh2YWx1ZSkgPyAhdmFsdWUubGVuZ3RoIDogIXZhbHVlLnNpemUpKSByZXR1cm47XG5cbiAgICBjb25zdCBjbGF6eiA9IEFycmF5LmlzQXJyYXkob3B0aW9ucy5jbGF6eilcbiAgICAgID8gb3B0aW9ucy5jbGF6elxuICAgICAgOiBbb3B0aW9ucy5jbGF6el07XG4gICAgbGV0IHZhbDogYW55LFxuICAgICAgaXNWYWxpZCA9IHRydWU7XG4gICAgZm9yIChcbiAgICAgIGxldCBpID0gMDtcbiAgICAgIGkgPCAoQXJyYXkuaXNBcnJheSh2YWx1ZSkgPyB2YWx1ZS5sZW5ndGggOiB2YWx1ZS5zaXplKTtcbiAgICAgIGkrK1xuICAgICkge1xuICAgICAgdmFsID0gKHZhbHVlIGFzIGFueSlbaV07XG4gICAgICBzd2l0Y2ggKHR5cGVvZiB2YWwpIHtcbiAgICAgICAgY2FzZSBcIm9iamVjdFwiOlxuICAgICAgICBjYXNlIFwiZnVuY3Rpb25cIjpcbiAgICAgICAgICBpc1ZhbGlkID0gY2xhenouaW5jbHVkZXMoKHZhbCBhcyBvYmplY3QpLmNvbnN0cnVjdG9yPy5uYW1lKTtcbiAgICAgICAgICBicmVhaztcbiAgICAgICAgZGVmYXVsdDpcbiAgICAgICAgICBpc1ZhbGlkID0gY2xhenouc29tZSgoYzogc3RyaW5nKSA9PiB0eXBlb2YgdmFsID09PSBjLnRvTG93ZXJDYXNlKCkpO1xuICAgICAgICAgIGJyZWFrO1xuICAgICAgfVxuICAgIH1cblxuICAgIHJldHVybiBpc1ZhbGlkXG4gICAgICA/IHVuZGVmaW5lZFxuICAgICAgOiB0aGlzLmdldE1lc3NhZ2Uob3B0aW9ucy5tZXNzYWdlIHx8IHRoaXMubWVzc2FnZSwgY2xhenopO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/lib/validation/Validators/ListValidator.d.ts

@@ -1,24 +1,62 @@
 import { Validator } from "./Validator";
 import { ListValidatorOptions } from "../types";
 /**
- * @summary List Validator
+ * @description Validator for checking if elements in a list or set match expected types
+ * @summary The ListValidator validates that all elements in an array or Set match the expected types.
+ * It checks each element against a list of allowed class types and ensures type consistency.
+ * This validator is typically used with the @list decorator.
  *
- * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LIST}
+ * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#LIST}
  *
  * @class ListValidator
  * @extends Validator
  *
+ * @example
+ * ```typescript
+ * // Create a list validator with default error message
+ * const listValidator = new ListValidator();
+ *
+ * // Create a list validator with custom error message
+ * const customListValidator = new ListValidator("All items must be of the specified type");
+ *
+ * // Validate a list
+ * const options = { clazz: ["String", "Number"] };
+ * const result = listValidator.hasErrors(["test", 123], options); // undefined (valid)
+ * const invalidResult = listValidator.hasErrors([new Date()], options); // Returns error message (invalid)
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant V as ListValidator
+ *
+ *   C->>V: new ListValidator(message)
+ *   C->>V: hasErrors(value, options)
+ *   alt value is empty
+ *     V-->>C: undefined (valid)
+ *   else value has elements
+ *     V->>V: Check each element's type
+ *     alt All elements match allowed types
+ *       V-->>C: undefined (valid)
+ *     else Some elements don't match
+ *       V-->>C: Error message
+ *     end
+ *   end
+ *
  * @category Validators
  */
 export declare class ListValidator extends Validator<ListValidatorOptions> {
     constructor(message?: string);
     /**
-     * @summary Validates a model
+     * @description Checks if all elements in a list or set match the expected types
+     * @summary Validates that each element in the provided array or Set matches one of the
+     * class types specified in the options. For object types, it checks the constructor name,
+     * and for primitive types, it compares against the lowercase type name.
      *
-     * @param {any[] | Set<any>} value
-     * @param {ListValidatorOptions} options
+     * @param {any[] | Set<any>} value - The array or Set to validate
+     * @param {ListValidatorOptions} options - Configuration options containing the allowed class types
      *
-     * @return {string | undefined}
+     * @return {string | undefined} Error message if validation fails, undefined if validation passes
      *
      * @override
      *

package/lib/validation/Validators/MaxValidator.cjs

@@ -14,13 +14,55 @@ const Validator_1 = require("./Validator.cjs");
 const constants_1 = require("./constants.cjs");
 const decorators_1 = require("./decorators.cjs");
 /**
- * @summary Max Validator
+ * @description Validator for checking if a value is less than or equal to a maximum
+ * @summary The MaxValidator checks if a numeric value, date, or string is less than or equal to
+ * a specified maximum value. It supports comparing numbers directly, dates chronologically,
+ * and strings lexicographically. This validator is typically used with the @max decorator.
  *
- * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#MAX}
+ * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#MAX}
  *
  * @class MaxValidator
  * @extends Validator
  *
+ * @example
+ * ```typescript
+ * // Create a max validator with default error message
+ * const maxValidator = new MaxValidator();
+ *
+ * // Create a max validator with custom error message
+ * const customMaxValidator = new MaxValidator("Value must not exceed {0}");
+ *
+ * // Validate a number
+ * const numOptions = { max: 100, message: "Number too large" };
+ * const numResult = maxValidator.hasErrors(50, numOptions); // undefined (valid)
+ * const invalidNumResult = maxValidator.hasErrors(150, numOptions); // Returns error message (invalid)
+ *
+ * // Validate a date
+ * const dateOptions = { max: new Date(2023, 11, 31) };
+ * const dateResult = maxValidator.hasErrors(new Date(2023, 5, 15), dateOptions); // undefined (valid)
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant V as MaxValidator
+ *
+ *   C->>V: new MaxValidator(message)
+ *   C->>V: hasErrors(value, options)
+ *   alt value is undefined
+ *     V-->>C: undefined (valid)
+ *   else value is Date and max is not Date
+ *     V->>V: Convert max to Date
+ *     alt conversion fails
+ *       V-->>C: Error: Invalid Max param
+ *     end
+ *   end
+ *   alt value > max
+ *     V-->>C: Error message
+ *   else value <= max
+ *     V-->>C: undefined (valid)
+ *   end
+ *
  * @category Validators
  */
 let MaxValidator = class MaxValidator extends Validator_1.Validator {
@@ -28,12 +70,16 @@ let MaxValidator = class MaxValidator extends Validator_1.Validator {
         super(message, "number", "Date", "string");
     }
     /**
-     * @summary Validates a Model
+     * @description Checks if a value is less than or equal to a maximum
+     * @summary Validates that the provided value does not exceed the maximum value
+     * specified in the options. For dates, it performs chronological comparison,
+     * converting string representations to Date objects if necessary. For numbers
+     * and strings, it performs direct comparison.
      *
-     * @param {string} value
-     * @param {MaxValidatorOptions} options
+     * @param {number | Date | string} value - The value to validate
+     * @param {MaxValidatorOptions} options - Configuration options containing the maximum value
      *
-     * @return {string | undefined}
+     * @return {string | undefined} Error message if validation fails, undefined if validation passes
      *
      * @override
      *
@@ -58,4 +104,4 @@ exports.MaxValidator = MaxValidator = __decorate([
     (0, decorators_1.validator)(constants_1.ValidationKeys.MAX),
     __metadata("design:paramtypes", [String])
 ], MaxValidator);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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