@decaf-ts/decorator-validation 1.6.1 → 1.6.3

package/lib/esm/validation/Validators/MaxValidator.js

@@ -11,13 +11,55 @@ import { Validator } from "./Validator";
 import { DEFAULT_ERROR_MESSAGES, ValidationKeys } from "./constants";
 import { validator } from "./decorators";
 /**
- * @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 {
@@ -25,12 +67,16 @@ let MaxValidator = class MaxValidator extends 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
      *
@@ -55,4 +101,4 @@ MaxValidator = __decorate([
     __metadata("design:paramtypes", [String])
 ], MaxValidator);
 export { MaxValidator };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/validation/Validators/MinValidator.d.ts

@@ -1,24 +1,70 @@
 import { Validator } from "./Validator";
 import { MinValidatorOptions } from "../types";
 /**
- * @summary Min Validator
+ * @description Validator for checking if a value is greater than or equal to a minimum
+ * @summary The MinValidator checks if a numeric value, date, or string is greater than or equal to
+ * a specified minimum value. It supports comparing numbers directly, dates chronologically,
+ * and strings lexicographically. This validator is typically used with the @min decorator.
  *
- * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#MIN}
+ * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#MIN}
  *
  * @class MinValidator
  * @extends Validator
  *
+ * @example
+ * ```typescript
+ * // Create a min validator with default error message
+ * const minValidator = new MinValidator();
+ *
+ * // Create a min validator with custom error message
+ * const customMinValidator = new MinValidator("Value must be at least {0}");
+ *
+ * // Validate a number
+ * const numOptions = { min: 10, message: "Number too small" };
+ * const numResult = minValidator.hasErrors(50, numOptions); // undefined (valid)
+ * const invalidNumResult = minValidator.hasErrors(5, numOptions); // Returns error message (invalid)
+ *
+ * // Validate a date
+ * const dateOptions = { min: new Date(2023, 0, 1) };
+ * const dateResult = minValidator.hasErrors(new Date(2023, 5, 15), dateOptions); // undefined (valid)
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant V as MinValidator
+ *
+ *   C->>V: new MinValidator(message)
+ *   C->>V: hasErrors(value, options)
+ *   alt value is undefined
+ *     V-->>C: undefined (valid)
+ *   else value is Date and min is not Date
+ *     V->>V: Convert min to Date
+ *     alt conversion fails
+ *       V-->>C: Error: Invalid Min param
+ *     end
+ *   end
+ *   alt value < min
+ *     V-->>C: Error message
+ *   else value >= min
+ *     V-->>C: undefined (valid)
+ *   end
+ *
  * @category Validators
  */
 export declare class MinValidator extends Validator<MinValidatorOptions> {
     constructor(message?: string);
     /**
-     * @summary Validates Model
+     * @description Checks if a value is greater than or equal to a minimum
+     * @summary Validates that the provided value is not less than the minimum 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 {MinValidatorOptions} options - Configuration options containing the minimum value
      *
-     * @return {string | undefined}
+     * @return {string | undefined} Error message if validation fails, undefined if validation passes
      *
      * @override
      *

package/lib/esm/validation/Validators/MinValidator.js

@@ -11,13 +11,55 @@ import { Validator } from "./Validator";
 import { DEFAULT_ERROR_MESSAGES, ValidationKeys } from "./constants";
 import { validator } from "./decorators";
 /**
- * @summary Min Validator
+ * @description Validator for checking if a value is greater than or equal to a minimum
+ * @summary The MinValidator checks if a numeric value, date, or string is greater than or equal to
+ * a specified minimum value. It supports comparing numbers directly, dates chronologically,
+ * and strings lexicographically. This validator is typically used with the @min decorator.
  *
- * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#MIN}
+ * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#MIN}
  *
  * @class MinValidator
  * @extends Validator
  *
+ * @example
+ * ```typescript
+ * // Create a min validator with default error message
+ * const minValidator = new MinValidator();
+ *
+ * // Create a min validator with custom error message
+ * const customMinValidator = new MinValidator("Value must be at least {0}");
+ *
+ * // Validate a number
+ * const numOptions = { min: 10, message: "Number too small" };
+ * const numResult = minValidator.hasErrors(50, numOptions); // undefined (valid)
+ * const invalidNumResult = minValidator.hasErrors(5, numOptions); // Returns error message (invalid)
+ *
+ * // Validate a date
+ * const dateOptions = { min: new Date(2023, 0, 1) };
+ * const dateResult = minValidator.hasErrors(new Date(2023, 5, 15), dateOptions); // undefined (valid)
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant V as MinValidator
+ *
+ *   C->>V: new MinValidator(message)
+ *   C->>V: hasErrors(value, options)
+ *   alt value is undefined
+ *     V-->>C: undefined (valid)
+ *   else value is Date and min is not Date
+ *     V->>V: Convert min to Date
+ *     alt conversion fails
+ *       V-->>C: Error: Invalid Min param
+ *     end
+ *   end
+ *   alt value < min
+ *     V-->>C: Error message
+ *   else value >= min
+ *     V-->>C: undefined (valid)
+ *   end
+ *
  * @category Validators
  */
 let MinValidator = class MinValidator extends Validator {
@@ -25,12 +67,16 @@ let MinValidator = class MinValidator extends Validator {
         super(message, "number", "Date", "string");
     }
     /**
-     * @summary Validates Model
+     * @description Checks if a value is greater than or equal to a minimum
+     * @summary Validates that the provided value is not less than the minimum 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 {MinValidatorOptions} options - Configuration options containing the minimum value
      *
-     * @return {string | undefined}
+     * @return {string | undefined} Error message if validation fails, undefined if validation passes
      *
      * @override
      *
@@ -55,4 +101,4 @@ MinValidator = __decorate([
     __metadata("design:paramtypes", [String])
 ], MinValidator);
 export { MinValidator };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/validation/Validators/PatternValidator.d.ts

@@ -1,33 +1,99 @@
 import { Validator } from "./Validator";
 import { PatternValidatorOptions } from "../types";
+/**
+ * @description Regular expression for parsing string patterns with flags
+ * @summary This regular expression is used to parse string patterns in the format "/pattern/flags".
+ * It captures the pattern and flags separately, allowing the creation of a RegExp object
+ * with the appropriate flags.
+ *
+ * @const {RegExp}
+ * @memberOf module:decorator-validation
+ * @category Validation
+ */
 export declare const regexpParser: RegExp;
 /**
- * @summary Pattern Validator
+ * @description Validator for checking if a string matches a regular expression pattern
+ * @summary The PatternValidator checks if a string value matches a specified regular expression pattern.
+ * It supports both RegExp objects and string representations of patterns, including those with flags.
+ * This validator is the foundation for specialized validators like EmailValidator and URLValidator,
+ * and is typically used with the @pattern decorator.
  *
- * @param {string} [key] defaults to {@link ValidationKeys#PATTERN}
- * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#PATTERN}
+ * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#PATTERN}
  *
  * @class PatternValidator
  * @extends Validator
  *
+ * @example
+ * ```typescript
+ * // Create a pattern validator with default error message
+ * const patternValidator = new PatternValidator();
+ *
+ * // Create a pattern validator with custom error message
+ * const customPatternValidator = new PatternValidator("Value must match the required format");
+ *
+ * // Validate using a RegExp object
+ * const regexOptions = { pattern: /^[A-Z][a-z]+$/ };
+ * patternValidator.hasErrors("Hello", regexOptions); // undefined (valid)
+ * patternValidator.hasErrors("hello", regexOptions); // Returns error message (invalid)
+ *
+ * // Validate using a string pattern
+ * const stringOptions = { pattern: "^\\d{3}-\\d{2}-\\d{4}$" };
+ * patternValidator.hasErrors("123-45-6789", stringOptions); // undefined (valid)
+ *
+ * // Validate using a string pattern with flags
+ * const flagOptions = { pattern: "/^hello$/i" };
+ * patternValidator.hasErrors("Hello", flagOptions); // undefined (valid)
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant V as PatternValidator
+ *
+ *   C->>V: new PatternValidator(message)
+ *   C->>V: hasErrors(value, options)
+ *   alt value is empty
+ *     V-->>C: undefined (valid)
+ *   else pattern is missing
+ *     V-->>C: Error: Missing Pattern
+ *   else pattern is string
+ *     V->>V: getPattern(pattern)
+ *   end
+ *   V->>V: Reset pattern.lastIndex
+ *   V->>V: Test value against pattern
+ *   alt pattern test passes
+ *     V-->>C: undefined (valid)
+ *   else pattern test fails
+ *     V-->>C: Error message
+ *   end
+ *
  * @category Validators
  */
 export declare class PatternValidator extends Validator<PatternValidatorOptions> {
     constructor(message?: string);
     /**
-     * @summary parses and validates a pattern
+     * @description Converts a string pattern to a RegExp object
+     * @summary Parses a string representation of a regular expression and converts it to a RegExp object.
+     * It handles both simple string patterns and patterns with flags in the format "/pattern/flags".
      *
-     * @param {string} pattern
+     * @param {string} pattern - The string pattern to convert
+     * @return {RegExp} A RegExp object created from the string pattern
      * @private
      */
     private getPattern;
     /**
-     * @summary Validates a Model
+     * @description Checks if a string matches a regular expression pattern
+     * @summary Validates that the provided string matches the pattern specified in the options.
+     * If the pattern is provided as a string, it's converted to a RegExp object using the getPattern method.
+     * The method resets the pattern's lastIndex property to ensure consistent validation results
+     * for patterns with the global flag.
+     *
+     * @param {string} value - The string to validate against the pattern
+     * @param {PatternValidatorOptions} options - Configuration options containing the pattern
      *
-     * @param {string} value
-     * @param {PatternValidatorOptions} options
+     * @return {string | undefined} Error message if validation fails, undefined if validation passes
      *
-     * @return {string | undefined}
+     * @throws {Error} If no pattern is provided in the options
      *
      * @override
      *

package/lib/esm/validation/Validators/PatternValidator.js

@@ -10,16 +10,73 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 import { Validator } from "./Validator";
 import { DEFAULT_ERROR_MESSAGES, ValidationKeys } from "./constants";
 import { validator } from "./decorators";
+/**
+ * @description Regular expression for parsing string patterns with flags
+ * @summary This regular expression is used to parse string patterns in the format "/pattern/flags".
+ * It captures the pattern and flags separately, allowing the creation of a RegExp object
+ * with the appropriate flags.
+ *
+ * @const {RegExp}
+ * @memberOf module:decorator-validation
+ * @category Validation
+ */
 export const regexpParser = new RegExp("^/(.+)/([gimus]*)$");
 /**
- * @summary Pattern Validator
+ * @description Validator for checking if a string matches a regular expression pattern
+ * @summary The PatternValidator checks if a string value matches a specified regular expression pattern.
+ * It supports both RegExp objects and string representations of patterns, including those with flags.
+ * This validator is the foundation for specialized validators like EmailValidator and URLValidator,
+ * and is typically used with the @pattern decorator.
  *
- * @param {string} [key] defaults to {@link ValidationKeys#PATTERN}
- * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#PATTERN}
+ * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#PATTERN}
  *
  * @class PatternValidator
  * @extends Validator
  *
+ * @example
+ * ```typescript
+ * // Create a pattern validator with default error message
+ * const patternValidator = new PatternValidator();
+ *
+ * // Create a pattern validator with custom error message
+ * const customPatternValidator = new PatternValidator("Value must match the required format");
+ *
+ * // Validate using a RegExp object
+ * const regexOptions = { pattern: /^[A-Z][a-z]+$/ };
+ * patternValidator.hasErrors("Hello", regexOptions); // undefined (valid)
+ * patternValidator.hasErrors("hello", regexOptions); // Returns error message (invalid)
+ *
+ * // Validate using a string pattern
+ * const stringOptions = { pattern: "^\\d{3}-\\d{2}-\\d{4}$" };
+ * patternValidator.hasErrors("123-45-6789", stringOptions); // undefined (valid)
+ *
+ * // Validate using a string pattern with flags
+ * const flagOptions = { pattern: "/^hello$/i" };
+ * patternValidator.hasErrors("Hello", flagOptions); // undefined (valid)
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant V as PatternValidator
+ *
+ *   C->>V: new PatternValidator(message)
+ *   C->>V: hasErrors(value, options)
+ *   alt value is empty
+ *     V-->>C: undefined (valid)
+ *   else pattern is missing
+ *     V-->>C: Error: Missing Pattern
+ *   else pattern is string
+ *     V->>V: getPattern(pattern)
+ *   end
+ *   V->>V: Reset pattern.lastIndex
+ *   V->>V: Test value against pattern
+ *   alt pattern test passes
+ *     V-->>C: undefined (valid)
+ *   else pattern test fails
+ *     V-->>C: Error message
+ *   end
+ *
  * @category Validators
  */
 let PatternValidator = class PatternValidator extends Validator {
@@ -27,9 +84,12 @@ let PatternValidator = class PatternValidator extends Validator {
         super(message, "string");
     }
     /**
-     * @summary parses and validates a pattern
+     * @description Converts a string pattern to a RegExp object
+     * @summary Parses a string representation of a regular expression and converts it to a RegExp object.
+     * It handles both simple string patterns and patterns with flags in the format "/pattern/flags".
      *
-     * @param {string} pattern
+     * @param {string} pattern - The string pattern to convert
+     * @return {RegExp} A RegExp object created from the string pattern
      * @private
      */
     getPattern(pattern) {
@@ -39,12 +99,18 @@ let PatternValidator = class PatternValidator extends Validator {
         return new RegExp(match[1], match[2]);
     }
     /**
-     * @summary Validates a Model
+     * @description Checks if a string matches a regular expression pattern
+     * @summary Validates that the provided string matches the pattern specified in the options.
+     * If the pattern is provided as a string, it's converted to a RegExp object using the getPattern method.
+     * The method resets the pattern's lastIndex property to ensure consistent validation results
+     * for patterns with the global flag.
+     *
+     * @param {string} value - The string to validate against the pattern
+     * @param {PatternValidatorOptions} options - Configuration options containing the pattern
      *
-     * @param {string} value
-     * @param {PatternValidatorOptions} options
+     * @return {string | undefined} Error message if validation fails, undefined if validation passes
      *
-     * @return {string | undefined}
+     * @throws {Error} If no pattern is provided in the options
      *
      * @override
      *
@@ -68,4 +134,4 @@ PatternValidator = __decorate([
     __metadata("design:paramtypes", [String])
 ], PatternValidator);
 export { PatternValidator };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PatternValidator.js","sourceRoot":"","sources":["../../../../src/validation/Validators/PatternValidator.ts"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,sBAAsB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AACrE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAGzC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,YAAY,GAAW,IAAI,MAAM,CAAC,oBAAoB,CAAC,CAAC;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAEI,IAAM,gBAAgB,GAAtB,MAAM,gBAAiB,SAAQ,SAAkC;IACtE,YAAY,UAAkB,sBAAsB,CAAC,OAAO;QAC1D,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC3B,CAAC;IAED;;;;;;;;OAQG;IACK,UAAU,CAAC,OAAe;QAChC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC;YAAE,OAAO,IAAI,MAAM,CAAC,OAAO,CAAC,CAAC;QAC5D,MAAM,KAAK,GAAQ,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QAC/C,OAAO,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACxC,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACI,SAAS,CACd,KAAa,EACb,OAAgC;QAEhC,IAAI,CAAC,KAAK;YAAE,OAAO;QAEnB,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;QAC1B,IAAI,CAAC,OAAO;YAAE,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;QACjD,OAAO,GAAG,OAAO,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;QAC3E,OAAO,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,yDAAyD;QAChF,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC;YACzB,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC;YAClD,CAAC,CAAC,SAAS,CAAC;IAChB,CAAC;CACF,CAAA;AApDY,gBAAgB;IAD5B,SAAS,CAAC,cAAc,CAAC,OAAO,CAAC;;GACrB,gBAAgB,CAoD5B","sourcesContent":["import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { PatternValidatorOptions } from \"../types\";\n\n/**\n * @description Regular expression for parsing string patterns with flags\n * @summary This regular expression is used to parse string patterns in the format \"/pattern/flags\".\n * It captures the pattern and flags separately, allowing the creation of a RegExp object\n * with the appropriate flags.\n *\n * @const {RegExp}\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport const regexpParser: RegExp = new RegExp(\"^/(.+)/([gimus]*)$\");\n\n/**\n * @description Validator for checking if a string matches a regular expression pattern\n * @summary The PatternValidator checks if a string value matches a specified regular expression pattern.\n * It supports both RegExp objects and string representations of patterns, including those with flags.\n * This validator is the foundation for specialized validators like EmailValidator and URLValidator,\n * and is typically used with the @pattern decorator.\n *\n * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#PATTERN}\n *\n * @class PatternValidator\n * @extends Validator\n *\n * @example\n * ```typescript\n * // Create a pattern validator with default error message\n * const patternValidator = new PatternValidator();\n *\n * // Create a pattern validator with custom error message\n * const customPatternValidator = new PatternValidator(\"Value must match the required format\");\n *\n * // Validate using a RegExp object\n * const regexOptions = { pattern: /^[A-Z][a-z]+$/ };\n * patternValidator.hasErrors(\"Hello\", regexOptions); // undefined (valid)\n * patternValidator.hasErrors(\"hello\", regexOptions); // Returns error message (invalid)\n *\n * // Validate using a string pattern\n * const stringOptions = { pattern: \"^\\\\d{3}-\\\\d{2}-\\\\d{4}$\" };\n * patternValidator.hasErrors(\"123-45-6789\", stringOptions); // undefined (valid)\n *\n * // Validate using a string pattern with flags\n * const flagOptions = { pattern: \"/^hello$/i\" };\n * patternValidator.hasErrors(\"Hello\", flagOptions); // undefined (valid)\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant V as PatternValidator\n *\n *   C->>V: new PatternValidator(message)\n *   C->>V: hasErrors(value, options)\n *   alt value is empty\n *     V-->>C: undefined (valid)\n *   else pattern is missing\n *     V-->>C: Error: Missing Pattern\n *   else pattern is string\n *     V->>V: getPattern(pattern)\n *   end\n *   V->>V: Reset pattern.lastIndex\n *   V->>V: Test value against pattern\n *   alt pattern test passes\n *     V-->>C: undefined (valid)\n *   else pattern test fails\n *     V-->>C: Error message\n *   end\n *\n * @category Validators\n */\n@validator(ValidationKeys.PATTERN)\nexport class PatternValidator extends Validator<PatternValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.PATTERN) {\n    super(message, \"string\");\n  }\n\n  /**\n   * @description Converts a string pattern to a RegExp object\n   * @summary Parses a string representation of a regular expression and converts it to a RegExp object.\n   * It handles both simple string patterns and patterns with flags in the format \"/pattern/flags\".\n   *\n   * @param {string} pattern - The string pattern to convert\n   * @return {RegExp} A RegExp object created from the string pattern\n   * @private\n   */\n  private getPattern(pattern: string): RegExp {\n    if (!regexpParser.test(pattern)) return new RegExp(pattern);\n    const match: any = pattern.match(regexpParser);\n    return new RegExp(match[1], match[2]);\n  }\n\n  /**\n   * @description Checks if a string matches a regular expression pattern\n   * @summary Validates that the provided string matches the pattern specified in the options.\n   * If the pattern is provided as a string, it's converted to a RegExp object using the getPattern method.\n   * The method resets the pattern's lastIndex property to ensure consistent validation results\n   * for patterns with the global flag.\n   *\n   * @param {string} value - The string to validate against the pattern\n   * @param {PatternValidatorOptions} options - Configuration options containing the pattern\n   *\n   * @return {string | undefined} Error message if validation fails, undefined if validation passes\n   *\n   * @throws {Error} If no pattern is provided in the options\n   *\n   * @override\n   *\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: string,\n    options: PatternValidatorOptions\n  ): string | undefined {\n    if (!value) return;\n\n    let { pattern } = options;\n    if (!pattern) throw new Error(\"Missing Pattern\");\n    pattern = typeof pattern === \"string\" ? this.getPattern(pattern) : pattern;\n    pattern.lastIndex = 0; // resets pattern position for repeat validation requests\n    return !pattern.test(value)\n      ? this.getMessage(options.message || this.message)\n      : undefined;\n  }\n}\n"]}

package/lib/esm/validation/Validators/RequiredValidator.d.ts

@@ -1,24 +1,70 @@
 import { Validator } from "./Validator";
 import { ValidatorOptions } from "../types";
 /**
- * @summary Required Validator
+ * @description Validator for checking if a value is present and not empty
+ * @summary The RequiredValidator ensures that a value is provided and not empty.
+ * It handles different types of values appropriately: for booleans and numbers,
+ * it checks if they're undefined; for other types (strings, arrays, objects),
+ * it checks if they're falsy. This validator is typically used with the @required decorator
+ * and is often the first validation applied to important fields.
  *
- * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#REQUIRED}
+ * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#REQUIRED}
  *
  * @class RequiredValidator
  * @extends Validator
  *
+ * @example
+ * ```typescript
+ * // Create a required validator with default error message
+ * const requiredValidator = new RequiredValidator();
+ *
+ * // Create a required validator with custom error message
+ * const customRequiredValidator = new RequiredValidator("This field is mandatory");
+ *
+ * // Validate different types of values
+ * requiredValidator.hasErrors("Hello"); // undefined (valid)
+ * requiredValidator.hasErrors(""); // Returns error message (invalid)
+ * requiredValidator.hasErrors(0); // undefined (valid - 0 is a valid number)
+ * requiredValidator.hasErrors(null); // Returns error message (invalid)
+ * requiredValidator.hasErrors([]); // undefined (valid - empty array is still an array)
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant V as RequiredValidator
+ *
+ *   C->>V: new RequiredValidator(message)
+ *   C->>V: hasErrors(value, options)
+ *   alt typeof value is boolean or number
+ *     alt value is undefined
+ *       V-->>C: Error message
+ *     else value is defined
+ *       V-->>C: undefined (valid)
+ *     end
+ *   else other types
+ *     alt value is falsy (null, undefined, empty string)
+ *       V-->>C: Error message
+ *     else value is truthy
+ *       V-->>C: undefined (valid)
+ *     end
+ *   end
+ *
  * @category Validators
  */
 export declare class RequiredValidator extends Validator {
     constructor(message?: string);
     /**
-     * @summary Validates a model
+     * @description Checks if a value is present and not empty
+     * @summary Validates that the provided value exists and is not empty.
+     * The validation logic varies by type:
+     * - For booleans and numbers: checks if the value is undefined
+     * - For other types (strings, arrays, objects): checks if the value is falsy
      *
-     * @param {string} value
-     * @param {ValidatorOptions} [options={}]
+     * @param {any} value - The value to validate
+     * @param {ValidatorOptions} [options={}] - Optional configuration options
      *
-     * @return {string | undefined}
+     * @return {string | undefined} Error message if validation fails, undefined if validation passes
      *
      * @override
      *