@decaf-ts/decorator-validation 1.7.6 → 1.7.8

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

@@ -1,84 +1,49 @@
 import { ValidatorOptions } from "../types";
 import type { PathProxy } from "../../utils";
+import { BaseValidator } from "./BaseValidator";
 /**
- * @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.
+ * @description
+ * Abstract class for defining synchronous validators.
  *
- * @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
+ * This class extends the base {@link BaseValidator} and enforces that any implementation of `hasErrors` must be synchronous.
  *
- * @class Validator
- * @abstract
+ * Use this when the validation process is immediate and does not require asynchronous operations.
  *
  * @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);
+ * // Example of a synchronous validator that checks if a number is greater than
+ * class GreaterThanValidator extends Validator<{ gt?: number }> {
+ *   constructor(message: string = "Value must be greater than {0}") {
+ *     super(message);
  *   }
  *
- *   public hasErrors(value: any, options?: CustomValidatorOptions): string | undefined {
- *     // Implement custom validation logic
- *     if (someCondition) {
- *       return this.getMessage(options?.message || this.message);
+ *   hasErrors(value: number, options?: { gt?: number }) {
+ *     const minValue = options?.gt ?? 0;
+ *     if (value <= minValue) {
+ *       return this.getMessage();
  *     }
- *     return undefined; // No errors
+ *     return undefined;
  *   }
  * }
- * ```
  *
- * @mermaid
- * sequenceDiagram
- *   participant C as Client
- *   participant V as Validator Subclass
- *   participant B as Base Validator
+ * // Example usage:
+ * const validator = new GreaterThanValidator();
+ * const error = validator.hasErrors(10, { gt: 15 });
+ * if (error) {
+ *   console.log('Value must be greater than 15')
+ * } else {
+ *   console.log('Value is valid');
+ * }
+ * ```
  *
- *   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
+ * - If `value` is less than or equal to `gt`, returns the error message.
+ * - Otherwise, returns `undefined` indicating validation success.
  *
- * @category Validators
+ * @see {@link BaseValidator} For the base validator.
+ * @see {@link ValidatorOptions} For the base validator options.
  */
-export declare abstract class Validator<V extends ValidatorOptions = ValidatorOptions> {
-    readonly message: string;
-    readonly acceptedTypes?: string[];
+export declare abstract class Validator<V extends ValidatorOptions = ValidatorOptions> extends BaseValidator<V, false> {
     protected constructor(message?: string, ...acceptedTypes: string[]);
-    /**
-     * @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
-     */
-    protected getMessage(message: string, ...args: any[]): string;
-    /**
-     * @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
-     */
-    private checkTypeAndHasErrors;
     /**
      * @description Validates a value against specific validation rules
      * @summary Abstract method that must be implemented by all validator subclasses.
@@ -97,9 +62,4 @@ export declare abstract class Validator<V extends ValidatorOptions = ValidatorOp
      * @see Model#validate
      */
     abstract hasErrors(value: any, options?: V, proxy?: PathProxy<any>): string | undefined;
-    /**
-     * @summary Duck typing for Validators
-     * @param val
-     */
-    static isValidator(val: any): boolean;
 }

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

@@ -1,105 +1,49 @@
 import { DEFAULT_ERROR_MESSAGES } from "./constants.js";
-import { sf } from "./../../utils/strings.js";
-import { Reflection } from "@decaf-ts/reflection";
+import { BaseValidator } from "./BaseValidator.js";
 /**
- * @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.
+ * @description
+ * Abstract class for defining synchronous validators.
  *
- * @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
+ * This class extends the base {@link BaseValidator} and enforces that any implementation of `hasErrors` must be synchronous.
  *
- * @class Validator
- * @abstract
+ * Use this when the validation process is immediate and does not require asynchronous operations.
  *
  * @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);
+ * // Example of a synchronous validator that checks if a number is greater than
+ * class GreaterThanValidator extends Validator<{ gt?: number }> {
+ *   constructor(message: string = "Value must be greater than {0}") {
+ *     super(message);
  *   }
  *
- *   public hasErrors(value: any, options?: CustomValidatorOptions): string | undefined {
- *     // Implement custom validation logic
- *     if (someCondition) {
- *       return this.getMessage(options?.message || this.message);
+ *   hasErrors(value: number, options?: { gt?: number }) {
+ *     const minValue = options?.gt ?? 0;
+ *     if (value <= minValue) {
+ *       return this.getMessage();
  *     }
- *     return undefined; // No errors
+ *     return undefined;
  *   }
  * }
- * ```
  *
- * @mermaid
- * sequenceDiagram
- *   participant C as Client
- *   participant V as Validator Subclass
- *   participant B as Base Validator
+ * // Example usage:
+ * const validator = new GreaterThanValidator();
+ * const error = validator.hasErrors(10, { gt: 15 });
+ * if (error) {
+ *   console.log('Value must be greater than 15')
+ * } else {
+ *   console.log('Value is valid');
+ * }
+ * ```
  *
- *   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
+ * - If `value` is less than or equal to `gt`, returns the error message.
+ * - Otherwise, returns `undefined` indicating validation success.
  *
- * @category Validators
+ * @see {@link BaseValidator} For the base validator.
+ * @see {@link ValidatorOptions} For the base validator options.
  */
-export class Validator {
+export class Validator extends BaseValidator {
     constructor(message = DEFAULT_ERROR_MESSAGES.DEFAULT, ...acceptedTypes) {
-        this.message = message;
-        if (acceptedTypes.length)
-            this.acceptedTypes = acceptedTypes;
-        if (this.acceptedTypes)
-            this.hasErrors = this.checkTypeAndHasErrors(this.hasErrors.bind(this));
-    }
-    /**
-     * @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 sf(message, ...args);
-    }
-    /**
-     * @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) {
-        return function (value, ...args) {
-            if (value === undefined || !this.acceptedTypes)
-                return unbound(value, ...args);
-            if (!Reflection.checkTypes(value, this.acceptedTypes))
-                return this.getMessage(DEFAULT_ERROR_MESSAGES.TYPE, this.acceptedTypes.join(", "), typeof value);
-            return unbound(value, ...args);
-        }.bind(this);
-    }
-    /**
-     * @summary Duck typing for Validators
-     * @param val
-     */
-    static isValidator(val) {
-        return val.constructor && !!val["hasErrors"];
+        super(false, message, ...acceptedTypes);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Validator.js","sourceRoot":"","sources":["../../../../src/validation/Validators/Validator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,uBAAoB;AACrD,OAAO,EAAE,EAAE,EAAE,iCAA4B;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAIlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,MAAM,OAAgB,SAAS;IAI7B,YACE,UAAkB,sBAAsB,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,EAAE,CAAC,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,UAAU,CAAC,UAAU,CAAC,KAAK,EAAE,IAAI,CAAC,aAAa,CAAC;gBACnD,OAAO,IAAI,CAAC,UAAU,CACpB,sBAAsB,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;IAyBD;;;OAGG;IACH,MAAM,CAAC,WAAW,CAAC,GAAQ;QACzB,OAAO,GAAG,CAAC,WAAW,IAAI,CAAC,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;IAC/C,CAAC;CACF","sourcesContent":["import { DEFAULT_ERROR_MESSAGES } from \"./constants\";\nimport { sf } from \"../../utils/strings\";\nimport { Reflection } from \"@decaf-ts/reflection\";\nimport { ValidatorOptions } from \"../types\";\nimport type { PathProxy } from \"../../utils\";\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   * @param {PathProxy<any>} proxy -\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(\n    value: any,\n    options?: V,\n    proxy?: PathProxy<any>\n  ): 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"]}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -50,21 +50,22 @@ export declare const ValidationKeys: {
     readonly GREATER_THAN: "greaterThan";
     readonly GREATER_THAN_OR_EQUAL: "greaterThanOrEqual";
     readonly REFLECT: "decaf.model.validation.";
-    readonly VALIDATOR: "validator";
-    readonly REQUIRED: "required";
-    readonly MIN: "min";
+    readonly DATE: "date";
+    readonly EMAIL: "email";
+    readonly FORMAT: "format";
+    readonly LIST: "list";
     readonly MAX: "max";
-    readonly STEP: "step";
-    readonly MIN_LENGTH: "minlength";
     readonly MAX_LENGTH: "maxlength";
+    readonly MIN: "min";
+    readonly MIN_LENGTH: "minlength";
+    readonly PASSWORD: "password";
     readonly PATTERN: "pattern";
-    readonly EMAIL: "email";
-    readonly URL: "url";
-    readonly DATE: "date";
+    readonly REQUIRED: "required";
+    readonly STEP: "step";
     readonly TYPE: "type";
-    readonly PASSWORD: "password";
-    readonly LIST: "list";
-    readonly FORMAT: "format";
+    readonly UNIQUE: "unique";
+    readonly URL: "url";
+    readonly VALIDATOR: "validator";
 };
 /**
  * @summary list of month names

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

@@ -45,21 +45,22 @@ export const ComparisonValidationKeys = {
  */
 export const ValidationKeys = {
     REFLECT: `${ModelKeys.REFLECT}validation.`,
-    VALIDATOR: "validator",
-    REQUIRED: "required",
-    MIN: "min",
+    DATE: "date",
+    EMAIL: "email",
+    FORMAT: "format",
+    LIST: "list",
     MAX: "max",
-    STEP: "step",
-    MIN_LENGTH: "minlength",
     MAX_LENGTH: "maxlength",
+    MIN: "min",
+    MIN_LENGTH: "minlength",
+    PASSWORD: "password",
     PATTERN: "pattern",
-    EMAIL: "email",
-    URL: "url",
-    DATE: "date",
+    REQUIRED: "required",
+    STEP: "step",
     TYPE: "type",
-    PASSWORD: "password",
-    LIST: "list",
-    FORMAT: "format",
+    UNIQUE: "unique",
+    URL: "url",
+    VALIDATOR: "validator",
     ...ComparisonValidationKeys,
 };
 /**
@@ -147,6 +148,7 @@ export const DEFAULT_ERROR_MESSAGES = {
     LESS_THAN_OR_EQUAL: "This field must be less than or equal to field {0}",
     GREATER_THAN: "This field must be greater than field {0}",
     GREATER_THAN_OR_EQUAL: "This field must be greater than or equal to field {0}",
+    UNIQUE: "Duplicate found, this field must be unique.",
 };
 /**
  * @summary Defines the various default regexp patterns used
@@ -162,4 +164,4 @@ export const DEFAULT_PATTERNS = {
         CHAR8_ONE_OF_EACH: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&_\-.,])[A-Za-z\d@$!%*?&_\-.,]{8,}$/g,
     },
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../../src/validation/Validators/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,mCAA8B;AAElD;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,WAAW;IACjB,SAAS,EAAE,UAAU;IACrB,kBAAkB,EAAE,iBAAiB;IACrC,YAAY,EAAE,aAAa;IAC3B,qBAAqB,EAAE,oBAAoB;CACnC,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,OAAO,EAAE,GAAG,SAAS,CAAC,OAAO,aAAa;IAC1C,SAAS,EAAE,WAAW;IACtB,QAAQ,EAAE,UAAU;IACpB,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,IAAI,EAAE,MAAM;IACZ,UAAU,EAAE,WAAW;IACvB,UAAU,EAAE,WAAW;IACvB,OAAO,EAAE,SAAS;IAClB,KAAK,EAAE,OAAO;IACd,GAAG,EAAE,KAAK;IACV,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,QAAQ,EAAE,UAAU;IACpB,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,QAAQ;IAChB,GAAG,wBAAwB;CACnB,CAAC;AAEX;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,SAAS;IACT,UAAU;IACV,OAAO;IACP,OAAO;IACP,KAAK;IACL,MAAM;IACN,MAAM;IACN,QAAQ;IACR,WAAW;IACX,SAAS;IACT,UAAU;IACV,UAAU;CACX,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,QAAQ;IACR,QAAQ;IACR,SAAS;IACT,WAAW;IACX,UAAU;IACV,QAAQ;IACR,UAAU;CACX,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAA2B;IAC5D,QAAQ,EAAE,wBAAwB;IAClC,GAAG,EAAE,0BAA0B;IAC/B,GAAG,EAAE,0BAA0B;IAC/B,UAAU,EAAE,2BAA2B;IACvC,UAAU,EAAE,2BAA2B;IACvC,OAAO,EAAE,sCAAsC;IAC/C,KAAK,EAAE,gCAAgC;IACvC,GAAG,EAAE,8BAA8B;IACnC,IAAI,EAAE,0CAA0C;IAChD,IAAI,EAAE,kCAAkC;IACxC,IAAI,EAAE,iCAAiC;IACvC,OAAO,EAAE,mBAAmB;IAC5B,QAAQ,EACN,4HAA4H;IAC9H,IAAI,EAAE,qBAAqB;IAC3B,eAAe,EAAE,+BAA+B;IAChD,MAAM,EAAE,uCAAuC;IAC/C,IAAI,EAAE,6CAA6C;IACnD,SAAS,EAAE,wCAAwC;IACnD,kBAAkB,EAAE,oDAAoD;IACxE,YAAY,EAAE,2CAA2C;IACzD,qBAAqB,EACnB,uDAAuD;CAC1D,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,KAAK,EACH,4JAA4J;IAC9J,GAAG,EAAE,yaAAya;IAC9a,QAAQ,EAAE;QACR,iBAAiB,EACf,iFAAiF;KACpF;CACF,CAAC","sourcesContent":["import { ModelKeys } from \"../../utils/constants\";\n\n/**\n * @summary Keys used for comparison-based validations.\n *\n * @property {string} EQUALS - Validates if two values are equal.\n * @property {string} DIFF - Validates if two values are different.\n * @property {string} LESS_THAN - Validates if a value is less than another.\n * @property {string} LESS_THAN_OR_EQUAL - Validates if a value is less than or equal to another.\n * @property {string} GREATER_THAN - Validates if a value is greater than another.\n * @property {string} GREATER_THAN_OR_EQUAL - Validates if a value is greater than or equal to another.\n *\n * @constant ComparisonValidationKeys\n * @memberof module:decorator-validation.Validation\n * @category Validation\n */\nexport const ComparisonValidationKeys = {\n  EQUALS: \"equals\",\n  DIFF: \"different\",\n  LESS_THAN: \"lessThan\",\n  LESS_THAN_OR_EQUAL: \"lessThanOrEqual\",\n  GREATER_THAN: \"greaterThan\",\n  GREATER_THAN_OR_EQUAL: \"greaterThanOrEqual\",\n} as const;\n\n/**\n * @summary The keys used for validation\n *\n * @property {string} REFLECT prefixes others\n * @property {string} REQUIRED sets as required\n * @property {string} MIN defines min value\n * @property {string} MAX defines max value\n * @property {string} STEP defines step\n * @property {string} MIN_LENGTH defines min length\n * @property {string} MAX_LENGTH defines max length\n * @property {string} PATTERN defines pattern\n * @property {string} EMAIL defines email\n * @property {string} URL defines url\n * @property {string} DATE defines date\n * @property {string} TYPE defines type\n * @property {string} PASSWORD defines password\n * @property {string} LIST defines list\n *\n * @constant ValidationKeys\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const ValidationKeys = {\n  REFLECT: `${ModelKeys.REFLECT}validation.`,\n  VALIDATOR: \"validator\",\n  REQUIRED: \"required\",\n  MIN: \"min\",\n  MAX: \"max\",\n  STEP: \"step\",\n  MIN_LENGTH: \"minlength\",\n  MAX_LENGTH: \"maxlength\",\n  PATTERN: \"pattern\",\n  EMAIL: \"email\",\n  URL: \"url\",\n  DATE: \"date\",\n  TYPE: \"type\",\n  PASSWORD: \"password\",\n  LIST: \"list\",\n  FORMAT: \"format\",\n  ...ComparisonValidationKeys,\n} as const;\n\n/**\n * @summary list of month names\n * @description Stores month names. Can be changed for localization purposes\n *\n * @constant MONTH_NAMES\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const MONTH_NAMES = [\n  \"January\",\n  \"February\",\n  \"March\",\n  \"April\",\n  \"May\",\n  \"June\",\n  \"July\",\n  \"August\",\n  \"September\",\n  \"October\",\n  \"November\",\n  \"December\",\n];\n\n/**\n * @summary list of names of days of the week\n * @description Stores names for days of the week. Can be changed for localization purposes\n *\n * @constant DAYS_OF_WEEK_NAMES\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const DAYS_OF_WEEK_NAMES = [\n  \"Sunday\",\n  \"Monday\",\n  \"Tuesday\",\n  \"Wednesday\",\n  \"Thursday\",\n  \"Friday\",\n  \"Saturday\",\n];\n\n/**\n * @summary Defines the default error messages\n *\n * @property {string} REQUIRED default error message\n * @property {string} MIN default error message\n * @property {string} MAX default error message\n * @property {string} MIN_LENGTH default error message\n * @property {string} MAX_LENGTH default error message\n * @property {string} PATTERN default error message\n * @property {string} EMAIL default error message\n * @property {string} URL default error message\n * @property {string} TYPE default error message\n * @property {string} STEP default error message\n * @property {string} DATE default error message\n * @property {string} DEFAULT default error message\n * @property {string} PASSWORD default error message\n * @property {string} LIST default error message\n * @property {string} LIST_INSIDE default error message\n * @property {string} MODEL_NOT_FOUND default error message\n *\n * @constant DEFAULT_ERROR_MESSAGES\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const DEFAULT_ERROR_MESSAGES: Record<string, string> = {\n  REQUIRED: \"This field is required\",\n  MIN: \"The minimum value is {0}\",\n  MAX: \"The maximum value is {0}\",\n  MIN_LENGTH: \"The minimum length is {0}\",\n  MAX_LENGTH: \"The maximum length is {0}\",\n  PATTERN: \"The value does not match the pattern\",\n  EMAIL: \"The value is not a valid email\",\n  URL: \"The value is not a valid URL\",\n  TYPE: \"Invalid type. Expected {0}, received {1}\",\n  STEP: \"Invalid value. Not a step of {0}\",\n  DATE: \"Invalid value. not a valid Date\",\n  DEFAULT: \"There is an Error\",\n  PASSWORD:\n    \"Must be at least 8 characters and contain one of number, lower and upper case letters, and special character (@$!%*?&_-.,)\",\n  LIST: \"Invalid list of {0}\",\n  MODEL_NOT_FOUND: \"No model registered under {0}\",\n  EQUALS: \"This field must be equal to field {0}\",\n  DIFF: \"This field must be different from field {0}\",\n  LESS_THAN: \"This field must be less than field {0}\",\n  LESS_THAN_OR_EQUAL: \"This field must be less than or equal to field {0}\",\n  GREATER_THAN: \"This field must be greater than field {0}\",\n  GREATER_THAN_OR_EQUAL:\n    \"This field must be greater than or equal to field {0}\",\n};\n\n/**\n * @summary Defines the various default regexp patterns used\n *\n * @enum DEFAULT_PATTERNS\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const DEFAULT_PATTERNS = {\n  EMAIL:\n    /[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-zA-Z0-9](?:[a-z0-9-]*[a-zA-Z0-9])?\\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?/,\n  URL: /^(?:(?:(?:https?|ftp):)?\\/\\/)(?:\\S+(?::\\S*)?@)?(?:(?!(?:10|127)(?:\\.\\d{1,3}){3})(?!(?:169\\.254|192\\.168)(?:\\.\\d{1,3}){2})(?!172\\.(?:1[6-9]|2\\d|3[0-1])(?:\\.\\d{1,3}){2})(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z0-9\\u00a1-\\uffff][a-z0-9\\u00a1-\\uffff_-]{0,62})?[a-z0-9\\u00a1-\\uffff]\\.)+(?:[a-z\\u00a1-\\uffff]{2,}\\.?))(?::\\d{2,5})?(?:[/?#]\\S*)?$/i,\n  PASSWORD: {\n    CHAR8_ONE_OF_EACH:\n      /^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[@$!%*?&_\\-.,])[A-Za-z\\d@$!%*?&_\\-.,]{8,}$/g,\n  },\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../../src/validation/Validators/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,mCAA8B;AAElD;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,WAAW;IACjB,SAAS,EAAE,UAAU;IACrB,kBAAkB,EAAE,iBAAiB;IACrC,YAAY,EAAE,aAAa;IAC3B,qBAAqB,EAAE,oBAAoB;CACnC,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,OAAO,EAAE,GAAG,SAAS,CAAC,OAAO,aAAa;IAC1C,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,MAAM;IACZ,GAAG,EAAE,KAAK;IACV,UAAU,EAAE,WAAW;IACvB,GAAG,EAAE,KAAK;IACV,UAAU,EAAE,WAAW;IACvB,QAAQ,EAAE,UAAU;IACpB,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,UAAU;IACpB,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,QAAQ;IAChB,GAAG,EAAE,KAAK;IACV,SAAS,EAAE,WAAW;IACtB,GAAG,wBAAwB;CACnB,CAAC;AAEX;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,SAAS;IACT,UAAU;IACV,OAAO;IACP,OAAO;IACP,KAAK;IACL,MAAM;IACN,MAAM;IACN,QAAQ;IACR,WAAW;IACX,SAAS;IACT,UAAU;IACV,UAAU;CACX,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,QAAQ;IACR,QAAQ;IACR,SAAS;IACT,WAAW;IACX,UAAU;IACV,QAAQ;IACR,UAAU;CACX,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAA2B;IAC5D,QAAQ,EAAE,wBAAwB;IAClC,GAAG,EAAE,0BAA0B;IAC/B,GAAG,EAAE,0BAA0B;IAC/B,UAAU,EAAE,2BAA2B;IACvC,UAAU,EAAE,2BAA2B;IACvC,OAAO,EAAE,sCAAsC;IAC/C,KAAK,EAAE,gCAAgC;IACvC,GAAG,EAAE,8BAA8B;IACnC,IAAI,EAAE,0CAA0C;IAChD,IAAI,EAAE,kCAAkC;IACxC,IAAI,EAAE,iCAAiC;IACvC,OAAO,EAAE,mBAAmB;IAC5B,QAAQ,EACN,4HAA4H;IAC9H,IAAI,EAAE,qBAAqB;IAC3B,eAAe,EAAE,+BAA+B;IAChD,MAAM,EAAE,uCAAuC;IAC/C,IAAI,EAAE,6CAA6C;IACnD,SAAS,EAAE,wCAAwC;IACnD,kBAAkB,EAAE,oDAAoD;IACxE,YAAY,EAAE,2CAA2C;IACzD,qBAAqB,EACnB,uDAAuD;IACzD,MAAM,EAAE,6CAA6C;CACtD,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,KAAK,EACH,4JAA4J;IAC9J,GAAG,EAAE,yaAAya;IAC9a,QAAQ,EAAE;QACR,iBAAiB,EACf,iFAAiF;KACpF;CACF,CAAC","sourcesContent":["import { ModelKeys } from \"../../utils/constants\";\n\n/**\n * @summary Keys used for comparison-based validations.\n *\n * @property {string} EQUALS - Validates if two values are equal.\n * @property {string} DIFF - Validates if two values are different.\n * @property {string} LESS_THAN - Validates if a value is less than another.\n * @property {string} LESS_THAN_OR_EQUAL - Validates if a value is less than or equal to another.\n * @property {string} GREATER_THAN - Validates if a value is greater than another.\n * @property {string} GREATER_THAN_OR_EQUAL - Validates if a value is greater than or equal to another.\n *\n * @constant ComparisonValidationKeys\n * @memberof module:decorator-validation.Validation\n * @category Validation\n */\nexport const ComparisonValidationKeys = {\n  EQUALS: \"equals\",\n  DIFF: \"different\",\n  LESS_THAN: \"lessThan\",\n  LESS_THAN_OR_EQUAL: \"lessThanOrEqual\",\n  GREATER_THAN: \"greaterThan\",\n  GREATER_THAN_OR_EQUAL: \"greaterThanOrEqual\",\n} as const;\n\n/**\n * @summary The keys used for validation\n *\n * @property {string} REFLECT prefixes others\n * @property {string} REQUIRED sets as required\n * @property {string} MIN defines min value\n * @property {string} MAX defines max value\n * @property {string} STEP defines step\n * @property {string} MIN_LENGTH defines min length\n * @property {string} MAX_LENGTH defines max length\n * @property {string} PATTERN defines pattern\n * @property {string} EMAIL defines email\n * @property {string} URL defines url\n * @property {string} DATE defines date\n * @property {string} TYPE defines type\n * @property {string} PASSWORD defines password\n * @property {string} LIST defines list\n *\n * @constant ValidationKeys\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const ValidationKeys = {\n  REFLECT: `${ModelKeys.REFLECT}validation.`,\n  DATE: \"date\",\n  EMAIL: \"email\",\n  FORMAT: \"format\",\n  LIST: \"list\",\n  MAX: \"max\",\n  MAX_LENGTH: \"maxlength\",\n  MIN: \"min\",\n  MIN_LENGTH: \"minlength\",\n  PASSWORD: \"password\",\n  PATTERN: \"pattern\",\n  REQUIRED: \"required\",\n  STEP: \"step\",\n  TYPE: \"type\",\n  UNIQUE: \"unique\",\n  URL: \"url\",\n  VALIDATOR: \"validator\",\n  ...ComparisonValidationKeys,\n} as const;\n\n/**\n * @summary list of month names\n * @description Stores month names. Can be changed for localization purposes\n *\n * @constant MONTH_NAMES\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const MONTH_NAMES = [\n  \"January\",\n  \"February\",\n  \"March\",\n  \"April\",\n  \"May\",\n  \"June\",\n  \"July\",\n  \"August\",\n  \"September\",\n  \"October\",\n  \"November\",\n  \"December\",\n];\n\n/**\n * @summary list of names of days of the week\n * @description Stores names for days of the week. Can be changed for localization purposes\n *\n * @constant DAYS_OF_WEEK_NAMES\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const DAYS_OF_WEEK_NAMES = [\n  \"Sunday\",\n  \"Monday\",\n  \"Tuesday\",\n  \"Wednesday\",\n  \"Thursday\",\n  \"Friday\",\n  \"Saturday\",\n];\n\n/**\n * @summary Defines the default error messages\n *\n * @property {string} REQUIRED default error message\n * @property {string} MIN default error message\n * @property {string} MAX default error message\n * @property {string} MIN_LENGTH default error message\n * @property {string} MAX_LENGTH default error message\n * @property {string} PATTERN default error message\n * @property {string} EMAIL default error message\n * @property {string} URL default error message\n * @property {string} TYPE default error message\n * @property {string} STEP default error message\n * @property {string} DATE default error message\n * @property {string} DEFAULT default error message\n * @property {string} PASSWORD default error message\n * @property {string} LIST default error message\n * @property {string} LIST_INSIDE default error message\n * @property {string} MODEL_NOT_FOUND default error message\n *\n * @constant DEFAULT_ERROR_MESSAGES\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const DEFAULT_ERROR_MESSAGES: Record<string, string> = {\n  REQUIRED: \"This field is required\",\n  MIN: \"The minimum value is {0}\",\n  MAX: \"The maximum value is {0}\",\n  MIN_LENGTH: \"The minimum length is {0}\",\n  MAX_LENGTH: \"The maximum length is {0}\",\n  PATTERN: \"The value does not match the pattern\",\n  EMAIL: \"The value is not a valid email\",\n  URL: \"The value is not a valid URL\",\n  TYPE: \"Invalid type. Expected {0}, received {1}\",\n  STEP: \"Invalid value. Not a step of {0}\",\n  DATE: \"Invalid value. not a valid Date\",\n  DEFAULT: \"There is an Error\",\n  PASSWORD:\n    \"Must be at least 8 characters and contain one of number, lower and upper case letters, and special character (@$!%*?&_-.,)\",\n  LIST: \"Invalid list of {0}\",\n  MODEL_NOT_FOUND: \"No model registered under {0}\",\n  EQUALS: \"This field must be equal to field {0}\",\n  DIFF: \"This field must be different from field {0}\",\n  LESS_THAN: \"This field must be less than field {0}\",\n  LESS_THAN_OR_EQUAL: \"This field must be less than or equal to field {0}\",\n  GREATER_THAN: \"This field must be greater than field {0}\",\n  GREATER_THAN_OR_EQUAL:\n    \"This field must be greater than or equal to field {0}\",\n  UNIQUE: \"Duplicate found, this field must be unique.\",\n};\n\n/**\n * @summary Defines the various default regexp patterns used\n *\n * @enum DEFAULT_PATTERNS\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport const DEFAULT_PATTERNS = {\n  EMAIL:\n    /[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-zA-Z0-9](?:[a-z0-9-]*[a-zA-Z0-9])?\\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?/,\n  URL: /^(?:(?:(?:https?|ftp):)?\\/\\/)(?:\\S+(?::\\S*)?@)?(?:(?!(?:10|127)(?:\\.\\d{1,3}){3})(?!(?:169\\.254|192\\.168)(?:\\.\\d{1,3}){2})(?!172\\.(?:1[6-9]|2\\d|3[0-1])(?:\\.\\d{1,3}){2})(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z0-9\\u00a1-\\uffff][a-z0-9\\u00a1-\\uffff_-]{0,62})?[a-z0-9\\u00a1-\\uffff]\\.)+(?:[a-z\\u00a1-\\uffff]{2,}\\.?))(?::\\d{2,5})?(?:[/?#]\\S*)?$/i,\n  PASSWORD: {\n    CHAR8_ONE_OF_EACH:\n      /^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[@$!%*?&_\\-.,])[A-Za-z\\d@$!%*?&_\\-.,]{8,}$/g,\n  },\n};\n"]}

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

@@ -1,4 +1,5 @@
 export * from "./constants";
+export * from "./AsyncValidator";
 export * from "./DateValidator";
 export * from "./decorators";
 export * from "./DiffValidator";

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

@@ -1,4 +1,5 @@
 export * from "./constants.js";
+export * from "./AsyncValidator.js";
 export * from "./DateValidator.js";
 export * from "./decorators.js";
 export * from "./DiffValidator.js";
@@ -22,4 +23,4 @@ export * from "./URLValidator.js";
 export * from "./Validator.js";
 export * from "./ValidatorRegistry.js";
 export * from "./utils.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdmFsaWRhdGlvbi9WYWxpZGF0b3JzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLCtCQUE0QjtBQUM1QixtQ0FBZ0M7QUFDaEMsZ0NBQTZCO0FBQzdCLG1DQUFnQztBQUNoQyxvQ0FBaUM7QUFDakMscUNBQWtDO0FBQ2xDLDBDQUF1QztBQUN2QyxpREFBOEM7QUFDOUMsdUNBQW9DO0FBQ3BDLDhDQUEyQztBQUMzQyxtQ0FBZ0M7QUFDaEMsd0NBQXFDO0FBQ3JDLGtDQUErQjtBQUMvQix3Q0FBcUM7QUFDckMsa0NBQStCO0FBQy9CLHVDQUFvQztBQUNwQyxzQ0FBbUM7QUFDbkMsdUNBQW9DO0FBQ3BDLG1DQUFnQztBQUNoQyxtQ0FBZ0M7QUFDaEMsa0NBQStCO0FBQy9CLCtCQUE0QjtBQUM1Qix1Q0FBb0M7QUFDcEMsMkJBQXdCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9EYXRlVmFsaWRhdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZWNvcmF0b3JzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9EaWZmVmFsaWRhdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9FbWFpbFZhbGlkYXRvclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vRXF1YWxzVmFsaWRhdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9HcmVhdGVyVGhhblZhbGlkYXRvclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vR3JlYXRlclRoYW5PckVxdWFsVmFsaWRhdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9MZXNzVGhhblZhbGlkYXRvclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vTGVzc1RoYW5PckVxdWFsVmFsaWRhdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9MaXN0VmFsaWRhdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9NYXhMZW5ndGhWYWxpZGF0b3JcIjtcbmV4cG9ydCAqIGZyb20gXCIuL01heFZhbGlkYXRvclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vTWluTGVuZ3RoVmFsaWRhdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9NaW5WYWxpZGF0b3JcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1Bhc3N3b3JkVmFsaWRhdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9QYXR0ZXJuVmFsaWRhdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9SZXF1aXJlZFZhbGlkYXRvclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vU3RlcFZhbGlkYXRvclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vVHlwZVZhbGlkYXRvclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vVVJMVmFsaWRhdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9WYWxpZGF0b3JcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1ZhbGlkYXRvclJlZ2lzdHJ5XCI7XG5leHBvcnQgKiBmcm9tIFwiLi91dGlsc1wiO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdmFsaWRhdGlvbi9WYWxpZGF0b3JzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLCtCQUE0QjtBQUM1QixvQ0FBaUM7QUFDakMsbUNBQWdDO0FBQ2hDLGdDQUE2QjtBQUM3QixtQ0FBZ0M7QUFDaEMsb0NBQWlDO0FBQ2pDLHFDQUFrQztBQUNsQywwQ0FBdUM7QUFDdkMsaURBQThDO0FBQzlDLHVDQUFvQztBQUNwQyw4Q0FBMkM7QUFDM0MsbUNBQWdDO0FBQ2hDLHdDQUFxQztBQUNyQyxrQ0FBK0I7QUFDL0Isd0NBQXFDO0FBQ3JDLGtDQUErQjtBQUMvQix1Q0FBb0M7QUFDcEMsc0NBQW1DO0FBQ25DLHVDQUFvQztBQUNwQyxtQ0FBZ0M7QUFDaEMsbUNBQWdDO0FBQ2hDLGtDQUErQjtBQUMvQiwrQkFBNEI7QUFDNUIsdUNBQW9DO0FBQ3BDLDJCQUF3QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2NvbnN0YW50c1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vQXN5bmNWYWxpZGF0b3JcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0RhdGVWYWxpZGF0b3JcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2RlY29yYXRvcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0RpZmZWYWxpZGF0b3JcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0VtYWlsVmFsaWRhdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9FcXVhbHNWYWxpZGF0b3JcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0dyZWF0ZXJUaGFuVmFsaWRhdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9HcmVhdGVyVGhhbk9yRXF1YWxWYWxpZGF0b3JcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0xlc3NUaGFuVmFsaWRhdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9MZXNzVGhhbk9yRXF1YWxWYWxpZGF0b3JcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0xpc3RWYWxpZGF0b3JcIjtcbmV4cG9ydCAqIGZyb20gXCIuL01heExlbmd0aFZhbGlkYXRvclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vTWF4VmFsaWRhdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9NaW5MZW5ndGhWYWxpZGF0b3JcIjtcbmV4cG9ydCAqIGZyb20gXCIuL01pblZhbGlkYXRvclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vUGFzc3dvcmRWYWxpZGF0b3JcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1BhdHRlcm5WYWxpZGF0b3JcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1JlcXVpcmVkVmFsaWRhdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9TdGVwVmFsaWRhdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9UeXBlVmFsaWRhdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9VUkxWYWxpZGF0b3JcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1ZhbGlkYXRvclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vVmFsaWRhdG9yUmVnaXN0cnlcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3V0aWxzXCI7XG4iXX0=

package/lib/esm/validation/decorators.d.ts

@@ -14,6 +14,7 @@ import { Constructor, ModelConstructor } from "../model/types";
  * @category Property Decorators
  */
 export declare function validationMetadata<V>(decorator: any, key: string, value: V): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+export declare function async(): (model: object) => void;
 /**
  * @description Property decorator that marks a field as required
  * @summary Marks the property as required, causing validation to fail if the property is undefined, null, or empty.
@@ -188,7 +189,7 @@ export interface ListMetadata extends ListValidatorOptions {
  * @summary List Decorator
  * @description Also sets the {@link type} to the provided collection
  *
- * @param {Constructor} clazz
+ * @param {ModelConstructor} clazz
  * @param {string} [collection] The collection being used. defaults to Array
  * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LIST}
  *