@decaf-ts/decorator-validation 1.6.1 → 1.6.2

package/lib/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
      *

package/lib/validation/Validators/TypeValidator.cjs

@@ -17,11 +17,61 @@ const Validation_1 = require("../Validation.cjs");
 const constants_2 = require("../../utils/constants.cjs");
 const reflection_1 = require("@decaf-ts/reflection");
 /**
- * @summary Required Validator
+ * @description Validator for checking if a value is of the expected type(s)
+ * @summary The TypeValidator ensures that a value matches one of the specified types.
+ * It can validate against a single type, multiple types, or a type with a specific name.
+ * This validator is typically used with the @type decorator and is fundamental for
+ * ensuring type safety in validated models.
  *
- * @class RequiredValidator
+ * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#TYPE}
+ *
+ * @class TypeValidator
  * @extends Validator
  *
+ * @example
+ * ```typescript
+ * // Create a type validator with default error message
+ * const typeValidator = new TypeValidator();
+ *
+ * // Create a type validator with custom error message
+ * const customTypeValidator = new TypeValidator("Value must be of type {0}, but got {1}");
+ *
+ * // Validate against a single type
+ * const stringOptions = { types: "string" };
+ * typeValidator.hasErrors("hello", stringOptions); // undefined (valid)
+ * typeValidator.hasErrors(123, stringOptions); // Returns error message (invalid)
+ *
+ * // Validate against multiple types
+ * const multiOptions = { types: ["string", "number"] };
+ * typeValidator.hasErrors("hello", multiOptions); // undefined (valid)
+ * typeValidator.hasErrors(123, multiOptions); // undefined (valid)
+ * typeValidator.hasErrors(true, multiOptions); // Returns error message (invalid)
+ *
+ * // Validate against a class type
+ * const classOptions = { types: { name: "Date" } };
+ * typeValidator.hasErrors(new Date(), classOptions); // undefined (valid)
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant V as TypeValidator
+ *   participant R as Reflection
+ *
+ *   C->>V: new TypeValidator(message)
+ *   C->>V: hasErrors(value, options)
+ *   alt value is undefined
+ *     V-->>C: undefined (valid)
+ *   else value is defined
+ *     V->>R: evaluateDesignTypes(value, types)
+ *     alt type evaluation passes
+ *       V-->>C: undefined (valid)
+ *     else type evaluation fails
+ *       V->>V: Format error message with type info
+ *       V-->>C: Error message
+ *     end
+ *   end
+ *
  * @category Validators
  */
 let TypeValidator = class TypeValidator extends Validator_1.Validator {
@@ -29,11 +79,15 @@ let TypeValidator = class TypeValidator extends Validator_1.Validator {
         super(message);
     }
     /**
-     * @summary Validates a model
-     * @param {string} value
-     * @param {TypeValidatorOptions} options
+     * @description Checks if a value is of the expected type(s)
+     * @summary Validates that the provided value matches one of the specified types.
+     * It uses the Reflection utility to evaluate if the value's type matches the expected types.
+     * The method skips validation for undefined values to avoid conflicts with the RequiredValidator.
+     *
+     * @param {any} value - The value to validate
+     * @param {TypeValidatorOptions} options - Configuration options containing the expected types
      *
-     * @return {string | undefined}
+     * @return {string | undefined} Error message if validation fails, undefined if validation passes
      *
      * @override
      *
@@ -56,9 +110,17 @@ exports.TypeValidator = TypeValidator = __decorate([
     (0, decorators_1.validator)(constants_1.ValidationKeys.TYPE),
     __metadata("design:paramtypes", [String])
 ], TypeValidator);
+/**
+ * @description Register the TypeValidator with the Validation registry
+ * @summary This registration associates the TypeValidator with the ModelKeys.TYPE key,
+ * allowing it to be used for validating design types. The save flag is set to false
+ * to prevent the validator from being saved in the standard validator registry.
+ *
+ * @memberOf module:decorator-validation
+ */
 Validation_1.Validation.register({
     validator: TypeValidator,
     validationKey: constants_2.ModelKeys.TYPE,
     save: false,
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,21 +1,75 @@
 import { Validator } from "./Validator";
 import { TypeValidatorOptions } from "../types";
 /**
- * @summary Required Validator
+ * @description Validator for checking if a value is of the expected type(s)
+ * @summary The TypeValidator ensures that a value matches one of the specified types.
+ * It can validate against a single type, multiple types, or a type with a specific name.
+ * This validator is typically used with the @type decorator and is fundamental for
+ * ensuring type safety in validated models.
  *
- * @class RequiredValidator
+ * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#TYPE}
+ *
+ * @class TypeValidator
  * @extends Validator
  *
+ * @example
+ * ```typescript
+ * // Create a type validator with default error message
+ * const typeValidator = new TypeValidator();
+ *
+ * // Create a type validator with custom error message
+ * const customTypeValidator = new TypeValidator("Value must be of type {0}, but got {1}");
+ *
+ * // Validate against a single type
+ * const stringOptions = { types: "string" };
+ * typeValidator.hasErrors("hello", stringOptions); // undefined (valid)
+ * typeValidator.hasErrors(123, stringOptions); // Returns error message (invalid)
+ *
+ * // Validate against multiple types
+ * const multiOptions = { types: ["string", "number"] };
+ * typeValidator.hasErrors("hello", multiOptions); // undefined (valid)
+ * typeValidator.hasErrors(123, multiOptions); // undefined (valid)
+ * typeValidator.hasErrors(true, multiOptions); // Returns error message (invalid)
+ *
+ * // Validate against a class type
+ * const classOptions = { types: { name: "Date" } };
+ * typeValidator.hasErrors(new Date(), classOptions); // undefined (valid)
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant V as TypeValidator
+ *   participant R as Reflection
+ *
+ *   C->>V: new TypeValidator(message)
+ *   C->>V: hasErrors(value, options)
+ *   alt value is undefined
+ *     V-->>C: undefined (valid)
+ *   else value is defined
+ *     V->>R: evaluateDesignTypes(value, types)
+ *     alt type evaluation passes
+ *       V-->>C: undefined (valid)
+ *     else type evaluation fails
+ *       V->>V: Format error message with type info
+ *       V-->>C: Error message
+ *     end
+ *   end
+ *
  * @category Validators
  */
 export declare class TypeValidator extends Validator<TypeValidatorOptions> {
     constructor(message?: string);
     /**
-     * @summary Validates a model
-     * @param {string} value
-     * @param {TypeValidatorOptions} options
+     * @description Checks if a value is of the expected type(s)
+     * @summary Validates that the provided value matches one of the specified types.
+     * It uses the Reflection utility to evaluate if the value's type matches the expected types.
+     * The method skips validation for undefined values to avoid conflicts with the RequiredValidator.
+     *
+     * @param {any} value - The value to validate
+     * @param {TypeValidatorOptions} options - Configuration options containing the expected types
      *
-     * @return {string | undefined}
+     * @return {string | undefined} Error message if validation fails, undefined if validation passes
      *
      * @override
      *

package/lib/validation/Validators/URLValidator.cjs

@@ -14,12 +14,43 @@ const constants_1 = require("./constants.cjs");
 const PatternValidator_1 = require("./PatternValidator.cjs");
 const decorators_1 = require("./decorators.cjs");
 /**
- * @summary URL Validator
- * @description Pattern from {@link https://gist.github.com/dperini/729294}
+ * @description Validator for checking if a string is a valid URL
+ * @summary The URLValidator checks if a string matches a standard URL pattern.
+ * It extends the PatternValidator and uses a robust URL regex pattern to validate web addresses.
+ * The pattern is sourced from {@link https://gist.github.com/dperini/729294} and is widely
+ * recognized for its accuracy in validating URLs. This validator is typically used with the @url decorator.
+ *
+ * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#URL}
  *
  * @class URLValidator
  * @extends PatternValidator
  *
+ * @example
+ * ```typescript
+ * // Create a URL validator with default error message
+ * const urlValidator = new URLValidator();
+ *
+ * // Create a URL validator with custom error message
+ * const customUrlValidator = new URLValidator("Please enter a valid web address");
+ *
+ * // Validate a URL
+ * const result = urlValidator.hasErrors("https://example.com"); // undefined (valid)
+ * const invalidResult = urlValidator.hasErrors("not-a-url"); // Returns error message (invalid)
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant U as URLValidator
+ *   participant P as PatternValidator
+ *
+ *   C->>U: new URLValidator(message)
+ *   U->>P: super(message)
+ *   C->>U: hasErrors(value, options)
+ *   U->>P: super.hasErrors(value, options with URL pattern)
+ *   P-->>U: validation result
+ *   U-->>C: validation result
+ *
  * @category Validators
  */
 let URLValidator = class URLValidator extends PatternValidator_1.PatternValidator {
@@ -27,16 +58,19 @@ let URLValidator = class URLValidator extends PatternValidator_1.PatternValidato
         super(message);
     }
     /**
-     * @summary Validates a model
+     * @description Checks if a string is a valid URL
+     * @summary Validates that the provided string matches the URL pattern.
+     * This method extends the PatternValidator's hasErrors method by ensuring
+     * the URL 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 a URL
+     * @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, {
@@ -50,4 +84,4 @@ exports.URLValidator = URLValidator = __decorate([
     (0, decorators_1.validator)(constants_1.ValidationKeys.URL),
     __metadata("design:paramtypes", [String])
 ], URLValidator);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,27 +1,61 @@
 import { PatternValidator } from "./PatternValidator";
 import { PatternValidatorOptions } from "../types";
 /**
- * @summary URL Validator
- * @description Pattern from {@link https://gist.github.com/dperini/729294}
+ * @description Validator for checking if a string is a valid URL
+ * @summary The URLValidator checks if a string matches a standard URL pattern.
+ * It extends the PatternValidator and uses a robust URL regex pattern to validate web addresses.
+ * The pattern is sourced from {@link https://gist.github.com/dperini/729294} and is widely
+ * recognized for its accuracy in validating URLs. This validator is typically used with the @url decorator.
+ *
+ * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#URL}
  *
  * @class URLValidator
  * @extends PatternValidator
  *
+ * @example
+ * ```typescript
+ * // Create a URL validator with default error message
+ * const urlValidator = new URLValidator();
+ *
+ * // Create a URL validator with custom error message
+ * const customUrlValidator = new URLValidator("Please enter a valid web address");
+ *
+ * // Validate a URL
+ * const result = urlValidator.hasErrors("https://example.com"); // undefined (valid)
+ * const invalidResult = urlValidator.hasErrors("not-a-url"); // Returns error message (invalid)
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant U as URLValidator
+ *   participant P as PatternValidator
+ *
+ *   C->>U: new URLValidator(message)
+ *   U->>P: super(message)
+ *   C->>U: hasErrors(value, options)
+ *   U->>P: super.hasErrors(value, options with URL pattern)
+ *   P-->>U: validation result
+ *   U-->>C: validation result
+ *
  * @category Validators
  */
 export declare class URLValidator extends PatternValidator {
     constructor(message?: string);
     /**
-     * @summary Validates a model
+     * @description Checks if a string is a valid URL
+     * @summary Validates that the provided string matches the URL pattern.
+     * This method extends the PatternValidator's hasErrors method by ensuring
+     * the URL 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 a URL
+     * @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/Validator.cjs

@@ -5,15 +5,55 @@ const constants_1 = require("./constants.cjs");
 const strings_1 = require("../../utils/strings.cjs");
 const reflection_1 = require("@decaf-ts/reflection");
 /**
- * @summary Base Implementation for Validators
- * @description Provides the underlying functionality for {@link Validator}s
+ * @description Abstract base class for all validators in the validation framework
+ * @summary The Validator class provides the foundation for all validator implementations.
+ * It handles type checking, error message formatting, and defines the common interface
+ * that all validators must implement. This class is designed to be extended by specific
+ * validator implementations that provide concrete validation logic.
  *
- * @param {string} validationKey the key to register the validator under
- * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#DEFAULT}
- * @param {string[]} [acceptedTypes] defines the value types this validator can validate
+ * @param {string} message - Default error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#DEFAULT}
+ * @param {string[]} acceptedTypes - Array of type names that this validator can validate
  *
  * @class Validator
  * @abstract
+ *
+ * @example
+ * ```typescript
+ * // Example of extending the Validator class to create a custom validator
+ * class CustomValidator extends Validator<CustomValidatorOptions> {
+ *   constructor(message: string = "Custom validation failed") {
+ *     // Specify that this validator accepts String and Number types
+ *     super(message, String.name, Number.name);
+ *   }
+ *
+ *   public hasErrors(value: any, options?: CustomValidatorOptions): string | undefined {
+ *     // Implement custom validation logic
+ *     if (someCondition) {
+ *       return this.getMessage(options?.message || this.message);
+ *     }
+ *     return undefined; // No errors
+ *   }
+ * }
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant V as Validator Subclass
+ *   participant B as Base Validator
+ *
+ *   C->>V: new CustomValidator(message)
+ *   V->>B: super(message, acceptedTypes)
+ *   B->>B: Store message and types
+ *   B->>B: Wrap hasErrors with type checking
+ *   C->>V: hasErrors(value, options)
+ *   alt value type not in acceptedTypes
+ *     B-->>C: Type error message
+ *   else value type is accepted
+ *     V->>V: Custom validation logic
+ *     V-->>C: Validation result
+ *   end
+ *
  * @category Validators
  */
 class Validator {
@@ -25,17 +65,27 @@ class Validator {
             this.hasErrors = this.checkTypeAndHasErrors(this.hasErrors.bind(this));
     }
     /**
-     * @summary builds the error message
-     * @param {string} message
-     * @param {any[]} args
+     * @description Formats an error message with optional arguments
+     * @summary Creates a formatted error message by replacing placeholders with provided arguments.
+     * This method uses the string formatting utility to generate consistent error messages
+     * across all validators.
+     *
+     * @param {string} message - The message template with placeholders
+     * @param {...any} args - Values to insert into the message template
+     * @return {string} The formatted error message
      * @protected
      */
     getMessage(message, ...args) {
         return (0, strings_1.sf)(message, ...args);
     }
     /**
-     * @summary Validates type
-     * @param {any} unbound
+     * @description Creates a type-checking wrapper around the hasErrors method
+     * @summary Wraps the hasErrors method with type validation logic to ensure that
+     * the value being validated is of an accepted type before performing specific validation.
+     * This method is called during construction if acceptedTypes are provided.
+     *
+     * @param {Function} unbound - The original hasErrors method to be wrapped
+     * @return {Function} A new function that performs type checking before calling the original method
      * @private
      */
     checkTypeAndHasErrors(unbound) {
@@ -47,6 +97,13 @@ class Validator {
             return unbound(value, ...args);
         }.bind(this);
     }
+    /**
+     * @summary Duck typing for Validators
+     * @param val
+     */
+    static isValidator(val) {
+        return val.constructor && !!val["hasErrors"];
+    }
 }
 exports.Validator = Validator;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Validator.js","sourceRoot":"","sources":["../../../src/validation/Validators/Validator.ts"],"names":[],"mappings":";;;AAAA,2CAAqD;AACrD,iDAAyC;AACzC,qDAAkD;AAGlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,MAAsB,SAAS;IAI7B,YACE,UAAkB,kCAAsB,CAAC,OAAO,EAChD,GAAG,aAAuB;QAE1B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QAEvB,IAAI,aAAa,CAAC,MAAM;YAAE,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QAC7D,IAAI,IAAI,CAAC,aAAa;YACpB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IAC3E,CAAC;IAED;;;;;;;;;;OAUG;IACO,UAAU,CAAC,OAAe,EAAE,GAAG,IAAW;QAClD,OAAO,IAAA,YAAE,EAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;IAC9B,CAAC;IAED;;;;;;;;;OASG;IACK,qBAAqB,CAC3B,OAA2D;QAE3D,OAAO,UAEL,KAAU,EACV,GAAG,IAAW;YAEd,IAAI,KAAK,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,aAAa;gBAC5C,OAAO,OAAO,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,CAAC;YACjC,IAAI,CAAC,uBAAU,CAAC,UAAU,CAAC,KAAK,EAAE,IAAI,CAAC,aAAa,CAAC;gBACnD,OAAO,IAAI,CAAC,UAAU,CACpB,kCAAsB,CAAC,IAAI,EAC3B,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,EAC7B,OAAO,KAAK,CACb,CAAC;YACJ,OAAO,OAAO,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,CAAC;QACjC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACf,CAAC;IAqBD;;;OAGG;IACH,MAAM,CAAC,WAAW,CAAC,GAAQ;QACzB,OAAO,GAAG,CAAC,WAAW,IAAI,CAAC,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;IAC/C,CAAC;CACF;AAtFD,8BAsFC","sourcesContent":["import { DEFAULT_ERROR_MESSAGES } from \"./constants\";\nimport { sf } from \"../../utils/strings\";\nimport { Reflection } from \"@decaf-ts/reflection\";\nimport { ValidatorOptions } from \"../types\";\n\n/**\n * @description Abstract base class for all validators in the validation framework\n * @summary The Validator class provides the foundation for all validator implementations.\n * It handles type checking, error message formatting, and defines the common interface\n * that all validators must implement. This class is designed to be extended by specific\n * validator implementations that provide concrete validation logic.\n *\n * @param {string} message - Default error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#DEFAULT}\n * @param {string[]} acceptedTypes - Array of type names that this validator can validate\n *\n * @class Validator\n * @abstract\n *\n * @example\n * ```typescript\n * // Example of extending the Validator class to create a custom validator\n * class CustomValidator extends Validator<CustomValidatorOptions> {\n *   constructor(message: string = \"Custom validation failed\") {\n *     // Specify that this validator accepts String and Number types\n *     super(message, String.name, Number.name);\n *   }\n *\n *   public hasErrors(value: any, options?: CustomValidatorOptions): string | undefined {\n *     // Implement custom validation logic\n *     if (someCondition) {\n *       return this.getMessage(options?.message || this.message);\n *     }\n *     return undefined; // No errors\n *   }\n * }\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant V as Validator Subclass\n *   participant B as Base Validator\n *\n *   C->>V: new CustomValidator(message)\n *   V->>B: super(message, acceptedTypes)\n *   B->>B: Store message and types\n *   B->>B: Wrap hasErrors with type checking\n *   C->>V: hasErrors(value, options)\n *   alt value type not in acceptedTypes\n *     B-->>C: Type error message\n *   else value type is accepted\n *     V->>V: Custom validation logic\n *     V-->>C: Validation result\n *   end\n *\n * @category Validators\n */\nexport abstract class Validator<V extends ValidatorOptions = ValidatorOptions> {\n  readonly message: string;\n  readonly acceptedTypes?: string[];\n\n  protected constructor(\n    message: string = DEFAULT_ERROR_MESSAGES.DEFAULT,\n    ...acceptedTypes: string[]\n  ) {\n    this.message = message;\n\n    if (acceptedTypes.length) this.acceptedTypes = acceptedTypes;\n    if (this.acceptedTypes)\n      this.hasErrors = this.checkTypeAndHasErrors(this.hasErrors.bind(this));\n  }\n\n  /**\n   * @description Formats an error message with optional arguments\n   * @summary Creates a formatted error message by replacing placeholders with provided arguments.\n   * This method uses the string formatting utility to generate consistent error messages\n   * across all validators.\n   *\n   * @param {string} message - The message template with placeholders\n   * @param {...any} args - Values to insert into the message template\n   * @return {string} The formatted error message\n   * @protected\n   */\n  protected getMessage(message: string, ...args: any[]) {\n    return sf(message, ...args);\n  }\n\n  /**\n   * @description Creates a type-checking wrapper around the hasErrors method\n   * @summary Wraps the hasErrors method with type validation logic to ensure that\n   * the value being validated is of an accepted type before performing specific validation.\n   * This method is called during construction if acceptedTypes are provided.\n   *\n   * @param {Function} unbound - The original hasErrors method to be wrapped\n   * @return {Function} A new function that performs type checking before calling the original method\n   * @private\n   */\n  private checkTypeAndHasErrors(\n    unbound: (value: any, ...args: any[]) => string | undefined\n  ) {\n    return function (\n      this: Validator,\n      value: any,\n      ...args: any[]\n    ): string | undefined {\n      if (value === undefined || !this.acceptedTypes)\n        return unbound(value, ...args);\n      if (!Reflection.checkTypes(value, this.acceptedTypes))\n        return this.getMessage(\n          DEFAULT_ERROR_MESSAGES.TYPE,\n          this.acceptedTypes.join(\", \"),\n          typeof value\n        );\n      return unbound(value, ...args);\n    }.bind(this);\n  }\n\n  /**\n   * @description Validates a value against specific validation rules\n   * @summary Abstract method that must be implemented by all validator subclasses.\n   * This method contains the core validation logic that determines whether a value\n   * is valid according to the specific rules of the validator. If the value is valid,\n   * the method returns undefined; otherwise, it returns an error message.\n   *\n   * @template V - Type of the options object that can be passed to the validator\n   * @param {any} value - The value to validate\n   * @param {V} [options] - Optional configuration options for customizing validation behavior\n   *\n   * @return {string | undefined} Error message if validation fails, undefined if validation passes\n   *\n   * @abstract\n   *\n   * @see Model#validate\n   */\n  public abstract hasErrors(value: any, options?: V): string | undefined;\n\n  /**\n   * @summary Duck typing for Validators\n   * @param val\n   */\n  static isValidator(val: any): boolean {\n    return val.constructor && !!val[\"hasErrors\"];\n  }\n}\n"]}