@decaf-ts/decorator-validation 1.7.7 → 1.7.9

package/dist/decorator-validation.esm.cjs

@@ -26,6 +26,7 @@ const COMPARISON_ERROR_MESSAGES = {
  * @memberOf module:decorator-validation
  */
 const VALIDATION_PARENT_KEY = Symbol("_parent");
+const ASYNC_META_KEY = Symbol("isAsync");
 
 /**
  * @description Enum containing metadata keys used for reflection in the model system
@@ -120,21 +121,22 @@ const ComparisonValidationKeys = {
  */
 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,
 };
 /**
@@ -222,6 +224,7 @@ 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
@@ -1031,117 +1034,58 @@ class ModelErrorDefinition {
 }
 
 /**
- * @summary References the relevant JS primitives
- *
- * @property {string} STRING references the string primitive
- * @property {string} NUMBER references the number primitive
- * @property {string} BOOLEAN references the boolean primitive
- * @property {string} BIGINT references the bigint primitive
- *
- * @constant Primitives
- * @memberOf module:decorator-validation
- */
-var Primitives;
-(function (Primitives) {
-    Primitives["STRING"] = "string";
-    Primitives["NUMBER"] = "number";
-    Primitives["BOOLEAN"] = "boolean";
-    Primitives["BIGINT"] = "bigint";
-})(Primitives || (Primitives = {}));
-/**
- * @summary References the Reserved model names to ignore during Model rebuilding
- *
- * @property {string} STRING
- * @property {string} OBJECT
- * @property {string} NUMBER
- * @property {string} BOOLEAN
- * @property {string} BIGINT
- * @property {string} DATE
+ * @description Abstract base class for all validators in the validation framework.
+ * @summary The BaseValidator class provides the foundation for all synchronous and asynchronous validator implementations.
+ * It handles type checking, error message formatting, and defines the interface that all validators must implement.
+ * This class is designed to be extended by specific validator classes that define their own validation logic.
  *
- * @constant ReservedModels
- * @memberOf module:decorator-validation
- */
-var ReservedModels;
-(function (ReservedModels) {
-    ReservedModels["STRING"] = "string";
-    ReservedModels["OBJECT"] = "object";
-    ReservedModels["NUMBER"] = "number";
-    ReservedModels["BOOLEAN"] = "boolean";
-    ReservedModels["BIGINT"] = "bigint";
-    ReservedModels["DATE"] = "date";
-})(ReservedModels || (ReservedModels = {}));
-/**
- * @summary References the basic supported js types
+ * @template V - Validator options type
+ * @template IsAsync - Whether the validator is async (true) or sync (false). Default `false`.
  *
- * @property {string} string
- * @property {string} array
- * @property {string} number
- * @property {string} boolean
- * @property {string} symbol
- * @property {string} function
- * @property {string} object
- * @property {string} undefined
- * @property {string} null
- * @property {string} BIGINT
+ * @param {boolean} async - Defines if the validator is async (must match the subclass signature)
+ * @param {string} message - Default error message to display when validation fails (defaults to {@link DEFAULT_ERROR_MESSAGES#DEFAULT})
+ * @param {string[]} acceptedTypes - Type names that this validator accepts (used for runtime type checking)
  *
- * @constant jsTypes
- * @memberOf module:decorator-validation
- */
-const jsTypes = [
-    "string",
-    "array",
-    "number",
-    "boolean",
-    "symbol",
-    "function",
-    "object",
-    "undefined",
-    "null",
-    "bigint",
-];
-
-/**
- * @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.
+ * @class BaseValidator
+ * @abstract
  *
- * @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
+ * @example
+ * // Example of a synchronous validator
+ * class SyncValidator extends BaseValidator<SomeOptions, false> {
+ *   constructor() {
+ *     super(false, "Sync validation failed", String.name);
+ *   }
  *
- * @class Validator
- * @abstract
+ *   public hasErrors(value: any, options?: SomeOptions): string | undefined {
+ *     if (typeof value !== "string") return this.getMessage(this.message);
+ *     return undefined;
+ *   }
+ * }
  *
  * @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 an asynchronous custom validator
+ * class AsyncValidator extends BaseValidator<SomeOptions, true> {
+ *   constructor() {
+ *     super(true, "Async validation failed", String.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
+ *   public async hasErrors(value: any, options?: SomeOptions): Promise<string | undefined> {
+ *     const result = await someAsyncCheck(value);
+ *     if (!result) return this.getMessage(this.message);
+ *     return undefined;
  *   }
  * }
- * ```
  *
  * @mermaid
  * sequenceDiagram
  *   participant C as Client
  *   participant V as Validator Subclass
- *   participant B as Base Validator
+ *   participant B as BaseValidator
  *
- *   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: new CustomValidator(async, message)
+ *   V->>B: super(async, message, acceptedTypes)
+ *   B->>B: Store message, async flag, and accepted types
+ *   B->>B: Optionally wrap hasErrors with type checking
  *   C->>V: hasErrors(value, options)
  *   alt value type not in acceptedTypes
  *     B-->>C: Type error message
@@ -1152,8 +1096,9 @@ const jsTypes = [
  *
  * @category Validators
  */
-class Validator {
-    constructor(message = DEFAULT_ERROR_MESSAGES.DEFAULT, ...acceptedTypes) {
+class BaseValidator {
+    constructor(async, message = DEFAULT_ERROR_MESSAGES.DEFAULT, ...acceptedTypes) {
+        this.async = async;
         this.message = message;
         if (acceptedTypes.length)
             this.acceptedTypes = acceptedTypes;
@@ -1185,12 +1130,12 @@ class Validator {
      * @private
      */
     checkTypeAndHasErrors(unbound) {
-        return function (value, ...args) {
+        return function (value, options, proxy, ...args) {
             if (value === undefined || !this.acceptedTypes)
-                return unbound(value, ...args);
+                return unbound(value, options, proxy, ...args);
             if (!Reflection.checkTypes(value, this.acceptedTypes))
                 return this.getMessage(DEFAULT_ERROR_MESSAGES.TYPE, this.acceptedTypes.join(", "), typeof value);
-            return unbound(value, ...args);
+            return unbound(value, options, proxy, ...args);
         }.bind(this);
     }
     /**
@@ -1202,6 +1147,53 @@ class Validator {
     }
 }
 
+/**
+ * @description
+ * Abstract class for defining synchronous validators.
+ *
+ * This class extends the base {@link BaseValidator} and enforces that any implementation of `hasErrors` must be synchronous.
+ *
+ * Use this when the validation process is immediate and does not require asynchronous operations.
+ *
+ * @example
+ * ```typescript
+ * // 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);
+ *   }
+ *
+ *   hasErrors(value: number, options?: { gt?: number }) {
+ *     const minValue = options?.gt ?? 0;
+ *     if (value <= minValue) {
+ *       return this.getMessage();
+ *     }
+ *     return undefined;
+ *   }
+ * }
+ *
+ * // 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');
+ * }
+ * ```
+ *
+ * - If `value` is less than or equal to `gt`, returns the error message.
+ * - Otherwise, returns `undefined` indicating validation success.
+ *
+ * @see {@link BaseValidator} For the base validator.
+ * @see {@link ValidatorOptions} For the base validator options.
+ */
+class Validator extends BaseValidator {
+    constructor(message = DEFAULT_ERROR_MESSAGES.DEFAULT, ...acceptedTypes) {
+        super(false, message, ...acceptedTypes);
+    }
+}
+
 /**
  * @summary Base Implementation of a Validator Registry
  *
@@ -1356,155 +1348,444 @@ class Validation {
     }
 }
 
+function getModelKey(str) {
+    return ModelKeys.REFLECT + str;
+}
+function getMetadata(model) {
+    const metadata = Reflect.getMetadata(getModelKey(ModelKeys.MODEL), model.constructor);
+    if (!metadata)
+        throw new Error("could not find metadata for provided " + model.constructor.name);
+    return metadata;
+}
+/**
+ * Wraps a value in a Promise if the `async` flag is true.
+ *
+ * @template T - The type of the value being wrapped.
+ * @template Async - A boolean type that determines if the result should be wrapped in a Promise.
+ *
+ * @param value - The value to return directly or wrap in a Promise.
+ * @param async - If true, the value is wrapped in a resolved Promise. If false or undefined, the value is returned as-is.
+ *
+ * @returns The original value or a Promise resolving to it, depending on the `async` flag.
+ */
+function toConditionalPromise(value, async) {
+    return (async ? Promise.resolve(value) : value);
+}
+
+/**
+ * Retrieves the validation metadata decorators associated with a specific property of a model,
+ * using the reflective metadata key.
+ *
+ * @param model - The model instance or class containing the decorated property.
+ * @param {string} prop - The name of the property whose decorators should be retrieved.
+ * @param {string} reflectKey - The metadata key used to retrieve the decorators.
+ *                     Defaults to `ValidationKeys.REFLECT`.
+ *
+ * @returns The validation decorators applied to the property
+ */
+function getValidationDecorators(model, prop, reflectKey = ValidationKeys.REFLECT) {
+    return Reflection.getPropertyDecorators(reflectKey, model, prop);
+}
+/**
+ * @description
+ * Retrieves all validatable property decorators from a given model, excluding specified properties.
+ *
+ * @summary
+ * Iterates through the own enumerable properties of a model instance, filtering out any properties
+ * listed in the `propsToIgnore` array. For each remaining property, it checks whether validation
+ * decorators are present using `getValidationDecorators`, and if so, collects them in the result array.
+ *
+ * @template M - A generic parameter extending the `Model` class, representing the model type being inspected.
+ *
+ * @param {M} model - An instance of a class extending `Model` from which validatable properties will be extracted.
+ * @param {string[]} propsToIgnore - An array of property names that should be excluded from validation inspection.
+ *
+ * @return {ValidationPropertyDecoratorDefinition[]} An array of validation decorator definitions
+ * associated with the model's properties, excluding those listed in `propsToIgnore`.
+ *
+ * @function getValidatableProperties
+ */
+function getValidatableProperties(model, propsToIgnore) {
+    const decoratedProperties = [];
+    for (const prop in model) {
+        if (Object.prototype.hasOwnProperty.call(model, prop) &&
+            !propsToIgnore.includes(prop)) {
+            const dec = getValidationDecorators(model, prop);
+            if (dec)
+                decoratedProperties.push(dec);
+        }
+    }
+    return decoratedProperties;
+}
 /**
- * @summary Analyses the decorations of the properties and validates the obj according to them
+ * Safely sets temporary metadata on an object
+ */
+function setTemporaryContext(target, key, value) {
+    if (!Object.hasOwnProperty.call(target, key))
+        target[key] = value;
+}
+/**
+ * Safely removes temporary metadata from an object
+ */
+function cleanupTemporaryContext(target, key) {
+    if (Object.hasOwnProperty.call(target, key))
+        delete target[key];
+}
+/**
+ * Executes validation with temporary context and returns the validation result
+ *
+ * @param nestedModel - The instance to validate
+ * @param parentModel - Reference to a parent object for nested validation
+ * @param isAsync - Whether to perform async validation
+ * @returns Validation result from hasErrors()
+ */
+function getNestedValidationErrors(nestedModel, parentModel, isAsync) {
+    // Set temporary context for nested models
+    if (parentModel) {
+        setTemporaryContext(nestedModel, VALIDATION_PARENT_KEY, parentModel);
+    }
+    setTemporaryContext(nestedModel, ASYNC_META_KEY, !!isAsync);
+    const errs = nestedModel.hasErrors();
+    cleanupTemporaryContext(nestedModel, VALIDATION_PARENT_KEY);
+    cleanupTemporaryContext(nestedModel, ASYNC_META_KEY);
+    return errs;
+}
+function validateDecorator(model, value, decorator, async) {
+    const validator = Validation.get(decorator.key);
+    if (!validator) {
+        throw new Error(`Missing validator for ${decorator.key}`);
+    }
+    // skip async decorators if validateDecorators is called synchronously (async = false)
+    if (!async && decorator.props.async)
+        return undefined;
+    const decoratorProps = decorator.key === ModelKeys.TYPE
+        ? [decorator.props]
+        : decorator.props || {};
+    const context = PathProxyEngine.create(model, {
+        ignoreUndefined: true,
+        ignoreNull: true,
+    });
+    const maybeAsyncErrors = validator.hasErrors(value, decoratorProps, context);
+    return toConditionalPromise(maybeAsyncErrors, async);
+}
+/**
+ * @description
+ * Executes validation logic for a set of decorators applied to a model's property, handling both
+ * synchronous and asynchronous validations, including support for nested validations and lists.
+ *
+ * @summary
+ * Iterates over an array of decorator metadata objects and applies each validation rule to the
+ * provided value. For list decorators (`ValidationKeys.LIST`), it performs element-wise validation,
+ * supporting nested model validation and type checks. If the `async` flag is set, asynchronous
+ * validation is supported using `Promise.all`. The result is a record mapping validation keys to
+ * error messages, or `undefined` if no errors are found.
+ *
+ * @template M - A type parameter extending `Model`, representing the model type being validated.
+ * @template Async - A boolean indicating whether validation should be performed asynchronously.
  *
- * @typedef M extends Model
- * @prop {M} obj Model object to validate
- * @prop {string[]} [propsToIgnore] object properties to ignore in the validation
+ * @param {M} model - The model instance that the validation is associated with.
+ * @param {any} value - The value to be validated against the provided decorators.
+ * @param {DecoratorMetadataAsync[]} decorators - An array of metadata objects representing validation decorators.
+ * @param {Async} [async] - Optional flag indicating whether validation should be performed asynchronously.
  *
+ * @return {ConditionalAsync<Async, Record<string, string>> | undefined}
+ * Returns either a record of validation errors (keyed by the decorator key) or `undefined` if no errors are found.
+ * If `async` is true, the return value is a Promise resolving to the same structure.
+ *
+ * @function validateDecorators
+ */
+function validateDecorators(model, value, decorators, async) {
+    const result = {};
+    for (const decorator of decorators) {
+        // skip async decorators if validateDecorators is called synchronously (async = false)
+        if (!async && decorator.props.async)
+            continue;
+        let validationErrors = validateDecorator(model, value, decorator, async);
+        /*
+        If the decorator is a list, each element must be checked.
+        When 'async' is true, the 'err' will always be a pending promise initially,
+        so the '!err' check will evaluate to false (even if the promise later resolves with no errors)
+        */
+        if (decorator.key === ValidationKeys.LIST && (!validationErrors || async)) {
+            const values = value instanceof Set ? [...value] : value;
+            if (values && values.length > 0) {
+                const types = decorator.props.class ||
+                    decorator.props.clazz ||
+                    decorator.props.customTypes;
+                const allowedTypes = [types].flat().map((t) => String(t).toLowerCase());
+                // const reserved = Object.values(ReservedModels).map((v) => v.toLowerCase()) as string[];
+                const errs = values.map((childValue) => {
+                    // if (Model.isModel(v) && !reserved.includes(v) {
+                    if (Model.isModel(childValue)) {
+                        return getNestedValidationErrors(childValue, model, async);
+                    }
+                    return allowedTypes.includes(typeof childValue)
+                        ? undefined
+                        : "Value has no validatable type";
+                });
+                if (async) {
+                    validationErrors = Promise.all(errs).then((result) => {
+                        const allEmpty = result.every((r) => !r);
+                        return allEmpty ? undefined : result;
+                    });
+                }
+                else {
+                    const allEmpty = errs.every((r) => !r);
+                    validationErrors = errs.length > 0 && !allEmpty ? errs : undefined;
+                }
+            }
+        }
+        if (validationErrors)
+            result[decorator.key] = validationErrors;
+    }
+    if (!async)
+        return Object.keys(result).length > 0
+            ? result
+            : undefined;
+    const keys = Object.keys(result);
+    const promises = Object.values(result);
+    return Promise.all(promises).then((resolvedValues) => {
+        const res = {};
+        for (let i = 0; i < resolvedValues.length; i++) {
+            const val = resolvedValues[i];
+            if (val !== undefined) {
+                res[keys[i]] = val;
+            }
+        }
+        return Object.keys(res).length > 0 ? res : undefined;
+    });
+}
+/**
  * @function validate
+ * @template M
+ * @template Async
  * @memberOf module:decorator-validation
  * @category Model
+ *
+ * @description
+ * Validates the properties of a {@link Model} instance using registered decorators.
+ * Supports both synchronous and asynchronous validation flows, depending on the `async` flag.
+ *
+ * @summary
+ * This function inspects a given model object, identifies decorated properties that require validation,
+ * and applies the corresponding validation rules. It also supports nested model validation and gracefully
+ * merges any validation errors. For collections (Array/Set), it enforces the presence of the `@list` decorator
+ * and checks the type of elements. If a property is a nested model, it will call `hasErrors` on it and flatten
+ * the nested error keys using dot notation.
+ *
+ * @param {M} model - The model instance to be validated. Must extend from {@link Model}.
+ * @param {Async} [async] - A flag indicating whether validation should be asynchronous.
+ * @param {...string} propsToIgnore - A variadic list of property names that should be skipped during validation.
+ *
+ * @returns {ConditionalAsync<Async, ModelErrorDefinition | undefined>}
+ * Returns either a {@link ModelErrorDefinition} containing validation errors,
+ * or `undefined` if no errors are found. When `async` is `true`, returns a Promise.
+ *
+ * @see {@link Model}
+ * @see {@link ModelErrorDefinition}
+ * @see {@link validateDecorators}
+ * @see {@link getValidatableProperties}
+ *
+ * @mermaid
+ * sequenceDiagram
+ *     participant Caller
+ *     participant validate
+ *     participant getValidatableProperties
+ *     participant validateDecorators
+ *     participant ModelInstance
+ *     Caller->>validate: call with obj, async, propsToIgnore
+ *     validate->>getValidatableProperties: retrieve decorated props
+ *     loop for each property
+ *         validate->>validateDecorators: validate using decorators
+ *         alt is nested model
+ *             validate->>ModelInstance: call hasErrors()
+ *         end
+ *     end
+ *     alt async
+ *         validate->>validate: Promise.allSettled for errors
+ *     end
+ *     validate-->>Caller: return ModelErrorDefinition | undefined
  */
-function validate(obj, ...propsToIgnore) {
-    const decoratedProperties = [];
-    for (const prop in obj)
-        if (Object.prototype.hasOwnProperty.call(obj, prop) &&
-            propsToIgnore.indexOf(prop) === -1) {
-            decoratedProperties.push(
-            // @ts-ignore
-            Reflection.getPropertyDecorators(ValidationKeys.REFLECT, obj, prop));
-        }
-    let result = undefined;
-    for (const decoratedProperty of decoratedProperties) {
-        const { prop, decorators } = decoratedProperty;
-        if (!decorators || !decorators.length)
+function validate(model, async, ...propsToIgnore) {
+    const decoratedProperties = getValidatableProperties(model, propsToIgnore);
+    const result = {};
+    const nestedErrors = {};
+    for (const { prop, decorators } of decoratedProperties) {
+        const propKey = String(prop);
+        let propValue = model[prop];
+        if (!decorators?.length)
             continue;
-        const defaultTypeDecorator = decorators[0];
-        // tries to find any type decorators or other decorators that already enforce type (the ones with the allowed types property defined). if so, skip the default type verification
-        if (decorators.find((d) => {
-            if (d.key === ValidationKeys.TYPE)
-                return true;
-            return !!d.props.types?.find((t) => t === defaultTypeDecorator.props.name);
-        })) {
-            decorators.shift(); // remove the design:type decorator, since the type will already be checked
+        // Get the default type validator
+        const designTypeDec = decorators.find((d) => {
+            return [ModelKeys.TYPE, ValidationKeys.TYPE].includes(d.key);
+        });
+        if (!designTypeDec)
+            continue;
+        const designType = designTypeDec.props.name;
+        // Handle array or Set types and enforce the presence of @list decorator
+        if ([Array.name, Set.name].includes(designType)) {
+            if (!decorators.some((d) => d.key === ValidationKeys.LIST)) {
+                result[propKey] = {
+                    [ValidationKeys.TYPE]: `Array or Set property '${propKey}' requires a @list decorator`,
+                };
+                continue;
+            }
+            if (propValue &&
+                !(Array.isArray(propValue) || propValue instanceof Set)) {
+                result[propKey] = {
+                    [ValidationKeys.TYPE]: `Property '${String(prop)}' must be either an Array or a Set`,
+                };
+                continue;
+            }
+            // Remove design:type decorator, since @list decorator already ensures type
+            for (let i = decorators.length - 1; i >= 0; i--) {
+                if (decorators[i].key === ModelKeys.TYPE) {
+                    decorators.splice(i, 1);
+                }
+            }
+            propValue = propValue instanceof Set ? [...propValue] : propValue;
         }
-        let errs = undefined;
-        for (const decorator of decorators) {
-            const validator = Validation.get(decorator.key);
-            if (!validator) {
-                throw new Error(`Missing validator for ${decorator.key}`);
+        const propErrors = validateDecorators(model, propValue, decorators, async) || {};
+        // Check for nested properties.
+        // To prevent unnecessary processing, "propValue" must be defined and validatable
+        // let nestedErrors: Record<string, any> = {};
+        const isConstr = Model.isPropertyModel(model, propKey);
+        // if propValue !== undefined, null
+        if (propValue && isConstr) {
+            const instance = propValue;
+            const isInvalidModel = typeof instance !== "object" ||
+                !instance.hasErrors ||
+                typeof instance.hasErrors !== "function";
+            if (isInvalidModel) {
+                // propErrors[ValidationKeys.TYPE] = "Model should be validatable but it's not.";
+                console.warn("Model should be validatable but it's not.");
             }
-            const decoratorProps = decorator.key === ModelKeys.TYPE
-                ? [decorator.props]
-                : decorator.props || {};
-            const err = validator.hasErrors(obj[prop.toString()], decoratorProps, PathProxyEngine.create(obj, { ignoreUndefined: true, ignoreNull: true }));
-            if (err) {
-                errs = errs || {};
-                errs[decorator.key] = err;
+            else {
+                nestedErrors[propKey] = getNestedValidationErrors(instance, model, async);
             }
         }
-        if (errs) {
-            result = result || {};
-            result[decoratedProperty.prop.toString()] = errs;
+        // Add to the result if we have any errors
+        // Async mode returns a Promise that resolves to undefined when no errors exist
+        if (Object.keys(propErrors).length > 0 || async)
+            result[propKey] = propErrors;
+        // Then merge any nested errors
+        if (!async) {
+            Object.entries(nestedErrors[propKey] || {}).forEach(([key, error]) => {
+                if (error !== undefined) {
+                    result[`${propKey}.${key}`] = error;
+                }
+            });
         }
     }
-    // tests nested classes
-    for (const prop of Object.keys(obj).filter((k) => !result || !result[k])) {
-        let err;
-        // if a nested Model
-        const allDecorators = Reflection.getPropertyDecorators(ValidationKeys.REFLECT, obj, prop).decorators;
-        const decorators = Reflection.getPropertyDecorators(ValidationKeys.REFLECT, obj, prop).decorators.filter((d) => [ModelKeys.TYPE, ValidationKeys.TYPE].indexOf(d.key) !== -1);
-        if (!decorators || !decorators.length)
-            continue;
-        const dec = decorators.pop();
-        const clazz = dec.props.name
-            ? [dec.props.name]
-            : Array.isArray(dec.props.customTypes)
-                ? dec.props.customTypes
-                : [dec.props.customTypes];
-        const reserved = Object.values(ReservedModels).map((v) => v.toLowerCase());
-        for (const c of clazz) {
-            if (reserved.indexOf(c.toLowerCase()) === -1) {
-                const typeDecoratorKey = Array.isArray(obj[prop])
-                    ? ValidationKeys.LIST
-                    : ValidationKeys.TYPE;
-                const types = allDecorators.find((d) => d.key === typeDecoratorKey) || {};
-                let allowedTypes = [];
-                if (types && types.props) {
-                    const customTypes = Array.isArray(obj[prop])
-                        ? types.props.class
-                        : types.props.customTypes;
-                    if (customTypes)
-                        allowedTypes = Array.isArray(customTypes)
-                            ? customTypes.map((t) => `${t}`.toLowerCase())
-                            : [customTypes.toLowerCase()];
-                }
-                const validate = (prop, value) => {
-                    if (typeof value !== "object" && typeof value !== "function")
-                        return undefined;
-                    try {
-                        if (value && !value[VALIDATION_PARENT_KEY])
-                            value[VALIDATION_PARENT_KEY] = obj; // TODO: freeze?
-                        return Model.isModel(value)
-                            ? value.hasErrors()
-                            : allowedTypes.includes(typeof value)
-                                ? undefined
-                                : "Value has no validatable type";
+    // Synchronous return
+    if (!async) {
+        return (Object.keys(result).length > 0
+            ? new ModelErrorDefinition(result)
+            : undefined);
+    }
+    const merged = result; // TODO: apply filtering
+    const keys = Object.keys(merged);
+    const promises = Object.values(merged);
+    return Promise.allSettled(promises).then(async (results) => {
+        const result = {};
+        for (const [parentProp, nestedErrPromise] of Object.entries(nestedErrors)) {
+            const nestedPropDecErrors = (await nestedErrPromise);
+            if (nestedPropDecErrors)
+                Object.entries(nestedPropDecErrors).forEach(([nestedProp, nestedPropDecError]) => {
+                    if (nestedPropDecError !== undefined) {
+                        const nestedKey = [parentProp, nestedProp].join(".");
+                        result[nestedKey] = nestedPropDecError;
                     }
-                    finally {
-                        if (value && value[VALIDATION_PARENT_KEY])
-                            delete value[VALIDATION_PARENT_KEY];
-                    }
-                };
-                switch (c) {
-                    case Array.name:
-                    case Set.name:
-                        if (allDecorators.length) {
-                            const listDec = allDecorators.find((d) => d.key === ValidationKeys.LIST);
-                            if (listDec) {
-                                err = (c === Array.name
-                                    ? obj[prop]
-                                    : // If it's a Set
-                                        obj[prop].values())
-                                    .map((v) => validate(prop, v))
-                                    .filter((e) => !!e);
-                                if (!err?.length) {
-                                    // if the result is an empty list...
-                                    err = undefined;
-                                }
-                            }
-                        }
-                        break;
-                    default:
-                        try {
-                            if (obj[prop])
-                                err = validate(prop, obj[prop]);
-                        }
-                        catch (e) {
-                            console.warn(`Model should be validatable but its not: ${e}`);
-                        }
-                }
+                });
+        }
+        for (let i = 0; i < results.length; i++) {
+            const key = keys[i];
+            const res = results[i];
+            if (res.status === "fulfilled" && res.value !== undefined) {
+                result[key] = res.value;
             }
-            if (err) {
-                result = result || {};
-                result[prop] = err;
+            else if (res.status === "rejected") {
+                result[key] =
+                    res.reason instanceof Error
+                        ? res.reason.message
+                        : String(res.reason || "Validation failed");
             }
         }
-    }
-    return result ? new ModelErrorDefinition(result) : undefined;
+        return Object.keys(result).length > 0
+            ? new ModelErrorDefinition(result)
+            : undefined;
+    });
 }
 
-function getModelKey(str) {
-    return ModelKeys.REFLECT + str;
-}
-function getMetadata(model) {
-    const metadata = Reflect.getMetadata(getModelKey(ModelKeys.MODEL), model.constructor);
-    if (!metadata)
-        throw new Error("could not find metadata for provided " + model.constructor.name);
-    return metadata;
-}
+/**
+ * @summary References the relevant JS primitives
+ *
+ * @property {string} STRING references the string primitive
+ * @property {string} NUMBER references the number primitive
+ * @property {string} BOOLEAN references the boolean primitive
+ * @property {string} BIGINT references the bigint primitive
+ *
+ * @constant Primitives
+ * @memberOf module:decorator-validation
+ */
+var Primitives;
+(function (Primitives) {
+    Primitives["STRING"] = "string";
+    Primitives["NUMBER"] = "number";
+    Primitives["BOOLEAN"] = "boolean";
+    Primitives["BIGINT"] = "bigint";
+})(Primitives || (Primitives = {}));
+/**
+ * @summary References the Reserved model names to ignore during Model rebuilding
+ *
+ * @property {string} STRING
+ * @property {string} OBJECT
+ * @property {string} NUMBER
+ * @property {string} BOOLEAN
+ * @property {string} BIGINT
+ * @property {string} DATE
+ *
+ * @constant ReservedModels
+ * @memberOf module:decorator-validation
+ */
+var ReservedModels;
+(function (ReservedModels) {
+    ReservedModels["STRING"] = "string";
+    ReservedModels["OBJECT"] = "object";
+    ReservedModels["NUMBER"] = "number";
+    ReservedModels["BOOLEAN"] = "boolean";
+    ReservedModels["BIGINT"] = "bigint";
+    ReservedModels["DATE"] = "date";
+})(ReservedModels || (ReservedModels = {}));
+/**
+ * @summary References the basic supported js types
+ *
+ * @property {string} string
+ * @property {string} array
+ * @property {string} number
+ * @property {string} boolean
+ * @property {string} symbol
+ * @property {string} function
+ * @property {string} object
+ * @property {string} undefined
+ * @property {string} null
+ * @property {string} BIGINT
+ *
+ * @constant jsTypes
+ * @memberOf module:decorator-validation
+ */
+const jsTypes = [
+    "string",
+    "array",
+    "number",
+    "boolean",
+    "symbol",
+    "function",
+    "object",
+    "undefined",
+    "null",
+    "bigint",
+];
 
 let modelBuilderFunction;
 let actingModelRegistry;
@@ -1647,7 +1928,11 @@ function bulkModelRegister(...models) {
  */
 class Model {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    constructor(arg) { }
+    constructor(arg = undefined) { }
+    isAsync() {
+        const self = this;
+        return !!(self[ASYNC_META_KEY] ?? self?.constructor[ASYNC_META_KEY]);
+    }
     /**
      * @description Validates the model object against its defined validation rules
      * @summary Validates the object according to its decorated properties, returning any validation errors
@@ -1656,7 +1941,7 @@ class Model {
      * @return {ModelErrorDefinition | undefined} - Returns a ModelErrorDefinition object if validation errors exist, otherwise undefined
      */
     hasErrors(...exceptions) {
-        return validate(this, ...exceptions);
+        return validate(this, this.isAsync(), ...exceptions);
     }
     /**
      * @description Determines if this model is equal to another object
@@ -1983,11 +2268,12 @@ class Model {
      *
      * @template M
      * @param {M} model - The model instance to validate
+     * @param {boolean} async - A flag indicating whether validation should be asynchronous.
      * @param {string[]} [propsToIgnore] - Properties to exclude from validation
      * @return {ModelErrorDefinition | undefined} - Returns validation errors if any, otherwise undefined
      */
-    static hasErrors(model, ...propsToIgnore) {
-        return validate(model, ...propsToIgnore);
+    static hasErrors(model, async, ...propsToIgnore) {
+        return validate(model, async, ...propsToIgnore);
     }
     /**
      * @description Converts a model instance to a serialized string
@@ -2174,6 +2460,65 @@ class Serialization {
     }
 }
 
+/**
+ * @description
+ * Abstract class for defining asynchronous validators.
+ *
+ * This class extends the base `Validator` and enforces that any implementation
+ * of `hasErrors` must be asynchronous, always returning a Promise.
+ *
+ * Use this when the validation process involves asynchronous operations,
+ * such as API calls, database lookups, or time-based checks (e.g., timeouts).
+ *
+ * @example
+ * ```typescript
+ * // Example of an asynchronous validator that compares value against a timeout
+ * class TimeoutValidator extends AsyncValidator<{ timeout?: number }> {
+ *   constructor(message: string = "Validation failed due to timeout") {
+ *     super(message);
+ *   }
+ *
+ *   async hasErrors(value: number, options?: { timeout?: number }) {
+ *     const delay = options?.timeout ?? 100;
+ *
+ *     // async call
+ *     await new Promise(res => setTimeout(res, delay));
+ *
+ *     if (value > delay) {
+ *       // Rejects the validation after waiting the delay if value is greater
+ *       return Promise.resolve(this.getMessage());
+ *     }
+ *
+ *     // Passes the validation after waiting the delay
+ *     return Promise.resolve(undefined);
+ *   }
+ * }
+ *
+ * // Example usage:
+ * const validator = new TimeoutValidator();
+ *
+ * async function runValidation() {
+ *  const error = await validator.hasErrors(50, { timeout: 100 });
+ *  if (error) {
+ *    return console.error('Validation error:', error);
+ *  }
+ *  console.log('Value is valid');
+ * }
+ *
+ * await runValidation();
+ * ```
+ *
+ * - If `value > timeout`, the validator waits for the delay and then rejects with an error.
+ * - If `value <= timeout`, the validator waits for the delay and resolves successfully with `undefined`.
+ *
+ * @see {@link Validator} For the base synchronous validator.
+ */
+class AsyncValidator extends BaseValidator {
+    constructor(message = DEFAULT_ERROR_MESSAGES.DEFAULT, ...acceptedTypes) {
+        super(true, message, ...acceptedTypes);
+    }
+}
+
 /**
  * @summary Marks the class as a validator for a certain key.
  * @description Registers the class in the {@link Validation} with the provided key
@@ -3024,7 +3369,7 @@ let ListValidator = class ListValidator extends Validator {
             switch (typeof val) {
                 case "object":
                 case "function":
-                    isValid = clazz.includes(val.constructor?.name);
+                    isValid = clazz.includes((val ?? {}).constructor?.name); // null is an object
                     break;
                 default:
                     isValid = clazz.some((c) => typeof val === c.toLowerCase());
@@ -3194,7 +3539,7 @@ let MinLengthValidator = class MinLengthValidator extends Validator {
      *
      * @return {string | undefined}
      *
-     * @memberOf MinLengthValidator
+     * @memberOf module:decorator-validation
      * @override
      *
      * @see Validator#hasErrors
@@ -3668,6 +4013,12 @@ function validationMetadata(decorator, key, value) {
     Validation.registerDecorator(key, decorator);
     return apply(propMetadata(key, value));
 }
+function async() {
+    return (model) => {
+        if (!Object.prototype.hasOwnProperty.call(model, ASYNC_META_KEY))
+            model[ASYNC_META_KEY] = true;
+    };
+}
 /**
  * @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.
@@ -3696,6 +4047,7 @@ function required(message = DEFAULT_ERROR_MESSAGES.REQUIRED) {
     const meta = {
         message: message,
         description: `defines the attribute as required`,
+        async: false,
     };
     return Decoration.for(key)
         .define(validationMetadata(required, key, meta))
@@ -3732,6 +4084,7 @@ function min(value, message = DEFAULT_ERROR_MESSAGES.MIN) {
         message: message,
         types: [Number.name, Date.name],
         description: `defines the max value of the attribute as ${value} (applies to numbers or Dates)`,
+        async: false,
     };
     return Decoration.for(key)
         .define(validationMetadata(min, key, meta))
@@ -3754,6 +4107,7 @@ function max(value, message = DEFAULT_ERROR_MESSAGES.MAX) {
         message: message,
         types: [Number.name, Date.name],
         description: `defines the max value of the attribute as ${value} (applies to numbers or Dates)`,
+        async: false,
     };
     return Decoration.for(key)
         .define(validationMetadata(max, key, meta))
@@ -3776,6 +4130,7 @@ function step(value, message = DEFAULT_ERROR_MESSAGES.STEP) {
         message: message,
         types: [Number.name],
         description: `defines the step of the attribute as ${value}`,
+        async: false,
     };
     return Decoration.for(key)
         .define(validationMetadata(step, key, meta))
@@ -3798,6 +4153,7 @@ function minlength(value, message = DEFAULT_ERROR_MESSAGES.MIN_LENGTH) {
         message: message,
         types: [String.name, Array.name, Set.name],
         description: `defines the min length of the attribute as ${value} (applies to strings or lists)`,
+        async: false,
     };
     return Decoration.for(key)
         .define(validationMetadata(minlength, key, meta))
@@ -3820,6 +4176,7 @@ function maxlength(value, message = DEFAULT_ERROR_MESSAGES.MAX_LENGTH) {
         message: message,
         types: [String.name, Array.name, Set.name],
         description: `defines the max length of the attribute as ${value} (applies to strings or lists)`,
+        async: false,
     };
     return Decoration.for(key)
         .define(validationMetadata(maxlength, key, meta))
@@ -3842,6 +4199,7 @@ function pattern(value, message = DEFAULT_ERROR_MESSAGES.PATTERN) {
         message: message,
         types: [String.name],
         description: `assigns the ${value === "string" ? value : value.toString()} pattern to the attribute`,
+        async: false,
     };
     return Decoration.for(key)
         .define(validationMetadata(pattern, key, meta))
@@ -3863,6 +4221,7 @@ function email(message = DEFAULT_ERROR_MESSAGES.EMAIL) {
         message: message,
         types: [String.name],
         description: "marks the attribute as an email",
+        async: false,
     };
     return Decoration.for(key)
         .define(validationMetadata(email, key, meta))
@@ -3884,6 +4243,7 @@ function url(message = DEFAULT_ERROR_MESSAGES.URL) {
         message: message,
         types: [String.name],
         description: "marks the attribute as an url",
+        async: false,
     };
     return Decoration.for(key)
         .define(validationMetadata(url, key, meta))
@@ -3905,6 +4265,7 @@ function type(types, message = DEFAULT_ERROR_MESSAGES.TYPE) {
         customTypes: types,
         message: message,
         description: "defines the accepted types for the attribute",
+        async: false,
     };
     return Decoration.for(key)
         .define(validationMetadata(type, key, meta))
@@ -3930,6 +4291,7 @@ function date(format = "dd/MM/yyyy", message = DEFAULT_ERROR_MESSAGES.DATE) {
         message: message,
         types: [Date.name],
         description: `defines the attribute as a date with the format ${format}`,
+        async: false,
     };
     const dateDec = (target, propertyKey) => {
         validationMetadata(date, key, meta)(target, propertyKey);
@@ -3981,6 +4343,7 @@ function password(pattern = DEFAULT_PATTERNS.PASSWORD.CHAR8_ONE_OF_EACH, message
         message: message,
         types: [String.name],
         description: `attribute as a password`,
+        async: false,
     };
     return Decoration.for(key)
         .define(validationMetadata(password, key, meta))
@@ -3990,7 +4353,7 @@ function password(pattern = DEFAULT_PATTERNS.PASSWORD.CHAR8_ONE_OF_EACH, message
  * @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}
  *
@@ -4004,6 +4367,7 @@ function list(clazz, collection = "Array", message = DEFAULT_ERROR_MESSAGES.LIST
         clazz: Array.isArray(clazz) ? clazz.map((c) => c.name) : [clazz.name],
         type: collection,
         message: message,
+        async: false,
         description: `defines the attribute as a ${collection} of ${clazz.name}`,
     };
     return Decoration.for(key)
@@ -4042,7 +4406,7 @@ function eq(propertyToCompare, message = DEFAULT_ERROR_MESSAGES.EQUALS) {
         [ValidationKeys.EQUALS]: propertyToCompare,
         description: `defines attribute as equal to ${propertyToCompare}`,
     };
-    return validationMetadata(eq, Validation.key(ValidationKeys.EQUALS), options);
+    return validationMetadata(eq, Validation.key(ValidationKeys.EQUALS), { ...options, async: false });
 }
 /**
  * @summary Declares that the decorated property must be different from another specified property.
@@ -4062,7 +4426,10 @@ function diff(propertyToCompare, message = DEFAULT_ERROR_MESSAGES.DIFF) {
         [ValidationKeys.DIFF]: propertyToCompare,
         description: `defines attribute as different to ${propertyToCompare}`,
     };
-    return validationMetadata(diff, Validation.key(ValidationKeys.DIFF), options);
+    return validationMetadata(diff, Validation.key(ValidationKeys.DIFF), {
+        ...options,
+        async: false,
+    });
 }
 /**
  * @summary Declares that the decorated property must be less than another specified property.
@@ -4082,7 +4449,7 @@ function lt(propertyToCompare, message = DEFAULT_ERROR_MESSAGES.LESS_THAN) {
         [ValidationKeys.LESS_THAN]: propertyToCompare,
         description: `defines attribute as less than to ${propertyToCompare}`,
     };
-    return validationMetadata(lt, Validation.key(ValidationKeys.LESS_THAN), options);
+    return validationMetadata(lt, Validation.key(ValidationKeys.LESS_THAN), { ...options, async: false });
 }
 /**
  * @summary Declares that the decorated property must be equal or less than another specified property.
@@ -4102,7 +4469,7 @@ function lte(propertyToCompare, message = DEFAULT_ERROR_MESSAGES.LESS_THAN_OR_EQ
         [ValidationKeys.LESS_THAN_OR_EQUAL]: propertyToCompare,
         description: `defines attribute as less or equal to ${propertyToCompare}`,
     };
-    return validationMetadata(lte, Validation.key(ValidationKeys.LESS_THAN_OR_EQUAL), options);
+    return validationMetadata(lte, Validation.key(ValidationKeys.LESS_THAN_OR_EQUAL), { ...options, async: false });
 }
 /**
  * @summary Declares that the decorated property must be greater than another specified property.
@@ -4122,7 +4489,7 @@ function gt(propertyToCompare, message = DEFAULT_ERROR_MESSAGES.GREATER_THAN) {
         [ValidationKeys.GREATER_THAN]: propertyToCompare,
         description: `defines attribute as greater than ${propertyToCompare}`,
     };
-    return validationMetadata(gt, Validation.key(ValidationKeys.GREATER_THAN), options);
+    return validationMetadata(gt, Validation.key(ValidationKeys.GREATER_THAN), { ...options, async: false });
 }
 /**
  * @summary Declares that the decorated property must be equal or greater than another specified property.
@@ -4142,7 +4509,7 @@ function gte(propertyToCompare, message = DEFAULT_ERROR_MESSAGES.GREATER_THAN_OR
         [ValidationKeys.GREATER_THAN_OR_EQUAL]: propertyToCompare,
         description: `defines attribute as greater or equal to ${propertyToCompare}`,
     };
-    return validationMetadata(gte, Validation.key(ValidationKeys.GREATER_THAN_OR_EQUAL), options);
+    return validationMetadata(gte, Validation.key(ValidationKeys.GREATER_THAN_OR_EQUAL), { ...options, async: false });
 }
 
 /**
@@ -4320,7 +4687,7 @@ function description(description) {
  * @const VERSION
  * @memberOf module:decorator-validation
  */
-const VERSION = "1.7.7";
+const VERSION = "1.7.9";
 
-export { COMPARISON_ERROR_MESSAGES, ComparisonValidationKeys, DAYS_OF_WEEK_NAMES, DEFAULT_ERROR_MESSAGES, DEFAULT_PATTERNS, DateValidator, Decoration, DefaultFlavour, DefaultHashingMethod, DefaultSerializationMethod, DiffValidator, EmailValidator, EqualsValidator, GreaterThanOrEqualValidator, GreaterThanValidator, Hashing, JSONSerializer, LessThanOrEqualValidator, LessThanValidator, ListValidator, MONTH_NAMES, MaxLengthValidator, MaxValidator, MinLengthValidator, MinValidator, Model, ModelErrorDefinition, ModelKeys, ModelRegistryManager, PasswordValidator, PathProxyEngine, PatternValidator, Primitives, RequiredValidator, ReservedModels, Serialization, StepValidator, TypeValidator, URLValidator, VALIDATION_PARENT_KEY, VERSION, Validation, ValidationKeys, Validator, ValidatorRegistry, bindDateToString, bindModelPrototype, bulkModelRegister, construct, date, dateFromFormat, description, diff, email, eq, findLastProtoBeforeObject, formatDate, getMetadata, getModelKey, gt, gte, hashCode, hashObj, hashedBy, isGreaterThan, isLessThan, isValidDate, isValidForGteOrLteComparison, jsTypes, list, lt, lte, max, maxlength, min, minlength, model, parseDate, password, pattern, prop, propMetadata, regexpParser, required, serializedBy, set, sf, step, stringFormat, twoDigitPad, type, url, validate, validationMetadata, validator };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"decorator-validation.esm.cjs","sources":["../src/constants/errors.ts","../src/constants/validation.ts","../src/utils/constants.ts","../src/validation/Validators/constants.ts","../src/utils/strings.ts","../src/utils/dates.ts","../src/utils/Decoration.ts","../src/utils/decorators.ts","../src/utils/hashing.ts","../src/utils/PathProxy.ts","../src/model/ModelErrorDefinition.ts","../src/model/constants.ts","../src/validation/Validators/Validator.ts","../src/validation/Validators/ValidatorRegistry.ts","../src/validation/Validation.ts","../src/model/validation.ts","../src/model/utils.ts","../src/model/Model.ts","../src/utils/serialization.ts","../src/validation/Validators/decorators.ts","../src/validation/Validators/DateValidator.ts","../src/validation/Validators/DiffValidator.ts","../src/validation/Validators/PatternValidator.ts","../src/validation/Validators/EmailValidator.ts","../src/validation/Validators/EqualsValidator.ts","../src/validation/Validators/utils.ts","../src/validation/Validators/GreaterThanValidator.ts","../src/validation/Validators/GreaterThanOrEqualValidator.ts","../src/validation/Validators/LessThanValidator.ts","../src/validation/Validators/LessThanOrEqualValidator.ts","../src/validation/Validators/ListValidator.ts","../src/validation/Validators/MaxLengthValidator.ts","../src/validation/Validators/MaxValidator.ts","../src/validation/Validators/MinLengthValidator.ts","../src/validation/Validators/MinValidator.ts","../src/validation/Validators/PasswordValidator.ts","../src/validation/Validators/RequiredValidator.ts","../src/validation/Validators/StepValidator.ts","../src/validation/Validators/TypeValidator.ts","../src/validation/Validators/URLValidator.ts","../src/validation/decorators.ts","../src/model/construction.ts","../src/model/decorators.ts","../src/index.ts"],"sourcesContent":["export const COMPARISON_ERROR_MESSAGES = {\n  INVALID_PATH:\n    \"Invalid path argument. Expected non-empty string but received: '{0}'\",\n  CONTEXT_NOT_OBJECT_COMPARISON:\n    \"Unable to access parent at level {0} for path '{1}': current context is not an object\",\n  PROPERTY_INVALID:\n    \"Failed to resolve path {0}: property '{1}' is invalid or does not exist.\",\n  PROPERTY_NOT_EXIST: \"Failed to resolve path: property '{0}' does not exist.\",\n  UNSUPPORTED_TYPES_COMPARISON:\n    \"Unsupported types for comparison: '{0}' and '{1}'\",\n  NULL_OR_UNDEFINED_COMPARISON:\n    \"Comparison failed due to null or undefined value\",\n  INVALID_DATE_COMPARISON: \"Invalid Date objects are not comparable\",\n  TYPE_MISMATCH_COMPARISON:\n    \"Cannot compare values of different types: {0} and {1}.\",\n  NAN_COMPARISON: \"Comparison not supported for NaN values\",\n  // NO_PARENT_COMPARISON: \"Unable to access parent at level {0} for path '{1}': no parent available\",\n  // PROPERTY_NOT_FOUND: \"Failed to resolve path {0}: property '{1}' does not exist.\",\n  // PROPERTY_NOT_FOUND_ON_PARENT: \"Failed to resolve path {0}: property '{1}' does not exist on parent.\",\n  // PROPERTY_NOT_FOUND_AFTER_PARENT: \"Failed to resolve path {0}: property '{1}' does not exist after {2} parent level(s).\",\n};\n","/**\n * @description Symbol key for tracking parent-child relationships in validation\n * @summary Symbol used to internally track the parent object during nested validation\n *\n * @const VALIDATION_PARENT_KEY\n * @memberOf module:decorator-validation\n */\nexport const VALIDATION_PARENT_KEY = Symbol(\"_parent\");\n","/**\n * @description Enum containing metadata keys used for reflection in the model system\n * @summary Defines the various Model keys used for reflection and metadata storage.\n * These keys are used throughout the library to store and retrieve metadata about models,\n * their properties, and their behavior.\n *\n * @property {string} REFLECT - Prefix to all other keys, used as a namespace\n * @property {string} TYPE - Key for storing design type information\n * @property {string} PARAMS - Key for storing method parameter types\n * @property {string} RETURN - Key for storing method return type\n * @property {string} MODEL - Key for identifying model metadata\n * @property {string} ANCHOR - Anchor key that serves as a ghost property in the model\n * @property {string} CONSTRUCTION - Key for storing construction information\n * @property {string} ATTRIBUTE - Key for storing attribute metadata\n * @property {string} HASHING - Key for storing hashing configuration\n * @property {string} SERIALIZATION - Key for storing serialization configuration\n *\n * @readonly\n * @enum {string}\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport enum ModelKeys {\n  REFLECT = \"decaf.model.\",\n  DESCRIPTION = \"decaf.description.\",\n  TYPE = \"design:type\",\n  PARAMS = \"design:paramtypes\",\n  RETURN = \"design:returntype\",\n  MODEL = \"model\",\n  ANCHOR = \"__model\",\n  CONSTRUCTION = \"constructed-by\",\n  ATTRIBUTE = \"__attributes\",\n  HASHING = \"hashing\",\n  SERIALIZATION = \"serialization\",\n}\n\n/**\n * @description Default flavour identifier for the decorator system\n * @summary Defines the default flavour used by the Decoration class when no specific flavour is provided.\n * This constant is used throughout the library as the fallback flavour for decorators.\n *\n * @const {string}\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport const DefaultFlavour = \"decaf\";\n","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","/**\n * @summary Util function to provide string format functionality similar to C#'s string.format\n *\n * @param {string} string\n * @param {Array<string | number>} [args] replacements made by order of appearance (replacement0 wil replace {0} and so on)\n * @return {string} formatted string\n *\n * @function stringFormat\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport function stringFormat(string: string, ...args: (string | number)[]) {\n  return string.replace(/{(\\d+)}/g, function (match, number) {\n    return typeof args[number] !== \"undefined\"\n      ? args[number].toString()\n      : \"undefined\";\n  });\n}\n\n/**\n * @summary Util function to provide string format functionality similar to C#'s string.format\n * @description alias for {@link stringFormat}\n *\n * @param {string} string\n * @param {string} args replacements made by order of appearance (replacement0 wil replace {0} and so on)\n * @return {string} formatted string\n *\n * @function sf\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport const sf = stringFormat;\n","import \"reflect-metadata\";\nimport {\n  DAYS_OF_WEEK_NAMES,\n  MONTH_NAMES,\n} from \"../validation/Validators/constants\";\nimport { sf } from \"./strings\";\n\n/**\n * @summary Reverses the process from {@link formatDate}\n *\n * @param {string} date the date string to be converted back into date\n * @param {string} format the date format\n * @return {Date} the date from the format or the standard new Date({@prop date}) if the string couldn't be parsed (are you sure the format matches the string?)\n *\n * @function dateFromFormat\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport function dateFromFormat(date: string, format: string) {\n  let formatRegexp: string = format;\n\n  // Hour\n  if (formatRegexp.match(/hh/))\n    formatRegexp = formatRegexp.replace(\"hh\", \"(?<hour>\\\\d{2})\");\n  else if (formatRegexp.match(/h/))\n    formatRegexp = formatRegexp.replace(\"h\", \"(?<hour>\\\\d{1,2})\");\n  else if (formatRegexp.match(/HH/))\n    formatRegexp = formatRegexp.replace(\"HH\", \"(?<hour>\\\\d{2})\");\n  else if (formatRegexp.match(/H/))\n    formatRegexp = formatRegexp.replace(\"H\", \"(?<hour>\\\\d{1,2})\");\n\n  // Minutes\n  if (formatRegexp.match(/mm/))\n    formatRegexp = formatRegexp.replace(\"mm\", \"(?<minutes>\\\\d{2})\");\n  else if (formatRegexp.match(/m/))\n    formatRegexp = formatRegexp.replace(\"m\", \"(?<minutes>\\\\d{1,2})\");\n\n  // Seconds\n  if (formatRegexp.match(/ss/))\n    formatRegexp = formatRegexp.replace(\"ss\", \"(?<seconds>\\\\d{2})\");\n  else if (formatRegexp.match(/s/))\n    formatRegexp = formatRegexp.replace(\"s\", \"(?<seconds>\\\\d{1,2})\");\n\n  // Day\n  if (formatRegexp.match(/dd/))\n    formatRegexp = formatRegexp.replace(\"dd\", \"(?<day>\\\\d{2})\");\n  else if (formatRegexp.match(/d/))\n    formatRegexp = formatRegexp.replace(\"d\", \"(?<day>\\\\d{1,2})\");\n\n  // Day Of Week\n  if (formatRegexp.match(/EEEE/))\n    formatRegexp = formatRegexp.replace(\"EEEE\", \"(?<dayofweek>\\\\w+)\");\n  // eslint-disable-next-line no-dupe-else-if\n  else if (formatRegexp.match(/EEEE/))\n    formatRegexp = formatRegexp.replace(\"EEE\", \"(?<dayofweek>\\\\w+)\");\n\n  // Year\n  if (formatRegexp.match(/yyyy/))\n    formatRegexp = formatRegexp.replace(\"yyyy\", \"(?<year>\\\\d{4})\");\n  else if (formatRegexp.match(/yy/))\n    formatRegexp = formatRegexp.replace(\"yy\", \"(?<year>\\\\d{2})\");\n\n  // Month\n  if (formatRegexp.match(/MMMM/))\n    formatRegexp = formatRegexp.replace(\"MMMM\", \"(?<monthname>\\\\w+)\");\n  else if (formatRegexp.match(/MMM/))\n    formatRegexp = formatRegexp.replace(\"MMM\", \"(?<monthnamesmall>\\\\w+)\");\n  if (formatRegexp.match(/MM/))\n    formatRegexp = formatRegexp.replace(\"MM\", \"(?<month>\\\\d{2})\");\n  else if (formatRegexp.match(/M/))\n    formatRegexp = formatRegexp.replace(\"M\", \"(?<month>\\\\d{1,2})\");\n\n  // Milis and Am Pm\n  formatRegexp = formatRegexp\n    .replace(\"S\", \"(?<milis>\\\\d{1,3})\")\n    .replace(\"aaa\", \"(?<ampm>\\\\w{2})\");\n\n  const regexp = new RegExp(formatRegexp, \"g\");\n\n  const match: {\n    groups: {\n      year?: string;\n      day?: string;\n      ampm?: string;\n      hour?: string;\n      minutes?: string;\n      seconds?: string;\n      milis?: string;\n      monthname?: string;\n      monthnamesmall?: string;\n      month?: string;\n    };\n  } = regexp.exec(date) as any;\n\n  if (!match || !match.groups) return new Date(date);\n\n  const safeParseInt = function (n?: string) {\n    if (!n) return 0;\n    const result = parseInt(n);\n\n    return isNaN(result) ? 0 : result;\n  };\n\n  const year = safeParseInt(match.groups.year);\n  const day = safeParseInt(match.groups.day);\n\n  const amPm = match.groups.ampm;\n  let hour = safeParseInt(match.groups.hour);\n\n  if (amPm) hour = amPm === \"PM\" ? hour + 12 : hour;\n\n  const minutes = safeParseInt(match.groups.minutes);\n  const seconds = safeParseInt(match.groups.seconds);\n  const ms = safeParseInt(match.groups.milis);\n\n  const monthName = match.groups.monthname;\n  const monthNameSmall = match.groups.monthnamesmall;\n  let month: number | string = match.groups.month as string;\n  if (monthName) month = MONTH_NAMES.indexOf(monthName);\n  else if (monthNameSmall) {\n    const m = MONTH_NAMES.find((m) =>\n      m.toLowerCase().startsWith(monthNameSmall.toLowerCase())\n    );\n    if (!m) return new Date(date);\n    month = MONTH_NAMES.indexOf(m);\n  } else month = safeParseInt(`${month}`);\n\n  return new Date(year, month - 1, day, hour, minutes, seconds, ms);\n}\n\n/**\n * @description Binds a specific date format to a Date object's toString and toISOString methods\n * @summary Modifies a Date object to return a formatted string when toString or toISOString is called.\n * This function overrides the default toString and toISOString methods of the Date object to return\n * the date formatted according to the specified format string.\n * @param {Date} [date] The Date object to modify\n * @param {string} [format] The format string to use for formatting the date\n * @return {Date|undefined} The modified Date object or undefined if no date was provided\n * @function bindDateToString\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport function bindDateToString(date: Date | undefined, format: string) {\n  if (!date) return;\n  const func = () => formatDate(date, format);\n  Object.defineProperty(date, \"toISOString\", {\n    enumerable: false,\n    configurable: false,\n    value: func,\n  });\n  Object.defineProperty(date, \"toString\", {\n    enumerable: false,\n    configurable: false,\n    value: func,\n  });\n  // Object.setPrototypeOf(date, Date.prototype);\n  return date;\n}\n\n/**\n * @description Safely checks if a value is a valid Date object\n * @summary A utility function that determines if a value is a valid Date object.\n * This function is more reliable than using instanceof Date as it also checks\n * that the date is not NaN, which can happen with invalid date strings.\n * @param {any} date The value to check\n * @return {boolean} True if the value is a valid Date object, false otherwise\n * @function isValidDate\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport function isValidDate(date: any): boolean {\n  return (\n    date &&\n    Object.prototype.toString.call(date) === \"[object Date]\" &&\n    !Number.isNaN(date)\n  );\n}\n\n/**\n * @summary Util function to pad numbers\n * @param {number} num\n *\n * @return {string}\n *\n * @function twoDigitPad\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport function twoDigitPad(num: number): string {\n  return num < 10 ? \"0\" + num : num.toString();\n}\n\n/**\n * @summary Date Format Handling\n * @description Code from {@link https://stackoverflow.com/questions/3552461/how-to-format-a-javascript-date}\n *\n * <pre>\n *      Using similar formatting as Moment.js, Class DateTimeFormatter (Java), and Class SimpleDateFormat (Java),\n *      I implemented a comprehensive solution formatDate(date, patternStr) where the code is easy to read and modify.\n *      You can display date, time, AM/PM, etc.\n *\n *      Date and Time Patterns\n *      yy = 2-digit year; yyyy = full year\n *      M = digit month; MM = 2-digit month; MMM = short month name; MMMM = full month name\n *      EEEE = full weekday name; EEE = short weekday name\n *      d = digit day; dd = 2-digit day\n *      h = hours am/pm; hh = 2-digit hours am/pm; H = hours; HH = 2-digit hours\n *      m = minutes; mm = 2-digit minutes; aaa = AM/PM\n *      s = seconds; ss = 2-digit seconds\n *      S = miliseconds\n * </pre>\n *\n * @param {Date} date\n * @param {string} [patternStr] defaults to 'yyyy/MM/dd'\n * @return {string} the formatted date\n *\n * @function formatDate\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport function formatDate(date: Date, patternStr: string = \"yyyy/MM/dd\") {\n  const day: number = date.getDate(),\n    month: number = date.getMonth(),\n    year: number = date.getFullYear(),\n    hour: number = date.getHours(),\n    minute: number = date.getMinutes(),\n    second: number = date.getSeconds(),\n    miliseconds: number = date.getMilliseconds(),\n    h: number = hour % 12,\n    hh: string = twoDigitPad(h),\n    HH: string = twoDigitPad(hour),\n    mm: string = twoDigitPad(minute),\n    ss: string = twoDigitPad(second),\n    aaa: string = hour < 12 ? \"AM\" : \"PM\",\n    EEEE: string = DAYS_OF_WEEK_NAMES[date.getDay()],\n    EEE: string = EEEE.substr(0, 3),\n    dd: string = twoDigitPad(day),\n    M: number = month + 1,\n    MM: string = twoDigitPad(M),\n    MMMM: string = MONTH_NAMES[month],\n    MMM: string = MMMM.substr(0, 3),\n    yyyy: string = year + \"\",\n    yy: string = yyyy.substr(2, 2);\n  // checks to see if month name will be used\n  patternStr = patternStr\n    .replace(\"hh\", hh)\n    .replace(\"h\", h.toString())\n    .replace(\"HH\", HH)\n    .replace(\"H\", hour.toString())\n    .replace(\"mm\", mm)\n    .replace(\"m\", minute.toString())\n    .replace(\"ss\", ss)\n    .replace(\"s\", second.toString())\n    .replace(\"S\", miliseconds.toString())\n    .replace(\"dd\", dd)\n    .replace(\"d\", day.toString())\n\n    .replace(\"EEEE\", EEEE)\n    .replace(\"EEE\", EEE)\n    .replace(\"yyyy\", yyyy)\n    .replace(\"yy\", yy)\n    .replace(\"aaa\", aaa);\n  if (patternStr.indexOf(\"MMM\") > -1) {\n    patternStr = patternStr.replace(\"MMMM\", MMMM).replace(\"MMM\", MMM);\n  } else {\n    patternStr = patternStr.replace(\"MM\", MM).replace(\"M\", M.toString());\n  }\n  return patternStr;\n}\n\n/**\n * @summary Parses a date from a specified format\n * @param {string} format\n * @param {string | Date | number} [v]\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport function parseDate(format: string, v?: string | Date | number) {\n  let value: Date | undefined = undefined;\n\n  if (!v) return undefined;\n\n  if (v instanceof Date)\n    try {\n      value = dateFromFormat(formatDate(v as Date, format), format);\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (e: any) {\n      throw new Error(\n        sf(\"Could not convert date {0} to format: {1}\", v.toString(), format)\n      );\n    }\n  else if (typeof v === \"string\") {\n    value = dateFromFormat(v, format);\n  } else if (typeof v === \"number\") {\n    const d = new Date(v);\n    value = dateFromFormat(formatDate(d, format), format);\n  } else if (isValidDate(v)) {\n    try {\n      const d = new Date(v);\n      value = dateFromFormat(formatDate(d, format), format);\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (e) {\n      throw new Error(\n        sf(\"Could not convert date {0} to format: {1}\", v, format)\n      );\n    }\n  } else {\n    throw new Error(`Invalid value provided ${v}`);\n  }\n  return bindDateToString(value, format);\n}\n","import {\n  DecorationBuilderBuild,\n  DecorationBuilderEnd,\n  DecorationBuilderMid,\n  DecorationBuilderStart,\n  FlavourResolver,\n  IDecorationBuilder,\n} from \"./types\";\nimport { DefaultFlavour } from \"./constants\";\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction defaultFlavourResolver(target: object) {\n  return DefaultFlavour;\n}\n\n/**\n * @description A decorator management class that handles flavoured decorators\n * @summary The Decoration class provides a builder pattern for creating and managing decorators with different flavours.\n * It supports registering, extending, and applying decorators with context-aware flavour resolution.\n * The class implements a fluent interface for defining, extending, and applying decorators with different flavours,\n * allowing for framework-specific decorator implementations while maintaining a consistent API.\n * @template T Type of the decorator (ClassDecorator | PropertyDecorator | MethodDecorator)\n * @param {string} [flavour] Optional flavour parameter for the decorator context\n * @class\n * @category Model\n * @example\n * ```typescript\n * // Create a new decoration for 'component' with default flavour\n * const componentDecorator = new Decoration()\n *   .for('component')\n *   .define(customComponentDecorator);\n *\n * // Create a flavoured decoration\n * const vueComponent = new Decoration('vue')\n *   .for('component')\n *   .define(vueComponentDecorator);\n *\n * // Apply the decoration\n * @componentDecorator\n * class MyComponent {}\n * ```\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant D as Decoration\n *   participant R as FlavourResolver\n *   participant F as DecoratorFactory\n *\n *   C->>D: new Decoration(flavour)\n *   C->>D: for(key)\n *   C->>D: define(decorators)\n *   D->>D: register(key, flavour, decorators)\n *   D->>F: decoratorFactory(key, flavour)\n *   F->>R: resolve(target)\n *   R-->>F: resolved flavour\n *   F->>F: apply decorators\n *   F-->>C: decorated target\n */\nexport class Decoration implements IDecorationBuilder {\n  /**\n   * @description Static map of registered decorators\n   * @summary Stores all registered decorators organized by key and flavour\n   */\n  private static decorators: Record<\n    string,\n    Record<\n      string,\n      {\n        decorators?: Set<ClassDecorator | PropertyDecorator | MethodDecorator>;\n        extras?: Set<ClassDecorator | PropertyDecorator | MethodDecorator>;\n      }\n    >\n  > = {};\n\n  /**\n   * @description Function to resolve flavour from a target\n   * @summary Resolver function that determines the appropriate flavour for a given target\n   */\n  private static flavourResolver: FlavourResolver = defaultFlavourResolver;\n\n  /**\n   * @description Set of decorators for the current context\n   */\n  private decorators?: Set<\n    ClassDecorator | PropertyDecorator | MethodDecorator\n  >;\n\n  /**\n   * @description Set of additional decorators\n   */\n  private extras?: Set<ClassDecorator | PropertyDecorator | MethodDecorator>;\n\n  /**\n   * @description Current decorator key\n   */\n  private key?: string;\n\n  constructor(private flavour: string = DefaultFlavour) {}\n\n  /**\n   * @description Sets the key for the decoration builder\n   * @summary Initializes a new decoration chain with the specified key\n   * @param {string} key The identifier for the decorator\n   * @return {DecorationBuilderMid} Builder instance for method chaining\n   */\n  for(key: string): DecorationBuilderMid {\n    this.key = key;\n    return this;\n  }\n\n  /**\n   * @description Adds decorators to the current context\n   * @summary Internal method to add decorators with addon support\n   * @param {boolean} [addon=false] Whether the decorators are addons\n   * @param decorators Array of decorators\n   * @return {this} Current instance for chaining\n   */\n  private decorate(\n    addon: boolean = false,\n    ...decorators: (ClassDecorator | PropertyDecorator | MethodDecorator)[]\n  ): this {\n    if (!this.key)\n      throw new Error(\"key must be provided before decorators can be added\");\n    if (\n      (!decorators || !decorators.length) &&\n      !addon &&\n      this.flavour !== DefaultFlavour\n    )\n      throw new Error(\n        \"Must provide overrides or addons to override or extend decaf's decorators\"\n      );\n    if (this.flavour === DefaultFlavour && addon)\n      throw new Error(\"Default flavour cannot be extended\");\n\n    this[addon ? \"extras\" : \"decorators\"] = new Set([\n      ...(this[addon ? \"extras\" : \"decorators\"] || new Set()).values(),\n      ...decorators,\n    ]);\n\n    return this;\n  }\n\n  /**\n   * @description Defines the base decorators\n   * @summary Sets the primary decorators for the current context\n   * @param decorators Decorators to define\n   * @return Builder instance for finishing the chain\n   */\n  define(\n    ...decorators: (ClassDecorator | PropertyDecorator | MethodDecorator)[]\n  ): DecorationBuilderEnd & DecorationBuilderBuild {\n    return this.decorate(false, ...decorators);\n  }\n\n  /**\n   * @description Extends existing decorators\n   * @summary Adds additional decorators to the current context\n   * @param decorators Additional decorators\n   * @return {DecorationBuilderBuild} Builder instance for building the decorator\n   */\n  extend(\n    ...decorators: (ClassDecorator | PropertyDecorator | MethodDecorator)[]\n  ): DecorationBuilderBuild {\n    return this.decorate(true, ...decorators);\n  }\n\n  protected decoratorFactory(key: string, f: string = DefaultFlavour) {\n    const contextDecorator = function contextDecorator(\n      target: object,\n      propertyKey?: any,\n      descriptor?: TypedPropertyDescriptor<any>\n    ) {\n      const flavour = Decoration.flavourResolver(target);\n      let decorators;\n      const extras = Decoration.decorators[key][flavour]\n        ? Decoration.decorators[key][flavour].extras\n        : Decoration.decorators[key][DefaultFlavour].extras;\n      if (\n        Decoration.decorators[key] &&\n        Decoration.decorators[key][flavour] &&\n        Decoration.decorators[key][flavour].decorators\n      ) {\n        decorators = Decoration.decorators[key][flavour].decorators;\n      } else {\n        decorators = Decoration.decorators[key][DefaultFlavour].decorators;\n      }\n      const toApply = [\n        ...(decorators ? decorators.values() : []),\n        ...(extras ? extras.values() : []),\n      ];\n      toApply.forEach((d) =>\n        (d as any)(target, propertyKey, descriptor, descriptor)\n      );\n    };\n    Object.defineProperty(contextDecorator, \"name\", {\n      value: [f, key].join(\"_decorator_for_\"),\n      writable: false,\n    });\n    return contextDecorator;\n  }\n\n  /**\n   * @description Creates the final decorator function\n   * @summary Builds and returns the decorator factory function\n   * @return {function(any, any?, TypedPropertyDescriptor?): any} The generated decorator function\n   */\n  apply(): (\n    target: any,\n    propertyKey?: any,\n    descriptor?: TypedPropertyDescriptor<any>\n  ) => any {\n    if (!this.key)\n      throw new Error(\"No key provided for the decoration builder\");\n    Decoration.register(this.key, this.flavour, this.decorators, this.extras);\n    return this.decoratorFactory(this.key, this.flavour);\n  }\n\n  /**\n   * @description Registers decorators for a specific key and flavour\n   * @summary Internal method to store decorators in the static registry\n   * @param {string} key Decorator key\n   * @param {string} flavour Decorator flavour\n   * @param [decorators] Primary decorators\n   * @param [extras] Additional decorators\n   */\n  private static register(\n    key: string,\n    flavour: string,\n    decorators?: Set<ClassDecorator | PropertyDecorator | MethodDecorator>,\n    extras?: Set<ClassDecorator | PropertyDecorator | MethodDecorator>\n  ) {\n    if (!key) throw new Error(\"No key provided for the decoration builder\");\n    if (!decorators)\n      throw new Error(\"No decorators provided for the decoration builder\");\n    if (!flavour)\n      throw new Error(\"No flavour provided for the decoration builder\");\n\n    if (!Decoration.decorators[key]) Decoration.decorators[key] = {};\n    if (!Decoration.decorators[key][flavour])\n      Decoration.decorators[key][flavour] = {};\n    if (decorators) Decoration.decorators[key][flavour].decorators = decorators;\n    if (extras) Decoration.decorators[key][flavour].extras = extras;\n  }\n\n  /**\n   * @description Sets the global flavour resolver\n   * @summary Configures the function used to determine decorator flavours\n   * @param {FlavourResolver} resolver Function to resolve flavours\n   */\n  static setFlavourResolver(resolver: FlavourResolver) {\n    Decoration.flavourResolver = resolver;\n  }\n\n  static for(key: string): DecorationBuilderMid {\n    return new Decoration().for(key);\n  }\n\n  static flavouredAs(flavour: string): DecorationBuilderStart {\n    return new Decoration(flavour);\n  }\n}\n","import { apply, metadata } from \"@decaf-ts/reflection\";\nimport { ModelKeys } from \"./constants\";\n\n/**\n * @description Property decorator factory for model attributes\n * @summary Creates a decorator that marks class properties as model attributes\n *\n * @param {string} [key=ModelKeys.ATTRIBUTE] - The metadata key under which to store the property name\n * @return {function(object, any?): void} - Decorator function that registers the property\n * @function prop\n * @category Property Decorators\n *\n * @mermaid\n * sequenceDiagram\n *    participant D as Decorator\n *    participant M as Model\n *\n *    D->>M: Check if key exists\n *    alt key exists\n *        M-->>D: Return existing props array\n *    else key doesn't exist\n *        D->>M: Create new props array\n *    end\n *    D->>M: Check if property exists\n *    alt property not in array\n *        D->>M: Add property to array\n *    end\n */\nexport function prop(key: string = ModelKeys.ATTRIBUTE) {\n  return (model: object, propertyKey?: any): void => {\n    let props: string[];\n    if (Object.prototype.hasOwnProperty.call(model, key)) {\n      props = (model as any)[key];\n    } else {\n      props = (model as any)[key] = [];\n    }\n    if (!props.includes(propertyKey as string))\n      props.push(propertyKey as string);\n  };\n}\n\n/**\n * @description Combined property decorator factory for metadata and attribute marking\n * @summary Creates a decorator that both marks a property as a model attribute and assigns metadata to it\n *\n * @template V\n * @param {string} key - The metadata key\n * @param {V} value - The metadata value to associate with the property\n * @return {Function} - Combined decorator function\n * @function propMetadata\n * @category Property Decorators\n */\nexport function propMetadata<V>(key: string, value: V) {\n  return apply(prop(), metadata<V>(key, value));\n}\n","/**\n * @summary Mimics Java's String's Hash implementation\n *\n * @param {string | number | symbol | Date} obj\n * @return {number} hash value of obj\n *\n * @function hashCode\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport function hashCode(obj: string | number | symbol | Date): string {\n  obj = String(obj);\n  let hash = 0;\n  for (let i = 0; i < obj.length; i++) {\n    const character = obj.charCodeAt(i);\n    hash = (hash << 5) - hash + character;\n    hash = hash & hash; // Convert to 32bit integer\n  }\n  return hash.toString();\n}\n\n/**\n * @summary Defines teh type for a Hashing function\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport type HashingFunction = (value: any, ...args: any[]) => string;\n\n/**\n * @summary Hashes an object by combining the hash of all its properties\n *\n * @param {Record<string, any>} obj\n * @return {string} the resulting hash\n *\n * @function hashObj\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport function hashObj(obj: Record<string, any> | any[]): string {\n  const hashReducer = function (h: number | string, el: any): string | number {\n    const elHash = hashFunction(el);\n\n    if (typeof elHash === \"string\")\n      return hashFunction(((h as string) || \"\") + hashFunction(el));\n\n    h = h || 0;\n    h = ((h as number) << 5) - (h as number) + elHash;\n    return h & h;\n  };\n\n  const func: HashingFunction = hashCode;\n\n  const hashFunction = function (value: any): string | number {\n    if (typeof value === \"undefined\") return \"\";\n    if ([\"string\", \"number\", \"symbol\"].indexOf(typeof value) !== -1)\n      return func(value.toString());\n    if (value instanceof Date) return func(value.getTime());\n    if (Array.isArray(value)) return value.reduce(hashReducer, undefined);\n    return (Object.values(value) as (string | number)[]).reduce(\n      hashReducer,\n      undefined as unknown as string | number\n    );\n  };\n\n  const result = Object.values(obj).reduce(hashReducer, 0);\n\n  return (typeof result === \"number\" ? Math.abs(result) : result).toString();\n}\n\nexport const DefaultHashingMethod = \"default\";\n\n/**\n * @description Manages hashing methods and provides a unified hashing interface\n * @summary A utility class that provides a registry for different hashing functions and methods to hash objects.\n * The class maintains a cache of registered hashing functions and allows setting a default hashing method.\n * It prevents direct instantiation and provides static methods for registration and hashing.\n *\n * @class Hashing\n * @category Model\n *\n * @example\n * ```typescript\n * // Register a custom hashing function\n * Hashing.register('md5', (obj) => createMD5Hash(obj), true);\n *\n * // Hash an object using default method\n * const hash1 = Hashing.hash(myObject);\n *\n * // Hash using specific method\n * const hash2 = Hashing.hash(myObject, 'md5');\n * ```\n */\nexport class Hashing {\n  /**\n   * @description Current default hashing method identifier\n   * @private\n   */\n  private static current: string = DefaultHashingMethod;\n\n  /**\n   * @description Cache of registered hashing functions\n   * @private\n   */\n  private static cache: Record<string, HashingFunction> = {\n    default: hashObj,\n  };\n\n  private constructor() {}\n\n  /**\n   * @description Retrieves a registered hashing function\n   * @summary Fetches a hashing function from the cache by its key. Throws an error if the method is not registered.\n   *\n   * @param {string} key - The identifier of the hashing function to retrieve\n   * @return {HashingFunction} The requested hashing function\n   * @private\n   */\n  private static get(key: string): any {\n    if (key in this.cache) return this.cache[key];\n    throw new Error(`No hashing method registered under ${key}`);\n  }\n\n  /**\n   * @description Registers a new hashing function\n   * @summary Adds a new hashing function to the registry. Optionally sets it as the default method.\n   * Throws an error if a method with the same key is already registered.\n   *\n   * @param {string} key - The identifier for the hashing function\n   */\n  static register(\n    key: string,\n    func: HashingFunction,\n    setDefault = false\n  ): void {\n    if (key in this.cache)\n      throw new Error(`Hashing method ${key} already registered`);\n    this.cache[key] = func;\n    if (setDefault) this.current = key;\n  }\n\n  static hash(obj: any, method?: string, ...args: any[]) {\n    if (!method) return this.get(this.current)(obj, ...args);\n    return this.get(method)(obj, ...args);\n  }\n\n  static setDefault(method: string) {\n    this.current = this.get(method);\n  }\n}\n","import { COMPARISON_ERROR_MESSAGES, VALIDATION_PARENT_KEY } from \"../constants\";\nimport { sf } from \"./strings\";\n\nconst fallbackGetParent = (target: any) => {\n  return target[VALIDATION_PARENT_KEY];\n};\n\nconst fallbackGetValue = (target: any, prop: string) => {\n  if (!Object.prototype.hasOwnProperty.call(target, prop))\n    throw new Error(sf(COMPARISON_ERROR_MESSAGES.PROPERTY_NOT_EXIST, prop));\n  return target[prop];\n};\n\n/**\n * Proxy object that provides path-based access to nested properties\n * @template T - The type of the target object being proxied\n */\nexport type PathProxy<T> = T & {\n  // [PROXY_PROP]: boolean;\n  getValueFromPath: (path: string, fallback?: any) => any;\n};\n\n/**\n * Standard path resolution utility for accessing nested object properties.\n * Provides consistent dot-notation access to both parent and child properties\n * across complex object structures.\n *\n * - Dot-notation path resolution ('object.child.property')\n * - Parent traversal using '../' notation\n * - Configurable property access behavior\n * - Null/undefined safety checks\n */\nexport class PathProxyEngine {\n  /**\n   * Creates a path-aware proxy for the target object\n   * @template T - The type of the target object\n   * @param {T} rootTarget - The target object to proxy\n   * @param opts - Configuration options\n   * @param opts.getValue - Custom function to get property value\n   * @param opts.getParent - Custom function to get parent object\n   * @param opts.ignoreUndefined - Whether to ignore undefined values in paths\n   * @param opts.ignoreNull - Whether to ignore null values in paths\n   * @returns A proxy object with path access capabilities\n   */\n  static create<T extends object>(\n    rootTarget: T,\n    opts?: {\n      getValue?: (target: T, prop: string) => any;\n      getParent?: (target: T) => any;\n      ignoreUndefined: boolean;\n      ignoreNull: boolean;\n    }\n  ): PathProxy<T> {\n    const { getValue, getParent, ignoreUndefined, ignoreNull } = {\n      getParent: fallbackGetParent,\n      getValue: fallbackGetValue,\n      ignoreNull: false,\n      ignoreUndefined: false,\n      ...opts,\n    };\n\n    const proxy = new Proxy({} as any, {\n      get(target, prop) {\n        if (prop === \"getValueFromPath\") {\n          return function (path: string): any {\n            const parts = PathProxyEngine.parsePath(path);\n            let current: any = rootTarget;\n\n            for (let i = 0; i < parts.length; i++) {\n              const part = parts[i];\n              if (part === \"..\") {\n                const parent = getParent(current);\n                if (!parent || typeof parent !== \"object\") {\n                  throw new Error(\n                    sf(\n                      COMPARISON_ERROR_MESSAGES.CONTEXT_NOT_OBJECT_COMPARISON,\n                      i + 1,\n                      path\n                    )\n                  );\n                }\n                current = parent; //PathProxyEngine.create(parentTarget, opts);\n                continue;\n              }\n\n              current = getValue(current, part);\n              if (!ignoreUndefined && typeof current === \"undefined\")\n                throw new Error(\n                  sf(COMPARISON_ERROR_MESSAGES.PROPERTY_INVALID, path, part)\n                );\n\n              if (!ignoreNull && current === null)\n                throw new Error(\n                  sf(COMPARISON_ERROR_MESSAGES.PROPERTY_INVALID, path, part)\n                );\n            }\n\n            return current;\n          };\n        }\n\n        return target[prop];\n      },\n    });\n\n    // Object.defineProperty(proxy, PROXY_PROP, {\n    //   value: true, // overwrite by proxy behavior\n    //   enumerable: false,\n    //   configurable: false,\n    //   writable: false,\n    // });\n\n    return proxy as PathProxy<T>;\n  }\n\n  /**\n   * Parses a path string into individual components\n   * @param path - The path string to parse (e.g., \"user.address.city\")\n   * @returns An array of path components\n   * @throws Error if the path is invalid\n   */\n  private static parsePath(path: string): string[] {\n    if (typeof path !== \"string\" || !path.trim())\n      throw new Error(sf(COMPARISON_ERROR_MESSAGES.INVALID_PATH, path));\n    return path.match(/(\\.\\.|[^/.]+)/g) || [];\n  }\n}\n","import { ModelErrors } from \"../validation/types\";\n\n/**\n * @summary Helper Class to hold the error results\n * @description holds error results in an 'indexable' manner\n * while still providing the same result on toString\n *\n * @param {ModelErrors} errors\n *\n * @class ModelErrorDefinition\n *\n * @category Model\n */\nexport class ModelErrorDefinition {\n  [indexer: string]:\n    | Record<string, string | undefined>\n    | (() => string | undefined);\n\n  constructor(errors: ModelErrors) {\n    for (const prop in errors) {\n      if (Object.prototype.hasOwnProperty.call(errors, prop) && errors[prop])\n        Object.defineProperty(this as any, prop, {\n          enumerable: true,\n          configurable: false,\n          value: errors[prop],\n          writable: false,\n        });\n    }\n  }\n\n  /**\n   * @summary Outputs the class to a nice readable string\n   *\n   * @override\n   */\n  toString(): string {\n    const self: any = this as any;\n    return Object.keys(self)\n      .filter(\n        (k) =>\n          Object.prototype.hasOwnProperty.call(self, k) &&\n          typeof self[k] !== \"function\"\n      )\n      .reduce((accum: string, prop) => {\n        let propError: string | undefined = Object.keys(self[prop]).reduce(\n          (propAccum: undefined | string, key) => {\n            if (!propAccum) propAccum = self[prop][key];\n            else propAccum += `\\n${self[prop][key]}`;\n            return propAccum;\n          },\n          undefined\n        );\n\n        if (propError) {\n          propError = `${prop} - ${propError}`;\n          if (!accum) accum = propError;\n          else accum += `\\n${propError}`;\n        }\n\n        return accum;\n      }, \"\");\n  }\n}\n","/**\n * @summary References the relevant JS primitives\n *\n * @property {string} STRING references the string primitive\n * @property {string} NUMBER references the number primitive\n * @property {string} BOOLEAN references the boolean primitive\n * @property {string} BIGINT references the bigint primitive\n *\n * @constant Primitives\n * @memberOf module:decorator-validation\n */\nexport enum Primitives {\n  STRING = \"string\",\n  NUMBER = \"number\",\n  BOOLEAN = \"boolean\",\n  BIGINT = \"bigint\",\n}\n\n/**\n * @summary References the Reserved model names to ignore during Model rebuilding\n *\n * @property {string} STRING\n * @property {string} OBJECT\n * @property {string} NUMBER\n * @property {string} BOOLEAN\n * @property {string} BIGINT\n * @property {string} DATE\n *\n * @constant ReservedModels\n * @memberOf module:decorator-validation\n */\nexport enum ReservedModels {\n  STRING = \"string\",\n  OBJECT = \"object\",\n  NUMBER = \"number\",\n  BOOLEAN = \"boolean\",\n  BIGINT = \"bigint\",\n  DATE = \"date\",\n}\n\n/**\n * @summary References the basic supported js types\n *\n * @property {string} string\n * @property {string} array\n * @property {string} number\n * @property {string} boolean\n * @property {string} symbol\n * @property {string} function\n * @property {string} object\n * @property {string} undefined\n * @property {string} null\n * @property {string} BIGINT\n *\n * @constant jsTypes\n * @memberOf module:decorator-validation\n */\nexport const jsTypes = [\n  \"string\",\n  \"array\",\n  \"number\",\n  \"boolean\",\n  \"symbol\",\n  \"function\",\n  \"object\",\n  \"undefined\",\n  \"null\",\n  \"bigint\",\n];\n","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","import { ValidatorDefinition } from \"../types\";\nimport { IValidatorRegistry } from \"../types\";\nimport { Validator } from \"./Validator\";\n\n/**\n * @summary Base Implementation of a Validator Registry\n *\n * @prop {Validator[]} [validators] the initial validators to register\n *\n * @class ValidatorRegistry\n * @implements IValidatorRegistry<T>\n *\n * @category Validation\n */\nexport class ValidatorRegistry<T extends Validator>\n  implements IValidatorRegistry<T>\n{\n  private cache: any = {};\n  private customKeyCache: Record<string, string>;\n\n  constructor(...validators: (ValidatorDefinition | Validator)[]) {\n    this.customKeyCache = {};\n    this.register(...validators);\n  }\n\n  /**\n   * @summary retrieves the custom keys\n   */\n  getCustomKeys(): { [indexer: string]: string } {\n    return Object.assign({}, this.customKeyCache);\n  }\n\n  /**\n   * @summary retrieves the registered validators keys\n   */\n  getKeys(): string[] {\n    return Object.keys(this.cache);\n  }\n\n  /**\n   * @summary Retrieves a validator\n   *\n   * @param {string} validatorKey one of the {@link ValidationKeys}\n   * @return {Validator | undefined} the registered Validator or undefined if there is nono matching the provided key\n   */\n  get<T extends Validator>(validatorKey: string): T | undefined {\n    if (!(validatorKey in this.cache)) return undefined;\n\n    const classOrInstance = this.cache[validatorKey];\n    if (Validator.isValidator(classOrInstance)) return classOrInstance as T;\n    const constructor = classOrInstance.default || classOrInstance;\n    const instance = new constructor();\n    this.cache[validatorKey] = instance;\n    return instance;\n  }\n\n  /**\n   * @summary Registers the provided validators onto the registry\n   *\n   * @param {T[] | ValidatorDefinition[]} validator\n   */\n  register<T extends Validator>(\n    ...validator: (ValidatorDefinition | T)[]\n  ): void {\n    validator.forEach((v) => {\n      if (Validator.isValidator(v)) {\n        // const k =\n\n        if ((v as ValidatorDefinition).validationKey in this.cache) return;\n        this.cache[(v as ValidatorDefinition).validationKey] = v;\n      } else {\n        const { validationKey, validator, save } = v as ValidatorDefinition;\n        if (validationKey in this.cache) return;\n        this.cache[validationKey] = validator;\n        if (!save) return;\n        const obj: Record<string, string> = {};\n        obj[validationKey.toUpperCase()] = validationKey;\n\n        this.customKeyCache = Object.assign({}, this.customKeyCache, obj);\n      }\n    });\n  }\n}\n","import { Validator } from \"./Validators/Validator\";\nimport { IValidatorRegistry, ValidatorDefinition } from \"./types\";\nimport { ValidatorRegistry } from \"./Validators/ValidatorRegistry\";\nimport { ValidationKeys } from \"./Validators/constants\";\n\n/**\n * @summary Static class acting as a namespace for the Validation\n *\n * @class Validation\n * @static\n *\n * @category Validation\n */\nexport class Validation {\n  private static actingValidatorRegistry?: IValidatorRegistry<Validator> =\n    undefined;\n\n  private static loadedDecorators: Record<string, PropertyDecorator> = {};\n  private constructor() {}\n\n  /**\n   * @summary Defines the acting ValidatorRegistry\n   *\n   * @param {IValidatorRegistry} validatorRegistry the new implementation of the validator Registry\n   * @param {function(Validator): Validator} [migrationHandler] the method to map the validator if required;\n   */\n  static setRegistry(\n    validatorRegistry: IValidatorRegistry<Validator>,\n    migrationHandler?: (validator: Validator) => Validator\n  ) {\n    if (migrationHandler && Validation.actingValidatorRegistry)\n      Validation.actingValidatorRegistry.getKeys().forEach((k: string) => {\n        const validator = validatorRegistry.get(k);\n        if (validator) validatorRegistry.register(migrationHandler(validator));\n      });\n    Validation.actingValidatorRegistry = validatorRegistry;\n  }\n\n  /**\n   * @summary Returns the current ValidatorRegistry\n   *\n   * @return IValidatorRegistry, defaults to {@link ValidatorRegistry}\n   */\n  private static getRegistry() {\n    if (!Validation.actingValidatorRegistry)\n      Validation.actingValidatorRegistry = new ValidatorRegistry();\n    return Validation.actingValidatorRegistry;\n  }\n\n  /**\n   * @summary Retrieves a validator\n   *\n   * @param {string} validatorKey one of the {@link ValidationKeys}\n   * @return {Validator | undefined} the registered Validator or undefined if there is nono matching the provided key\n   */\n  static get<T extends Validator>(validatorKey: string): T | undefined {\n    return Validation.getRegistry().get(validatorKey);\n  }\n\n  /**\n   * @summary Registers the provided validators onto the registry\n   *\n   * @param {T[] | ValidatorDefinition[]} validator\n   */\n  static register<T extends Validator>(\n    ...validator: (ValidatorDefinition | T)[]\n  ): void {\n    return Validation.getRegistry().register(...validator);\n  }\n\n  /**\n   * @summary Builds the key to store as Metadata under Reflections\n   * @description concatenates {@link ValidationKeys#REFLECT} with the provided key\n   *\n   * @param {string} key\n   */\n  static key(key: string) {\n    return ValidationKeys.REFLECT + key;\n  }\n\n  /**\n   * @summary Returns all registered validation keys\n   */\n  static keys() {\n    return this.getRegistry().getKeys();\n  }\n\n  static registerDecorator(key: string, decorator: PropertyDecorator) {\n    if (key in this.loadedDecorators) return;\n    this.loadedDecorators[key] = decorator;\n  }\n\n  static decoratorFromKey(key: string) {\n    if (!(key in this.loadedDecorators))\n      throw new Error(`No decorator registered under ${key}`);\n    return this.loadedDecorators[key];\n  }\n}\n","import { ModelErrorDefinition } from \"./ModelErrorDefinition\";\nimport {\n  DecoratorMetadata,\n  Reflection,\n  FullPropertyDecoratorList,\n} from \"@decaf-ts/reflection\";\nimport { ModelKeys } from \"../utils/constants\";\nimport { ReservedModels } from \"./constants\";\nimport { VALIDATION_PARENT_KEY } from \"../constants\";\nimport { Validatable } from \"./types\";\nimport { Model } from \"./Model\";\nimport { Validation } from \"../validation/Validation\";\nimport { ValidationKeys } from \"../validation/Validators/constants\";\nimport {\n  ModelErrors,\n  ValidationPropertyDecoratorDefinition,\n  ValidatorOptions,\n} from \"../validation/types\";\nimport { PathProxyEngine } from \"../utils/PathProxy\";\n\n/**\n * @summary Analyses the decorations of the properties and validates the obj according to them\n *\n * @typedef M extends Model\n * @prop {M} obj Model object to validate\n * @prop {string[]} [propsToIgnore] object properties to ignore in the validation\n *\n * @function validate\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport function validate<M extends Model>(\n  obj: M,\n  ...propsToIgnore: string[]\n): ModelErrorDefinition | undefined {\n  const decoratedProperties: ValidationPropertyDecoratorDefinition[] = [];\n  for (const prop in obj)\n    if (\n      Object.prototype.hasOwnProperty.call(obj, prop) &&\n      propsToIgnore.indexOf(prop) === -1\n    ) {\n      decoratedProperties.push(\n        // @ts-ignore\n        Reflection.getPropertyDecorators(\n          ValidationKeys.REFLECT,\n          obj,\n          prop\n        ) as FullPropertyDecoratorList\n      );\n    }\n\n  let result: ModelErrors | undefined = undefined;\n\n  for (const decoratedProperty of decoratedProperties) {\n    const { prop, decorators } = decoratedProperty;\n\n    if (!decorators || !decorators.length) continue;\n\n    const defaultTypeDecorator: DecoratorMetadata = decorators[0];\n\n    // tries to find any type decorators or other decorators that already enforce type (the ones with the allowed types property defined). if so, skip the default type verification\n    if (\n      decorators.find((d) => {\n        if (d.key === ValidationKeys.TYPE) return true;\n        return !!d.props.types?.find(\n          (t) => t === defaultTypeDecorator.props.name\n        );\n      })\n    ) {\n      decorators.shift(); // remove the design:type decorator, since the type will already be checked\n    }\n\n    let errs: Record<string, string | undefined> | undefined = undefined;\n\n    for (const decorator of decorators) {\n      const validator = Validation.get(decorator.key);\n      if (!validator) {\n        throw new Error(`Missing validator for ${decorator.key}`);\n      }\n\n      const decoratorProps =\n        decorator.key === ModelKeys.TYPE\n          ? [decorator.props]\n          : decorator.props || {};\n\n      const err: string | undefined = validator.hasErrors(\n        (obj as any)[prop.toString()],\n        decoratorProps as ValidatorOptions,\n        PathProxyEngine.create(obj, { ignoreUndefined: true, ignoreNull: true })\n      );\n\n      if (err) {\n        errs = errs || {};\n        errs[decorator.key] = err;\n      }\n    }\n\n    if (errs) {\n      result = result || {};\n      result[decoratedProperty.prop.toString()] = errs;\n    }\n  }\n\n  // tests nested classes\n  for (const prop of Object.keys(obj).filter((k) => !result || !result[k])) {\n    let err: string | undefined;\n    // if a nested Model\n    const allDecorators = Reflection.getPropertyDecorators(\n      ValidationKeys.REFLECT,\n      obj,\n      prop\n    ).decorators;\n    const decorators = Reflection.getPropertyDecorators(\n      ValidationKeys.REFLECT,\n      obj,\n      prop\n    ).decorators.filter(\n      (d: { key: string }) =>\n        [ModelKeys.TYPE, ValidationKeys.TYPE as string].indexOf(d.key) !== -1\n    );\n    if (!decorators || !decorators.length) continue;\n    const dec = decorators.pop() as DecoratorMetadata;\n    const clazz = dec.props.name\n      ? [dec.props.name]\n      : Array.isArray(dec.props.customTypes)\n        ? dec.props.customTypes\n        : [dec.props.customTypes];\n    const reserved = Object.values(ReservedModels).map((v) =>\n      v.toLowerCase()\n    ) as string[];\n\n    for (const c of clazz) {\n      if (reserved.indexOf(c.toLowerCase()) === -1) {\n        const typeDecoratorKey = Array.isArray((obj as any)[prop])\n          ? ValidationKeys.LIST\n          : ValidationKeys.TYPE;\n        const types: any =\n          allDecorators.find(\n            (d: { key: string }) => d.key === typeDecoratorKey\n          ) || {};\n        let allowedTypes: string[] = [];\n        if (types && types.props) {\n          const customTypes = Array.isArray((obj as any)[prop])\n            ? types.props.class\n            : types.props.customTypes;\n          if (customTypes)\n            allowedTypes = Array.isArray(customTypes)\n              ? customTypes.map((t) => `${t}`.toLowerCase())\n              : [customTypes.toLowerCase()];\n        }\n\n        const validate = (prop: string, value: any): any => {\n          if (typeof value !== \"object\" && typeof value !== \"function\")\n            return undefined;\n\n          try {\n            if (value && !value[VALIDATION_PARENT_KEY])\n              value[VALIDATION_PARENT_KEY] = obj; // TODO: freeze?\n\n            return Model.isModel(value)\n              ? value.hasErrors()\n              : allowedTypes.includes(typeof value)\n                ? undefined\n                : \"Value has no validatable type\";\n          } finally {\n            if (value && value[VALIDATION_PARENT_KEY])\n              delete value[VALIDATION_PARENT_KEY];\n          }\n        };\n\n        switch (c) {\n          case Array.name:\n          case Set.name:\n            if (allDecorators.length) {\n              const listDec = allDecorators.find(\n                (d: { key: string }) => d.key === ValidationKeys.LIST\n              );\n              if (listDec) {\n                err = (\n                  c === Array.name\n                    ? (obj as Record<string, any>)[prop]\n                    : // If it's a Set\n                      (obj as Record<string, any>)[prop].values()\n                )\n                  .map((v: Validatable) => validate(prop, v))\n                  .filter((e: any) => !!e) as any;\n                if (!err?.length) {\n                  // if the result is an empty list...\n                  err = undefined;\n                }\n              }\n            }\n            break;\n          default:\n            try {\n              if ((obj as Record<string, any>)[prop])\n                err = validate(prop, (obj as any)[prop]);\n            } catch (e: unknown) {\n              console.warn(`Model should be validatable but its not: ${e}`);\n            }\n        }\n      }\n      if (err) {\n        result = result || {};\n        result[prop] = err as any;\n      }\n    }\n  }\n\n  return result ? new ModelErrorDefinition(result) : undefined;\n}\n","import { ModelKeys } from \"../utils/constants\";\nimport type { Model } from \"./Model\";\n\nexport function getModelKey(str: string) {\n  return ModelKeys.REFLECT + str;\n}\n\nexport function getMetadata<M extends Model>(model: M) {\n  const metadata = Reflect.getMetadata(\n    getModelKey(ModelKeys.MODEL),\n    model.constructor\n  );\n  if (!metadata)\n    throw new Error(\n      \"could not find metadata for provided \" + model.constructor.name\n    );\n  return metadata;\n}\n","import { Serialization } from \"../utils/serialization\";\nimport { BuilderRegistry } from \"../utils/registry\";\nimport { ModelErrorDefinition } from \"./ModelErrorDefinition\";\nimport {\n  Comparable,\n  Constructor,\n  Hashable,\n  ModelArg,\n  ModelBuilderFunction,\n  ModelConstructor,\n  Serializable,\n  Validatable,\n} from \"./types\";\nimport { DecoratorMetadata, isEqual, Reflection } from \"@decaf-ts/reflection\";\nimport { validate } from \"./validation\";\nimport { Hashing } from \"../utils/hashing\";\nimport { ModelKeys } from \"../utils/constants\";\nimport { ValidationKeys } from \"../validation/Validators/constants\";\nimport { jsTypes, ReservedModels } from \"./constants\";\nimport { getModelKey, getMetadata } from \"./utils\";\n\nlet modelBuilderFunction: ModelBuilderFunction | undefined;\nlet actingModelRegistry: BuilderRegistry<any>;\n\n/**\n * @description Registry type for storing and retrieving model constructors\n * @summary The ModelRegistry type defines a registry for model constructors that extends\n * the BuilderRegistry interface. It provides a standardized way to register, retrieve,\n * and build model instances, enabling the model system to work with different types of models.\n *\n * @interface ModelRegistry\n * @template T Type of model that can be registered, must extend Model\n * @extends BuilderRegistry<T>\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport type ModelRegistry<T extends Model> = BuilderRegistry<T>;\n\n/**\n * @description Registry manager for model constructors that enables serialization and rebuilding\n * @summary The ModelRegistryManager implements the ModelRegistry interface and provides\n * functionality for registering, retrieving, and building model instances. It maintains\n * a cache of model constructors indexed by name, allowing for efficient lookup and instantiation.\n * This class is essential for the serialization and deserialization of model objects.\n *\n * @param {function(Record<string, any>): boolean} [testFunction] - Function to test if an object is a model, defaults to {@link Model#isModel}\n *\n * @class ModelRegistryManager\n * @template M Type of model that can be registered, must extend Model\n * @implements ModelRegistry<M>\n * @category Model\n *\n * @example\n * ```typescript\n * // Create a model registry\n * const registry = new ModelRegistryManager();\n *\n * // Register a model class\n * registry.register(User);\n *\n * // Retrieve a model constructor by name\n * const UserClass = registry.get(\"User\");\n *\n * // Build a model instance from a plain object\n * const userData = { name: \"John\", age: 30 };\n * const user = registry.build(userData, \"User\");\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant R as ModelRegistryManager\n *   participant M as Model Class\n *\n *   C->>R: new ModelRegistryManager(testFunction)\n *   C->>R: register(ModelClass)\n *   R->>R: Store in cache\n *   C->>R: get(\"ModelName\")\n *   R-->>C: ModelClass constructor\n *   C->>R: build(data, \"ModelName\")\n *   R->>R: Get constructor from cache\n *   R->>M: new ModelClass(data)\n *   M-->>R: Model instance\n *   R-->>C: Model instance\n */\nexport class ModelRegistryManager<M extends Model> implements ModelRegistry<M> {\n  private cache: Record<string, ModelConstructor<M>> = {};\n  private readonly testFunction: (obj: object) => boolean;\n\n  constructor(\n    testFunction: (obj: Record<string, any>) => boolean = Model.isModel\n  ) {\n    this.testFunction = testFunction;\n  }\n\n  /**\n   * @description Registers a model constructor with the registry\n   * @summary Adds a model constructor to the registry cache, making it available for\n   * later retrieval and instantiation. If no name is provided, the constructor's name\n   * property is used as the key in the registry.\n   *\n   * @param {ModelConstructor<M>} constructor - The model constructor to register\n   * @param {string} [name] - Optional name to register the constructor under, defaults to constructor.name\n   * @return {void}\n   * @throws {Error} If the constructor is not a function\n   */\n  register(constructor: ModelConstructor<M>, name?: string): void {\n    if (typeof constructor !== \"function\")\n      throw new Error(\n        \"Model registering failed. Missing Class name or constructor\"\n      );\n    name = name || constructor.name;\n    this.cache[name] = constructor;\n  }\n\n  /**\n   * @summary Gets a registered Model {@link ModelConstructor}\n   * @param {string} name\n   */\n  get(name: string): ModelConstructor<M> | undefined {\n    try {\n      return this.cache[name];\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (e: any) {\n      return undefined;\n    }\n  }\n\n  /**\n   * @param {Record<string, any>} obj\n   * @param {string} [clazz] when provided, it will attempt to find the matching constructor\n   *\n   * @throws Error If clazz is not found, or obj is not a {@link Model} meaning it has no {@link ModelKeys.ANCHOR} property\n   */\n  build(obj: Record<string, any> = {}, clazz?: string): M {\n    if (!clazz && !this.testFunction(obj))\n      throw new Error(\"Provided obj is not a Model object\");\n    const name = clazz || Model.getMetadata(obj as any);\n    if (!(name in this.cache))\n      throw new Error(\n        `Provided class ${name} is not a registered Model object`\n      );\n    return new this.cache[name](obj);\n  }\n}\n\n/**\n * @summary Bulk Registers Models\n * @description Useful when using bundlers that might not evaluate all the code at once\n *\n * @template M extends Model\n * @param {Array<Constructor<M>> | Array<{name: string, constructor: Constructor<M>}>} [models]\n *\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport function bulkModelRegister<M extends Model>(\n  ...models: (Constructor<M> | { name: string; constructor: Constructor<M> })[]\n) {\n  models.forEach(\n    (m: Constructor<M> | { name: string; constructor: Constructor<M> }) => {\n      const constructor: Constructor<M> = (\n        m.constructor ? m.constructor : m\n      ) as Constructor<M>;\n      Model.register(constructor, (m as Constructor<M>).name);\n    }\n  );\n}\n\n/**\n * @summary Abstract class representing a Validatable Model object\n * @description Meant to be used as a base class for all Model classes\n *\n * Model objects must:\n *  - Have all their required properties marked with '!';\n *  - Have all their optional properties marked as '?':\n *\n * @param {ModelArg<Model>} model base object from which to populate properties from\n *\n * @class Model\n * @category Model\n * @abstract\n * @implements Validatable\n * @implements Serializable\n *\n * @example\n *      class ClassName {\n *          @required()\n *          requiredPropertyName!: PropertyType;\n *\n *          optionalPropertyName?: PropertyType;\n *      }\n */\nexport abstract class Model\n  implements Validatable, Serializable, Hashable, Comparable<Model>\n{\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  protected constructor(arg?: ModelArg<Model>) {}\n\n  /**\n   * @description Validates the model object against its defined validation rules\n   * @summary Validates the object according to its decorated properties, returning any validation errors\n   *\n   * @param {any[]} [exceptions] - Properties in the object to be ignored for the validation. Marked as 'any' to allow for extension but expects strings\n   * @return {ModelErrorDefinition | undefined} - Returns a ModelErrorDefinition object if validation errors exist, otherwise undefined\n   */\n  public hasErrors(...exceptions: any[]): ModelErrorDefinition | undefined {\n    return validate(this, ...exceptions);\n  }\n\n  /**\n   * @description Determines if this model is equal to another object\n   * @summary Compare object equality recursively, checking all properties unless excluded\n   *\n   * @param {any} obj - Object to compare to\n   * @param {string[]} [exceptions] - Property names to be excluded from the comparison\n   * @return {boolean} - True if objects are equal, false otherwise\n   */\n  public equals(obj: any, ...exceptions: string[]): boolean {\n    return isEqual(this, obj, ...exceptions);\n  }\n\n  /**\n   * @description Converts the model to a serialized string representation\n   * @summary Returns the serialized model according to the currently defined {@link Serializer}\n   *\n   * @return {string} - The serialized string representation of the model\n   */\n  serialize(): string {\n    return Model.serialize(this);\n  }\n\n  /**\n   * @description Provides a human-readable string representation of the model\n   * @summary Override the implementation for js's 'toString()' to provide a more useful representation\n   *\n   * @return {string} - A string representation of the model including its class name and JSON representation\n   * @override\n   */\n  public toString(): string {\n    return this.constructor.name + \": \" + JSON.stringify(this, undefined, 2);\n  }\n\n  /**\n   * @description Generates a hash string for the model object\n   * @summary Defines a default implementation for object hash, relying on a basic implementation based on Java's string hash\n   *\n   * @return {string} - A hash string representing the model\n   */\n  public hash(): string {\n    return Model.hash(this);\n  }\n\n  /**\n   * @description Converts a serialized string back into a model instance\n   * @summary Deserializes a Model from its string representation\n   *\n   * @param {string} str - The serialized string to convert back to a model\n   * @return {any} - The deserialized model instance\n   * @throws {Error} If it fails to parse the string, or if it fails to build the model\n   */\n  static deserialize(str: string) {\n    const metadata = Reflect.getMetadata(\n      Model.key(ModelKeys.SERIALIZATION),\n      this.constructor\n    );\n\n    if (metadata && metadata.serializer)\n      return Serialization.deserialize(\n        str,\n        metadata.serializer,\n        ...(metadata.args || [])\n      );\n    return Serialization.deserialize(str);\n  }\n\n  /**\n   * @description Copies properties from a source object to a model instance\n   * @summary Repopulates the Object properties with the ones from the new object\n   *\n   * @template T\n   * @param {T} self - The target model instance to update\n   * @param {T | Record<string, any>} [obj] - The source object containing properties to copy\n   * @return {T} - The updated model instance\n   */\n  static fromObject<T extends Model>(\n    self: T,\n    obj?: T | Record<string, any>\n  ): T {\n    if (!obj) obj = {};\n    for (const prop of Model.getAttributes(self)) {\n      (self as any)[prop] = (obj as any)[prop] || undefined;\n    }\n    return self;\n  }\n\n  /**\n   * @description Copies and rebuilds properties from a source object to a model instance, handling nested models\n   * @summary Repopulates the instance with properties from the new Model Object, recursively rebuilding nested models\n   *\n   * @template T\n   * @param {T} self - The target model instance to update\n   * @param {T | Record<string, any>} [obj] - The source object containing properties to copy\n   * @return {T} - The updated model instance with rebuilt nested models\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant C as Client\n   *   participant M as Model.fromModel\n   *   participant B as Model.build\n   *   participant R as Reflection\n   *\n   *   C->>M: fromModel(self, obj)\n   *   M->>M: Get attributes from self\n   *   loop For each property\n   *     M->>M: Copy property from obj to self\n   *     alt Property is a model\n   *       M->>M: Check if property is a model\n   *       M->>B: build(property, modelType)\n   *       B-->>M: Return built model\n   *     else Property is a complex type\n   *       M->>R: Get property decorators\n   *       R-->>M: Return decorators\n   *       M->>M: Filter type decorators\n   *       alt Property is Array/Set with list decorator\n   *         M->>M: Process each item in collection\n   *         loop For each item\n   *           M->>B: build(item, itemModelType)\n   *           B-->>M: Return built model\n   *         end\n   *       else Property is another model type\n   *         M->>B: build(property, propertyType)\n   *         B-->>M: Return built model\n   *       end\n   *     end\n   *   end\n   *   M-->>C: Return updated self\n   */\n  static fromModel<T extends Model>(self: T, obj?: T | Record<string, any>): T {\n    if (!obj) obj = {};\n\n    let decorators: DecoratorMetadata[], dec: DecoratorMetadata;\n\n    const props = Model.getAttributes(self);\n\n    for (const prop of props) {\n      (self as Record<string, any>)[prop] =\n        (obj as Record<string, any>)[prop] ?? undefined;\n      if (typeof (self as any)[prop] !== \"object\") continue;\n      const propM = Model.isPropertyModel(self, prop);\n      if (propM) {\n        try {\n          (self as Record<string, any>)[prop] = Model.build(\n            (self as Record<string, any>)[prop],\n            typeof propM === \"string\" ? propM : undefined\n          );\n        } catch (e: any) {\n          console.log(e);\n        }\n        continue;\n      }\n\n      const allDecorators: DecoratorMetadata[] =\n        Reflection.getPropertyDecorators(\n          ValidationKeys.REFLECT,\n          self,\n          prop\n        ).decorators;\n      decorators = allDecorators.filter(\n        (d: DecoratorMetadata) =>\n          [ModelKeys.TYPE, ValidationKeys.TYPE as string].indexOf(d.key) !== -1\n      );\n      if (!decorators || !decorators.length)\n        throw new Error(`failed to find decorators for property ${prop}`);\n      dec = decorators.pop() as DecoratorMetadata;\n      const clazz = dec.props.name\n        ? [dec.props.name]\n        : Array.isArray(dec.props.customTypes)\n          ? dec.props.customTypes\n          : [dec.props.customTypes];\n      const reserved = Object.values(ReservedModels).map((v) =>\n        v.toLowerCase()\n      ) as string[];\n\n      clazz.forEach((c) => {\n        if (reserved.indexOf(c.toLowerCase()) === -1)\n          try {\n            switch (c) {\n              case \"Array\":\n              case \"Set\":\n                if (allDecorators.length) {\n                  const listDec = allDecorators.find(\n                    (d) => d.key === ValidationKeys.LIST\n                  );\n                  if (listDec) {\n                    const clazzName = (listDec.props.clazz as string[]).find(\n                      (t: string) => !jsTypes.includes(t.toLowerCase())\n                    );\n                    if (c === \"Array\")\n                      (self as Record<string, any>)[prop] = (\n                        self as Record<string, any>\n                      )[prop].map((el: any) => {\n                        return [\"object\", \"function\"].includes(typeof el) &&\n                          clazzName\n                          ? Model.build(el, clazzName)\n                          : el;\n                      });\n                    if (c === \"Set\") {\n                      const s = new Set();\n                      for (const v of (self as Record<string, any>)[prop]) {\n                        if (\n                          [\"object\", \"function\"].includes(typeof v) &&\n                          clazzName\n                        ) {\n                          s.add(Model.build(v, clazzName));\n                        } else {\n                          s.add(v);\n                        }\n                      }\n                      (self as Record<string, any>)[prop] = s;\n                    }\n                  }\n                }\n                break;\n              default:\n                if (\n                  typeof self[prop as keyof typeof self] !== \"undefined\" &&\n                  Model.get(c)\n                )\n                  (self as Record<string, any>)[prop] = Model.build(\n                    (self as any)[prop],\n                    c\n                  );\n            }\n          } catch (e: any) {\n            console.log(e);\n            // do nothing. we have no registry of this class\n          }\n      });\n    }\n    return self;\n  }\n\n  /**\n   * @description Configures the global model builder function\n   * @summary Sets the Global {@link ModelBuilderFunction} used for building model instances\n   *\n   * @param {ModelBuilderFunction} [builder] - The builder function to set as the global builder\n   * @return {void}\n   */\n  static setBuilder(builder?: ModelBuilderFunction) {\n    modelBuilderFunction = builder;\n  }\n\n  /**\n   * @description Retrieves the currently configured global model builder function\n   * @summary Returns the current global {@link ModelBuilderFunction} used for building model instances\n   *\n   * @return {ModelBuilderFunction | undefined} - The current global builder function or undefined if not set\n   */\n  static getBuilder(): ModelBuilderFunction | undefined {\n    return modelBuilderFunction || Model.fromModel;\n  }\n\n  /**\n   * @description Provides access to the current model registry\n   * @summary Returns the current {@link ModelRegistryManager} instance, creating one if it doesn't exist\n   *\n   * @return {ModelRegistry<any>} - The current model registry, defaults to a new {@link ModelRegistryManager} if not set\n   * @private\n   */\n  private static getRegistry() {\n    if (!actingModelRegistry) actingModelRegistry = new ModelRegistryManager();\n    return actingModelRegistry;\n  }\n\n  /**\n   * @description Configures the model registry to be used by the Model system\n   * @summary Sets the current model registry to a custom implementation\n   *\n   * @param {BuilderRegistry<any>} modelRegistry - The new implementation of Registry to use\n   * @return {void}\n   */\n  static setRegistry(modelRegistry: BuilderRegistry<any>) {\n    actingModelRegistry = modelRegistry;\n  }\n\n  /**\n   * @description Registers a model constructor with the model registry\n   * @summary Registers new model classes to make them available for serialization and deserialization\n   *\n   * @template T\n   * @param {ModelConstructor<T>} constructor - The model constructor to register\n   * @param {string} [name] - Optional name to register the constructor under, defaults to constructor.name\n   * @return {void}\n   *\n   * @see ModelRegistry\n   */\n  static register<T extends Model>(\n    constructor: ModelConstructor<T>,\n    name?: string\n  ): void {\n    return Model.getRegistry().register(constructor, name);\n  }\n\n  /**\n   * @description Retrieves a registered model constructor by name\n   * @summary Gets a registered Model {@link ModelConstructor} from the model registry\n   *\n   * @template T\n   * @param {string} name - The name of the model constructor to retrieve\n   * @return {ModelConstructor<T> | undefined} - The model constructor if found, undefined otherwise\n   *\n   * @see ModelRegistry\n   */\n  static get<T extends Model>(name: string): ModelConstructor<T> | undefined {\n    return Model.getRegistry().get(name);\n  }\n\n  /**\n   * @description Creates a model instance from a plain object\n   * @summary Builds a model instance using the model registry, optionally specifying the model class\n   *\n   * @template T\n   * @param {Record<string, any>} obj - The source object to build the model from\n   * @param {string} [clazz] - When provided, it will attempt to find the matching constructor by name\n   * @return {T} - The built model instance\n   * @throws {Error} If clazz is not found, or obj is not a {@link Model} meaning it has no {@link ModelKeys.ANCHOR} property\n   *\n   * @see ModelRegistry\n   */\n  static build<T extends Model>(\n    obj: Record<string, any> = {},\n    clazz?: string\n  ): T {\n    return Model.getRegistry().build(obj, clazz);\n  }\n\n  /**\n   * @description Retrieves the model metadata from a model instance\n   * @summary Gets the metadata associated with a model instance, typically the model class name\n   *\n   * @template M\n   * @param {M} model - The model instance to get metadata from\n   * @return {string} - The model metadata (typically the class name)\n   */\n  static getMetadata<M extends Model>(model: M) {\n    return getMetadata<M>(model);\n  }\n\n  /**\n   * @description Retrieves all attribute names from a model class or instance\n   * @summary Gets all attributes defined in a model, traversing the prototype chain to include inherited attributes\n   *\n   * @template V\n   * @param {Constructor<V> | V} model - The model class or instance to get attributes from\n   * @return {string[]} - Array of attribute names defined in the model\n   */\n  static getAttributes<V extends Model>(model: Constructor<V> | V) {\n    const result: string[] = [];\n    let prototype =\n      model instanceof Model\n        ? Object.getPrototypeOf(model)\n        : (model as any).prototype;\n    while (prototype != null) {\n      const props: string[] = prototype[ModelKeys.ATTRIBUTE];\n      if (props) {\n        result.push(...props);\n      }\n      prototype = Object.getPrototypeOf(prototype);\n    }\n    return result;\n  }\n\n  /**\n   * @description Compares two model instances for equality\n   * @summary Determines if two model instances are equal by comparing their properties\n   *\n   * @template M\n   * @param {M} obj1 - First model instance to compare\n   * @param {M} obj2 - Second model instance to compare\n   * @param {any[]} [exceptions] - Property names to exclude from comparison\n   * @return {boolean} - True if the models are equal, false otherwise\n   */\n  static equals<M extends Model>(obj1: M, obj2: M, ...exceptions: any[]) {\n    return isEqual(obj1, obj2, ...exceptions);\n  }\n\n  /**\n   * @description Validates a model instance against its validation rules\n   * @summary Checks if a model has validation errors, optionally ignoring specified properties\n   *\n   * @template M\n   * @param {M} model - The model instance to validate\n   * @param {string[]} [propsToIgnore] - Properties to exclude from validation\n   * @return {ModelErrorDefinition | undefined} - Returns validation errors if any, otherwise undefined\n   */\n  static hasErrors<M extends Model>(model: M, ...propsToIgnore: string[]) {\n    return validate(model, ...propsToIgnore);\n  }\n\n  /**\n   * @description Converts a model instance to a serialized string\n   * @summary Serializes a model instance using the configured serializer or the default one\n   *\n   * @template M\n   * @param {M} model - The model instance to serialize\n   * @return {string} - The serialized string representation of the model\n   */\n  static serialize<M extends Model>(model: M) {\n    const metadata = Reflect.getMetadata(\n      Model.key(ModelKeys.SERIALIZATION),\n      model.constructor\n    );\n\n    if (metadata && metadata.serializer)\n      return Serialization.serialize(\n        this,\n        metadata.serializer,\n        ...(metadata.args || [])\n      );\n    return Serialization.serialize(model);\n  }\n\n  /**\n   * @description Generates a hash string for a model instance\n   * @summary Creates a hash representation of a model using the configured algorithm or the default one\n   *\n   * @template M\n   * @param {M} model - The model instance to hash\n   * @return {string} - The hash string representing the model\n   */\n  static hash<M extends Model>(model: M) {\n    const metadata = Reflect.getMetadata(\n      Model.key(ModelKeys.HASHING),\n      model.constructor\n    );\n\n    if (metadata && metadata.algorithm)\n      return Hashing.hash(model, metadata.algorithm, ...(metadata.args || []));\n    return Hashing.hash(model);\n  }\n  /**\n   * @description Creates a metadata key for use with the Reflection API\n   * @summary Builds the key to store as Metadata under Reflections\n   *\n   * @param {string} str - The base key to concatenate with the model reflection prefix\n   * @return {string} - The complete metadata key\n   */\n  static key(str: string) {\n    return getModelKey(str);\n  }\n\n  /**\n   * @description Determines if an object is a model instance or has model metadata\n   * @summary Checks whether a given object is either an instance of the Model class or\n   * has model metadata attached to it. This function is essential for serialization and\n   * deserialization processes, as it helps identify model objects that need special handling.\n   * It safely handles potential errors during metadata retrieval.\n   *\n   * @param {Record<string, any>} target - The object to check\n   * @return {boolean} True if the object is a model instance or has model metadata, false otherwise\n   *\n   * @example\n   * ```typescript\n   * // Check if an object is a model\n   * const user = new User({ name: \"John\" });\n   * const isUserModel = isModel(user); // true\n   *\n   * // Check a plain object\n   * const plainObject = { name: \"John\" };\n   * const isPlainObjectModel = isModel(plainObject); // false\n   * ```\n   */\n  static isModel(target: Record<string, any>) {\n    try {\n      return target instanceof Model || !!Model.getMetadata(target as any);\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (e: any) {\n      return false;\n    }\n  }\n\n  /**\n   * @description Checks if a property of a model is itself a model or has a model type\n   * @summary Determines whether a specific property of a model instance is either a model instance\n   * or has a type that is registered as a model\n   *\n   * @template M\n   * @param {M} target - The model instance to check\n   * @param {string} attribute - The property name to check\n   * @return {boolean | string | undefined} - Returns true if the property is a model instance,\n   * the model name if the property has a model type, or undefined if not a model\n   */\n  static isPropertyModel<M extends Model>(\n    target: M,\n    attribute: string\n  ): boolean | string | undefined {\n    if (Model.isModel((target as Record<string, any>)[attribute])) return true;\n    const metadata = Reflect.getMetadata(ModelKeys.TYPE, target, attribute);\n    return Model.get(metadata.name) ? metadata.name : undefined;\n  }\n\n  static describe<M extends Model>(model: M | Constructor<M>, key?: keyof M) {\n    const descKey = Model.key(ModelKeys.DESCRIPTION);\n    if (key) {\n      model = model instanceof Model ? model : new model();\n      return (\n        Reflect.getMetadataKeys(model.constructor, key.toString())\n          .find((k) => k === descKey)\n          ?.toString() || model.toString()\n      );\n    }\n\n    return (\n      Reflect.getMetadata(\n        Model.key(ModelKeys.DESCRIPTION),\n        model instanceof Model ? model.constructor : model\n      ) || model.toString()\n    );\n  }\n}\n","import { Constructor } from \"../model/types\";\nimport { Serializer } from \"./types\";\nimport { Model } from \"../model/Model\";\nimport { ModelKeys } from \"./constants\";\nimport { getMetadata } from \"../model/utils\";\n\nexport const DefaultSerializationMethod = \"json\";\n\n/**\n * @summary Concrete implementation of a {@link Serializer} in JSON format\n * @description JS's native JSON.stringify (used here) is not deterministic\n * and therefore should not be used for hashing purposes\n *\n * To keep dependencies low, we will not implement this, but we recommend\n * implementing a similar {@link JSONSerializer} using 'deterministic-json' libraries\n *\n * @class JSONSerializer\n * @implements Serializer\n *\n * @category Model\n */\nexport class JSONSerializer<T extends Model> implements Serializer<T> {\n  constructor() {}\n  /**\n   * @summary prepares the model for serialization\n   * @description returns a shallow copy of the object, containing an enumerable {@link ModelKeys#ANCHOR} property\n   * so the object can be recognized upon deserialization\n   *\n   * @param {T} model\n   * @protected\n   */\n  protected preSerialize(model: T) {\n    // TODO: nested preserialization (so increase performance when deserializing)\n    const toSerialize: Record<string, any> = Object.assign({}, model);\n    const metadata = getMetadata(model);\n    toSerialize[ModelKeys.ANCHOR] = metadata || model.constructor.name;\n    return toSerialize;\n  }\n\n  /**\n   * @summary Rebuilds a model from a serialization\n   * @param {string} str\n   *\n   * @throws {Error} If it fails to parse the string, or to build the model\n   */\n  deserialize(str: string): T {\n    const deserialization = JSON.parse(str);\n    const className = deserialization[ModelKeys.ANCHOR];\n    if (!className)\n      throw new Error(\"Could not find class reference in serialized model\");\n    const model: T = Model.build(deserialization, className) as unknown as T;\n    return model;\n  }\n\n  /**\n   * @summary Serializes a model\n   * @param {T} model\n   *\n   * @throws {Error} if fails to serialize\n   */\n  serialize(model: T): string {\n    return JSON.stringify(this.preSerialize(model));\n  }\n}\n\nexport class Serialization {\n  private static current: string = DefaultSerializationMethod;\n\n  private static cache: Record<string, Serializer<any>> = {\n    json: new JSONSerializer(),\n  };\n\n  private constructor() {}\n\n  private static get(key: string): any {\n    if (key in this.cache) return this.cache[key];\n    throw new Error(`No serialization method registered under ${key}`);\n  }\n\n  static register(\n    key: string,\n    func: Constructor<Serializer<any>>,\n    setDefault = false\n  ): void {\n    if (key in this.cache)\n      throw new Error(`Serialization method ${key} already registered`);\n    this.cache[key] = new func();\n    if (setDefault) this.current = key;\n  }\n\n  static serialize(obj: any, method?: string, ...args: any[]) {\n    if (!method) return this.get(this.current).serialize(obj, ...args);\n    return this.get(method).serialize(obj, ...args);\n  }\n\n  static deserialize(obj: string, method?: string, ...args: any[]) {\n    if (!method) return this.get(this.current).deserialize(obj, ...args);\n    return this.get(method).deserialize(obj, ...args);\n  }\n\n  static setDefault(method: string) {\n    this.current = this.get(method);\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { Validation } from \"../Validation\";\nimport { Constructor } from \"../../model/types\";\nimport { ValidationKeys } from \"./constants\";\nimport { apply, metadata } from \"@decaf-ts/reflection\";\nimport { ValidatorDefinition } from \"../types\";\n\n/**\n * @summary Marks the class as a validator for a certain key.\n * @description Registers the class in the {@link Validation} with the provided key\n *\n * @param {string} keys the validation key\n *\n * @function validator\n *\n * @category Class Decorators\n */\nexport function validator<T extends Validator>(...keys: string[]) {\n  return apply(\n    ((original: Constructor<T>) => {\n      keys.forEach((k: string) => {\n        Validation.register({\n          validator: original,\n          validationKey: k,\n          save: true,\n        } as ValidatorDefinition);\n      });\n      return original;\n    }) as ClassDecorator,\n    metadata(Validation.key(ValidationKeys.VALIDATOR), keys)\n  );\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { DateValidatorOptions } from \"../types\";\n\n/**\n * @description Validator for checking if a value is a valid date\n * @summary The DateValidator checks if a value is a valid date object or a string that can be converted to a valid date.\n * It validates that the value represents a real date and not an invalid date like \"2023-02-31\".\n * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#DATE}\n * @class DateValidator\n * @extends Validator\n *\n * @category Validators\n * @example\n * ```typescript\n * // Create a date validator with default error message\n * const dateValidator = new DateValidator();\n *\n * // Create a date validator with custom error message\n * const customDateValidator = new DateValidator(\"Please enter a valid date\");\n *\n * // Validate a date\n * const result = dateValidator.hasErrors(new Date()); // undefined (valid)\n * const invalidResult = dateValidator.hasErrors(\"not a date\"); // Returns error message (invalid)\n * ```\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant V as DateValidator\n *\n *   C->>V: new DateValidator(message)\n *   C->>V: hasErrors(value, options)\n *   alt value is undefined\n *     V-->>C: undefined (valid)\n *   else value is string\n *     V->>V: Convert to Date\n *   end\n *   alt Date is invalid (NaN)\n *     V-->>C: Error message\n *   else Date is valid\n *     V-->>C: undefined (valid)\n *   end\n */\n@validator(ValidationKeys.DATE)\nexport class DateValidator extends Validator<DateValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.DATE) {\n    super(message, Number.name, Date.name, String.name);\n  }\n\n  /**\n   * @description Checks if the provided value is a valid date\n   * @summary Validates that the given value is a valid date. If the value is a string,\n   * it attempts to convert it to a Date object. Returns an error message if the date is invalid,\n   * or undefined if the date is valid or if the value is undefined.\n   *\n   * @param {Date | string} value - The value to validate, can be a Date object or a string\n   * @param {DateValidatorOptions} [options={}] - Optional configuration options for the validator\n   *\n   * @return {string | undefined} Error message if validation fails, undefined if validation passes\n   *\n   * @override\n   *\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: Date | string,\n    options: DateValidatorOptions = {}\n  ): string | undefined {\n    if (value === undefined) return;\n\n    if (typeof value === \"string\") value = new Date(value);\n\n    if (Number.isNaN(value.getDate())) {\n      const { message = \"\" } = options;\n      return this.getMessage(message || this.message);\n    }\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { DiffValidatorOptions } from \"../types\";\nimport { isEqual } from \"@decaf-ts/reflection\";\nimport type { PathProxy } from \"../../utils\";\n\n/**\n * @summary Diff Validator\n *\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#DiffValidator}\n *\n * @class DiffValidator\n * @extends Validator\n *\n * @category Validators\n */\n@validator(ValidationKeys.DIFF)\nexport class DiffValidator extends Validator<DiffValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.DIFF) {\n    super(message);\n  }\n\n  /**\n   * @summary Validates a model\n   *\n   * @param {string} value\n   * @param {DiffValidatorOptions} options\n   * @param {PathProxy<any>} accessor - Proxy-like object used to resolve values from nested structures via path strings.\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: DiffValidatorOptions,\n    accessor: PathProxy<any>\n  ): string | undefined {\n    let comparisonPropertyValue: any;\n    try {\n      comparisonPropertyValue = accessor.getValueFromPath(\n        options[ValidationKeys.DIFF]\n      );\n    } catch (e: any) {\n      return this.getMessage(e.message || this.message);\n    }\n\n    return isEqual(value, comparisonPropertyValue)\n      ? this.getMessage(\n          options.message || this.message,\n          options[ValidationKeys.DIFF]\n        )\n      : undefined;\n  }\n}\n","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","import {\n  DEFAULT_ERROR_MESSAGES,\n  DEFAULT_PATTERNS,\n  ValidationKeys,\n} from \"./constants\";\nimport { PatternValidator } from \"./PatternValidator\";\nimport { validator } from \"./decorators\";\nimport { PatternValidatorOptions } from \"../types\";\n\n/**\n * @description Validator for checking if a string is a valid email address\n * @summary The EmailValidator checks if a string matches a standard email address pattern.\n * It extends the PatternValidator and uses a predefined email regex pattern to validate email addresses.\n * This validator is typically used with the @email decorator.\n *\n * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#EMAIL}\n *\n * @class EmailValidator\n * @extends PatternValidator\n *\n * @example\n * ```typescript\n * // Create an email validator with default error message\n * const emailValidator = new EmailValidator();\n *\n * // Create an email validator with custom error message\n * const customEmailValidator = new EmailValidator(\"Please enter a valid email address\");\n *\n * // Validate an email\n * const result = emailValidator.hasErrors(\"user@example.com\"); // undefined (valid)\n * const invalidResult = emailValidator.hasErrors(\"invalid-email\"); // Returns error message (invalid)\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant E as EmailValidator\n *   participant P as PatternValidator\n *\n *   C->>E: new EmailValidator(message)\n *   E->>P: super(message)\n *   C->>E: hasErrors(value, options)\n *   E->>P: super.hasErrors(value, options with EMAIL pattern)\n *   P-->>E: validation result\n *   E-->>C: validation result\n *\n * @category Validators\n */\n@validator(ValidationKeys.EMAIL)\nexport class EmailValidator extends PatternValidator {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.EMAIL) {\n    super(message);\n  }\n\n  /**\n   * @description Checks if a string is a valid email address\n   * @summary Validates that the provided string matches the email pattern.\n   * This method extends the PatternValidator's hasErrors method by ensuring\n   * the email pattern is used, even if not explicitly provided in the options.\n   *\n   * @param {string} value - The string to validate as an email address\n   * @param {PatternValidatorOptions} [options={}] - Optional configuration options\n   *\n   * @return {string | undefined} Error message if validation fails, undefined if validation passes\n   *\n   * @override\n   *\n   * @see PatternValidator#hasErrors\n   */\n  public override hasErrors(\n    value: string,\n    options: PatternValidatorOptions = {}\n  ): string | undefined {\n    return super.hasErrors(value, {\n      ...options,\n      message: options.message || this.message,\n      pattern: options?.pattern || DEFAULT_PATTERNS.EMAIL,\n    });\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { EqualsValidatorOptions } from \"../types\";\nimport { isEqual } from \"@decaf-ts/reflection\";\nimport type { PathProxy } from \"../../utils\";\n\n/**\n * @summary Equals Validator\n *\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#EQUALS}\n *\n * @class EqualsValidator\n * @extends Validator\n *\n * @category Validators\n */\n@validator(ValidationKeys.EQUALS)\nexport class EqualsValidator extends Validator<EqualsValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.EQUALS) {\n    super(message);\n  }\n\n  /**\n   * @summary Validates a model\n   *\n   * @param {string} value\n   * @param {EqualsValidatorOptions} options\n   * @param {PathProxy<any>} accessor - Proxy-like object used to resolve values from nested structures via path strings.\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: EqualsValidatorOptions,\n    accessor: PathProxy<any>\n  ): string | undefined {\n    let comparisonPropertyValue: any;\n    try {\n      comparisonPropertyValue = accessor.getValueFromPath(\n        options[ValidationKeys.EQUALS]\n      );\n    } catch (e: any) {\n      return this.getMessage(e.message || this.message);\n    }\n\n    return isEqual(value, comparisonPropertyValue)\n      ? undefined\n      : this.getMessage(\n          options.message || this.message,\n          options[ValidationKeys.EQUALS]\n        );\n  }\n}\n\n// Validation.register({\n//   validator: EqualsValidator,\n//   validationKey: ValidationKeys.EQUALS,\n//   save: false,\n// } as ValidatorDefinition);\n","import { COMPARISON_ERROR_MESSAGES } from \"../../constants\";\nimport { sf } from \"../../utils\";\n\n// /**\n//  * Safely retrieves a nested property value from an object using a dot-notated path string.\n//  *\n//  * @template T - The expected return type of the property value.\n//  *\n//  * @param {Record<string, any>} obj - The source object to retrieve the value from.\n//  * @param {string} path - A dot-separated string representing the path to the desired property (e.g., \"user.address.street\").\n//  *\n//  * @returns {T} - The value found at the specified path\n//  *\n//  * @throws {Error} - Throws an error if the path is not a non-empty string or if any part of the path does not exist in the object.\n//  * @memberOf module:decorator-validation\n//  */\n// export function getValueByPath<T>(obj: Record<string, any>, path: string): T {\n//   if (typeof path !== \"string\" || !path.trim()) {\n//     throw new Error(sf(COMPARISON_ERROR_MESSAGES.INVALID_PATH, path));\n//   }\n//\n//   // Process parent directory access (../)\n//   const parentAccessors = path.match(/\\.\\.\\//g) || [];\n//   const parentLevel = parentAccessors.length;\n//   const cleanPath = path.replace(/\\.\\.\\//g, \"\");\n//\n//   // Navigate up the parent chain\n//   let currentContext: any = obj;\n//   for (let i = 0; i < parentLevel; i++) {\n//     if (!currentContext || typeof currentContext !== \"object\") {\n//       throw new Error(\n//         sf(COMPARISON_ERROR_MESSAGES.CONTEXT_NOT_OBJECT_COMPARISON, i + 1, path)\n//       );\n//     }\n//\n//     if (!currentContext[VALIDATION_PARENT_KEY]) {\n//       throw new Error(\n//         sf(COMPARISON_ERROR_MESSAGES.NO_PARENT_COMPARISON, i + 1, path)\n//       );\n//     }\n//\n//     currentContext = currentContext[VALIDATION_PARENT_KEY];\n//   }\n//\n//   // Process dot notation path\n//   const parts = cleanPath.split(\".\");\n//   let currentValue: any = currentContext;\n//\n//   for (const part of parts) {\n//     if (\n//       currentValue !== null &&\n//       typeof currentValue === \"object\" &&\n//       part in currentValue\n//     ) {\n//       currentValue = (currentValue as Record<string, any>)[part];\n//     } else {\n//       const errorMsgTemplate =\n//         parentLevel === 0\n//           ? COMPARISON_ERROR_MESSAGES.PROPERTY_NOT_FOUND\n//           : parentLevel === 1\n//             ? COMPARISON_ERROR_MESSAGES.PROPERTY_NOT_FOUND_ON_PARENT\n//             : COMPARISON_ERROR_MESSAGES.PROPERTY_NOT_FOUND_AFTER_PARENT;\n//\n//       throw new Error(sf(errorMsgTemplate, path, part, parentLevel));\n//     }\n//   }\n//\n//   return currentValue as T;\n// }\n\nconst getTypeName = (value: unknown): string => {\n  if (value === null) return \"null\";\n  if (value instanceof Date) return \"Date\";\n  if (Number.isNaN(value)) return \"NaN\";\n  if (value === Infinity) return \"Infinity\";\n  if (value === -Infinity) return \"-Infinity\";\n  if (Array.isArray(value)) return \"array\";\n  return typeof value;\n};\n\nconst isSupported = (\n  value: unknown\n): value is undefined | number | bigint | Date => {\n  if (value === undefined || value instanceof Date) return true;\n\n  if (typeof value === \"bigint\") return true;\n\n  // Numbers must be finite (excludes NaN, Infinity, -Infinity)\n  if (typeof value === \"number\") return Number.isFinite(value);\n\n  return false;\n};\n\n/**\n * Validates whether two values are eligible for comparison using >= or <= operators.\n *\n * Supported types: `undefined`, `number`, `bigint`, and `Date`.\n *\n * @param a - The first value to compare.\n * @param b - The second value to compare.\n *\n * @returns {boolean} True if both values are of supported types.\n *\n * @throws {TypeError} If either value is of an unsupported type.\n * @memberOf module:decorator-validation\n */\nexport function isValidForGteOrLteComparison(a: any, b: any): boolean {\n  if (isSupported(a) && isSupported(b)) return true;\n\n  throw new TypeError(\n    sf(\n      COMPARISON_ERROR_MESSAGES.UNSUPPORTED_TYPES_COMPARISON,\n      getTypeName(a),\n      getTypeName(b)\n    )\n  );\n}\n\n/**\n * @summary Compares two values to determine if the first is less than the second.\n * @description Supports numbers and dates. Throws an error for unsupported types.\n *\n * @param {any} a - The first value to compare.\n * @param {any} b - The second value to compare against.\n *\n * @returns {boolean} True if `a` is less than `b`, false otherwise.\n *\n * @throws {Error} If either `a` or `b` is `null` or `undefined`.\n * @throws {TypeError} If values are of mismatched or unsupported types.\n * @memberOf module:decorator-validation\n */\nexport function isLessThan(a: any, b: any): boolean {\n  if ([null, undefined].includes(a) || [null, undefined].includes(b))\n    throw new Error(COMPARISON_ERROR_MESSAGES.NULL_OR_UNDEFINED_COMPARISON);\n\n  // Validate type compatibility\n  const aType = typeof a;\n  const bType = typeof b;\n\n  if (aType !== bType) {\n    // Allow number X bigint\n    if (aType === \"bigint\" && bType === \"number\")\n      return Number(a) < (b as number);\n    if (aType === \"number\" && bType === \"bigint\")\n      return (a as number) < Number(b);\n    throw new TypeError(\n      sf(COMPARISON_ERROR_MESSAGES.TYPE_MISMATCH_COMPARISON, aType, bType)\n    );\n  }\n\n  if (\n    (aType === \"number\" && bType === \"number\") ||\n    (aType === \"bigint\" && bType === \"bigint\")\n  ) {\n    if (Number.isNaN(a) || Number.isNaN(b))\n      throw new TypeError(COMPARISON_ERROR_MESSAGES.NAN_COMPARISON);\n    return a < b;\n  }\n\n  if (a instanceof Date && b instanceof Date) {\n    if (isNaN(a.getTime()) || isNaN(b.getTime()))\n      throw new TypeError(COMPARISON_ERROR_MESSAGES.INVALID_DATE_COMPARISON);\n    return a.getTime() < b.getTime();\n  }\n\n  throw new TypeError(\n    sf(\n      COMPARISON_ERROR_MESSAGES.UNSUPPORTED_TYPES_COMPARISON,\n      getTypeName(a),\n      getTypeName(b)\n    )\n  );\n}\n\n/**\n * Checks if `a` is greater than `b`.\n * Supports comparison for numbers and Date objects.\n *\n * @param {any} a - The value to validate.\n * @param {any} b - The value to compare against.\n *\n * @returns {boolean} True if `a` is greater than `b`, otherwise false.\n *\n * @throws {Error} If either `a` or `b` is `null` or `undefined`.\n * @throws {TypeError} If values are of mismatched or unsupported types.\n * @memberOf module:decorator-validation\n */\nexport function isGreaterThan(a: any, b: any): boolean {\n  if ([null, undefined].includes(a) || [null, undefined].includes(b))\n    throw new Error(COMPARISON_ERROR_MESSAGES.NULL_OR_UNDEFINED_COMPARISON);\n\n  const aType = typeof a;\n  const bType = typeof b;\n\n  if (aType !== bType) {\n    // Allow number X bigint\n    if (aType === \"bigint\" && bType === \"number\")\n      return Number(a) > (b as number);\n    if (aType === \"number\" && bType === \"bigint\")\n      return (a as number) > Number(b);\n    throw new Error(\n      sf(COMPARISON_ERROR_MESSAGES.TYPE_MISMATCH_COMPARISON, aType, bType)\n    );\n  }\n\n  if (\n    (aType === \"number\" && bType === \"number\") ||\n    (aType === \"bigint\" && bType === \"bigint\")\n  ) {\n    if (Number.isNaN(a) || Number.isNaN(b))\n      throw new TypeError(COMPARISON_ERROR_MESSAGES.NAN_COMPARISON);\n    return a > b;\n  }\n\n  if (a instanceof Date && b instanceof Date) {\n    if (isNaN(a.getTime()) || isNaN(b.getTime()))\n      throw new TypeError(COMPARISON_ERROR_MESSAGES.INVALID_DATE_COMPARISON);\n    return a.getTime() > b.getTime();\n  }\n\n  throw new TypeError(\n    sf(\n      COMPARISON_ERROR_MESSAGES.UNSUPPORTED_TYPES_COMPARISON,\n      getTypeName(a),\n      getTypeName(b)\n    )\n  );\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { GreaterThanValidatorOptions } from \"../types\";\nimport { isGreaterThan } from \"./utils\";\nimport type { PathProxy } from \"../../utils/PathProxy\";\n\n/**\n * @summary Greater Than Validator\n *\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#GREATER_THAN}\n *\n * @class GreaterThanValidator\n * @extends Validator\n *\n * @category Validators\n */\n@validator(ValidationKeys.GREATER_THAN)\nexport class GreaterThanValidator extends Validator<GreaterThanValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.GREATER_THAN) {\n    super(message);\n  }\n\n  /**\n   * @summary Validates a model\n   *\n   * @param {string} value\n   * @param {GreaterThanValidatorOptions} options\n   * @param {PathProxy<any>} accessor - Proxy-like object used to resolve values from nested structures via path strings.\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: GreaterThanValidatorOptions,\n    accessor: PathProxy<any>\n  ): string | undefined {\n    let comparisonPropertyValue: any;\n    try {\n      comparisonPropertyValue = accessor.getValueFromPath(\n        options[ValidationKeys.GREATER_THAN]\n      );\n    } catch (e: any) {\n      return this.getMessage(e.message || this.message);\n    }\n\n    try {\n      if (!isGreaterThan(value, comparisonPropertyValue))\n        throw new Error(options.message || this.message);\n    } catch (e: any) {\n      return this.getMessage(e.message, options[ValidationKeys.GREATER_THAN]);\n    }\n\n    return undefined;\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { GreaterThanOrEqualValidatorOptions } from \"../types\";\nimport { isGreaterThan, isValidForGteOrLteComparison } from \"./utils\";\nimport { isEqual } from \"@decaf-ts/reflection\";\nimport type { PathProxy } from \"../../utils/PathProxy\";\n\n/**\n * @summary Greater Than or Equal Validator\n *\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#GREATER_THAN_OR_EQUAL}\n *\n * @class GreaterThanOrEqualValidator\n * @extends Validator\n *\n * @category Validators\n */\n@validator(ValidationKeys.GREATER_THAN_OR_EQUAL)\nexport class GreaterThanOrEqualValidator extends Validator<GreaterThanOrEqualValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.GREATER_THAN_OR_EQUAL) {\n    super(message);\n  }\n\n  /**\n   * @summary Validates a model\n   *\n   * @param {string} value\n   * @param {GreaterThanOrEqualValidatorOptions} options\n   * @param {PathProxy<any>} accessor - Proxy-like object used to resolve values from nested structures via path strings.\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: GreaterThanOrEqualValidatorOptions,\n    accessor: PathProxy<any>\n  ): string | undefined {\n    let comparisonPropertyValue: any;\n    try {\n      comparisonPropertyValue = accessor.getValueFromPath(\n        options[ValidationKeys.GREATER_THAN_OR_EQUAL]\n      );\n    } catch (e: any) {\n      return this.getMessage(e.message || this.message);\n    }\n\n    try {\n      if (\n        (isValidForGteOrLteComparison(value, comparisonPropertyValue) &&\n          isEqual(value, comparisonPropertyValue)) ||\n        isGreaterThan(value, comparisonPropertyValue)\n      )\n        return undefined;\n\n      throw new Error(options.message || this.message);\n    } catch (e: any) {\n      return this.getMessage(\n        e.message,\n        options[ValidationKeys.GREATER_THAN_OR_EQUAL]\n      );\n    }\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { LessThanValidatorOptions } from \"../types\";\nimport { isLessThan } from \"./utils\";\nimport type { PathProxy } from \"../../utils/PathProxy\";\n\n/**\n * @summary Less Than Validator\n *\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LESS_THAN}\n *\n * @class LessThanValidator\n * @extends Validator\n *\n * @category Validators\n */\n@validator(ValidationKeys.LESS_THAN)\nexport class LessThanValidator extends Validator<LessThanValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.LESS_THAN) {\n    super(message);\n  }\n\n  /**\n   * @summary Validates a model\n   *\n   * @param {string} value\n   * @param {LessThanValidatorOptions} options\n   * @param {PathProxy<any>} accessor - Proxy-like object used to resolve values from nested structures via path strings.\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: LessThanValidatorOptions,\n    accessor: PathProxy<any>\n  ): string | undefined {\n    let comparisonPropertyValue: any;\n    try {\n      comparisonPropertyValue = accessor.getValueFromPath(\n        options[ValidationKeys.LESS_THAN]\n      );\n    } catch (e: any) {\n      return this.getMessage(e.message || this.message);\n    }\n\n    try {\n      if (!isLessThan(value, comparisonPropertyValue))\n        throw new Error(options.message || this.message);\n    } catch (e: any) {\n      return this.getMessage(e.message, options[ValidationKeys.LESS_THAN]);\n    }\n\n    return undefined;\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport type { LessThanOrEqualValidatorOptions } from \"../types\";\nimport { isLessThan, isValidForGteOrLteComparison } from \"./utils\";\nimport { isEqual } from \"@decaf-ts/reflection\";\nimport type { PathProxy } from \"../../utils/PathProxy\";\n\n/**\n * @summary Less Than or Equal Validator\n *\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LESS_THAN_OR_EQUAL}\n *\n * @class LessThanOrEqualValidator\n * @extends Validator\n *\n * @category Validators\n */\n@validator(ValidationKeys.LESS_THAN_OR_EQUAL)\nexport class LessThanOrEqualValidator extends Validator<LessThanOrEqualValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.LESS_THAN_OR_EQUAL) {\n    super(message);\n  }\n\n  /**\n   * @summary Validates a model\n   *\n   * @param {string} value\n   * @param {LessThanOrEqualValidatorOptions} options\n   * @param {PathProxy<any>} accessor - Proxy-like object used to resolve values from nested structures via path strings.\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: LessThanOrEqualValidatorOptions,\n    accessor: PathProxy<any>\n  ): string | undefined {\n    let comparisonPropertyValue: any;\n    try {\n      comparisonPropertyValue = accessor.getValueFromPath(\n        options[ValidationKeys.LESS_THAN_OR_EQUAL]\n      );\n    } catch (e: any) {\n      return this.getMessage(e.message || this.message);\n    }\n\n    try {\n      if (\n        (isValidForGteOrLteComparison(value, comparisonPropertyValue) &&\n          isEqual(value, comparisonPropertyValue)) ||\n        isLessThan(value, comparisonPropertyValue)\n      )\n        return undefined;\n\n      throw new Error(options.message || this.message);\n    } catch (e: any) {\n      return this.getMessage(\n        e.message,\n        options[ValidationKeys.LESS_THAN_OR_EQUAL]\n      );\n    }\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { ListValidatorOptions } from \"../types\";\n\n/**\n * @description Validator for checking if elements in a list or set match expected types\n * @summary The ListValidator validates that all elements in an array or Set match the expected types.\n * It checks each element against a list of allowed class types and ensures type consistency.\n * This validator is typically used with the @list decorator.\n * \n * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#LIST}\n * \n * @class ListValidator\n * @extends Validator\n * \n * @example\n * ```typescript\n * // Create a list validator with default error message\n * const listValidator = new ListValidator();\n * \n * // Create a list validator with custom error message\n * const customListValidator = new ListValidator(\"All items must be of the specified type\");\n * \n * // Validate a list\n * const options = { clazz: [\"String\", \"Number\"] };\n * const result = listValidator.hasErrors([\"test\", 123], options); // undefined (valid)\n * const invalidResult = listValidator.hasErrors([new Date()], options); // Returns error message (invalid)\n * ```\n * \n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant V as ListValidator\n *   \n *   C->>V: new ListValidator(message)\n *   C->>V: hasErrors(value, options)\n *   alt value is empty\n *     V-->>C: undefined (valid)\n *   else value has elements\n *     V->>V: Check each element's type\n *     alt All elements match allowed types\n *       V-->>C: undefined (valid)\n *     else Some elements don't match\n *       V-->>C: Error message\n *     end\n *   end\n * \n * @category Validators\n */\n@validator(ValidationKeys.LIST)\nexport class ListValidator extends Validator<ListValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.LIST) {\n    super(message, Array.name, Set.name);\n  }\n\n  /**\n   * @description Checks if all elements in a list or set match the expected types\n   * @summary Validates that each element in the provided array or Set matches one of the \n   * class types specified in the options. For object types, it checks the constructor name,\n   * and for primitive types, it compares against the lowercase type name.\n   *\n   * @param {any[] | Set<any>} value - The array or Set to validate\n   * @param {ListValidatorOptions} options - Configuration options containing the allowed class types\n   *\n   * @return {string | undefined} Error message if validation fails, undefined if validation passes\n   *\n   * @override\n   *\n   * @see Validator#hasErrors\n   */\n  hasErrors(\n    value: any[] | Set<any>,\n    options: ListValidatorOptions\n  ): string | undefined {\n    if (!value || (Array.isArray(value) ? !value.length : !value.size)) return;\n\n    const clazz = Array.isArray(options.clazz)\n      ? options.clazz\n      : [options.clazz];\n    let val: any,\n      isValid = true;\n    for (\n      let i = 0;\n      i < (Array.isArray(value) ? value.length : value.size);\n      i++\n    ) {\n      val = (value as any)[i];\n      switch (typeof val) {\n        case \"object\":\n        case \"function\":\n          isValid = clazz.includes((val as object).constructor?.name);\n          break;\n        default:\n          isValid = clazz.some((c: string) => typeof val === c.toLowerCase());\n          break;\n      }\n    }\n\n    return isValid\n      ? undefined\n      : this.getMessage(options.message || this.message, clazz);\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { ValidationKeys, DEFAULT_ERROR_MESSAGES } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { MaxLengthValidatorOptions } from \"../types\";\n\n/**\n * @summary Maximum Length Validator\n * @description Validates strings and Arrays on their maximum length\n *\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#MAX_LENGTH}\n *\n * @class MinLengthValidator\n * @extends Validator\n *\n * @category Validators\n */\n@validator(ValidationKeys.MAX_LENGTH)\nexport class MaxLengthValidator extends Validator<MaxLengthValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.MAX_LENGTH) {\n    super(message, String.name, Array.name);\n  }\n\n  /**\n   * @summary Validates a model\n   *\n   * @param {string} value\n   * @param {MaxLengthValidatorOptions} options\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   *\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: string | any[],\n    options: MaxLengthValidatorOptions\n  ): string | undefined {\n    if (typeof value === \"undefined\") return;\n    return value.length > options.maxlength\n      ? this.getMessage(options.message || this.message, options.maxlength)\n      : undefined;\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { MaxValidatorOptions } from \"../types\";\n\n/**\n * @description Validator for checking if a value is less than or equal to a maximum\n * @summary The MaxValidator checks if a numeric value, date, or string is less than or equal to\n * a specified maximum value. It supports comparing numbers directly, dates chronologically,\n * and strings lexicographically. This validator is typically used with the @max decorator.\n * \n * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#MAX}\n * \n * @class MaxValidator\n * @extends Validator\n * \n * @example\n * ```typescript\n * // Create a max validator with default error message\n * const maxValidator = new MaxValidator();\n * \n * // Create a max validator with custom error message\n * const customMaxValidator = new MaxValidator(\"Value must not exceed {0}\");\n * \n * // Validate a number\n * const numOptions = { max: 100, message: \"Number too large\" };\n * const numResult = maxValidator.hasErrors(50, numOptions); // undefined (valid)\n * const invalidNumResult = maxValidator.hasErrors(150, numOptions); // Returns error message (invalid)\n * \n * // Validate a date\n * const dateOptions = { max: new Date(2023, 11, 31) };\n * const dateResult = maxValidator.hasErrors(new Date(2023, 5, 15), dateOptions); // undefined (valid)\n * ```\n * \n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant V as MaxValidator\n *   \n *   C->>V: new MaxValidator(message)\n *   C->>V: hasErrors(value, options)\n *   alt value is undefined\n *     V-->>C: undefined (valid)\n *   else value is Date and max is not Date\n *     V->>V: Convert max to Date\n *     alt conversion fails\n *       V-->>C: Error: Invalid Max param\n *     end\n *   end\n *   alt value > max\n *     V-->>C: Error message\n *   else value <= max\n *     V-->>C: undefined (valid)\n *   end\n * \n * @category Validators\n */\n@validator(ValidationKeys.MAX)\nexport class MaxValidator extends Validator<MaxValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.MAX) {\n    super(message, \"number\", \"Date\", \"string\");\n  }\n\n  /**\n   * @description Checks if a value is less than or equal to a maximum\n   * @summary Validates that the provided value does not exceed the maximum value\n   * specified in the options. For dates, it performs chronological comparison,\n   * converting string representations to Date objects if necessary. For numbers\n   * and strings, it performs direct comparison.\n   *\n   * @param {number | Date | string} value - The value to validate\n   * @param {MaxValidatorOptions} options - Configuration options containing the maximum value\n   *\n   * @return {string | undefined} Error message if validation fails, undefined if validation passes\n   *\n   * @override\n   *\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: number | Date | string,\n    options: MaxValidatorOptions\n  ): string | undefined {\n    if (typeof value === \"undefined\") return;\n\n    let { max } = options;\n    if (value instanceof Date && !(max instanceof Date)) {\n      max = new Date(max);\n      if (Number.isNaN(max.getDate()))\n        throw new Error(\"Invalid Max param defined\");\n    }\n\n    return value > max\n      ? this.getMessage(options.message || this.message, max)\n      : undefined;\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { MinLengthValidatorOptions } from \"../types\";\n\n/**\n * @summary Minimum Length Validator\n * @description Validates strings and Arrays on their minimum length\n *\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#MIN_LENGTH}\n *\n * @class MinLengthValidator\n * @extends Validator\n *\n * @category Validators\n */\n@validator(ValidationKeys.MIN_LENGTH)\nexport class MinLengthValidator extends Validator<MinLengthValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.MIN_LENGTH) {\n    super(message, String.name, Array.name);\n  }\n\n  /**\n   *\n   * @param {string | Array} value\n   * @param {MinLengthValidatorOptions} options\n   *\n   * @return {string | undefined}\n   *\n   * @memberOf MinLengthValidator\n   * @override\n   *\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: string | any[],\n    options: MinLengthValidatorOptions\n  ): string | undefined {\n    if (typeof value === \"undefined\") return;\n    return value.length < options.minlength\n      ? this.getMessage(options.message || this.message, options.minlength)\n      : undefined;\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { MinValidatorOptions } from \"../types\";\n\n/**\n * @description Validator for checking if a value is greater than or equal to a minimum\n * @summary The MinValidator checks if a numeric value, date, or string is greater than or equal to\n * a specified minimum value. It supports comparing numbers directly, dates chronologically,\n * and strings lexicographically. This validator is typically used with the @min decorator.\n * \n * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#MIN}\n * \n * @class MinValidator\n * @extends Validator\n * \n * @example\n * ```typescript\n * // Create a min validator with default error message\n * const minValidator = new MinValidator();\n * \n * // Create a min validator with custom error message\n * const customMinValidator = new MinValidator(\"Value must be at least {0}\");\n * \n * // Validate a number\n * const numOptions = { min: 10, message: \"Number too small\" };\n * const numResult = minValidator.hasErrors(50, numOptions); // undefined (valid)\n * const invalidNumResult = minValidator.hasErrors(5, numOptions); // Returns error message (invalid)\n * \n * // Validate a date\n * const dateOptions = { min: new Date(2023, 0, 1) };\n * const dateResult = minValidator.hasErrors(new Date(2023, 5, 15), dateOptions); // undefined (valid)\n * ```\n * \n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant V as MinValidator\n *   \n *   C->>V: new MinValidator(message)\n *   C->>V: hasErrors(value, options)\n *   alt value is undefined\n *     V-->>C: undefined (valid)\n *   else value is Date and min is not Date\n *     V->>V: Convert min to Date\n *     alt conversion fails\n *       V-->>C: Error: Invalid Min param\n *     end\n *   end\n *   alt value < min\n *     V-->>C: Error message\n *   else value >= min\n *     V-->>C: undefined (valid)\n *   end\n * \n * @category Validators\n */\n@validator(ValidationKeys.MIN)\nexport class MinValidator extends Validator<MinValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.MIN) {\n    super(message, \"number\", \"Date\", \"string\");\n  }\n\n  /**\n   * @description Checks if a value is greater than or equal to a minimum\n   * @summary Validates that the provided value is not less than the minimum value\n   * specified in the options. For dates, it performs chronological comparison,\n   * converting string representations to Date objects if necessary. For numbers\n   * and strings, it performs direct comparison.\n   *\n   * @param {number | Date | string} value - The value to validate\n   * @param {MinValidatorOptions} options - Configuration options containing the minimum value\n   *\n   * @return {string | undefined} Error message if validation fails, undefined if validation passes\n   *\n   * @override\n   *\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: number | Date | string,\n    options: MinValidatorOptions\n  ): string | undefined {\n    if (typeof value === \"undefined\") return;\n\n    let { min } = options;\n    if (value instanceof Date && !(min instanceof Date)) {\n      min = new Date(min);\n      if (Number.isNaN(min.getDate()))\n        throw new Error(\"Invalid Min param defined\");\n    }\n    return value < min\n      ? this.getMessage(options.message || this.message, min)\n      : undefined;\n  }\n}\n","import { PatternValidator } from \"./PatternValidator\";\nimport {\n  DEFAULT_ERROR_MESSAGES,\n  DEFAULT_PATTERNS,\n  ValidationKeys,\n} from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { PatternValidatorOptions } from \"../types\";\n\n/**\n * @summary Handles Password Validation\n *\n * @param {string} [errorMessage] defaults to {@link DEFAULT_ERROR_MESSAGES#PASSWORD}\n *\n * @class PasswordValidator\n * @extends PatternValidator\n *\n * @category Validators\n */\n@validator(ValidationKeys.PASSWORD)\nexport class PasswordValidator extends PatternValidator {\n  constructor(message = DEFAULT_ERROR_MESSAGES.PASSWORD) {\n    super(message);\n  }\n\n  /**\n   * @summary Validates a model\n   *\n   * @param {string} value\n   * @param {PatternValidatorOptions} [options={}]\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   *\n   * @see PatternValidator#hasErrors\n   */\n  public override hasErrors(\n    value: string,\n    options: PatternValidatorOptions = {}\n  ): string | undefined {\n    return super.hasErrors(value, {\n      ...options,\n      message: options.message || this.message,\n      [ValidationKeys.PATTERN]:\n        options?.pattern || DEFAULT_PATTERNS.PASSWORD.CHAR8_ONE_OF_EACH,\n    });\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { ValidatorOptions } from \"../types\";\n\n/**\n * @description Validator for checking if a value is present and not empty\n * @summary The RequiredValidator ensures that a value is provided and not empty.\n * It handles different types of values appropriately: for booleans and numbers,\n * it checks if they're undefined; for other types (strings, arrays, objects),\n * it checks if they're falsy. This validator is typically used with the @required decorator\n * and is often the first validation applied to important fields.\n * \n * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#REQUIRED}\n * \n * @class RequiredValidator\n * @extends Validator\n * \n * @example\n * ```typescript\n * // Create a required validator with default error message\n * const requiredValidator = new RequiredValidator();\n * \n * // Create a required validator with custom error message\n * const customRequiredValidator = new RequiredValidator(\"This field is mandatory\");\n * \n * // Validate different types of values\n * requiredValidator.hasErrors(\"Hello\"); // undefined (valid)\n * requiredValidator.hasErrors(\"\"); // Returns error message (invalid)\n * requiredValidator.hasErrors(0); // undefined (valid - 0 is a valid number)\n * requiredValidator.hasErrors(null); // Returns error message (invalid)\n * requiredValidator.hasErrors([]); // undefined (valid - empty array is still an array)\n * ```\n * \n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant V as RequiredValidator\n *   \n *   C->>V: new RequiredValidator(message)\n *   C->>V: hasErrors(value, options)\n *   alt typeof value is boolean or number\n *     alt value is undefined\n *       V-->>C: Error message\n *     else value is defined\n *       V-->>C: undefined (valid)\n *     end\n *   else other types\n *     alt value is falsy (null, undefined, empty string)\n *       V-->>C: Error message\n *     else value is truthy\n *       V-->>C: undefined (valid)\n *     end\n *   end\n * \n * @category Validators\n */\n@validator(ValidationKeys.REQUIRED)\nexport class RequiredValidator extends Validator {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.REQUIRED) {\n    super(message);\n  }\n\n  /**\n   * @description Checks if a value is present and not empty\n   * @summary Validates that the provided value exists and is not empty.\n   * The validation logic varies by type:\n   * - For booleans and numbers: checks if the value is undefined\n   * - For other types (strings, arrays, objects): checks if the value is falsy\n   *\n   * @param {any} value - The value to validate\n   * @param {ValidatorOptions} [options={}] - Optional configuration options\n   *\n   * @return {string | undefined} Error message if validation fails, undefined if validation passes\n   *\n   * @override\n   *\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: ValidatorOptions = {}\n  ): string | undefined {\n    switch (typeof value) {\n      case \"boolean\":\n      case \"number\":\n        return typeof value === \"undefined\"\n          ? this.getMessage(options.message || this.message)\n          : undefined;\n      default:\n        return !value\n          ? this.getMessage(options.message || this.message)\n          : undefined;\n    }\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { StepValidatorOptions } from \"../types\";\n\n/**\n * @summary Step Validator\n *\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#STEP}\n *\n * @class StepValidator\n * @extends Validator\n *\n * @category Validators\n */\n@validator(ValidationKeys.STEP)\nexport class StepValidator extends Validator<StepValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.STEP) {\n    super(message, \"number\", \"string\");\n  }\n\n  /**\n   * @summary Validates a model\n   *\n   * @param {string} value\n   * @param {number} step\n   * @param {StepValidatorOptions} options\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   *\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: number | string,\n    options: StepValidatorOptions\n  ): string | undefined {\n    if (typeof value === \"undefined\") return;\n    return Number(value) % Number(options.step) !== 0\n      ? this.getMessage(options.message || this.message, options.step)\n      : undefined;\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { Validation } from \"../Validation\";\nimport { TypeValidatorOptions, ValidatorDefinition } from \"../types\";\nimport { ModelKeys } from \"../../utils/constants\";\nimport { Reflection } from \"@decaf-ts/reflection\";\n\n/**\n * @description Validator for checking if a value is of the expected type(s)\n * @summary The TypeValidator ensures that a value matches one of the specified types.\n * It can validate against a single type, multiple types, or a type with a specific name.\n * This validator is typically used with the @type decorator and is fundamental for\n * ensuring type safety in validated models.\n *\n * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#TYPE}\n *\n * @class TypeValidator\n * @extends Validator\n *\n * @example\n * ```typescript\n * // Create a type validator with default error message\n * const typeValidator = new TypeValidator();\n *\n * // Create a type validator with custom error message\n * const customTypeValidator = new TypeValidator(\"Value must be of type {0}, but got {1}\");\n *\n * // Validate against a single type\n * const stringOptions = { types: \"string\" };\n * typeValidator.hasErrors(\"hello\", stringOptions); // undefined (valid)\n * typeValidator.hasErrors(123, stringOptions); // Returns error message (invalid)\n *\n * // Validate against multiple types\n * const multiOptions = { types: [\"string\", \"number\"] };\n * typeValidator.hasErrors(\"hello\", multiOptions); // undefined (valid)\n * typeValidator.hasErrors(123, multiOptions); // undefined (valid)\n * typeValidator.hasErrors(true, multiOptions); // Returns error message (invalid)\n *\n * // Validate against a class type\n * const classOptions = { types: { name: \"Date\" } };\n * typeValidator.hasErrors(new Date(), classOptions); // undefined (valid)\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant V as TypeValidator\n *   participant R as Reflection\n *\n *   C->>V: new TypeValidator(message)\n *   C->>V: hasErrors(value, options)\n *   alt value is undefined\n *     V-->>C: undefined (valid)\n *   else value is defined\n *     V->>R: evaluateDesignTypes(value, types)\n *     alt type evaluation passes\n *       V-->>C: undefined (valid)\n *     else type evaluation fails\n *       V->>V: Format error message with type info\n *       V-->>C: Error message\n *     end\n *   end\n *\n * @category Validators\n */\n@validator(ValidationKeys.TYPE)\nexport class TypeValidator extends Validator<TypeValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.TYPE) {\n    super(message);\n  }\n\n  /**\n   * @description Checks if a value is of the expected type(s)\n   * @summary Validates that the provided value matches one of the specified types.\n   * It uses the Reflection utility to evaluate if the value's type matches the expected types.\n   * The method skips validation for undefined values to avoid conflicts with the RequiredValidator.\n   *\n   * @param {any} value - The value to validate\n   * @param {TypeValidatorOptions} options - Configuration options containing the expected types\n   *\n   * @return {string | undefined} Error message if validation fails, undefined if validation passes\n   *\n   * @override\n   *\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: TypeValidatorOptions\n  ): string | undefined {\n    if (value === undefined) return; // Don't try and enforce type if undefined\n    const { types, message } = options;\n    if (!Reflection.evaluateDesignTypes(value, types))\n      return this.getMessage(\n        message || this.message,\n        typeof types === \"string\"\n          ? types\n          : Array.isArray(types)\n            ? types.join(\", \")\n            : types.name,\n        typeof value\n      );\n  }\n}\n\n/**\n * @description Register the TypeValidator with the Validation registry\n * @summary This registration associates the TypeValidator with the ModelKeys.TYPE key,\n * allowing it to be used for validating design types. The save flag is set to false\n * to prevent the validator from being saved in the standard validator registry.\n *\n * @memberOf module:decorator-validation\n */\nValidation.register({\n  validator: TypeValidator,\n  validationKey: ModelKeys.TYPE,\n  save: false,\n} as ValidatorDefinition);\n","import {\n  ValidationKeys,\n  DEFAULT_ERROR_MESSAGES,\n  DEFAULT_PATTERNS,\n} from \"./constants\";\nimport { PatternValidator } from \"./PatternValidator\";\nimport { validator } from \"./decorators\";\nimport { PatternValidatorOptions } from \"../types\";\n\n/**\n * @description Validator for checking if a string is a valid URL\n * @summary The URLValidator checks if a string matches a standard URL pattern.\n * It extends the PatternValidator and uses a robust URL regex pattern to validate web addresses.\n * The pattern is sourced from {@link https://gist.github.com/dperini/729294} and is widely\n * recognized for its accuracy in validating URLs. This validator is typically used with the @url decorator.\n *\n * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#URL}\n *\n * @class URLValidator\n * @extends PatternValidator\n *\n * @example\n * ```typescript\n * // Create a URL validator with default error message\n * const urlValidator = new URLValidator();\n *\n * // Create a URL validator with custom error message\n * const customUrlValidator = new URLValidator(\"Please enter a valid web address\");\n *\n * // Validate a URL\n * const result = urlValidator.hasErrors(\"https://example.com\"); // undefined (valid)\n * const invalidResult = urlValidator.hasErrors(\"not-a-url\"); // Returns error message (invalid)\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant U as URLValidator\n *   participant P as PatternValidator\n *\n *   C->>U: new URLValidator(message)\n *   U->>P: super(message)\n *   C->>U: hasErrors(value, options)\n *   U->>P: super.hasErrors(value, options with URL pattern)\n *   P-->>U: validation result\n *   U-->>C: validation result\n *\n * @category Validators\n */\n@validator(ValidationKeys.URL)\nexport class URLValidator extends PatternValidator {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.URL) {\n    super(message);\n  }\n\n  /**\n   * @description Checks if a string is a valid URL\n   * @summary Validates that the provided string matches the URL pattern.\n   * This method extends the PatternValidator's hasErrors method by ensuring\n   * the URL pattern is used, even if not explicitly provided in the options.\n   *\n   * @param {string} value - The string to validate as a URL\n   * @param {PatternValidatorOptions} [options={}] - Optional configuration options\n   *\n   * @return {string | undefined} Error message if validation fails, undefined if validation passes\n   *\n   * @override\n   *\n   * @see PatternValidator#hasErrors\n   */\n  public override hasErrors(\n    value: string,\n    options: PatternValidatorOptions = {}\n  ): string | undefined {\n    return super.hasErrors(value, {\n      ...options,\n      message: options.message || this.message,\n      pattern: options.pattern || DEFAULT_PATTERNS.URL,\n    });\n  }\n}\n","import \"reflect-metadata\";\nimport {\n  DateValidatorOptions,\n  DiffValidatorOptions,\n  EqualsValidatorOptions,\n  GreaterThanOrEqualValidatorOptions,\n  GreaterThanValidatorOptions,\n  LessThanOrEqualValidatorOptions,\n  LessThanValidatorOptions,\n  ListValidatorOptions,\n  MaxLengthValidatorOptions,\n  MaxValidatorOptions,\n  MinLengthValidatorOptions,\n  MinValidatorOptions,\n  PatternValidatorOptions,\n  StepValidatorOptions,\n  ValidationMetadata,\n  ValidatorOptions,\n} from \"./types\";\nimport {\n  DEFAULT_ERROR_MESSAGES,\n  DEFAULT_PATTERNS,\n  ValidationKeys,\n} from \"./Validators/constants\";\nimport { sf } from \"../utils/strings\";\nimport { Constructor, ModelConstructor } from \"../model/types\";\nimport { parseDate } from \"../utils/dates\";\nimport { propMetadata } from \"../utils/decorators\";\nimport { Validation } from \"./Validation\";\nimport { Decoration } from \"../utils/Decoration\";\nimport { apply } from \"@decaf-ts/reflection\";\n\n/**\n * @description Combined property decorator factory for metadata and attribute marking\n * @summary Creates a decorator that both marks a property as a model attribute and assigns metadata to it\n *\n * @template V\n * @param {PropertyDecorator} decorator - The metadata key\n * @param {string} key - The metadata key\n * @param {V} value - The metadata value to associate with the property\n * @return {Function} - Combined decorator function\n * @function validationMetadata\n * @category Property Decorators\n */\nexport function validationMetadata<V>(decorator: any, key: string, value: V) {\n  Validation.registerDecorator(key, decorator);\n  return apply(propMetadata<V>(key, value));\n}\n\n/**\n * @description Property decorator that marks a field as required\n * @summary Marks the property as required, causing validation to fail if the property is undefined, null, or empty.\n * Validators to validate a decorated property must use key {@link ValidationKeys#REQUIRED}.\n * This decorator is commonly used as the first validation step for important fields.\n *\n * @param {string} [message] - The error message to display when validation fails. Defaults to {@link DEFAULT_ERROR_MESSAGES#REQUIRED}\n * @return {PropertyDecorator} A decorator function that can be applied to class properties\n *\n * @function required\n * @category Property Decorators\n *\n * @example\n * ```typescript\n * class User {\n *   @required()\n *   username: string;\n *\n *   @required(\"Email address is mandatory\")\n *   email: string;\n * }\n * ```\n */\nexport function required(message: string = DEFAULT_ERROR_MESSAGES.REQUIRED) {\n  const key = Validation.key(ValidationKeys.REQUIRED);\n  const meta: ValidatorOptions = {\n    message: message,\n    description: `defines the attribute as required`,\n  };\n  return Decoration.for(key)\n    .define(validationMetadata<ValidatorOptions>(required, key, meta))\n    .apply();\n}\n\n/**\n * @description Property decorator that enforces a minimum value constraint\n * @summary Defines a minimum value for the property, causing validation to fail if the property value is less than the specified minimum.\n * Validators to validate a decorated property must use key {@link ValidationKeys#MIN}.\n * This decorator works with numeric values and dates.\n *\n * @param {number | Date | string} value - The minimum value allowed. For dates, can be a Date object or a string that can be converted to a date\n * @param {string} [message] - The error message to display when validation fails. Defaults to {@link DEFAULT_ERROR_MESSAGES#MIN}\n * @return {PropertyDecorator} A decorator function that can be applied to class properties\n *\n * @function min\n * @category Property Decorators\n *\n * @example\n * ```typescript\n * class Product {\n *   @min(0)\n *   price: number;\n *\n *   @min(new Date(2023, 0, 1), \"Date must be after January 1, 2023\")\n *   releaseDate: Date;\n * }\n * ```\n */\nexport function min(\n  value: number | Date | string,\n  message: string = DEFAULT_ERROR_MESSAGES.MIN\n) {\n  const key = Validation.key(ValidationKeys.MIN);\n  const meta: MinValidatorOptions = {\n    [ValidationKeys.MIN]: value,\n    message: message,\n    types: [Number.name, Date.name],\n    description: `defines the max value of the attribute as ${value} (applies to numbers or Dates)`,\n  };\n  return Decoration.for(key)\n    .define(validationMetadata<MinValidatorOptions>(min, key, meta))\n    .apply();\n}\n\n/**\n * @summary Defines a maximum value for the property\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#MAX}\n *\n * @param {number | Date} value\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#MAX}\n *\n * @function max\n * @category Property Decorators\n */\nexport function max(\n  value: number | Date | string,\n  message: string = DEFAULT_ERROR_MESSAGES.MAX\n) {\n  const key = Validation.key(ValidationKeys.MAX);\n  const meta: MaxValidatorOptions = {\n    [ValidationKeys.MAX]: value,\n    message: message,\n    types: [Number.name, Date.name],\n    description: `defines the max value of the attribute as ${value} (applies to numbers or Dates)`,\n  };\n  return Decoration.for(key)\n    .define(validationMetadata<MaxValidatorOptions>(max, key, meta))\n    .apply();\n}\n\n/**\n * @summary Defines a step value for the property\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#STEP}\n *\n * @param {number} value\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#STEP}\n *\n * @function step\n * @category Property Decorators\n */\nexport function step(\n  value: number,\n  message: string = DEFAULT_ERROR_MESSAGES.STEP\n) {\n  const key = Validation.key(ValidationKeys.STEP);\n  const meta: StepValidatorOptions = {\n    [ValidationKeys.STEP]: value,\n    message: message,\n    types: [Number.name],\n    description: `defines the step of the attribute as ${value}`,\n  };\n  return Decoration.for(key)\n    .define(validationMetadata<StepValidatorOptions>(step, key, meta))\n    .apply();\n}\n\n/**\n * @summary Defines a minimum length for the property\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#MIN_LENGTH}\n *\n * @param {string} value\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#MIN_LENGTH}\n *\n * @function minlength\n * @category Property Decorators\n */\nexport function minlength(\n  value: number,\n  message: string = DEFAULT_ERROR_MESSAGES.MIN_LENGTH\n) {\n  const key = Validation.key(ValidationKeys.MIN_LENGTH);\n  const meta: MinLengthValidatorOptions = {\n    [ValidationKeys.MIN_LENGTH]: value,\n    message: message,\n    types: [String.name, Array.name, Set.name],\n    description: `defines the min length of the attribute as ${value} (applies to strings or lists)`,\n  };\n  return Decoration.for(key)\n    .define(validationMetadata<MinLengthValidatorOptions>(minlength, key, meta))\n    .apply();\n}\n\n/**\n * @summary Defines a maximum length for the property\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#MAX_LENGTH}\n *\n * @param {string} value\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#MAX_LENGTH}\n *\n * @function maxlength\n * @category Property Decorators\n */\nexport function maxlength(\n  value: number,\n  message: string = DEFAULT_ERROR_MESSAGES.MAX_LENGTH\n) {\n  const key = Validation.key(ValidationKeys.MAX_LENGTH);\n  const meta: MaxLengthValidatorOptions = {\n    [ValidationKeys.MAX_LENGTH]: value,\n    message: message,\n    types: [String.name, Array.name, Set.name],\n    description: `defines the max length of the attribute as ${value} (applies to strings or lists)`,\n  };\n  return Decoration.for(key)\n    .define(validationMetadata<MaxLengthValidatorOptions>(maxlength, key, meta))\n    .apply();\n}\n\n/**\n * @summary Defines a RegExp pattern the property must respect\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#PATTERN}\n *\n * @param {string} value\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#PATTERN}\n *\n * @function pattern\n * @category Property Decorators\n */\nexport function pattern(\n  value: RegExp | string,\n  message: string = DEFAULT_ERROR_MESSAGES.PATTERN\n) {\n  const key = Validation.key(ValidationKeys.PATTERN);\n  const meta: PatternValidatorOptions = {\n    [ValidationKeys.PATTERN]:\n      typeof value === \"string\" ? value : value.toString(),\n    message: message,\n    types: [String.name],\n    description: `assigns the ${value === \"string\" ? value : value.toString()} pattern to the attribute`,\n  };\n  return Decoration.for(key)\n    .define(validationMetadata<PatternValidatorOptions>(pattern, key, meta))\n    .apply();\n}\n\n/**\n * @summary Defines the property as an email\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#EMAIL}\n *\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#EMAIL}\n *\n * @function email\n * @category Property Decorators\n */\nexport function email(message: string = DEFAULT_ERROR_MESSAGES.EMAIL) {\n  const key = Validation.key(ValidationKeys.EMAIL);\n  const meta: PatternValidatorOptions = {\n    [ValidationKeys.PATTERN]: DEFAULT_PATTERNS.EMAIL.toString(),\n    message: message,\n    types: [String.name],\n    description: \"marks the attribute as an email\",\n  };\n  return Decoration.for(key)\n    .define(validationMetadata<PatternValidatorOptions>(email, key, meta))\n    .apply();\n}\n\n/**\n * @summary Defines the property as an URL\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#URL}\n *\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#URL}\n *\n * @function url\n * @category Property Decorators\n */\nexport function url(message: string = DEFAULT_ERROR_MESSAGES.URL) {\n  const key = Validation.key(ValidationKeys.URL);\n  const meta: PatternValidatorOptions = {\n    [ValidationKeys.PATTERN]: DEFAULT_PATTERNS.URL.toString(),\n    message: message,\n    types: [String.name],\n    description: \"marks the attribute as an url\",\n  };\n  return Decoration.for(key)\n    .define(validationMetadata<PatternValidatorOptions>(url, key, meta))\n    .apply();\n}\n\nexport interface TypeMetadata extends ValidatorOptions {\n  customTypes: string[] | string;\n}\n\n/**\n * @summary Enforces type verification\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#TYPE}\n *\n * @param {string[] | string} types accepted types\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#TYPE}\n *\n * @function type\n * @category Property Decorators\n */\nexport function type(\n  types: string[] | string,\n  message: string = DEFAULT_ERROR_MESSAGES.TYPE\n) {\n  const key = Validation.key(ValidationKeys.TYPE);\n  const meta: TypeMetadata = {\n    customTypes: types,\n    message: message,\n    description: \"defines the accepted types for the attribute\",\n  };\n  return Decoration.for(key)\n    .define(validationMetadata<TypeMetadata>(type, key, meta))\n    .apply();\n}\n\nexport interface DateMetadata extends DateValidatorOptions {\n  types: string[];\n}\n\n/**\n * @summary Date Handler Decorator\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#DATE}\n *\n * Will enforce serialization according to the selected format\n *\n * @param {string} format accepted format according to {@link formatDate}\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#DATE}\n *\n * @function date\n *\n * @category Property Decorators\n */\nexport function date(\n  format: string = \"dd/MM/yyyy\",\n  message: string = DEFAULT_ERROR_MESSAGES.DATE\n) {\n  const key = Validation.key(ValidationKeys.DATE);\n  const meta: DateMetadata = {\n    [ValidationKeys.FORMAT]: format,\n    message: message,\n    types: [Date.name],\n    description: `defines the attribute as a date with the format ${format}`,\n  };\n  const dateDec = (target: Record<string, any>, propertyKey?: any): any => {\n    validationMetadata(date, key, meta)(target, propertyKey);\n\n    const values = new WeakMap();\n\n    Object.defineProperty(target, propertyKey, {\n      configurable: false,\n      set(this: any, newValue: string | Date) {\n        const descriptor = Object.getOwnPropertyDescriptor(this, propertyKey);\n        if (!descriptor || descriptor.configurable)\n          Object.defineProperty(this, propertyKey, {\n            enumerable: true,\n            configurable: false,\n            get: () => values.get(this),\n            set: (newValue: string | Date | number) => {\n              let val: Date | undefined;\n              try {\n                val = parseDate(format, newValue);\n                values.set(this, val);\n              } catch (e: any) {\n                console.error(sf(\"Failed to parse date: {0}\", e.message || e));\n              }\n            },\n          });\n        this[propertyKey] = newValue;\n      },\n      get() {\n        console.log(\"here\");\n      },\n    });\n  };\n  return Decoration.for(key).define(dateDec).apply();\n}\n\n/**\n * @summary Password Handler Decorator\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#PASSWORD}\n *\n * @param {RegExp} [pattern] defaults to {@link DEFAULT_PATTERNS#CHAR8_ONE_OF_EACH}\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#PASSWORD}\n *\n * @function password\n *\n * @category Property Decorators\n */\nexport function password(\n  pattern: RegExp = DEFAULT_PATTERNS.PASSWORD.CHAR8_ONE_OF_EACH,\n  message: string = DEFAULT_ERROR_MESSAGES.PASSWORD\n) {\n  const key = Validation.key(ValidationKeys.PASSWORD);\n  const meta: PatternValidatorOptions = {\n    [ValidationKeys.PATTERN]: pattern.toString(),\n    message: message,\n    types: [String.name],\n    description: `attribute as a password`,\n  };\n  return Decoration.for(key)\n    .define(validationMetadata(password, key, meta))\n    .apply();\n}\n\nexport interface ListMetadata extends ListValidatorOptions {\n  type: \"Array\" | \"Set\";\n}\n\n/**\n * @summary List Decorator\n * @description Also sets the {@link type} to the provided collection\n *\n * @param {Constructor} clazz\n * @param {string} [collection] The collection being used. defaults to Array\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LIST}\n *\n * @function list\n *\n * @category Property Decorators\n */\nexport function list(\n  clazz: Constructor<any> | Constructor<any>[],\n  collection: \"Array\" | \"Set\" = \"Array\",\n  message: string = DEFAULT_ERROR_MESSAGES.LIST\n) {\n  const key = Validation.key(ValidationKeys.LIST);\n  const meta: ListMetadata = {\n    clazz: Array.isArray(clazz) ? clazz.map((c) => c.name) : [clazz.name],\n    type: collection,\n    message: message,\n    description: `defines the attribute as a ${collection} of ${(clazz as ModelConstructor<any>).name}`,\n  };\n  return Decoration.for(key)\n    .define(validationMetadata(list, key, meta))\n    .apply();\n}\n\n/**\n * @summary Set Decorator\n * @description Wrapper for {@link list} with the 'Set' Collection\n *\n * @param {ModelConstructor} clazz\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LIST}\n *\n * @function set\n *\n * @category Property Decorators\n */\nexport function set(\n  clazz: ModelConstructor<any>,\n  message: string = DEFAULT_ERROR_MESSAGES.LIST\n) {\n  return list(clazz, \"Set\", message);\n}\n\n/**\n * @summary Declares that the decorated property must be equal to another specified property.\n * @description Applies the {@link ValidationKeys.EQUALS} validator to ensure the decorated value matches the value of the given property.\n *\n * @param {string} propertyToCompare - The name of the property to compare equality against.\n * @param {string} [message=DEFAULT_ERROR_MESSAGES.EQUALS] - Custom error message to return if validation fails.\n *\n * @returns {PropertyDecorator} A property decorator used to register the equality validation metadata.\n *\n * @function eq\n * @category Property Decorators\n */\nexport function eq(\n  propertyToCompare: string,\n  message: string = DEFAULT_ERROR_MESSAGES.EQUALS\n) {\n  const options: EqualsValidatorOptions = {\n    message: message,\n    [ValidationKeys.EQUALS]: propertyToCompare,\n    description: `defines attribute as equal to ${propertyToCompare}`,\n  };\n\n  return validationMetadata<ValidationMetadata>(\n    eq,\n    Validation.key(ValidationKeys.EQUALS),\n    options as ValidationMetadata\n  );\n}\n\n/**\n * @summary Declares that the decorated property must be different from another specified property.\n * @description Applies the {@link ValidationKeys.DIFF} validator to ensure the decorated value is different from the value of the given property.\n *\n * @param {string} propertyToCompare - The name of the property to compare difference against.\n * @param {string} [message=DEFAULT_ERROR_MESSAGES.DIFF] - Custom error message to return if validation fails.\n *\n * @returns {PropertyDecorator} A property decorator used to register the difference validation metadata.\n *\n * @function diff\n * @category Property Decorators\n */\nexport function diff(\n  propertyToCompare: string,\n  message: string = DEFAULT_ERROR_MESSAGES.DIFF\n) {\n  const options: DiffValidatorOptions = {\n    message: message,\n    [ValidationKeys.DIFF]: propertyToCompare,\n    description: `defines attribute as different to ${propertyToCompare}`,\n  };\n\n  return validationMetadata<ValidationMetadata>(\n    diff,\n    Validation.key(ValidationKeys.DIFF),\n    options as ValidationMetadata\n  );\n}\n\n/**\n * @summary Declares that the decorated property must be less than another specified property.\n * @description Applies the {@link ValidationKeys.LESS_THAN} validator to ensure the decorated value is less than the value of the given property.\n *\n * @param {string} propertyToCompare - The name of the property to compare against.\n * @param {string} [message=DEFAULT_ERROR_MESSAGES.LESS_THAN] - Custom error message to return if validation fails.\n *\n * @returns {PropertyDecorator} A property decorator used to register the less than validation metadata.\n *\n * @function lt\n * @category Property Decorators\n */\nexport function lt(\n  propertyToCompare: string,\n  message: string = DEFAULT_ERROR_MESSAGES.LESS_THAN\n) {\n  const options: LessThanValidatorOptions = {\n    message: message,\n    [ValidationKeys.LESS_THAN]: propertyToCompare,\n    description: `defines attribute as less than to ${propertyToCompare}`,\n  };\n\n  return validationMetadata<ValidationMetadata>(\n    lt,\n    Validation.key(ValidationKeys.LESS_THAN),\n    options as ValidationMetadata\n  );\n}\n\n/**\n * @summary Declares that the decorated property must be equal or less than another specified property.\n * @description Applies the {@link ValidationKeys.LESS_THAN_OR_EQUAL} validator to ensure the decorated value is equal or less than the value of the given property.\n *\n * @param {string} propertyToCompare - The name of the property to compare against.\n * @param {string} [message=DEFAULT_ERROR_MESSAGES.LESS_THAN_OR_EQUAL] - Custom error message to return if validation fails.\n *\n * @returns {PropertyDecorator} A property decorator used to register the less than or equal validation metadata.\n *\n * @function lte\n * @category Property Decorators\n */\nexport function lte(\n  propertyToCompare: string,\n  message: string = DEFAULT_ERROR_MESSAGES.LESS_THAN_OR_EQUAL\n) {\n  const options: LessThanOrEqualValidatorOptions = {\n    message: message,\n    [ValidationKeys.LESS_THAN_OR_EQUAL]: propertyToCompare,\n    description: `defines attribute as less or equal to ${propertyToCompare}`,\n  };\n\n  return validationMetadata<ValidationMetadata>(\n    lte,\n    Validation.key(ValidationKeys.LESS_THAN_OR_EQUAL),\n    options as ValidationMetadata\n  );\n}\n\n/**\n * @summary Declares that the decorated property must be greater than another specified property.\n * @description Applies the {@link ValidationKeys.GREATER_THAN} validator to ensure the decorated value is greater than the value of the given property.\n *\n * @param {string} propertyToCompare - The name of the property to compare against.\n * @param {string} [message=DEFAULT_ERROR_MESSAGES.GREATER_THAN] - Custom error message to return if validation fails.\n *\n * @returns {PropertyDecorator} A property decorator used to register the greater than validation metadata.\n *\n * @function gt\n * @category Property Decorators\n */\nexport function gt(\n  propertyToCompare: string,\n  message: string = DEFAULT_ERROR_MESSAGES.GREATER_THAN\n) {\n  const options: GreaterThanValidatorOptions = {\n    message: message,\n    [ValidationKeys.GREATER_THAN]: propertyToCompare,\n    description: `defines attribute as greater than ${propertyToCompare}`,\n  };\n\n  return validationMetadata<ValidationMetadata>(\n    gt,\n    Validation.key(ValidationKeys.GREATER_THAN),\n    options as ValidationMetadata\n  );\n}\n\n/**\n * @summary Declares that the decorated property must be equal or greater than another specified property.\n * @description Applies the {@link ValidationKeys.GREATER_THAN_OR_EQUAL} validator to ensure the decorated value is equal or greater than the value of the given property.\n *\n * @param {string} propertyToCompare - The name of the property to compare against.\n * @param {string} [message=DEFAULT_ERROR_MESSAGES.GREATER_THAN_OR_EQUAL] - Custom error message to return if validation fails.\n *\n * @returns {PropertyDecorator} A property decorator used to register the greater than or equal validation metadata.\n *\n * @function gte\n * @category Property Decorators\n */\nexport function gte(\n  propertyToCompare: string,\n  message: string = DEFAULT_ERROR_MESSAGES.GREATER_THAN_OR_EQUAL\n) {\n  const options: GreaterThanOrEqualValidatorOptions = {\n    message: message,\n    [ValidationKeys.GREATER_THAN_OR_EQUAL]: propertyToCompare,\n    description: `defines attribute as greater or equal to ${propertyToCompare}`,\n  };\n\n  return validationMetadata<ValidationMetadata>(\n    gte,\n    Validation.key(ValidationKeys.GREATER_THAN_OR_EQUAL),\n    options as ValidationMetadata\n  );\n}\n","import { Model } from \"./Model\";\n\n/**\n * @summary Helper Function to override constructors\n *\n * @template M the model instance type\n *\n * @param {Function} constructor\n * @param {any[]} [args]\n * @return {M} the new instance\n *\n * @function construct\n * @memberOf module:decorator-validation\n */\nexport function construct<M extends Model>(\n  constructor: any,\n  ...args: any[]\n): M {\n  const _constr = (...argz: any[]) => new constructor(...argz);\n  _constr.prototype = constructor.prototype;\n  return _constr(...args);\n}\n\n/**\n * @summary Recursively finds the last prototype before Object\n * @param {object} obj\n *\n * @function findLastProtoBeforeObject\n * @memberOf module:decorator-validation\n */\nexport function findLastProtoBeforeObject(obj: object): object {\n  let prototype: any = Object.getPrototypeOf(obj);\n  if (prototype === Object.prototype) return obj;\n  while (prototype !== Object.prototype) {\n    prototype = Object.getPrototypeOf(prototype);\n    if (prototype === Object.prototype) return prototype;\n    if (Object.getPrototypeOf(prototype) === Object.prototype) return prototype;\n  }\n  throw new Error(\"Could not find proper prototype\");\n}\n\n/**\n * @sumary binds the {@link Model} class as a root prototype of the provided instance\n *\n * @param {unknown} obj\n *\n * @function bindModelPrototype\n * @memberOf module:decorator-validation\n */\nexport function bindModelPrototype(obj: unknown) {\n  if (obj instanceof Model) return;\n\n  function bindPrototype(objToOverride: unknown, prototype: object) {\n    Object.setPrototypeOf(objToOverride, prototype);\n  }\n\n  const prototype: any = Object.getPrototypeOf(obj);\n  if (prototype === Object.prototype) {\n    return bindPrototype(obj, Model.prototype);\n  }\n  while (prototype !== Object.prototype) {\n    const prot = Object.getPrototypeOf(prototype);\n    if (\n      prot === Object.prototype ||\n      Object.getPrototypeOf(prot) === Object.prototype\n    ) {\n      return bindPrototype(prototype, Model.prototype);\n    }\n  }\n  throw new Error(\"Could not find proper prototype to bind\");\n}\n","import { bindModelPrototype, construct } from \"./construction\";\nimport { ModelKeys } from \"../utils/constants\";\nimport { Model } from \"./Model\";\nimport { metadata } from \"@decaf-ts/reflection\";\nimport { propMetadata } from \"../utils\";\n\n/**\n * @summary defines the tpe os an InstanceCallback function\n *\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport type InstanceCallback = (instance: any, ...args: any[]) => void;\n\n/**\n * @summary Defines a class as a Model class\n * @description\n *\n * - Registers the class under the model registry so it can be easily rebuilt;\n * - Overrides the class constructor;\n * - Runs the global {@link ModelBuilderFunction} if defined;\n * - Runs the optional {@link InstanceCallback} if provided;\n *\n * @param {InstanceCallback} [instanceCallback] optional callback that will be called with the instance upon instantiation. defaults to undefined\n *\n * @function model\n *\n * @category Class Decorators\n */\nexport function model(instanceCallback?: InstanceCallback) {\n  return ((original: any) => {\n    // the new constructor behaviour\n    const newConstructor: any = function (...args: any[]) {\n      const instance: ReturnType<typeof original> = construct(\n        original,\n        ...args\n      );\n      bindModelPrototype(instance);\n      // run a builder function if defined with the first argument (The ModelArg)\n      const builder = Model.getBuilder();\n      if (builder) builder(instance, args.length ? args[0] : undefined);\n\n      metadata(Model.key(ModelKeys.MODEL), original.name)(instance.constructor);\n\n      if (instanceCallback) instanceCallback(instance, ...args);\n\n      return instance;\n    };\n\n    // copy prototype so instanceof operator still works\n    newConstructor.prototype = original.prototype;\n\n    Reflect.getMetadataKeys(original).forEach((key) => {\n      Reflect.defineMetadata(\n        key,\n        Reflect.getMetadata(key, original),\n        newConstructor\n      );\n    });\n    // Sets the proper constructor name for type verification\n    Object.defineProperty(newConstructor, \"name\", {\n      writable: false,\n      enumerable: true,\n      configurable: false,\n      value: original.prototype.constructor.name,\n    });\n\n    metadata(Model.key(ModelKeys.MODEL), original.name)(original);\n\n    Model.register(newConstructor, original.name);\n\n    // return new constructor (will override original)\n    return newConstructor;\n  }) as any;\n}\n\n/**\n * @summary Defines the hashing algorithm to use on the model\n * @description\n *\n * - Registers the class under the model registry so it can be easily rebuilt;\n * - Overrides the class constructor;\n * - Runs the global {@link ModelBuilderFunction} if defined;\n * - Runs the optional {@link InstanceCallback} if provided;\n *\n * @param {string} algorithm the algorithm to use\n *\n * @function hashedBy\n *\n * @category Class Decorators\n */\nexport function hashedBy(algorithm: string, ...args: any[]) {\n  return metadata(Model.key(ModelKeys.HASHING), {\n    algorithm: algorithm,\n    args: args,\n  });\n}\n\n/**\n * @summary Defines the serialization algorithm to use on the model\n *\n * @param {string} serializer the algorithm to use\n *\n * @function serializedBy\n *\n * @category Class Decorators\n */\nexport function serializedBy(serializer: string, ...args: any[]) {\n  return metadata(Model.key(ModelKeys.SERIALIZATION), {\n    serializer: serializer,\n    args: args,\n  });\n}\n\n/**\n * @summary Applies descriptive metadata to a class, property or method\n *\n * @param {string} description the description to apply\n *\n * @function description\n *\n * @category Decorators\n */\nexport function description(description: string) {\n  return metadata(Model.key(ModelKeys.DESCRIPTION), description);\n}\n","/**\n * @module decorator-validation\n * @description TypeScript decorator-based validation library\n * @summary This module provides a comprehensive validation framework using TypeScript decorators.\n * It exposes utility functions, validation decorators, and model-related functionality for\n * implementing type-safe, declarative validation in TypeScript applications.\n */\nexport * from \"./constants\";\nexport * from \"./utils\";\nexport * from \"./validation\";\nexport * from \"./model\";\n\n/**\n * @description Current version of the reflection package\n * @summary Stores the semantic version number of the package\n * @const VERSION\n * @memberOf module:decorator-validation\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":[],"mappings":"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"}
+export { ASYNC_META_KEY, AsyncValidator, COMPARISON_ERROR_MESSAGES, ComparisonValidationKeys, DAYS_OF_WEEK_NAMES, DEFAULT_ERROR_MESSAGES, DEFAULT_PATTERNS, DateValidator, Decoration, DefaultFlavour, DefaultHashingMethod, DefaultSerializationMethod, DiffValidator, EmailValidator, EqualsValidator, GreaterThanOrEqualValidator, GreaterThanValidator, Hashing, JSONSerializer, LessThanOrEqualValidator, LessThanValidator, ListValidator, MONTH_NAMES, MaxLengthValidator, MaxValidator, MinLengthValidator, MinValidator, Model, ModelErrorDefinition, ModelKeys, ModelRegistryManager, PasswordValidator, PathProxyEngine, PatternValidator, Primitives, RequiredValidator, ReservedModels, Serialization, StepValidator, TypeValidator, URLValidator, VALIDATION_PARENT_KEY, VERSION, Validation, ValidationKeys, Validator, ValidatorRegistry, async, bindDateToString, bindModelPrototype, bulkModelRegister, construct, date, dateFromFormat, description, diff, email, eq, findLastProtoBeforeObject, formatDate, getMetadata, getModelKey, getValidatableProperties, getValidationDecorators, gt, gte, hashCode, hashObj, hashedBy, isGreaterThan, isLessThan, isValidDate, isValidForGteOrLteComparison, jsTypes, list, lt, lte, max, maxlength, min, minlength, model, parseDate, password, pattern, prop, propMetadata, regexpParser, required, serializedBy, set, sf, step, stringFormat, toConditionalPromise, twoDigitPad, type, url, validate, validateDecorator, validateDecorators, validationMetadata, validator };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"decorator-validation.esm.cjs","sources":["../src/constants/errors.ts","../src/constants/validation.ts","../src/utils/constants.ts","../src/validation/Validators/constants.ts","../src/utils/strings.ts","../src/utils/dates.ts","../src/utils/Decoration.ts","../src/utils/decorators.ts","../src/utils/hashing.ts","../src/utils/PathProxy.ts","../src/model/ModelErrorDefinition.ts","../src/validation/Validators/BaseValidator.ts","../src/validation/Validators/Validator.ts","../src/validation/Validators/ValidatorRegistry.ts","../src/validation/Validation.ts","../src/model/utils.ts","../src/model/validation.ts","../src/model/constants.ts","../src/model/Model.ts","../src/utils/serialization.ts","../src/validation/Validators/AsyncValidator.ts","../src/validation/Validators/decorators.ts","../src/validation/Validators/DateValidator.ts","../src/validation/Validators/DiffValidator.ts","../src/validation/Validators/PatternValidator.ts","../src/validation/Validators/EmailValidator.ts","../src/validation/Validators/EqualsValidator.ts","../src/validation/Validators/utils.ts","../src/validation/Validators/GreaterThanValidator.ts","../src/validation/Validators/GreaterThanOrEqualValidator.ts","../src/validation/Validators/LessThanValidator.ts","../src/validation/Validators/LessThanOrEqualValidator.ts","../src/validation/Validators/ListValidator.ts","../src/validation/Validators/MaxLengthValidator.ts","../src/validation/Validators/MaxValidator.ts","../src/validation/Validators/MinLengthValidator.ts","../src/validation/Validators/MinValidator.ts","../src/validation/Validators/PasswordValidator.ts","../src/validation/Validators/RequiredValidator.ts","../src/validation/Validators/StepValidator.ts","../src/validation/Validators/TypeValidator.ts","../src/validation/Validators/URLValidator.ts","../src/validation/decorators.ts","../src/model/construction.ts","../src/model/decorators.ts","../src/index.ts"],"sourcesContent":["export const COMPARISON_ERROR_MESSAGES = {\n  INVALID_PATH:\n    \"Invalid path argument. Expected non-empty string but received: '{0}'\",\n  CONTEXT_NOT_OBJECT_COMPARISON:\n    \"Unable to access parent at level {0} for path '{1}': current context is not an object\",\n  PROPERTY_INVALID:\n    \"Failed to resolve path {0}: property '{1}' is invalid or does not exist.\",\n  PROPERTY_NOT_EXIST: \"Failed to resolve path: property '{0}' does not exist.\",\n  UNSUPPORTED_TYPES_COMPARISON:\n    \"Unsupported types for comparison: '{0}' and '{1}'\",\n  NULL_OR_UNDEFINED_COMPARISON:\n    \"Comparison failed due to null or undefined value\",\n  INVALID_DATE_COMPARISON: \"Invalid Date objects are not comparable\",\n  TYPE_MISMATCH_COMPARISON:\n    \"Cannot compare values of different types: {0} and {1}.\",\n  NAN_COMPARISON: \"Comparison not supported for NaN values\",\n  // NO_PARENT_COMPARISON: \"Unable to access parent at level {0} for path '{1}': no parent available\",\n  // PROPERTY_NOT_FOUND: \"Failed to resolve path {0}: property '{1}' does not exist.\",\n  // PROPERTY_NOT_FOUND_ON_PARENT: \"Failed to resolve path {0}: property '{1}' does not exist on parent.\",\n  // PROPERTY_NOT_FOUND_AFTER_PARENT: \"Failed to resolve path {0}: property '{1}' does not exist after {2} parent level(s).\",\n};\n","/**\n * @description Symbol key for tracking parent-child relationships in validation\n * @summary Symbol used to internally track the parent object during nested validation\n *\n * @const VALIDATION_PARENT_KEY\n * @memberOf module:decorator-validation\n */\nexport const VALIDATION_PARENT_KEY = Symbol(\"_parent\");\nexport const ASYNC_META_KEY = Symbol(\"isAsync\");\n","/**\n * @description Enum containing metadata keys used for reflection in the model system\n * @summary Defines the various Model keys used for reflection and metadata storage.\n * These keys are used throughout the library to store and retrieve metadata about models,\n * their properties, and their behavior.\n *\n * @property {string} REFLECT - Prefix to all other keys, used as a namespace\n * @property {string} TYPE - Key for storing design type information\n * @property {string} PARAMS - Key for storing method parameter types\n * @property {string} RETURN - Key for storing method return type\n * @property {string} MODEL - Key for identifying model metadata\n * @property {string} ANCHOR - Anchor key that serves as a ghost property in the model\n * @property {string} CONSTRUCTION - Key for storing construction information\n * @property {string} ATTRIBUTE - Key for storing attribute metadata\n * @property {string} HASHING - Key for storing hashing configuration\n * @property {string} SERIALIZATION - Key for storing serialization configuration\n *\n * @readonly\n * @enum {string}\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport enum ModelKeys {\n  REFLECT = \"decaf.model.\",\n  DESCRIPTION = \"decaf.description.\",\n  TYPE = \"design:type\",\n  PARAMS = \"design:paramtypes\",\n  RETURN = \"design:returntype\",\n  MODEL = \"model\",\n  ANCHOR = \"__model\",\n  CONSTRUCTION = \"constructed-by\",\n  ATTRIBUTE = \"__attributes\",\n  HASHING = \"hashing\",\n  SERIALIZATION = \"serialization\",\n}\n\n/**\n * @description Default flavour identifier for the decorator system\n * @summary Defines the default flavour used by the Decoration class when no specific flavour is provided.\n * This constant is used throughout the library as the fallback flavour for decorators.\n *\n * @const {string}\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport const DefaultFlavour = \"decaf\";\n","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","/**\n * @summary Util function to provide string format functionality similar to C#'s string.format\n *\n * @param {string} string\n * @param {Array<string | number>} [args] replacements made by order of appearance (replacement0 wil replace {0} and so on)\n * @return {string} formatted string\n *\n * @function stringFormat\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport function stringFormat(string: string, ...args: (string | number)[]) {\n  return string.replace(/{(\\d+)}/g, function (match, number) {\n    return typeof args[number] !== \"undefined\"\n      ? args[number].toString()\n      : \"undefined\";\n  });\n}\n\n/**\n * @summary Util function to provide string format functionality similar to C#'s string.format\n * @description alias for {@link stringFormat}\n *\n * @param {string} string\n * @param {string} args replacements made by order of appearance (replacement0 wil replace {0} and so on)\n * @return {string} formatted string\n *\n * @function sf\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport const sf = stringFormat;\n","import \"reflect-metadata\";\nimport {\n  DAYS_OF_WEEK_NAMES,\n  MONTH_NAMES,\n} from \"../validation/Validators/constants\";\nimport { sf } from \"./strings\";\n\n/**\n * @summary Reverses the process from {@link formatDate}\n *\n * @param {string} date the date string to be converted back into date\n * @param {string} format the date format\n * @return {Date} the date from the format or the standard new Date({@prop date}) if the string couldn't be parsed (are you sure the format matches the string?)\n *\n * @function dateFromFormat\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport function dateFromFormat(date: string, format: string) {\n  let formatRegexp: string = format;\n\n  // Hour\n  if (formatRegexp.match(/hh/))\n    formatRegexp = formatRegexp.replace(\"hh\", \"(?<hour>\\\\d{2})\");\n  else if (formatRegexp.match(/h/))\n    formatRegexp = formatRegexp.replace(\"h\", \"(?<hour>\\\\d{1,2})\");\n  else if (formatRegexp.match(/HH/))\n    formatRegexp = formatRegexp.replace(\"HH\", \"(?<hour>\\\\d{2})\");\n  else if (formatRegexp.match(/H/))\n    formatRegexp = formatRegexp.replace(\"H\", \"(?<hour>\\\\d{1,2})\");\n\n  // Minutes\n  if (formatRegexp.match(/mm/))\n    formatRegexp = formatRegexp.replace(\"mm\", \"(?<minutes>\\\\d{2})\");\n  else if (formatRegexp.match(/m/))\n    formatRegexp = formatRegexp.replace(\"m\", \"(?<minutes>\\\\d{1,2})\");\n\n  // Seconds\n  if (formatRegexp.match(/ss/))\n    formatRegexp = formatRegexp.replace(\"ss\", \"(?<seconds>\\\\d{2})\");\n  else if (formatRegexp.match(/s/))\n    formatRegexp = formatRegexp.replace(\"s\", \"(?<seconds>\\\\d{1,2})\");\n\n  // Day\n  if (formatRegexp.match(/dd/))\n    formatRegexp = formatRegexp.replace(\"dd\", \"(?<day>\\\\d{2})\");\n  else if (formatRegexp.match(/d/))\n    formatRegexp = formatRegexp.replace(\"d\", \"(?<day>\\\\d{1,2})\");\n\n  // Day Of Week\n  if (formatRegexp.match(/EEEE/))\n    formatRegexp = formatRegexp.replace(\"EEEE\", \"(?<dayofweek>\\\\w+)\");\n  // eslint-disable-next-line no-dupe-else-if\n  else if (formatRegexp.match(/EEEE/))\n    formatRegexp = formatRegexp.replace(\"EEE\", \"(?<dayofweek>\\\\w+)\");\n\n  // Year\n  if (formatRegexp.match(/yyyy/))\n    formatRegexp = formatRegexp.replace(\"yyyy\", \"(?<year>\\\\d{4})\");\n  else if (formatRegexp.match(/yy/))\n    formatRegexp = formatRegexp.replace(\"yy\", \"(?<year>\\\\d{2})\");\n\n  // Month\n  if (formatRegexp.match(/MMMM/))\n    formatRegexp = formatRegexp.replace(\"MMMM\", \"(?<monthname>\\\\w+)\");\n  else if (formatRegexp.match(/MMM/))\n    formatRegexp = formatRegexp.replace(\"MMM\", \"(?<monthnamesmall>\\\\w+)\");\n  if (formatRegexp.match(/MM/))\n    formatRegexp = formatRegexp.replace(\"MM\", \"(?<month>\\\\d{2})\");\n  else if (formatRegexp.match(/M/))\n    formatRegexp = formatRegexp.replace(\"M\", \"(?<month>\\\\d{1,2})\");\n\n  // Milis and Am Pm\n  formatRegexp = formatRegexp\n    .replace(\"S\", \"(?<milis>\\\\d{1,3})\")\n    .replace(\"aaa\", \"(?<ampm>\\\\w{2})\");\n\n  const regexp = new RegExp(formatRegexp, \"g\");\n\n  const match: {\n    groups: {\n      year?: string;\n      day?: string;\n      ampm?: string;\n      hour?: string;\n      minutes?: string;\n      seconds?: string;\n      milis?: string;\n      monthname?: string;\n      monthnamesmall?: string;\n      month?: string;\n    };\n  } = regexp.exec(date) as any;\n\n  if (!match || !match.groups) return new Date(date);\n\n  const safeParseInt = function (n?: string) {\n    if (!n) return 0;\n    const result = parseInt(n);\n\n    return isNaN(result) ? 0 : result;\n  };\n\n  const year = safeParseInt(match.groups.year);\n  const day = safeParseInt(match.groups.day);\n\n  const amPm = match.groups.ampm;\n  let hour = safeParseInt(match.groups.hour);\n\n  if (amPm) hour = amPm === \"PM\" ? hour + 12 : hour;\n\n  const minutes = safeParseInt(match.groups.minutes);\n  const seconds = safeParseInt(match.groups.seconds);\n  const ms = safeParseInt(match.groups.milis);\n\n  const monthName = match.groups.monthname;\n  const monthNameSmall = match.groups.monthnamesmall;\n  let month: number | string = match.groups.month as string;\n  if (monthName) month = MONTH_NAMES.indexOf(monthName);\n  else if (monthNameSmall) {\n    const m = MONTH_NAMES.find((m) =>\n      m.toLowerCase().startsWith(monthNameSmall.toLowerCase())\n    );\n    if (!m) return new Date(date);\n    month = MONTH_NAMES.indexOf(m);\n  } else month = safeParseInt(`${month}`);\n\n  return new Date(year, month - 1, day, hour, minutes, seconds, ms);\n}\n\n/**\n * @description Binds a specific date format to a Date object's toString and toISOString methods\n * @summary Modifies a Date object to return a formatted string when toString or toISOString is called.\n * This function overrides the default toString and toISOString methods of the Date object to return\n * the date formatted according to the specified format string.\n * @param {Date} [date] The Date object to modify\n * @param {string} [format] The format string to use for formatting the date\n * @return {Date|undefined} The modified Date object or undefined if no date was provided\n * @function bindDateToString\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport function bindDateToString(date: Date | undefined, format: string) {\n  if (!date) return;\n  const func = () => formatDate(date, format);\n  Object.defineProperty(date, \"toISOString\", {\n    enumerable: false,\n    configurable: false,\n    value: func,\n  });\n  Object.defineProperty(date, \"toString\", {\n    enumerable: false,\n    configurable: false,\n    value: func,\n  });\n  // Object.setPrototypeOf(date, Date.prototype);\n  return date;\n}\n\n/**\n * @description Safely checks if a value is a valid Date object\n * @summary A utility function that determines if a value is a valid Date object.\n * This function is more reliable than using instanceof Date as it also checks\n * that the date is not NaN, which can happen with invalid date strings.\n * @param {any} date The value to check\n * @return {boolean} True if the value is a valid Date object, false otherwise\n * @function isValidDate\n * @memberOf module:decorator-validation\n * @category Validation\n */\nexport function isValidDate(date: any): boolean {\n  return (\n    date &&\n    Object.prototype.toString.call(date) === \"[object Date]\" &&\n    !Number.isNaN(date)\n  );\n}\n\n/**\n * @summary Util function to pad numbers\n * @param {number} num\n *\n * @return {string}\n *\n * @function twoDigitPad\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport function twoDigitPad(num: number): string {\n  return num < 10 ? \"0\" + num : num.toString();\n}\n\n/**\n * @summary Date Format Handling\n * @description Code from {@link https://stackoverflow.com/questions/3552461/how-to-format-a-javascript-date}\n *\n * <pre>\n *      Using similar formatting as Moment.js, Class DateTimeFormatter (Java), and Class SimpleDateFormat (Java),\n *      I implemented a comprehensive solution formatDate(date, patternStr) where the code is easy to read and modify.\n *      You can display date, time, AM/PM, etc.\n *\n *      Date and Time Patterns\n *      yy = 2-digit year; yyyy = full year\n *      M = digit month; MM = 2-digit month; MMM = short month name; MMMM = full month name\n *      EEEE = full weekday name; EEE = short weekday name\n *      d = digit day; dd = 2-digit day\n *      h = hours am/pm; hh = 2-digit hours am/pm; H = hours; HH = 2-digit hours\n *      m = minutes; mm = 2-digit minutes; aaa = AM/PM\n *      s = seconds; ss = 2-digit seconds\n *      S = miliseconds\n * </pre>\n *\n * @param {Date} date\n * @param {string} [patternStr] defaults to 'yyyy/MM/dd'\n * @return {string} the formatted date\n *\n * @function formatDate\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport function formatDate(date: Date, patternStr: string = \"yyyy/MM/dd\") {\n  const day: number = date.getDate(),\n    month: number = date.getMonth(),\n    year: number = date.getFullYear(),\n    hour: number = date.getHours(),\n    minute: number = date.getMinutes(),\n    second: number = date.getSeconds(),\n    miliseconds: number = date.getMilliseconds(),\n    h: number = hour % 12,\n    hh: string = twoDigitPad(h),\n    HH: string = twoDigitPad(hour),\n    mm: string = twoDigitPad(minute),\n    ss: string = twoDigitPad(second),\n    aaa: string = hour < 12 ? \"AM\" : \"PM\",\n    EEEE: string = DAYS_OF_WEEK_NAMES[date.getDay()],\n    EEE: string = EEEE.substr(0, 3),\n    dd: string = twoDigitPad(day),\n    M: number = month + 1,\n    MM: string = twoDigitPad(M),\n    MMMM: string = MONTH_NAMES[month],\n    MMM: string = MMMM.substr(0, 3),\n    yyyy: string = year + \"\",\n    yy: string = yyyy.substr(2, 2);\n  // checks to see if month name will be used\n  patternStr = patternStr\n    .replace(\"hh\", hh)\n    .replace(\"h\", h.toString())\n    .replace(\"HH\", HH)\n    .replace(\"H\", hour.toString())\n    .replace(\"mm\", mm)\n    .replace(\"m\", minute.toString())\n    .replace(\"ss\", ss)\n    .replace(\"s\", second.toString())\n    .replace(\"S\", miliseconds.toString())\n    .replace(\"dd\", dd)\n    .replace(\"d\", day.toString())\n\n    .replace(\"EEEE\", EEEE)\n    .replace(\"EEE\", EEE)\n    .replace(\"yyyy\", yyyy)\n    .replace(\"yy\", yy)\n    .replace(\"aaa\", aaa);\n  if (patternStr.indexOf(\"MMM\") > -1) {\n    patternStr = patternStr.replace(\"MMMM\", MMMM).replace(\"MMM\", MMM);\n  } else {\n    patternStr = patternStr.replace(\"MM\", MM).replace(\"M\", M.toString());\n  }\n  return patternStr;\n}\n\n/**\n * @summary Parses a date from a specified format\n * @param {string} format\n * @param {string | Date | number} [v]\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport function parseDate(format: string, v?: string | Date | number) {\n  let value: Date | undefined = undefined;\n\n  if (!v) return undefined;\n\n  if (v instanceof Date)\n    try {\n      value = dateFromFormat(formatDate(v as Date, format), format);\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (e: any) {\n      throw new Error(\n        sf(\"Could not convert date {0} to format: {1}\", v.toString(), format)\n      );\n    }\n  else if (typeof v === \"string\") {\n    value = dateFromFormat(v, format);\n  } else if (typeof v === \"number\") {\n    const d = new Date(v);\n    value = dateFromFormat(formatDate(d, format), format);\n  } else if (isValidDate(v)) {\n    try {\n      const d = new Date(v);\n      value = dateFromFormat(formatDate(d, format), format);\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (e) {\n      throw new Error(\n        sf(\"Could not convert date {0} to format: {1}\", v, format)\n      );\n    }\n  } else {\n    throw new Error(`Invalid value provided ${v}`);\n  }\n  return bindDateToString(value, format);\n}\n","import {\n  DecorationBuilderBuild,\n  DecorationBuilderEnd,\n  DecorationBuilderMid,\n  DecorationBuilderStart,\n  FlavourResolver,\n  IDecorationBuilder,\n} from \"./types\";\nimport { DefaultFlavour } from \"./constants\";\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction defaultFlavourResolver(target: object) {\n  return DefaultFlavour;\n}\n\n/**\n * @description A decorator management class that handles flavoured decorators\n * @summary The Decoration class provides a builder pattern for creating and managing decorators with different flavours.\n * It supports registering, extending, and applying decorators with context-aware flavour resolution.\n * The class implements a fluent interface for defining, extending, and applying decorators with different flavours,\n * allowing for framework-specific decorator implementations while maintaining a consistent API.\n * @template T Type of the decorator (ClassDecorator | PropertyDecorator | MethodDecorator)\n * @param {string} [flavour] Optional flavour parameter for the decorator context\n * @class\n * @category Model\n * @example\n * ```typescript\n * // Create a new decoration for 'component' with default flavour\n * const componentDecorator = new Decoration()\n *   .for('component')\n *   .define(customComponentDecorator);\n *\n * // Create a flavoured decoration\n * const vueComponent = new Decoration('vue')\n *   .for('component')\n *   .define(vueComponentDecorator);\n *\n * // Apply the decoration\n * @componentDecorator\n * class MyComponent {}\n * ```\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant D as Decoration\n *   participant R as FlavourResolver\n *   participant F as DecoratorFactory\n *\n *   C->>D: new Decoration(flavour)\n *   C->>D: for(key)\n *   C->>D: define(decorators)\n *   D->>D: register(key, flavour, decorators)\n *   D->>F: decoratorFactory(key, flavour)\n *   F->>R: resolve(target)\n *   R-->>F: resolved flavour\n *   F->>F: apply decorators\n *   F-->>C: decorated target\n */\nexport class Decoration implements IDecorationBuilder {\n  /**\n   * @description Static map of registered decorators\n   * @summary Stores all registered decorators organized by key and flavour\n   */\n  private static decorators: Record<\n    string,\n    Record<\n      string,\n      {\n        decorators?: Set<ClassDecorator | PropertyDecorator | MethodDecorator>;\n        extras?: Set<ClassDecorator | PropertyDecorator | MethodDecorator>;\n      }\n    >\n  > = {};\n\n  /**\n   * @description Function to resolve flavour from a target\n   * @summary Resolver function that determines the appropriate flavour for a given target\n   */\n  private static flavourResolver: FlavourResolver = defaultFlavourResolver;\n\n  /**\n   * @description Set of decorators for the current context\n   */\n  private decorators?: Set<\n    ClassDecorator | PropertyDecorator | MethodDecorator\n  >;\n\n  /**\n   * @description Set of additional decorators\n   */\n  private extras?: Set<ClassDecorator | PropertyDecorator | MethodDecorator>;\n\n  /**\n   * @description Current decorator key\n   */\n  private key?: string;\n\n  constructor(private flavour: string = DefaultFlavour) {}\n\n  /**\n   * @description Sets the key for the decoration builder\n   * @summary Initializes a new decoration chain with the specified key\n   * @param {string} key The identifier for the decorator\n   * @return {DecorationBuilderMid} Builder instance for method chaining\n   */\n  for(key: string): DecorationBuilderMid {\n    this.key = key;\n    return this;\n  }\n\n  /**\n   * @description Adds decorators to the current context\n   * @summary Internal method to add decorators with addon support\n   * @param {boolean} [addon=false] Whether the decorators are addons\n   * @param decorators Array of decorators\n   * @return {this} Current instance for chaining\n   */\n  private decorate(\n    addon: boolean = false,\n    ...decorators: (ClassDecorator | PropertyDecorator | MethodDecorator)[]\n  ): this {\n    if (!this.key)\n      throw new Error(\"key must be provided before decorators can be added\");\n    if (\n      (!decorators || !decorators.length) &&\n      !addon &&\n      this.flavour !== DefaultFlavour\n    )\n      throw new Error(\n        \"Must provide overrides or addons to override or extend decaf's decorators\"\n      );\n    if (this.flavour === DefaultFlavour && addon)\n      throw new Error(\"Default flavour cannot be extended\");\n\n    this[addon ? \"extras\" : \"decorators\"] = new Set([\n      ...(this[addon ? \"extras\" : \"decorators\"] || new Set()).values(),\n      ...decorators,\n    ]);\n\n    return this;\n  }\n\n  /**\n   * @description Defines the base decorators\n   * @summary Sets the primary decorators for the current context\n   * @param decorators Decorators to define\n   * @return Builder instance for finishing the chain\n   */\n  define(\n    ...decorators: (ClassDecorator | PropertyDecorator | MethodDecorator)[]\n  ): DecorationBuilderEnd & DecorationBuilderBuild {\n    return this.decorate(false, ...decorators);\n  }\n\n  /**\n   * @description Extends existing decorators\n   * @summary Adds additional decorators to the current context\n   * @param decorators Additional decorators\n   * @return {DecorationBuilderBuild} Builder instance for building the decorator\n   */\n  extend(\n    ...decorators: (ClassDecorator | PropertyDecorator | MethodDecorator)[]\n  ): DecorationBuilderBuild {\n    return this.decorate(true, ...decorators);\n  }\n\n  protected decoratorFactory(key: string, f: string = DefaultFlavour) {\n    const contextDecorator = function contextDecorator(\n      target: object,\n      propertyKey?: any,\n      descriptor?: TypedPropertyDescriptor<any>\n    ) {\n      const flavour = Decoration.flavourResolver(target);\n      let decorators;\n      const extras = Decoration.decorators[key][flavour]\n        ? Decoration.decorators[key][flavour].extras\n        : Decoration.decorators[key][DefaultFlavour].extras;\n      if (\n        Decoration.decorators[key] &&\n        Decoration.decorators[key][flavour] &&\n        Decoration.decorators[key][flavour].decorators\n      ) {\n        decorators = Decoration.decorators[key][flavour].decorators;\n      } else {\n        decorators = Decoration.decorators[key][DefaultFlavour].decorators;\n      }\n      const toApply = [\n        ...(decorators ? decorators.values() : []),\n        ...(extras ? extras.values() : []),\n      ];\n      toApply.forEach((d) =>\n        (d as any)(target, propertyKey, descriptor, descriptor)\n      );\n    };\n    Object.defineProperty(contextDecorator, \"name\", {\n      value: [f, key].join(\"_decorator_for_\"),\n      writable: false,\n    });\n    return contextDecorator;\n  }\n\n  /**\n   * @description Creates the final decorator function\n   * @summary Builds and returns the decorator factory function\n   * @return {function(any, any?, TypedPropertyDescriptor?): any} The generated decorator function\n   */\n  apply(): (\n    target: any,\n    propertyKey?: any,\n    descriptor?: TypedPropertyDescriptor<any>\n  ) => any {\n    if (!this.key)\n      throw new Error(\"No key provided for the decoration builder\");\n    Decoration.register(this.key, this.flavour, this.decorators, this.extras);\n    return this.decoratorFactory(this.key, this.flavour);\n  }\n\n  /**\n   * @description Registers decorators for a specific key and flavour\n   * @summary Internal method to store decorators in the static registry\n   * @param {string} key Decorator key\n   * @param {string} flavour Decorator flavour\n   * @param [decorators] Primary decorators\n   * @param [extras] Additional decorators\n   */\n  private static register(\n    key: string,\n    flavour: string,\n    decorators?: Set<ClassDecorator | PropertyDecorator | MethodDecorator>,\n    extras?: Set<ClassDecorator | PropertyDecorator | MethodDecorator>\n  ) {\n    if (!key) throw new Error(\"No key provided for the decoration builder\");\n    if (!decorators)\n      throw new Error(\"No decorators provided for the decoration builder\");\n    if (!flavour)\n      throw new Error(\"No flavour provided for the decoration builder\");\n\n    if (!Decoration.decorators[key]) Decoration.decorators[key] = {};\n    if (!Decoration.decorators[key][flavour])\n      Decoration.decorators[key][flavour] = {};\n    if (decorators) Decoration.decorators[key][flavour].decorators = decorators;\n    if (extras) Decoration.decorators[key][flavour].extras = extras;\n  }\n\n  /**\n   * @description Sets the global flavour resolver\n   * @summary Configures the function used to determine decorator flavours\n   * @param {FlavourResolver} resolver Function to resolve flavours\n   */\n  static setFlavourResolver(resolver: FlavourResolver) {\n    Decoration.flavourResolver = resolver;\n  }\n\n  static for(key: string): DecorationBuilderMid {\n    return new Decoration().for(key);\n  }\n\n  static flavouredAs(flavour: string): DecorationBuilderStart {\n    return new Decoration(flavour);\n  }\n}\n","import { apply, metadata } from \"@decaf-ts/reflection\";\nimport { ModelKeys } from \"./constants\";\n\n/**\n * @description Property decorator factory for model attributes\n * @summary Creates a decorator that marks class properties as model attributes\n *\n * @param {string} [key=ModelKeys.ATTRIBUTE] - The metadata key under which to store the property name\n * @return {function(object, any?): void} - Decorator function that registers the property\n * @function prop\n * @category Property Decorators\n *\n * @mermaid\n * sequenceDiagram\n *    participant D as Decorator\n *    participant M as Model\n *\n *    D->>M: Check if key exists\n *    alt key exists\n *        M-->>D: Return existing props array\n *    else key doesn't exist\n *        D->>M: Create new props array\n *    end\n *    D->>M: Check if property exists\n *    alt property not in array\n *        D->>M: Add property to array\n *    end\n */\nexport function prop(key: string = ModelKeys.ATTRIBUTE) {\n  return (model: object, propertyKey?: any): void => {\n    let props: string[];\n    if (Object.prototype.hasOwnProperty.call(model, key)) {\n      props = (model as any)[key];\n    } else {\n      props = (model as any)[key] = [];\n    }\n    if (!props.includes(propertyKey as string))\n      props.push(propertyKey as string);\n  };\n}\n\n/**\n * @description Combined property decorator factory for metadata and attribute marking\n * @summary Creates a decorator that both marks a property as a model attribute and assigns metadata to it\n *\n * @template V\n * @param {string} key - The metadata key\n * @param {V} value - The metadata value to associate with the property\n * @return {Function} - Combined decorator function\n * @function propMetadata\n * @category Property Decorators\n */\nexport function propMetadata<V>(key: string, value: V) {\n  return apply(prop(), metadata<V>(key, value));\n}\n","/**\n * @summary Mimics Java's String's Hash implementation\n *\n * @param {string | number | symbol | Date} obj\n * @return {number} hash value of obj\n *\n * @function hashCode\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport function hashCode(obj: string | number | symbol | Date): string {\n  obj = String(obj);\n  let hash = 0;\n  for (let i = 0; i < obj.length; i++) {\n    const character = obj.charCodeAt(i);\n    hash = (hash << 5) - hash + character;\n    hash = hash & hash; // Convert to 32bit integer\n  }\n  return hash.toString();\n}\n\n/**\n * @summary Defines teh type for a Hashing function\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport type HashingFunction = (value: any, ...args: any[]) => string;\n\n/**\n * @summary Hashes an object by combining the hash of all its properties\n *\n * @param {Record<string, any>} obj\n * @return {string} the resulting hash\n *\n * @function hashObj\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport function hashObj(obj: Record<string, any> | any[]): string {\n  const hashReducer = function (h: number | string, el: any): string | number {\n    const elHash = hashFunction(el);\n\n    if (typeof elHash === \"string\")\n      return hashFunction(((h as string) || \"\") + hashFunction(el));\n\n    h = h || 0;\n    h = ((h as number) << 5) - (h as number) + elHash;\n    return h & h;\n  };\n\n  const func: HashingFunction = hashCode;\n\n  const hashFunction = function (value: any): string | number {\n    if (typeof value === \"undefined\") return \"\";\n    if ([\"string\", \"number\", \"symbol\"].indexOf(typeof value) !== -1)\n      return func(value.toString());\n    if (value instanceof Date) return func(value.getTime());\n    if (Array.isArray(value)) return value.reduce(hashReducer, undefined);\n    return (Object.values(value) as (string | number)[]).reduce(\n      hashReducer,\n      undefined as unknown as string | number\n    );\n  };\n\n  const result = Object.values(obj).reduce(hashReducer, 0);\n\n  return (typeof result === \"number\" ? Math.abs(result) : result).toString();\n}\n\nexport const DefaultHashingMethod = \"default\";\n\n/**\n * @description Manages hashing methods and provides a unified hashing interface\n * @summary A utility class that provides a registry for different hashing functions and methods to hash objects.\n * The class maintains a cache of registered hashing functions and allows setting a default hashing method.\n * It prevents direct instantiation and provides static methods for registration and hashing.\n *\n * @class Hashing\n * @category Model\n *\n * @example\n * ```typescript\n * // Register a custom hashing function\n * Hashing.register('md5', (obj) => createMD5Hash(obj), true);\n *\n * // Hash an object using default method\n * const hash1 = Hashing.hash(myObject);\n *\n * // Hash using specific method\n * const hash2 = Hashing.hash(myObject, 'md5');\n * ```\n */\nexport class Hashing {\n  /**\n   * @description Current default hashing method identifier\n   * @private\n   */\n  private static current: string = DefaultHashingMethod;\n\n  /**\n   * @description Cache of registered hashing functions\n   * @private\n   */\n  private static cache: Record<string, HashingFunction> = {\n    default: hashObj,\n  };\n\n  private constructor() {}\n\n  /**\n   * @description Retrieves a registered hashing function\n   * @summary Fetches a hashing function from the cache by its key. Throws an error if the method is not registered.\n   *\n   * @param {string} key - The identifier of the hashing function to retrieve\n   * @return {HashingFunction} The requested hashing function\n   * @private\n   */\n  private static get(key: string): any {\n    if (key in this.cache) return this.cache[key];\n    throw new Error(`No hashing method registered under ${key}`);\n  }\n\n  /**\n   * @description Registers a new hashing function\n   * @summary Adds a new hashing function to the registry. Optionally sets it as the default method.\n   * Throws an error if a method with the same key is already registered.\n   *\n   * @param {string} key - The identifier for the hashing function\n   */\n  static register(\n    key: string,\n    func: HashingFunction,\n    setDefault = false\n  ): void {\n    if (key in this.cache)\n      throw new Error(`Hashing method ${key} already registered`);\n    this.cache[key] = func;\n    if (setDefault) this.current = key;\n  }\n\n  static hash(obj: any, method?: string, ...args: any[]) {\n    if (!method) return this.get(this.current)(obj, ...args);\n    return this.get(method)(obj, ...args);\n  }\n\n  static setDefault(method: string) {\n    this.current = this.get(method);\n  }\n}\n","import { COMPARISON_ERROR_MESSAGES, VALIDATION_PARENT_KEY } from \"../constants\";\nimport { sf } from \"./strings\";\n\nconst fallbackGetParent = (target: any) => {\n  return target[VALIDATION_PARENT_KEY];\n};\n\nconst fallbackGetValue = (target: any, prop: string) => {\n  if (!Object.prototype.hasOwnProperty.call(target, prop))\n    throw new Error(sf(COMPARISON_ERROR_MESSAGES.PROPERTY_NOT_EXIST, prop));\n  return target[prop];\n};\n\n/**\n * Proxy object that provides path-based access to nested properties\n * @template T - The type of the target object being proxied\n */\nexport type PathProxy<T> = T & {\n  // [PROXY_PROP]: boolean;\n  getValueFromPath: (path: string, fallback?: any) => any;\n};\n\n/**\n * Standard path resolution utility for accessing nested object properties.\n * Provides consistent dot-notation access to both parent and child properties\n * across complex object structures.\n *\n * - Dot-notation path resolution ('object.child.property')\n * - Parent traversal using '../' notation\n * - Configurable property access behavior\n * - Null/undefined safety checks\n */\nexport class PathProxyEngine {\n  /**\n   * Creates a path-aware proxy for the target object\n   * @template T - The type of the target object\n   * @param {T} rootTarget - The target object to proxy\n   * @param opts - Configuration options\n   * @param opts.getValue - Custom function to get property value\n   * @param opts.getParent - Custom function to get parent object\n   * @param opts.ignoreUndefined - Whether to ignore undefined values in paths\n   * @param opts.ignoreNull - Whether to ignore null values in paths\n   * @returns A proxy object with path access capabilities\n   */\n  static create<T extends object>(\n    rootTarget: T,\n    opts?: {\n      getValue?: (target: T, prop: string) => any;\n      getParent?: (target: T) => any;\n      ignoreUndefined: boolean;\n      ignoreNull: boolean;\n    }\n  ): PathProxy<T> {\n    const { getValue, getParent, ignoreUndefined, ignoreNull } = {\n      getParent: fallbackGetParent,\n      getValue: fallbackGetValue,\n      ignoreNull: false,\n      ignoreUndefined: false,\n      ...opts,\n    };\n\n    const proxy = new Proxy({} as any, {\n      get(target, prop) {\n        if (prop === \"getValueFromPath\") {\n          return function (path: string): any {\n            const parts = PathProxyEngine.parsePath(path);\n            let current: any = rootTarget;\n\n            for (let i = 0; i < parts.length; i++) {\n              const part = parts[i];\n              if (part === \"..\") {\n                const parent = getParent(current);\n                if (!parent || typeof parent !== \"object\") {\n                  throw new Error(\n                    sf(\n                      COMPARISON_ERROR_MESSAGES.CONTEXT_NOT_OBJECT_COMPARISON,\n                      i + 1,\n                      path\n                    )\n                  );\n                }\n                current = parent; //PathProxyEngine.create(parentTarget, opts);\n                continue;\n              }\n\n              current = getValue(current, part);\n              if (!ignoreUndefined && typeof current === \"undefined\")\n                throw new Error(\n                  sf(COMPARISON_ERROR_MESSAGES.PROPERTY_INVALID, path, part)\n                );\n\n              if (!ignoreNull && current === null)\n                throw new Error(\n                  sf(COMPARISON_ERROR_MESSAGES.PROPERTY_INVALID, path, part)\n                );\n            }\n\n            return current;\n          };\n        }\n\n        return target[prop];\n      },\n    });\n\n    // Object.defineProperty(proxy, PROXY_PROP, {\n    //   value: true, // overwrite by proxy behavior\n    //   enumerable: false,\n    //   configurable: false,\n    //   writable: false,\n    // });\n\n    return proxy as PathProxy<T>;\n  }\n\n  /**\n   * Parses a path string into individual components\n   * @param path - The path string to parse (e.g., \"user.address.city\")\n   * @returns An array of path components\n   * @throws Error if the path is invalid\n   */\n  private static parsePath(path: string): string[] {\n    if (typeof path !== \"string\" || !path.trim())\n      throw new Error(sf(COMPARISON_ERROR_MESSAGES.INVALID_PATH, path));\n    return path.match(/(\\.\\.|[^/.]+)/g) || [];\n  }\n}\n","import { ModelErrors } from \"../validation/types\";\n\n/**\n * @summary Helper Class to hold the error results\n * @description holds error results in an 'indexable' manner\n * while still providing the same result on toString\n *\n * @param {ModelErrors} errors\n *\n * @class ModelErrorDefinition\n *\n * @category Model\n */\nexport class ModelErrorDefinition {\n  [indexer: string]:\n    | Record<string, string | undefined>\n    | (() => string | undefined);\n\n  constructor(errors: ModelErrors) {\n    for (const prop in errors) {\n      if (Object.prototype.hasOwnProperty.call(errors, prop) && errors[prop])\n        Object.defineProperty(this as any, prop, {\n          enumerable: true,\n          configurable: false,\n          value: errors[prop],\n          writable: false,\n        });\n    }\n  }\n\n  /**\n   * @summary Outputs the class to a nice readable string\n   *\n   * @override\n   */\n  toString(): string {\n    const self: any = this as any;\n    return Object.keys(self)\n      .filter(\n        (k) =>\n          Object.prototype.hasOwnProperty.call(self, k) &&\n          typeof self[k] !== \"function\"\n      )\n      .reduce((accum: string, prop) => {\n        let propError: string | undefined = Object.keys(self[prop]).reduce(\n          (propAccum: undefined | string, key) => {\n            if (!propAccum) propAccum = self[prop][key];\n            else propAccum += `\\n${self[prop][key]}`;\n            return propAccum;\n          },\n          undefined\n        );\n\n        if (propError) {\n          propError = `${prop} - ${propError}`;\n          if (!accum) accum = propError;\n          else accum += `\\n${propError}`;\n        }\n\n        return accum;\n      }, \"\");\n  }\n}\n","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\";\nimport type { ConditionalAsync } from \"../../types\";\n\n/**\n * @description Abstract base class for all validators in the validation framework.\n * @summary The BaseValidator class provides the foundation for all synchronous and asynchronous validator implementations.\n * It handles type checking, error message formatting, and defines the interface that all validators must implement.\n * This class is designed to be extended by specific validator classes that define their own validation logic.\n *\n * @template V - Validator options type\n * @template IsAsync - Whether the validator is async (true) or sync (false). Default `false`.\n *\n * @param {boolean} async - Defines if the validator is async (must match the subclass signature)\n * @param {string} message - Default error message to display when validation fails (defaults to {@link DEFAULT_ERROR_MESSAGES#DEFAULT})\n * @param {string[]} acceptedTypes - Type names that this validator accepts (used for runtime type checking)\n *\n * @class BaseValidator\n * @abstract\n *\n * @example\n * // Example of a synchronous validator\n * class SyncValidator extends BaseValidator<SomeOptions, false> {\n *   constructor() {\n *     super(false, \"Sync validation failed\", String.name);\n *   }\n *\n *   public hasErrors(value: any, options?: SomeOptions): string | undefined {\n *     if (typeof value !== \"string\") return this.getMessage(this.message);\n *     return undefined;\n *   }\n * }\n *\n * @example\n * // Example of an asynchronous custom validator\n * class AsyncValidator extends BaseValidator<SomeOptions, true> {\n *   constructor() {\n *     super(true, \"Async validation failed\", String.name);\n *   }\n *\n *   public async hasErrors(value: any, options?: SomeOptions): Promise<string | undefined> {\n *     const result = await someAsyncCheck(value);\n *     if (!result) return this.getMessage(this.message);\n *     return undefined;\n *   }\n * }\n *\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant V as Validator Subclass\n *   participant B as BaseValidator\n *\n *   C->>V: new CustomValidator(async, message)\n *   V->>B: super(async, message, acceptedTypes)\n *   B->>B: Store message, async flag, and accepted types\n *   B->>B: Optionally 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 BaseValidator<\n  V extends ValidatorOptions = ValidatorOptions,\n  Async extends boolean = false,\n> {\n  readonly message: string;\n  readonly acceptedTypes?: string[];\n  readonly async?: Async;\n\n  protected constructor(\n    async: Async,\n    message: string = DEFAULT_ERROR_MESSAGES.DEFAULT,\n    ...acceptedTypes: string[]\n  ) {\n    this.async = async;\n    this.message = message;\n\n    if (acceptedTypes.length) this.acceptedTypes = acceptedTypes;\n    if (this.acceptedTypes)\n      this.hasErrors = this.checkTypeAndHasErrors(\n        this.hasErrors.bind(this) as any\n      ) as any;\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: (\n      value: any,\n      options?: V,\n      proxy?: PathProxy<any>,\n      ...args: any[]\n    ) => ConditionalAsync<Async, string | undefined>\n  ) {\n    return function (\n      this: BaseValidator,\n      value: any,\n      options: V,\n      proxy?: PathProxy<any>,\n      ...args: any[]\n    ) {\n      if (value === undefined || !this.acceptedTypes)\n        return unbound(value, options, proxy, ...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, options, proxy, ...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  ): ConditionalAsync<Async, 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","import { DEFAULT_ERROR_MESSAGES } from \"./constants\";\nimport { ValidatorOptions } from \"../types\";\nimport type { PathProxy } from \"../../utils\";\nimport { BaseValidator } from \"./BaseValidator\";\n\n/**\n * @description\n * Abstract class for defining synchronous validators.\n *\n * This class extends the base {@link BaseValidator} and enforces that any implementation of `hasErrors` must be synchronous.\n *\n * Use this when the validation process is immediate and does not require asynchronous operations.\n *\n * @example\n * ```typescript\n * // Example of a synchronous validator that checks if a number is greater than\n * class GreaterThanValidator extends Validator<{ gt?: number }> {\n *   constructor(message: string = \"Value must be greater than {0}\") {\n *     super(message);\n *   }\n *\n *   hasErrors(value: number, options?: { gt?: number }) {\n *     const minValue = options?.gt ?? 0;\n *     if (value <= minValue) {\n *       return this.getMessage();\n *     }\n *     return undefined;\n *   }\n * }\n *\n * // Example usage:\n * const validator = new GreaterThanValidator();\n * const error = validator.hasErrors(10, { gt: 15 });\n * if (error) {\n *   console.log('Value must be greater than 15')\n * } else {\n *   console.log('Value is valid');\n * }\n * ```\n *\n * - If `value` is less than or equal to `gt`, returns the error message.\n * - Otherwise, returns `undefined` indicating validation success.\n *\n * @see {@link BaseValidator} For the base validator.\n * @see {@link ValidatorOptions} For the base validator options.\n */\nexport abstract class Validator<\n  V extends ValidatorOptions = ValidatorOptions,\n> extends BaseValidator<V, false> {\n  protected constructor(\n    message: string = DEFAULT_ERROR_MESSAGES.DEFAULT,\n    ...acceptedTypes: string[]\n  ) {\n    super(false, message, ...acceptedTypes);\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  abstract override hasErrors(\n    value: any,\n    options?: V,\n    proxy?: PathProxy<any>\n  ): string | undefined;\n}\n","import { ValidatorDefinition } from \"../types\";\nimport { IValidatorRegistry } from \"../types\";\nimport { Validator } from \"./Validator\";\n\n/**\n * @summary Base Implementation of a Validator Registry\n *\n * @prop {Validator[]} [validators] the initial validators to register\n *\n * @class ValidatorRegistry\n * @implements IValidatorRegistry<T>\n *\n * @category Validation\n */\nexport class ValidatorRegistry<T extends Validator>\n  implements IValidatorRegistry<T>\n{\n  private cache: any = {};\n  private customKeyCache: Record<string, string>;\n\n  constructor(...validators: (ValidatorDefinition | Validator)[]) {\n    this.customKeyCache = {};\n    this.register(...validators);\n  }\n\n  /**\n   * @summary retrieves the custom keys\n   */\n  getCustomKeys(): { [indexer: string]: string } {\n    return Object.assign({}, this.customKeyCache);\n  }\n\n  /**\n   * @summary retrieves the registered validators keys\n   */\n  getKeys(): string[] {\n    return Object.keys(this.cache);\n  }\n\n  /**\n   * @summary Retrieves a validator\n   *\n   * @param {string} validatorKey one of the {@link ValidationKeys}\n   * @return {Validator | undefined} the registered Validator or undefined if there is nono matching the provided key\n   */\n  get<T extends Validator>(validatorKey: string): T | undefined {\n    if (!(validatorKey in this.cache)) return undefined;\n\n    const classOrInstance = this.cache[validatorKey];\n    if (Validator.isValidator(classOrInstance)) return classOrInstance as T;\n    const constructor = classOrInstance.default || classOrInstance;\n    const instance = new constructor();\n    this.cache[validatorKey] = instance;\n    return instance;\n  }\n\n  /**\n   * @summary Registers the provided validators onto the registry\n   *\n   * @param {T[] | ValidatorDefinition[]} validator\n   */\n  register<T extends Validator>(\n    ...validator: (ValidatorDefinition | T)[]\n  ): void {\n    validator.forEach((v) => {\n      if (Validator.isValidator(v)) {\n        // const k =\n\n        if ((v as ValidatorDefinition).validationKey in this.cache) return;\n        this.cache[(v as ValidatorDefinition).validationKey] = v;\n      } else {\n        const { validationKey, validator, save } = v as ValidatorDefinition;\n        if (validationKey in this.cache) return;\n        this.cache[validationKey] = validator;\n        if (!save) return;\n        const obj: Record<string, string> = {};\n        obj[validationKey.toUpperCase()] = validationKey;\n\n        this.customKeyCache = Object.assign({}, this.customKeyCache, obj);\n      }\n    });\n  }\n}\n","import { Validator } from \"./Validators/Validator\";\nimport { IValidatorRegistry, ValidatorDefinition } from \"./types\";\nimport { ValidatorRegistry } from \"./Validators/ValidatorRegistry\";\nimport { ValidationKeys } from \"./Validators/constants\";\n\n/**\n * @summary Static class acting as a namespace for the Validation\n *\n * @class Validation\n * @static\n *\n * @category Validation\n */\nexport class Validation {\n  private static actingValidatorRegistry?: IValidatorRegistry<Validator> =\n    undefined;\n\n  private static loadedDecorators: Record<string, PropertyDecorator> = {};\n  private constructor() {}\n\n  /**\n   * @summary Defines the acting ValidatorRegistry\n   *\n   * @param {IValidatorRegistry} validatorRegistry the new implementation of the validator Registry\n   * @param {function(Validator): Validator} [migrationHandler] the method to map the validator if required;\n   */\n  static setRegistry(\n    validatorRegistry: IValidatorRegistry<Validator>,\n    migrationHandler?: (validator: Validator) => Validator\n  ) {\n    if (migrationHandler && Validation.actingValidatorRegistry)\n      Validation.actingValidatorRegistry.getKeys().forEach((k: string) => {\n        const validator = validatorRegistry.get(k);\n        if (validator) validatorRegistry.register(migrationHandler(validator));\n      });\n    Validation.actingValidatorRegistry = validatorRegistry;\n  }\n\n  /**\n   * @summary Returns the current ValidatorRegistry\n   *\n   * @return IValidatorRegistry, defaults to {@link ValidatorRegistry}\n   */\n  private static getRegistry() {\n    if (!Validation.actingValidatorRegistry)\n      Validation.actingValidatorRegistry = new ValidatorRegistry();\n    return Validation.actingValidatorRegistry;\n  }\n\n  /**\n   * @summary Retrieves a validator\n   *\n   * @param {string} validatorKey one of the {@link ValidationKeys}\n   * @return {Validator | undefined} the registered Validator or undefined if there is nono matching the provided key\n   */\n  static get<T extends Validator>(validatorKey: string): T | undefined {\n    return Validation.getRegistry().get(validatorKey);\n  }\n\n  /**\n   * @summary Registers the provided validators onto the registry\n   *\n   * @param {T[] | ValidatorDefinition[]} validator\n   */\n  static register<T extends Validator>(\n    ...validator: (ValidatorDefinition | T)[]\n  ): void {\n    return Validation.getRegistry().register(...validator);\n  }\n\n  /**\n   * @summary Builds the key to store as Metadata under Reflections\n   * @description concatenates {@link ValidationKeys#REFLECT} with the provided key\n   *\n   * @param {string} key\n   */\n  static key(key: string) {\n    return ValidationKeys.REFLECT + key;\n  }\n\n  /**\n   * @summary Returns all registered validation keys\n   */\n  static keys() {\n    return this.getRegistry().getKeys();\n  }\n\n  static registerDecorator(key: string, decorator: PropertyDecorator) {\n    if (key in this.loadedDecorators) return;\n    this.loadedDecorators[key] = decorator;\n  }\n\n  static decoratorFromKey(key: string) {\n    if (!(key in this.loadedDecorators))\n      throw new Error(`No decorator registered under ${key}`);\n    return this.loadedDecorators[key];\n  }\n}\n","import { ModelKeys } from \"../utils/constants\";\nimport { ConditionalAsync } from \"../types\";\nimport { Model } from \"./Model\";\n\nexport function getModelKey(str: string) {\n  return ModelKeys.REFLECT + str;\n}\n\nexport function getMetadata<M extends Model>(model: M) {\n  const metadata = Reflect.getMetadata(\n    getModelKey(ModelKeys.MODEL),\n    model.constructor\n  );\n  if (!metadata)\n    throw new Error(\n      \"could not find metadata for provided \" + model.constructor.name\n    );\n  return metadata;\n}\n\n/**\n * Wraps a value in a Promise if the `async` flag is true.\n *\n * @template T - The type of the value being wrapped.\n * @template Async - A boolean type that determines if the result should be wrapped in a Promise.\n *\n * @param value - The value to return directly or wrap in a Promise.\n * @param async - If true, the value is wrapped in a resolved Promise. If false or undefined, the value is returned as-is.\n *\n * @returns The original value or a Promise resolving to it, depending on the `async` flag.\n */\nexport function toConditionalPromise<T, Async extends boolean>(\n  value: T,\n  async?: Async\n): ConditionalAsync<Async, T> {\n  return (async ? Promise.resolve(value) : value) as ConditionalAsync<Async, T>;\n}\n","import { ModelErrorDefinition } from \"./ModelErrorDefinition\";\nimport { ModelKeys } from \"../utils/constants\";\nimport { Model } from \"./Model\";\nimport { Validation } from \"../validation/Validation\";\nimport { ValidationKeys } from \"../validation/Validators/constants\";\nimport {\n  ModelErrors,\n  ValidationPropertyDecoratorDefinition,\n  ValidatorOptions,\n} from \"../validation\";\nimport { PathProxyEngine } from \"../utils/PathProxy\";\nimport { ASYNC_META_KEY, VALIDATION_PARENT_KEY } from \"../constants\";\nimport { ConditionalAsync, DecoratorMetadataAsync } from \"../types\";\nimport { Reflection } from \"@decaf-ts/reflection\";\nimport { toConditionalPromise } from \"./utils\";\n\n/**\n * Retrieves the validation metadata decorators associated with a specific property of a model,\n * using the reflective metadata key.\n *\n * @param model - The model instance or class containing the decorated property.\n * @param {string} prop - The name of the property whose decorators should be retrieved.\n * @param {string} reflectKey - The metadata key used to retrieve the decorators.\n *                     Defaults to `ValidationKeys.REFLECT`.\n *\n * @returns The validation decorators applied to the property\n */\nexport function getValidationDecorators(\n  model: Record<string, any>,\n  prop: string,\n  reflectKey: string = ValidationKeys.REFLECT\n): ValidationPropertyDecoratorDefinition {\n  return Reflection.getPropertyDecorators(\n    reflectKey,\n    model,\n    prop\n  ) as unknown as ValidationPropertyDecoratorDefinition;\n}\n\n/**\n * @description\n * Retrieves all validatable property decorators from a given model, excluding specified properties.\n *\n * @summary\n * Iterates through the own enumerable properties of a model instance, filtering out any properties\n * listed in the `propsToIgnore` array. For each remaining property, it checks whether validation\n * decorators are present using `getValidationDecorators`, and if so, collects them in the result array.\n *\n * @template M - A generic parameter extending the `Model` class, representing the model type being inspected.\n *\n * @param {M} model - An instance of a class extending `Model` from which validatable properties will be extracted.\n * @param {string[]} propsToIgnore - An array of property names that should be excluded from validation inspection.\n *\n * @return {ValidationPropertyDecoratorDefinition[]} An array of validation decorator definitions\n * associated with the model's properties, excluding those listed in `propsToIgnore`.\n *\n * @function getValidatableProperties\n */\nexport function getValidatableProperties<M extends Model>(\n  model: M,\n  propsToIgnore: string[]\n): ValidationPropertyDecoratorDefinition[] {\n  const decoratedProperties: ValidationPropertyDecoratorDefinition[] = [];\n\n  for (const prop in model) {\n    if (\n      Object.prototype.hasOwnProperty.call(model, prop) &&\n      !propsToIgnore.includes(prop)\n    ) {\n      const dec = getValidationDecorators(model, prop);\n      if (dec) decoratedProperties.push(dec);\n    }\n  }\n\n  return decoratedProperties;\n}\n\n/**\n * Safely sets temporary metadata on an object\n */\nfunction setTemporaryContext(\n  target: any,\n  key: symbol | string,\n  value: unknown\n): void {\n  if (!Object.hasOwnProperty.call(target, key)) target[key] = value;\n}\n\n/**\n * Safely removes temporary metadata from an object\n */\nfunction cleanupTemporaryContext(target: any, key: symbol | string): void {\n  if (Object.hasOwnProperty.call(target, key)) delete target[key];\n}\n\n/**\n * Executes validation with temporary context and returns the validation result\n *\n * @param nestedModel - The instance to validate\n * @param parentModel - Reference to a parent object for nested validation\n * @param isAsync - Whether to perform async validation\n * @returns Validation result from hasErrors()\n */\nfunction getNestedValidationErrors<\n  M extends Model,\n  Async extends boolean = false,\n>(\n  nestedModel: M,\n  parentModel?: M,\n  isAsync?: Async\n): ConditionalAsync<Async, ModelErrorDefinition | undefined> {\n  // Set temporary context for nested models\n  if (parentModel) {\n    setTemporaryContext(nestedModel, VALIDATION_PARENT_KEY, parentModel);\n  }\n  setTemporaryContext(nestedModel, ASYNC_META_KEY, !!isAsync);\n\n  const errs = nestedModel.hasErrors();\n  cleanupTemporaryContext(nestedModel, VALIDATION_PARENT_KEY);\n  cleanupTemporaryContext(nestedModel, ASYNC_META_KEY);\n  return errs as any;\n}\n\nexport function validateDecorator<\n  M extends Model,\n  Async extends boolean = false,\n>(\n  model: M,\n  value: any,\n  decorator: DecoratorMetadataAsync,\n  async?: Async\n): ConditionalAsync<Async, string | undefined> {\n  const validator = Validation.get(decorator.key);\n  if (!validator) {\n    throw new Error(`Missing validator for ${decorator.key}`);\n  }\n\n  // skip async decorators if validateDecorators is called synchronously (async = false)\n  if (!async && decorator.props.async) return undefined as any;\n\n  const decoratorProps =\n    decorator.key === ModelKeys.TYPE\n      ? [decorator.props]\n      : decorator.props || {};\n\n  const context = PathProxyEngine.create(model, {\n    ignoreUndefined: true,\n    ignoreNull: true,\n  });\n\n  const maybeAsyncErrors = validator.hasErrors(\n    value,\n    decoratorProps as ValidatorOptions,\n    context\n  );\n\n  return toConditionalPromise(maybeAsyncErrors, async);\n}\n\n/**\n * @description\n * Executes validation logic for a set of decorators applied to a model's property, handling both\n * synchronous and asynchronous validations, including support for nested validations and lists.\n *\n * @summary\n * Iterates over an array of decorator metadata objects and applies each validation rule to the\n * provided value. For list decorators (`ValidationKeys.LIST`), it performs element-wise validation,\n * supporting nested model validation and type checks. If the `async` flag is set, asynchronous\n * validation is supported using `Promise.all`. The result is a record mapping validation keys to\n * error messages, or `undefined` if no errors are found.\n *\n * @template M - A type parameter extending `Model`, representing the model type being validated.\n * @template Async - A boolean indicating whether validation should be performed asynchronously.\n *\n * @param {M} model - The model instance that the validation is associated with.\n * @param {any} value - The value to be validated against the provided decorators.\n * @param {DecoratorMetadataAsync[]} decorators - An array of metadata objects representing validation decorators.\n * @param {Async} [async] - Optional flag indicating whether validation should be performed asynchronously.\n *\n * @return {ConditionalAsync<Async, Record<string, string>> | undefined}\n * Returns either a record of validation errors (keyed by the decorator key) or `undefined` if no errors are found.\n * If `async` is true, the return value is a Promise resolving to the same structure.\n *\n * @function validateDecorators\n */\nexport function validateDecorators<\n  M extends Model,\n  Async extends boolean = false,\n>(\n  model: M,\n  value: any,\n  decorators: DecoratorMetadataAsync[],\n  async?: Async\n): ConditionalAsync<Async, Record<string, string> | undefined> {\n  const result: Record<string, string | Promise<string>> = {};\n\n  for (const decorator of decorators) {\n    // skip async decorators if validateDecorators is called synchronously (async = false)\n    if (!async && decorator.props.async) continue;\n\n    let validationErrors = validateDecorator(model, value, decorator, async);\n\n    /*\n    If the decorator is a list, each element must be checked.\n    When 'async' is true, the 'err' will always be a pending promise initially,\n    so the '!err' check will evaluate to false (even if the promise later resolves with no errors)\n    */\n    if (decorator.key === ValidationKeys.LIST && (!validationErrors || async)) {\n      const values = value instanceof Set ? [...value] : value;\n      if (values && values.length > 0) {\n        const types =\n          decorator.props.class ||\n          decorator.props.clazz ||\n          decorator.props.customTypes;\n\n        const allowedTypes = [types].flat().map((t) => String(t).toLowerCase());\n        // const reserved = Object.values(ReservedModels).map((v) => v.toLowerCase()) as string[];\n\n        const errs = values.map((childValue: any) => {\n          // if (Model.isModel(v) && !reserved.includes(v) {\n          if (Model.isModel(childValue)) {\n            return getNestedValidationErrors(childValue, model, async);\n          }\n\n          return allowedTypes.includes(typeof childValue)\n            ? undefined\n            : \"Value has no validatable type\";\n        });\n\n        if (async) {\n          validationErrors = Promise.all(errs).then((result) => {\n            const allEmpty = result.every((r) => !r);\n            return allEmpty ? undefined : result;\n          }) as any;\n        } else {\n          const allEmpty = errs.every((r: string | undefined) => !r);\n          validationErrors = errs.length > 0 && !allEmpty ? errs : undefined;\n        }\n      }\n    }\n\n    if (validationErrors) (result as any)[decorator.key] = validationErrors;\n  }\n\n  if (!async)\n    return Object.keys(result).length > 0\n      ? (result as any)\n      : (undefined as any);\n\n  const keys = Object.keys(result);\n  const promises = Object.values(result) as Promise<string | undefined>[];\n  return Promise.all(promises).then((resolvedValues) => {\n    const res: Record<string, string> = {};\n    for (let i = 0; i < resolvedValues.length; i++) {\n      const val = resolvedValues[i];\n      if (val !== undefined) {\n        res[keys[i]] = val;\n      }\n    }\n    return Object.keys(res).length > 0 ? res : undefined;\n  }) as any;\n}\n\n/**\n * @function validate\n * @template M\n * @template Async\n * @memberOf module:decorator-validation\n * @category Model\n *\n * @description\n * Validates the properties of a {@link Model} instance using registered decorators.\n * Supports both synchronous and asynchronous validation flows, depending on the `async` flag.\n *\n * @summary\n * This function inspects a given model object, identifies decorated properties that require validation,\n * and applies the corresponding validation rules. It also supports nested model validation and gracefully\n * merges any validation errors. For collections (Array/Set), it enforces the presence of the `@list` decorator\n * and checks the type of elements. If a property is a nested model, it will call `hasErrors` on it and flatten\n * the nested error keys using dot notation.\n *\n * @param {M} model - The model instance to be validated. Must extend from {@link Model}.\n * @param {Async} [async] - A flag indicating whether validation should be asynchronous.\n * @param {...string} propsToIgnore - A variadic list of property names that should be skipped during validation.\n *\n * @returns {ConditionalAsync<Async, ModelErrorDefinition | undefined>}\n * Returns either a {@link ModelErrorDefinition} containing validation errors,\n * or `undefined` if no errors are found. When `async` is `true`, returns a Promise.\n *\n * @see {@link Model}\n * @see {@link ModelErrorDefinition}\n * @see {@link validateDecorators}\n * @see {@link getValidatableProperties}\n *\n * @mermaid\n * sequenceDiagram\n *     participant Caller\n *     participant validate\n *     participant getValidatableProperties\n *     participant validateDecorators\n *     participant ModelInstance\n *     Caller->>validate: call with obj, async, propsToIgnore\n *     validate->>getValidatableProperties: retrieve decorated props\n *     loop for each property\n *         validate->>validateDecorators: validate using decorators\n *         alt is nested model\n *             validate->>ModelInstance: call hasErrors()\n *         end\n *     end\n *     alt async\n *         validate->>validate: Promise.allSettled for errors\n *     end\n *     validate-->>Caller: return ModelErrorDefinition | undefined\n */\nexport function validate<\n  M extends Model<boolean>,\n  Async extends boolean = false,\n>(\n  model: M,\n  async: Async,\n  ...propsToIgnore: string[]\n): ConditionalAsync<Async, ModelErrorDefinition | undefined> {\n  const decoratedProperties: ValidationPropertyDecoratorDefinition[] =\n    getValidatableProperties(model, propsToIgnore);\n\n  const result: Record<string, any> = {};\n  const nestedErrors: Record<string, any> = {};\n\n  for (const { prop, decorators } of decoratedProperties) {\n    const propKey = String(prop);\n    let propValue = (model as any)[prop];\n\n    if (!decorators?.length) continue;\n\n    // Get the default type validator\n    const designTypeDec = decorators.find((d) => {\n      return [ModelKeys.TYPE, ValidationKeys.TYPE].includes(d.key as any);\n    });\n\n    if (!designTypeDec) continue;\n\n    const designType = designTypeDec.props.name;\n\n    // Handle array or Set types and enforce the presence of @list decorator\n    if ([Array.name, Set.name].includes(designType)) {\n      if (!decorators.some((d) => d.key === ValidationKeys.LIST)) {\n        result[propKey] = {\n          [ValidationKeys.TYPE]: `Array or Set property '${propKey}' requires a @list decorator`,\n        };\n        continue;\n      }\n\n      if (\n        propValue &&\n        !(Array.isArray(propValue) || propValue instanceof Set)\n      ) {\n        result[propKey] = {\n          [ValidationKeys.TYPE]: `Property '${String(prop)}' must be either an Array or a Set`,\n        };\n        continue;\n      }\n\n      // Remove design:type decorator, since @list decorator already ensures type\n      for (let i = decorators.length - 1; i >= 0; i--) {\n        if (decorators[i].key === ModelKeys.TYPE) {\n          decorators.splice(i, 1);\n        }\n      }\n      propValue = propValue instanceof Set ? [...propValue] : propValue;\n    }\n\n    const propErrors: Record<string, any> =\n      validateDecorators(model, propValue, decorators, async) || {};\n\n    // Check for nested properties.\n    // To prevent unnecessary processing, \"propValue\" must be defined and validatable\n    // let nestedErrors: Record<string, any> = {};\n    const isConstr = Model.isPropertyModel(model, propKey);\n    // if propValue !== undefined, null\n    if (propValue && isConstr) {\n      const instance: Model = propValue;\n      const isInvalidModel =\n        typeof instance !== \"object\" ||\n        !instance.hasErrors ||\n        typeof instance.hasErrors !== \"function\";\n\n      if (isInvalidModel) {\n        // propErrors[ValidationKeys.TYPE] = \"Model should be validatable but it's not.\";\n        console.warn(\"Model should be validatable but it's not.\");\n      } else {\n        nestedErrors[propKey] = getNestedValidationErrors(\n          instance,\n          model,\n          async\n        );\n      }\n    }\n\n    // Add to the result if we have any errors\n    // Async mode returns a Promise that resolves to undefined when no errors exist\n    if (Object.keys(propErrors).length > 0 || async)\n      result[propKey] = propErrors;\n\n    // Then merge any nested errors\n    if (!async) {\n      Object.entries(nestedErrors[propKey] || {}).forEach(([key, error]) => {\n        if (error !== undefined) {\n          result[`${propKey}.${key}`] = error;\n        }\n      });\n    }\n  }\n\n  // Synchronous return\n  if (!async) {\n    return (\n      Object.keys(result).length > 0\n        ? new ModelErrorDefinition(result)\n        : undefined\n    ) as any;\n  }\n\n  const merged: any = result; // TODO: apply filtering\n\n  const keys = Object.keys(merged);\n  const promises = Object.values(merged);\n  return Promise.allSettled(promises).then(async (results) => {\n    const result: ModelErrors = {};\n\n    for (const [parentProp, nestedErrPromise] of Object.entries(nestedErrors)) {\n      const nestedPropDecErrors = (await nestedErrPromise) as Record<\n        string,\n        any\n      >;\n\n      if (nestedPropDecErrors)\n        Object.entries(nestedPropDecErrors).forEach(\n          ([nestedProp, nestedPropDecError]) => {\n            if (nestedPropDecError !== undefined) {\n              const nestedKey = [parentProp, nestedProp].join(\".\");\n              result[nestedKey] = nestedPropDecError;\n            }\n          }\n        );\n    }\n\n    for (let i = 0; i < results.length; i++) {\n      const key = keys[i];\n      const res = results[i];\n\n      if (res.status === \"fulfilled\" && res.value !== undefined) {\n        (result as any)[key] = res.value;\n      } else if (res.status === \"rejected\") {\n        (result as any)[key] =\n          res.reason instanceof Error\n            ? res.reason.message\n            : String(res.reason || \"Validation failed\");\n      }\n    }\n\n    return Object.keys(result).length > 0\n      ? new ModelErrorDefinition(result)\n      : undefined;\n  }) as any;\n}\n","/**\n * @summary References the relevant JS primitives\n *\n * @property {string} STRING references the string primitive\n * @property {string} NUMBER references the number primitive\n * @property {string} BOOLEAN references the boolean primitive\n * @property {string} BIGINT references the bigint primitive\n *\n * @constant Primitives\n * @memberOf module:decorator-validation\n */\nexport enum Primitives {\n  STRING = \"string\",\n  NUMBER = \"number\",\n  BOOLEAN = \"boolean\",\n  BIGINT = \"bigint\",\n}\n\n/**\n * @summary References the Reserved model names to ignore during Model rebuilding\n *\n * @property {string} STRING\n * @property {string} OBJECT\n * @property {string} NUMBER\n * @property {string} BOOLEAN\n * @property {string} BIGINT\n * @property {string} DATE\n *\n * @constant ReservedModels\n * @memberOf module:decorator-validation\n */\nexport enum ReservedModels {\n  STRING = \"string\",\n  OBJECT = \"object\",\n  NUMBER = \"number\",\n  BOOLEAN = \"boolean\",\n  BIGINT = \"bigint\",\n  DATE = \"date\",\n}\n\n/**\n * @summary References the basic supported js types\n *\n * @property {string} string\n * @property {string} array\n * @property {string} number\n * @property {string} boolean\n * @property {string} symbol\n * @property {string} function\n * @property {string} object\n * @property {string} undefined\n * @property {string} null\n * @property {string} BIGINT\n *\n * @constant jsTypes\n * @memberOf module:decorator-validation\n */\nexport const jsTypes = [\n  \"string\",\n  \"array\",\n  \"number\",\n  \"boolean\",\n  \"symbol\",\n  \"function\",\n  \"object\",\n  \"undefined\",\n  \"null\",\n  \"bigint\",\n];\n","import { Serialization } from \"../utils/serialization\";\nimport { BuilderRegistry } from \"../utils/registry\";\nimport { ModelErrorDefinition } from \"./ModelErrorDefinition\";\nimport {\n  Comparable,\n  Constructor,\n  Hashable,\n  ModelArg,\n  ModelBuilderFunction,\n  ModelConstructor,\n  Serializable,\n  Validatable,\n} from \"./types\";\nimport { DecoratorMetadata, isEqual, Reflection } from \"@decaf-ts/reflection\";\nimport { validate } from \"./validation\";\nimport { Hashing } from \"../utils/hashing\";\nimport { ModelKeys } from \"../utils/constants\";\nimport { ValidationKeys } from \"../validation/Validators/constants\";\nimport { jsTypes, ReservedModels } from \"./constants\";\nimport { getMetadata, getModelKey } from \"./utils\";\nimport { ConditionalAsync } from \"../types\";\nimport { ASYNC_META_KEY } from \"../constants\";\n\nlet modelBuilderFunction: ModelBuilderFunction | undefined;\nlet actingModelRegistry: BuilderRegistry<any>;\n\n/**\n * @description Registry type for storing and retrieving model constructors\n * @summary The ModelRegistry type defines a registry for model constructors that extends\n * the BuilderRegistry interface. It provides a standardized way to register, retrieve,\n * and build model instances, enabling the model system to work with different types of models.\n *\n * @interface ModelRegistry\n * @template T Type of model that can be registered, must extend Model\n * @extends BuilderRegistry<T>\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport type ModelRegistry<T extends Model> = BuilderRegistry<T>;\n\n/**\n * @description Registry manager for model constructors that enables serialization and rebuilding\n * @summary The ModelRegistryManager implements the ModelRegistry interface and provides\n * functionality for registering, retrieving, and building model instances. It maintains\n * a cache of model constructors indexed by name, allowing for efficient lookup and instantiation.\n * This class is essential for the serialization and deserialization of model objects.\n *\n * @param {function(Record<string, any>): boolean} [testFunction] - Function to test if an object is a model, defaults to {@link Model#isModel}\n *\n * @class ModelRegistryManager\n * @template M Type of model that can be registered, must extend Model\n * @implements ModelRegistry<M>\n * @category Model\n *\n * @example\n * ```typescript\n * // Create a model registry\n * const registry = new ModelRegistryManager();\n *\n * // Register a model class\n * registry.register(User);\n *\n * // Retrieve a model constructor by name\n * const UserClass = registry.get(\"User\");\n *\n * // Build a model instance from a plain object\n * const userData = { name: \"John\", age: 30 };\n * const user = registry.build(userData, \"User\");\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant R as ModelRegistryManager\n *   participant M as Model Class\n *\n *   C->>R: new ModelRegistryManager(testFunction)\n *   C->>R: register(ModelClass)\n *   R->>R: Store in cache\n *   C->>R: get(\"ModelName\")\n *   R-->>C: ModelClass constructor\n *   C->>R: build(data, \"ModelName\")\n *   R->>R: Get constructor from cache\n *   R->>M: new ModelClass(data)\n *   M-->>R: Model instance\n *   R-->>C: Model instance\n */\nexport class ModelRegistryManager<M extends Model<true | false>>\n  implements ModelRegistry<M>\n{\n  private cache: Record<string, ModelConstructor<M>> = {};\n  private readonly testFunction: (obj: object) => boolean;\n\n  constructor(\n    testFunction: (obj: Record<string, any>) => boolean = Model.isModel\n  ) {\n    this.testFunction = testFunction;\n  }\n\n  /**\n   * @description Registers a model constructor with the registry\n   * @summary Adds a model constructor to the registry cache, making it available for\n   * later retrieval and instantiation. If no name is provided, the constructor's name\n   * property is used as the key in the registry.\n   *\n   * @param {ModelConstructor<M>} constructor - The model constructor to register\n   * @param {string} [name] - Optional name to register the constructor under, defaults to constructor.name\n   * @return {void}\n   * @throws {Error} If the constructor is not a function\n   */\n  register(constructor: ModelConstructor<M>, name?: string): void {\n    if (typeof constructor !== \"function\")\n      throw new Error(\n        \"Model registering failed. Missing Class name or constructor\"\n      );\n    name = name || constructor.name;\n    this.cache[name] = constructor;\n  }\n\n  /**\n   * @summary Gets a registered Model {@link ModelConstructor}\n   * @param {string} name\n   */\n  get(name: string): ModelConstructor<M> | undefined {\n    try {\n      return this.cache[name];\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (e: any) {\n      return undefined;\n    }\n  }\n\n  /**\n   * @param {Record<string, any>} obj\n   * @param {string} [clazz] when provided, it will attempt to find the matching constructor\n   *\n   * @throws Error If clazz is not found, or obj is not a {@link Model} meaning it has no {@link ModelKeys.ANCHOR} property\n   */\n  build(obj: Record<string, any> = {}, clazz?: string): M {\n    if (!clazz && !this.testFunction(obj))\n      throw new Error(\"Provided obj is not a Model object\");\n    const name = clazz || Model.getMetadata(obj as any);\n    if (!(name in this.cache))\n      throw new Error(\n        `Provided class ${name} is not a registered Model object`\n      );\n    return new this.cache[name](obj);\n  }\n}\n\n/**\n * @summary Bulk Registers Models\n * @description Useful when using bundlers that might not evaluate all the code at once\n *\n * @template M extends Model\n * @param {Array<Constructor<M>> | Array<{name: string, constructor: Constructor<M>}>} [models]\n *\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport function bulkModelRegister<M extends Model>(\n  ...models: (Constructor<M> | { name: string; constructor: Constructor<M> })[]\n) {\n  models.forEach(\n    (m: Constructor<M> | { name: string; constructor: Constructor<M> }) => {\n      const constructor: Constructor<M> = (\n        m.constructor ? m.constructor : m\n      ) as Constructor<M>;\n      Model.register(constructor, (m as Constructor<M>).name);\n    }\n  );\n}\n\n/**\n * @summary Abstract class representing a Validatable Model object\n * @description Meant to be used as a base class for all Model classes\n *\n * Model objects must:\n *  - Have all their required properties marked with '!';\n *  - Have all their optional properties marked as '?':\n *\n * @param {ModelArg<Model>} model base object from which to populate properties from\n *\n * @class Model\n * @category Model\n * @abstract\n * @implements Validatable\n * @implements Serializable\n *\n * @example\n *      class ClassName {\n *          @required()\n *          requiredPropertyName!: PropertyType;\n *\n *          optionalPropertyName?: PropertyType;\n *      }\n */\nexport abstract class Model<Async extends boolean = false>\n  implements\n    Validatable<Async>,\n    Serializable,\n    Hashable,\n    Comparable<Model<Async>>\n{\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  protected constructor(arg: ModelArg<Model> | undefined = undefined) {}\n\n  public isAsync(): boolean {\n    const self = this as any;\n    return !!(self[ASYNC_META_KEY] ?? self?.constructor[ASYNC_META_KEY]);\n  }\n\n  /**\n   * @description Validates the model object against its defined validation rules\n   * @summary Validates the object according to its decorated properties, returning any validation errors\n   *\n   * @param {any[]} [exceptions] - Properties in the object to be ignored for the validation. Marked as 'any' to allow for extension but expects strings\n   * @return {ModelErrorDefinition | undefined} - Returns a ModelErrorDefinition object if validation errors exist, otherwise undefined\n   */\n  public hasErrors(\n    ...exceptions: any[]\n  ): ConditionalAsync<Async, ModelErrorDefinition | undefined> {\n    return validate<any, Async>(\n      this,\n      this.isAsync() as any,\n      ...exceptions\n    ) as any;\n  }\n\n  /**\n   * @description Determines if this model is equal to another object\n   * @summary Compare object equality recursively, checking all properties unless excluded\n   *\n   * @param {any} obj - Object to compare to\n   * @param {string[]} [exceptions] - Property names to be excluded from the comparison\n   * @return {boolean} - True if objects are equal, false otherwise\n   */\n  public equals(obj: any, ...exceptions: string[]): boolean {\n    return isEqual(this, obj, ...exceptions);\n  }\n\n  /**\n   * @description Converts the model to a serialized string representation\n   * @summary Returns the serialized model according to the currently defined {@link Serializer}\n   *\n   * @return {string} - The serialized string representation of the model\n   */\n  serialize(): string {\n    return Model.serialize(this);\n  }\n\n  /**\n   * @description Provides a human-readable string representation of the model\n   * @summary Override the implementation for js's 'toString()' to provide a more useful representation\n   *\n   * @return {string} - A string representation of the model including its class name and JSON representation\n   * @override\n   */\n  public toString(): string {\n    return this.constructor.name + \": \" + JSON.stringify(this, undefined, 2);\n  }\n\n  /**\n   * @description Generates a hash string for the model object\n   * @summary Defines a default implementation for object hash, relying on a basic implementation based on Java's string hash\n   *\n   * @return {string} - A hash string representing the model\n   */\n  public hash(): string {\n    return Model.hash(this);\n  }\n\n  /**\n   * @description Converts a serialized string back into a model instance\n   * @summary Deserializes a Model from its string representation\n   *\n   * @param {string} str - The serialized string to convert back to a model\n   * @return {any} - The deserialized model instance\n   * @throws {Error} If it fails to parse the string, or if it fails to build the model\n   */\n  static deserialize(str: string) {\n    const metadata = Reflect.getMetadata(\n      Model.key(ModelKeys.SERIALIZATION),\n      this.constructor\n    );\n\n    if (metadata && metadata.serializer)\n      return Serialization.deserialize(\n        str,\n        metadata.serializer,\n        ...(metadata.args || [])\n      );\n    return Serialization.deserialize(str);\n  }\n\n  /**\n   * @description Copies properties from a source object to a model instance\n   * @summary Repopulates the Object properties with the ones from the new object\n   *\n   * @template T\n   * @param {T} self - The target model instance to update\n   * @param {T | Record<string, any>} [obj] - The source object containing properties to copy\n   * @return {T} - The updated model instance\n   */\n  static fromObject<T extends Model<any>>(\n    self: T,\n    obj?: T | Record<string, any>\n  ): T {\n    if (!obj) obj = {};\n    for (const prop of Model.getAttributes(self)) {\n      (self as any)[prop] = (obj as any)[prop] || undefined;\n    }\n    return self;\n  }\n\n  /**\n   * @description Copies and rebuilds properties from a source object to a model instance, handling nested models\n   * @summary Repopulates the instance with properties from the new Model Object, recursively rebuilding nested models\n   *\n   * @template T\n   * @param {T} self - The target model instance to update\n   * @param {T | Record<string, any>} [obj] - The source object containing properties to copy\n   * @return {T} - The updated model instance with rebuilt nested models\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant C as Client\n   *   participant M as Model.fromModel\n   *   participant B as Model.build\n   *   participant R as Reflection\n   *\n   *   C->>M: fromModel(self, obj)\n   *   M->>M: Get attributes from self\n   *   loop For each property\n   *     M->>M: Copy property from obj to self\n   *     alt Property is a model\n   *       M->>M: Check if property is a model\n   *       M->>B: build(property, modelType)\n   *       B-->>M: Return built model\n   *     else Property is a complex type\n   *       M->>R: Get property decorators\n   *       R-->>M: Return decorators\n   *       M->>M: Filter type decorators\n   *       alt Property is Array/Set with list decorator\n   *         M->>M: Process each item in collection\n   *         loop For each item\n   *           M->>B: build(item, itemModelType)\n   *           B-->>M: Return built model\n   *         end\n   *       else Property is another model type\n   *         M->>B: build(property, propertyType)\n   *         B-->>M: Return built model\n   *       end\n   *     end\n   *   end\n   *   M-->>C: Return updated self\n   */\n  static fromModel<T extends Model>(self: T, obj?: T | Record<string, any>): T {\n    if (!obj) obj = {};\n\n    let decorators: DecoratorMetadata[], dec: DecoratorMetadata;\n\n    const props = Model.getAttributes(self);\n\n    for (const prop of props) {\n      (self as Record<string, any>)[prop] =\n        (obj as Record<string, any>)[prop] ?? undefined;\n      if (typeof (self as any)[prop] !== \"object\") continue;\n      const propM = Model.isPropertyModel(self, prop);\n      if (propM) {\n        try {\n          (self as Record<string, any>)[prop] = Model.build(\n            (self as Record<string, any>)[prop],\n            typeof propM === \"string\" ? propM : undefined\n          );\n        } catch (e: any) {\n          console.log(e);\n        }\n        continue;\n      }\n\n      const allDecorators: DecoratorMetadata[] =\n        Reflection.getPropertyDecorators(\n          ValidationKeys.REFLECT,\n          self,\n          prop\n        ).decorators;\n      decorators = allDecorators.filter(\n        (d: DecoratorMetadata) =>\n          [ModelKeys.TYPE, ValidationKeys.TYPE as string].indexOf(d.key) !== -1\n      );\n      if (!decorators || !decorators.length)\n        throw new Error(`failed to find decorators for property ${prop}`);\n      dec = decorators.pop() as DecoratorMetadata;\n      const clazz = dec.props.name\n        ? [dec.props.name]\n        : Array.isArray(dec.props.customTypes)\n          ? dec.props.customTypes\n          : [dec.props.customTypes];\n      const reserved = Object.values(ReservedModels).map((v) =>\n        v.toLowerCase()\n      ) as string[];\n\n      clazz.forEach((c) => {\n        if (reserved.indexOf(c.toLowerCase()) === -1)\n          try {\n            switch (c) {\n              case \"Array\":\n              case \"Set\":\n                if (allDecorators.length) {\n                  const listDec = allDecorators.find(\n                    (d) => d.key === ValidationKeys.LIST\n                  );\n                  if (listDec) {\n                    const clazzName = (listDec.props.clazz as string[]).find(\n                      (t: string) => !jsTypes.includes(t.toLowerCase())\n                    );\n                    if (c === \"Array\")\n                      (self as Record<string, any>)[prop] = (\n                        self as Record<string, any>\n                      )[prop].map((el: any) => {\n                        return [\"object\", \"function\"].includes(typeof el) &&\n                          clazzName\n                          ? Model.build(el, clazzName)\n                          : el;\n                      });\n                    if (c === \"Set\") {\n                      const s = new Set();\n                      for (const v of (self as Record<string, any>)[prop]) {\n                        if (\n                          [\"object\", \"function\"].includes(typeof v) &&\n                          clazzName\n                        ) {\n                          s.add(Model.build(v, clazzName));\n                        } else {\n                          s.add(v);\n                        }\n                      }\n                      (self as Record<string, any>)[prop] = s;\n                    }\n                  }\n                }\n                break;\n              default:\n                if (\n                  typeof self[prop as keyof typeof self] !== \"undefined\" &&\n                  Model.get(c)\n                )\n                  (self as Record<string, any>)[prop] = Model.build(\n                    (self as any)[prop],\n                    c\n                  );\n            }\n          } catch (e: any) {\n            console.log(e);\n            // do nothing. we have no registry of this class\n          }\n      });\n    }\n    return self;\n  }\n\n  /**\n   * @description Configures the global model builder function\n   * @summary Sets the Global {@link ModelBuilderFunction} used for building model instances\n   *\n   * @param {ModelBuilderFunction} [builder] - The builder function to set as the global builder\n   * @return {void}\n   */\n  static setBuilder(builder?: ModelBuilderFunction) {\n    modelBuilderFunction = builder;\n  }\n\n  /**\n   * @description Retrieves the currently configured global model builder function\n   * @summary Returns the current global {@link ModelBuilderFunction} used for building model instances\n   *\n   * @return {ModelBuilderFunction | undefined} - The current global builder function or undefined if not set\n   */\n  static getBuilder(): ModelBuilderFunction | undefined {\n    return modelBuilderFunction || Model.fromModel;\n  }\n\n  /**\n   * @description Provides access to the current model registry\n   * @summary Returns the current {@link ModelRegistryManager} instance, creating one if it doesn't exist\n   *\n   * @return {ModelRegistry<any>} - The current model registry, defaults to a new {@link ModelRegistryManager} if not set\n   * @private\n   */\n  private static getRegistry() {\n    if (!actingModelRegistry) actingModelRegistry = new ModelRegistryManager();\n    return actingModelRegistry;\n  }\n\n  /**\n   * @description Configures the model registry to be used by the Model system\n   * @summary Sets the current model registry to a custom implementation\n   *\n   * @param {BuilderRegistry<any>} modelRegistry - The new implementation of Registry to use\n   * @return {void}\n   */\n  static setRegistry(modelRegistry: BuilderRegistry<any>) {\n    actingModelRegistry = modelRegistry;\n  }\n\n  /**\n   * @description Registers a model constructor with the model registry\n   * @summary Registers new model classes to make them available for serialization and deserialization\n   *\n   * @template T\n   * @param {ModelConstructor<T>} constructor - The model constructor to register\n   * @param {string} [name] - Optional name to register the constructor under, defaults to constructor.name\n   * @return {void}\n   *\n   * @see ModelRegistry\n   */\n  static register<T extends Model>(\n    constructor: ModelConstructor<T>,\n    name?: string\n  ): void {\n    return Model.getRegistry().register(constructor, name);\n  }\n\n  /**\n   * @description Retrieves a registered model constructor by name\n   * @summary Gets a registered Model {@link ModelConstructor} from the model registry\n   *\n   * @template T\n   * @param {string} name - The name of the model constructor to retrieve\n   * @return {ModelConstructor<T> | undefined} - The model constructor if found, undefined otherwise\n   *\n   * @see ModelRegistry\n   */\n  static get<T extends Model>(name: string): ModelConstructor<T> | undefined {\n    return Model.getRegistry().get(name);\n  }\n\n  /**\n   * @description Creates a model instance from a plain object\n   * @summary Builds a model instance using the model registry, optionally specifying the model class\n   *\n   * @template T\n   * @param {Record<string, any>} obj - The source object to build the model from\n   * @param {string} [clazz] - When provided, it will attempt to find the matching constructor by name\n   * @return {T} - The built model instance\n   * @throws {Error} If clazz is not found, or obj is not a {@link Model} meaning it has no {@link ModelKeys.ANCHOR} property\n   *\n   * @see ModelRegistry\n   */\n  static build<T extends Model>(\n    obj: Record<string, any> = {},\n    clazz?: string\n  ): T {\n    return Model.getRegistry().build(obj, clazz);\n  }\n\n  /**\n   * @description Retrieves the model metadata from a model instance\n   * @summary Gets the metadata associated with a model instance, typically the model class name\n   *\n   * @template M\n   * @param {M} model - The model instance to get metadata from\n   * @return {string} - The model metadata (typically the class name)\n   */\n  static getMetadata<M extends Model>(model: M) {\n    return getMetadata<M>(model);\n  }\n\n  /**\n   * @description Retrieves all attribute names from a model class or instance\n   * @summary Gets all attributes defined in a model, traversing the prototype chain to include inherited attributes\n   *\n   * @template V\n   * @param {Constructor<V> | V} model - The model class or instance to get attributes from\n   * @return {string[]} - Array of attribute names defined in the model\n   */\n  static getAttributes<V extends Model>(model: Constructor<V> | V) {\n    const result: string[] = [];\n    let prototype =\n      model instanceof Model\n        ? Object.getPrototypeOf(model)\n        : (model as any).prototype;\n    while (prototype != null) {\n      const props: string[] = prototype[ModelKeys.ATTRIBUTE];\n      if (props) {\n        result.push(...props);\n      }\n      prototype = Object.getPrototypeOf(prototype);\n    }\n    return result;\n  }\n\n  /**\n   * @description Compares two model instances for equality\n   * @summary Determines if two model instances are equal by comparing their properties\n   *\n   * @template M\n   * @param {M} obj1 - First model instance to compare\n   * @param {M} obj2 - Second model instance to compare\n   * @param {any[]} [exceptions] - Property names to exclude from comparison\n   * @return {boolean} - True if the models are equal, false otherwise\n   */\n  static equals<M extends Model>(obj1: M, obj2: M, ...exceptions: any[]) {\n    return isEqual(obj1, obj2, ...exceptions);\n  }\n\n  /**\n   * @description Validates a model instance against its validation rules\n   * @summary Checks if a model has validation errors, optionally ignoring specified properties\n   *\n   * @template M\n   * @param {M} model - The model instance to validate\n   * @param {boolean} async - A flag indicating whether validation should be asynchronous.\n   * @param {string[]} [propsToIgnore] - Properties to exclude from validation\n   * @return {ModelErrorDefinition | undefined} - Returns validation errors if any, otherwise undefined\n   */\n  static hasErrors<M extends Model, Async extends boolean = false>(\n    model: M,\n    async: Async,\n    ...propsToIgnore: string[]\n  ): ConditionalAsync<Async, ModelErrorDefinition | undefined> {\n    return validate<any, Async>(model, async, ...propsToIgnore) as any;\n  }\n\n  /**\n   * @description Converts a model instance to a serialized string\n   * @summary Serializes a model instance using the configured serializer or the default one\n   *\n   * @template M\n   * @param {M} model - The model instance to serialize\n   * @return {string} - The serialized string representation of the model\n   */\n  static serialize<M extends Model<boolean>>(model: M) {\n    const metadata = Reflect.getMetadata(\n      Model.key(ModelKeys.SERIALIZATION),\n      model.constructor\n    );\n\n    if (metadata && metadata.serializer)\n      return Serialization.serialize(\n        this,\n        metadata.serializer,\n        ...(metadata.args || [])\n      );\n    return Serialization.serialize(model);\n  }\n\n  /**\n   * @description Generates a hash string for a model instance\n   * @summary Creates a hash representation of a model using the configured algorithm or the default one\n   *\n   * @template M\n   * @param {M} model - The model instance to hash\n   * @return {string} - The hash string representing the model\n   */\n  static hash<M extends Model<boolean>>(model: M) {\n    const metadata = Reflect.getMetadata(\n      Model.key(ModelKeys.HASHING),\n      model.constructor\n    );\n\n    if (metadata && metadata.algorithm)\n      return Hashing.hash(model, metadata.algorithm, ...(metadata.args || []));\n    return Hashing.hash(model);\n  }\n\n  /**\n   * @description Creates a metadata key for use with the Reflection API\n   * @summary Builds the key to store as Metadata under Reflections\n   *\n   * @param {string} str - The base key to concatenate with the model reflection prefix\n   * @return {string} - The complete metadata key\n   */\n  static key(str: string) {\n    return getModelKey(str);\n  }\n\n  /**\n   * @description Determines if an object is a model instance or has model metadata\n   * @summary Checks whether a given object is either an instance of the Model class or\n   * has model metadata attached to it. This function is essential for serialization and\n   * deserialization processes, as it helps identify model objects that need special handling.\n   * It safely handles potential errors during metadata retrieval.\n   *\n   * @param {Record<string, any>} target - The object to check\n   * @return {boolean} True if the object is a model instance or has model metadata, false otherwise\n   *\n   * @example\n   * ```typescript\n   * // Check if an object is a model\n   * const user = new User({ name: \"John\" });\n   * const isUserModel = isModel(user); // true\n   *\n   * // Check a plain object\n   * const plainObject = { name: \"John\" };\n   * const isPlainObjectModel = isModel(plainObject); // false\n   * ```\n   */\n  static isModel(target: Record<string, any>) {\n    try {\n      return target instanceof Model || !!Model.getMetadata(target as any);\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    } catch (e: any) {\n      return false;\n    }\n  }\n\n  /**\n   * @description Checks if a property of a model is itself a model or has a model type\n   * @summary Determines whether a specific property of a model instance is either a model instance\n   * or has a type that is registered as a model\n   *\n   * @template M\n   * @param {M} target - The model instance to check\n   * @param {string} attribute - The property name to check\n   * @return {boolean | string | undefined} - Returns true if the property is a model instance,\n   * the model name if the property has a model type, or undefined if not a model\n   */\n  static isPropertyModel<M extends Model>(\n    target: M,\n    attribute: string\n  ): boolean | string | undefined {\n    if (Model.isModel((target as Record<string, any>)[attribute])) return true;\n    const metadata = Reflect.getMetadata(ModelKeys.TYPE, target, attribute);\n    return Model.get(metadata.name) ? metadata.name : undefined;\n  }\n\n  static describe<M extends Model>(model: M | Constructor<M>, key?: keyof M) {\n    const descKey = Model.key(ModelKeys.DESCRIPTION);\n    if (key) {\n      model = model instanceof Model ? model : new model();\n      return (\n        Reflect.getMetadataKeys(model.constructor, key.toString())\n          .find((k) => k === descKey)\n          ?.toString() || model.toString()\n      );\n    }\n\n    return (\n      Reflect.getMetadata(\n        Model.key(ModelKeys.DESCRIPTION),\n        model instanceof Model ? model.constructor : model\n      ) || model.toString()\n    );\n  }\n}\n","import { Constructor } from \"../model/types\";\nimport { Serializer } from \"./types\";\nimport { Model } from \"../model/Model\";\nimport { ModelKeys } from \"./constants\";\nimport { getMetadata } from \"../model/utils\";\n\nexport const DefaultSerializationMethod = \"json\";\n\n/**\n * @summary Concrete implementation of a {@link Serializer} in JSON format\n * @description JS's native JSON.stringify (used here) is not deterministic\n * and therefore should not be used for hashing purposes\n *\n * To keep dependencies low, we will not implement this, but we recommend\n * implementing a similar {@link JSONSerializer} using 'deterministic-json' libraries\n *\n * @class JSONSerializer\n * @implements Serializer\n *\n * @category Model\n */\nexport class JSONSerializer<T extends Model> implements Serializer<T> {\n  constructor() {}\n  /**\n   * @summary prepares the model for serialization\n   * @description returns a shallow copy of the object, containing an enumerable {@link ModelKeys#ANCHOR} property\n   * so the object can be recognized upon deserialization\n   *\n   * @param {T} model\n   * @protected\n   */\n  protected preSerialize(model: T) {\n    // TODO: nested preserialization (so increase performance when deserializing)\n    const toSerialize: Record<string, any> = Object.assign({}, model);\n    const metadata = getMetadata(model);\n    toSerialize[ModelKeys.ANCHOR] = metadata || model.constructor.name;\n    return toSerialize;\n  }\n\n  /**\n   * @summary Rebuilds a model from a serialization\n   * @param {string} str\n   *\n   * @throws {Error} If it fails to parse the string, or to build the model\n   */\n  deserialize(str: string): T {\n    const deserialization = JSON.parse(str);\n    const className = deserialization[ModelKeys.ANCHOR];\n    if (!className)\n      throw new Error(\"Could not find class reference in serialized model\");\n    const model: T = Model.build(deserialization, className) as unknown as T;\n    return model;\n  }\n\n  /**\n   * @summary Serializes a model\n   * @param {T} model\n   *\n   * @throws {Error} if fails to serialize\n   */\n  serialize(model: T): string {\n    return JSON.stringify(this.preSerialize(model));\n  }\n}\n\nexport class Serialization {\n  private static current: string = DefaultSerializationMethod;\n\n  private static cache: Record<string, Serializer<any>> = {\n    json: new JSONSerializer(),\n  };\n\n  private constructor() {}\n\n  private static get(key: string): any {\n    if (key in this.cache) return this.cache[key];\n    throw new Error(`No serialization method registered under ${key}`);\n  }\n\n  static register(\n    key: string,\n    func: Constructor<Serializer<any>>,\n    setDefault = false\n  ): void {\n    if (key in this.cache)\n      throw new Error(`Serialization method ${key} already registered`);\n    this.cache[key] = new func();\n    if (setDefault) this.current = key;\n  }\n\n  static serialize(obj: any, method?: string, ...args: any[]) {\n    if (!method) return this.get(this.current).serialize(obj, ...args);\n    return this.get(method).serialize(obj, ...args);\n  }\n\n  static deserialize(obj: string, method?: string, ...args: any[]) {\n    if (!method) return this.get(this.current).deserialize(obj, ...args);\n    return this.get(method).deserialize(obj, ...args);\n  }\n\n  static setDefault(method: string) {\n    this.current = this.get(method);\n  }\n}\n","import type { ValidatorOptions } from \"../types\";\nimport type { PathProxy } from \"../../utils\";\nimport { BaseValidator } from \"./BaseValidator\";\nimport { DEFAULT_ERROR_MESSAGES } from \"./constants\";\n\n/**\n * @description\n * Abstract class for defining asynchronous validators.\n *\n * This class extends the base `Validator` and enforces that any implementation\n * of `hasErrors` must be asynchronous, always returning a Promise.\n *\n * Use this when the validation process involves asynchronous operations,\n * such as API calls, database lookups, or time-based checks (e.g., timeouts).\n *\n * @example\n * ```typescript\n * // Example of an asynchronous validator that compares value against a timeout\n * class TimeoutValidator extends AsyncValidator<{ timeout?: number }> {\n *   constructor(message: string = \"Validation failed due to timeout\") {\n *     super(message);\n *   }\n *\n *   async hasErrors(value: number, options?: { timeout?: number }) {\n *     const delay = options?.timeout ?? 100;\n *\n *     // async call\n *     await new Promise(res => setTimeout(res, delay));\n *\n *     if (value > delay) {\n *       // Rejects the validation after waiting the delay if value is greater\n *       return Promise.resolve(this.getMessage());\n *     }\n *\n *     // Passes the validation after waiting the delay\n *     return Promise.resolve(undefined);\n *   }\n * }\n *\n * // Example usage:\n * const validator = new TimeoutValidator();\n *\n * async function runValidation() {\n *  const error = await validator.hasErrors(50, { timeout: 100 });\n *  if (error) {\n *    return console.error('Validation error:', error);\n *  }\n *  console.log('Value is valid');\n * }\n *\n * await runValidation();\n * ```\n *\n * - If `value > timeout`, the validator waits for the delay and then rejects with an error.\n * - If `value <= timeout`, the validator waits for the delay and resolves successfully with `undefined`.\n *\n * @see {@link Validator} For the base synchronous validator.\n */\nexport abstract class AsyncValidator<\n  V extends ValidatorOptions,\n> extends BaseValidator<V, true> {\n  protected constructor(\n    message: string = DEFAULT_ERROR_MESSAGES.DEFAULT,\n    ...acceptedTypes: string[]\n  ) {\n    super(true, message, ...acceptedTypes);\n  }\n\n  /**\n   * @description\n   * Asynchronously validates a value.\n   *\n   * @template V - Type of the option 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 Promise<string | undefined> Error message if validation fails, undefined if validation passes\n   *\n   * @see {@link Validator}\n   */\n  public abstract override hasErrors(\n    value: any,\n    options?: V,\n    proxy?: PathProxy<any>\n  ): Promise<string | undefined>;\n}\n","import { Validator } from \"./Validator\";\nimport { Validation } from \"../Validation\";\nimport { Constructor } from \"../../model/types\";\nimport { ValidationKeys } from \"./constants\";\nimport { apply, metadata } from \"@decaf-ts/reflection\";\nimport { ValidatorDefinition } from \"../types\";\n\n/**\n * @summary Marks the class as a validator for a certain key.\n * @description Registers the class in the {@link Validation} with the provided key\n *\n * @param {string} keys the validation key\n *\n * @function validator\n *\n * @category Class Decorators\n */\nexport function validator<T extends Validator>(...keys: string[]) {\n  return apply(\n    ((original: Constructor<T>) => {\n      keys.forEach((k: string) => {\n        Validation.register({\n          validator: original,\n          validationKey: k,\n          save: true,\n        } as ValidatorDefinition);\n      });\n      return original;\n    }) as ClassDecorator,\n    metadata(Validation.key(ValidationKeys.VALIDATOR), keys)\n  );\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { DateValidatorOptions } from \"../types\";\n\n/**\n * @description Validator for checking if a value is a valid date\n * @summary The DateValidator checks if a value is a valid date object or a string that can be converted to a valid date.\n * It validates that the value represents a real date and not an invalid date like \"2023-02-31\".\n * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#DATE}\n * @class DateValidator\n * @extends Validator\n *\n * @category Validators\n * @example\n * ```typescript\n * // Create a date validator with default error message\n * const dateValidator = new DateValidator();\n *\n * // Create a date validator with custom error message\n * const customDateValidator = new DateValidator(\"Please enter a valid date\");\n *\n * // Validate a date\n * const result = dateValidator.hasErrors(new Date()); // undefined (valid)\n * const invalidResult = dateValidator.hasErrors(\"not a date\"); // Returns error message (invalid)\n * ```\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant V as DateValidator\n *\n *   C->>V: new DateValidator(message)\n *   C->>V: hasErrors(value, options)\n *   alt value is undefined\n *     V-->>C: undefined (valid)\n *   else value is string\n *     V->>V: Convert to Date\n *   end\n *   alt Date is invalid (NaN)\n *     V-->>C: Error message\n *   else Date is valid\n *     V-->>C: undefined (valid)\n *   end\n */\n@validator(ValidationKeys.DATE)\nexport class DateValidator extends Validator<DateValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.DATE) {\n    super(message, Number.name, Date.name, String.name);\n  }\n\n  /**\n   * @description Checks if the provided value is a valid date\n   * @summary Validates that the given value is a valid date. If the value is a string,\n   * it attempts to convert it to a Date object. Returns an error message if the date is invalid,\n   * or undefined if the date is valid or if the value is undefined.\n   *\n   * @param {Date | string} value - The value to validate, can be a Date object or a string\n   * @param {DateValidatorOptions} [options={}] - Optional configuration options for the validator\n   *\n   * @return {string | undefined} Error message if validation fails, undefined if validation passes\n   *\n   * @override\n   *\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: Date | string,\n    options: DateValidatorOptions = {}\n  ): string | undefined {\n    if (value === undefined) return;\n\n    if (typeof value === \"string\") value = new Date(value);\n\n    if (Number.isNaN(value.getDate())) {\n      const { message = \"\" } = options;\n      return this.getMessage(message || this.message);\n    }\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { DiffValidatorOptions } from \"../types\";\nimport { isEqual } from \"@decaf-ts/reflection\";\nimport type { PathProxy } from \"../../utils\";\n\n/**\n * @summary Diff Validator\n *\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#DiffValidator}\n *\n * @class DiffValidator\n * @extends Validator\n *\n * @category Validators\n */\n@validator(ValidationKeys.DIFF)\nexport class DiffValidator extends Validator<DiffValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.DIFF) {\n    super(message);\n  }\n\n  /**\n   * @summary Validates a model\n   *\n   * @param {string} value\n   * @param {DiffValidatorOptions} options\n   * @param {PathProxy<any>} accessor - Proxy-like object used to resolve values from nested structures via path strings.\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: DiffValidatorOptions,\n    accessor: PathProxy<any>\n  ): string | undefined {\n    let comparisonPropertyValue: any;\n    try {\n      comparisonPropertyValue = accessor.getValueFromPath(\n        options[ValidationKeys.DIFF]\n      );\n    } catch (e: any) {\n      return this.getMessage(e.message || this.message);\n    }\n\n    return isEqual(value, comparisonPropertyValue)\n      ? this.getMessage(\n          options.message || this.message,\n          options[ValidationKeys.DIFF]\n        )\n      : undefined;\n  }\n}\n","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","import {\n  DEFAULT_ERROR_MESSAGES,\n  DEFAULT_PATTERNS,\n  ValidationKeys,\n} from \"./constants\";\nimport { PatternValidator } from \"./PatternValidator\";\nimport { validator } from \"./decorators\";\nimport { PatternValidatorOptions } from \"../types\";\n\n/**\n * @description Validator for checking if a string is a valid email address\n * @summary The EmailValidator checks if a string matches a standard email address pattern.\n * It extends the PatternValidator and uses a predefined email regex pattern to validate email addresses.\n * This validator is typically used with the @email decorator.\n *\n * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#EMAIL}\n *\n * @class EmailValidator\n * @extends PatternValidator\n *\n * @example\n * ```typescript\n * // Create an email validator with default error message\n * const emailValidator = new EmailValidator();\n *\n * // Create an email validator with custom error message\n * const customEmailValidator = new EmailValidator(\"Please enter a valid email address\");\n *\n * // Validate an email\n * const result = emailValidator.hasErrors(\"user@example.com\"); // undefined (valid)\n * const invalidResult = emailValidator.hasErrors(\"invalid-email\"); // Returns error message (invalid)\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant E as EmailValidator\n *   participant P as PatternValidator\n *\n *   C->>E: new EmailValidator(message)\n *   E->>P: super(message)\n *   C->>E: hasErrors(value, options)\n *   E->>P: super.hasErrors(value, options with EMAIL pattern)\n *   P-->>E: validation result\n *   E-->>C: validation result\n *\n * @category Validators\n */\n@validator(ValidationKeys.EMAIL)\nexport class EmailValidator extends PatternValidator {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.EMAIL) {\n    super(message);\n  }\n\n  /**\n   * @description Checks if a string is a valid email address\n   * @summary Validates that the provided string matches the email pattern.\n   * This method extends the PatternValidator's hasErrors method by ensuring\n   * the email pattern is used, even if not explicitly provided in the options.\n   *\n   * @param {string} value - The string to validate as an email address\n   * @param {PatternValidatorOptions} [options={}] - Optional configuration options\n   *\n   * @return {string | undefined} Error message if validation fails, undefined if validation passes\n   *\n   * @override\n   *\n   * @see PatternValidator#hasErrors\n   */\n  public override hasErrors(\n    value: string,\n    options: PatternValidatorOptions = {}\n  ): string | undefined {\n    return super.hasErrors(value, {\n      ...options,\n      message: options.message || this.message,\n      pattern: options?.pattern || DEFAULT_PATTERNS.EMAIL,\n    });\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { EqualsValidatorOptions } from \"../types\";\nimport { isEqual } from \"@decaf-ts/reflection\";\nimport type { PathProxy } from \"../../utils\";\n\n/**\n * @summary Equals Validator\n *\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#EQUALS}\n *\n * @class EqualsValidator\n * @extends Validator\n *\n * @category Validators\n */\n@validator(ValidationKeys.EQUALS)\nexport class EqualsValidator extends Validator<EqualsValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.EQUALS) {\n    super(message);\n  }\n\n  /**\n   * @summary Validates a model\n   *\n   * @param {string} value\n   * @param {EqualsValidatorOptions} options\n   * @param {PathProxy<any>} accessor - Proxy-like object used to resolve values from nested structures via path strings.\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: EqualsValidatorOptions,\n    accessor: PathProxy<any>\n  ): string | undefined {\n    let comparisonPropertyValue: any;\n    try {\n      comparisonPropertyValue = accessor.getValueFromPath(\n        options[ValidationKeys.EQUALS]\n      );\n    } catch (e: any) {\n      return this.getMessage(e.message || this.message);\n    }\n\n    return isEqual(value, comparisonPropertyValue)\n      ? undefined\n      : this.getMessage(\n          options.message || this.message,\n          options[ValidationKeys.EQUALS]\n        );\n  }\n}\n\n// Validation.register({\n//   validator: EqualsValidator,\n//   validationKey: ValidationKeys.EQUALS,\n//   save: false,\n// } as ValidatorDefinition);\n","import { COMPARISON_ERROR_MESSAGES } from \"../../constants\";\nimport { sf } from \"../../utils\";\n\n// /**\n//  * Safely retrieves a nested property value from an object using a dot-notated path string.\n//  *\n//  * @template T - The expected return type of the property value.\n//  *\n//  * @param {Record<string, any>} obj - The source object to retrieve the value from.\n//  * @param {string} path - A dot-separated string representing the path to the desired property (e.g., \"user.address.street\").\n//  *\n//  * @returns {T} - The value found at the specified path\n//  *\n//  * @throws {Error} - Throws an error if the path is not a non-empty string or if any part of the path does not exist in the object.\n//  * @memberOf module:decorator-validation\n//  */\n// export function getValueByPath<T>(obj: Record<string, any>, path: string): T {\n//   if (typeof path !== \"string\" || !path.trim()) {\n//     throw new Error(sf(COMPARISON_ERROR_MESSAGES.INVALID_PATH, path));\n//   }\n//\n//   // Process parent directory access (../)\n//   const parentAccessors = path.match(/\\.\\.\\//g) || [];\n//   const parentLevel = parentAccessors.length;\n//   const cleanPath = path.replace(/\\.\\.\\//g, \"\");\n//\n//   // Navigate up the parent chain\n//   let currentContext: any = obj;\n//   for (let i = 0; i < parentLevel; i++) {\n//     if (!currentContext || typeof currentContext !== \"object\") {\n//       throw new Error(\n//         sf(COMPARISON_ERROR_MESSAGES.CONTEXT_NOT_OBJECT_COMPARISON, i + 1, path)\n//       );\n//     }\n//\n//     if (!currentContext[VALIDATION_PARENT_KEY]) {\n//       throw new Error(\n//         sf(COMPARISON_ERROR_MESSAGES.NO_PARENT_COMPARISON, i + 1, path)\n//       );\n//     }\n//\n//     currentContext = currentContext[VALIDATION_PARENT_KEY];\n//   }\n//\n//   // Process dot notation path\n//   const parts = cleanPath.split(\".\");\n//   let currentValue: any = currentContext;\n//\n//   for (const part of parts) {\n//     if (\n//       currentValue !== null &&\n//       typeof currentValue === \"object\" &&\n//       part in currentValue\n//     ) {\n//       currentValue = (currentValue as Record<string, any>)[part];\n//     } else {\n//       const errorMsgTemplate =\n//         parentLevel === 0\n//           ? COMPARISON_ERROR_MESSAGES.PROPERTY_NOT_FOUND\n//           : parentLevel === 1\n//             ? COMPARISON_ERROR_MESSAGES.PROPERTY_NOT_FOUND_ON_PARENT\n//             : COMPARISON_ERROR_MESSAGES.PROPERTY_NOT_FOUND_AFTER_PARENT;\n//\n//       throw new Error(sf(errorMsgTemplate, path, part, parentLevel));\n//     }\n//   }\n//\n//   return currentValue as T;\n// }\n\nconst getTypeName = (value: unknown): string => {\n  if (value === null) return \"null\";\n  if (value instanceof Date) return \"Date\";\n  if (Number.isNaN(value)) return \"NaN\";\n  if (value === Infinity) return \"Infinity\";\n  if (value === -Infinity) return \"-Infinity\";\n  if (Array.isArray(value)) return \"array\";\n  return typeof value;\n};\n\nconst isSupported = (\n  value: unknown\n): value is undefined | number | bigint | Date => {\n  if (value === undefined || value instanceof Date) return true;\n\n  if (typeof value === \"bigint\") return true;\n\n  // Numbers must be finite (excludes NaN, Infinity, -Infinity)\n  if (typeof value === \"number\") return Number.isFinite(value);\n\n  return false;\n};\n\n/**\n * Validates whether two values are eligible for comparison using >= or <= operators.\n *\n * Supported types: `undefined`, `number`, `bigint`, and `Date`.\n *\n * @param a - The first value to compare.\n * @param b - The second value to compare.\n *\n * @returns {boolean} True if both values are of supported types.\n *\n * @throws {TypeError} If either value is of an unsupported type.\n * @memberOf module:decorator-validation\n */\nexport function isValidForGteOrLteComparison(a: any, b: any): boolean {\n  if (isSupported(a) && isSupported(b)) return true;\n\n  throw new TypeError(\n    sf(\n      COMPARISON_ERROR_MESSAGES.UNSUPPORTED_TYPES_COMPARISON,\n      getTypeName(a),\n      getTypeName(b)\n    )\n  );\n}\n\n/**\n * @summary Compares two values to determine if the first is less than the second.\n * @description Supports numbers and dates. Throws an error for unsupported types.\n *\n * @param {any} a - The first value to compare.\n * @param {any} b - The second value to compare against.\n *\n * @returns {boolean} True if `a` is less than `b`, false otherwise.\n *\n * @throws {Error} If either `a` or `b` is `null` or `undefined`.\n * @throws {TypeError} If values are of mismatched or unsupported types.\n * @memberOf module:decorator-validation\n */\nexport function isLessThan(a: any, b: any): boolean {\n  if ([null, undefined].includes(a) || [null, undefined].includes(b))\n    throw new Error(COMPARISON_ERROR_MESSAGES.NULL_OR_UNDEFINED_COMPARISON);\n\n  // Validate type compatibility\n  const aType = typeof a;\n  const bType = typeof b;\n\n  if (aType !== bType) {\n    // Allow number X bigint\n    if (aType === \"bigint\" && bType === \"number\")\n      return Number(a) < (b as number);\n    if (aType === \"number\" && bType === \"bigint\")\n      return (a as number) < Number(b);\n    throw new TypeError(\n      sf(COMPARISON_ERROR_MESSAGES.TYPE_MISMATCH_COMPARISON, aType, bType)\n    );\n  }\n\n  if (\n    (aType === \"number\" && bType === \"number\") ||\n    (aType === \"bigint\" && bType === \"bigint\")\n  ) {\n    if (Number.isNaN(a) || Number.isNaN(b))\n      throw new TypeError(COMPARISON_ERROR_MESSAGES.NAN_COMPARISON);\n    return a < b;\n  }\n\n  if (a instanceof Date && b instanceof Date) {\n    if (isNaN(a.getTime()) || isNaN(b.getTime()))\n      throw new TypeError(COMPARISON_ERROR_MESSAGES.INVALID_DATE_COMPARISON);\n    return a.getTime() < b.getTime();\n  }\n\n  throw new TypeError(\n    sf(\n      COMPARISON_ERROR_MESSAGES.UNSUPPORTED_TYPES_COMPARISON,\n      getTypeName(a),\n      getTypeName(b)\n    )\n  );\n}\n\n/**\n * Checks if `a` is greater than `b`.\n * Supports comparison for numbers and Date objects.\n *\n * @param {any} a - The value to validate.\n * @param {any} b - The value to compare against.\n *\n * @returns {boolean} True if `a` is greater than `b`, otherwise false.\n *\n * @throws {Error} If either `a` or `b` is `null` or `undefined`.\n * @throws {TypeError} If values are of mismatched or unsupported types.\n * @memberOf module:decorator-validation\n */\nexport function isGreaterThan(a: any, b: any): boolean {\n  if ([null, undefined].includes(a) || [null, undefined].includes(b))\n    throw new Error(COMPARISON_ERROR_MESSAGES.NULL_OR_UNDEFINED_COMPARISON);\n\n  const aType = typeof a;\n  const bType = typeof b;\n\n  if (aType !== bType) {\n    // Allow number X bigint\n    if (aType === \"bigint\" && bType === \"number\")\n      return Number(a) > (b as number);\n    if (aType === \"number\" && bType === \"bigint\")\n      return (a as number) > Number(b);\n    throw new Error(\n      sf(COMPARISON_ERROR_MESSAGES.TYPE_MISMATCH_COMPARISON, aType, bType)\n    );\n  }\n\n  if (\n    (aType === \"number\" && bType === \"number\") ||\n    (aType === \"bigint\" && bType === \"bigint\")\n  ) {\n    if (Number.isNaN(a) || Number.isNaN(b))\n      throw new TypeError(COMPARISON_ERROR_MESSAGES.NAN_COMPARISON);\n    return a > b;\n  }\n\n  if (a instanceof Date && b instanceof Date) {\n    if (isNaN(a.getTime()) || isNaN(b.getTime()))\n      throw new TypeError(COMPARISON_ERROR_MESSAGES.INVALID_DATE_COMPARISON);\n    return a.getTime() > b.getTime();\n  }\n\n  throw new TypeError(\n    sf(\n      COMPARISON_ERROR_MESSAGES.UNSUPPORTED_TYPES_COMPARISON,\n      getTypeName(a),\n      getTypeName(b)\n    )\n  );\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { GreaterThanValidatorOptions } from \"../types\";\nimport { isGreaterThan } from \"./utils\";\nimport type { PathProxy } from \"../../utils/PathProxy\";\n\n/**\n * @summary Greater Than Validator\n *\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#GREATER_THAN}\n *\n * @class GreaterThanValidator\n * @extends Validator\n *\n * @category Validators\n */\n@validator(ValidationKeys.GREATER_THAN)\nexport class GreaterThanValidator extends Validator<GreaterThanValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.GREATER_THAN) {\n    super(message);\n  }\n\n  /**\n   * @summary Validates a model\n   *\n   * @param {string} value\n   * @param {GreaterThanValidatorOptions} options\n   * @param {PathProxy<any>} accessor - Proxy-like object used to resolve values from nested structures via path strings.\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: GreaterThanValidatorOptions,\n    accessor: PathProxy<any>\n  ): string | undefined {\n    let comparisonPropertyValue: any;\n    try {\n      comparisonPropertyValue = accessor.getValueFromPath(\n        options[ValidationKeys.GREATER_THAN]\n      );\n    } catch (e: any) {\n      return this.getMessage(e.message || this.message);\n    }\n\n    try {\n      if (!isGreaterThan(value, comparisonPropertyValue))\n        throw new Error(options.message || this.message);\n    } catch (e: any) {\n      return this.getMessage(e.message, options[ValidationKeys.GREATER_THAN]);\n    }\n\n    return undefined;\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { GreaterThanOrEqualValidatorOptions } from \"../types\";\nimport { isGreaterThan, isValidForGteOrLteComparison } from \"./utils\";\nimport { isEqual } from \"@decaf-ts/reflection\";\nimport type { PathProxy } from \"../../utils/PathProxy\";\n\n/**\n * @summary Greater Than or Equal Validator\n *\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#GREATER_THAN_OR_EQUAL}\n *\n * @class GreaterThanOrEqualValidator\n * @extends Validator\n *\n * @category Validators\n */\n@validator(ValidationKeys.GREATER_THAN_OR_EQUAL)\nexport class GreaterThanOrEqualValidator extends Validator<GreaterThanOrEqualValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.GREATER_THAN_OR_EQUAL) {\n    super(message);\n  }\n\n  /**\n   * @summary Validates a model\n   *\n   * @param {string} value\n   * @param {GreaterThanOrEqualValidatorOptions} options\n   * @param {PathProxy<any>} accessor - Proxy-like object used to resolve values from nested structures via path strings.\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: GreaterThanOrEqualValidatorOptions,\n    accessor: PathProxy<any>\n  ): string | undefined {\n    let comparisonPropertyValue: any;\n    try {\n      comparisonPropertyValue = accessor.getValueFromPath(\n        options[ValidationKeys.GREATER_THAN_OR_EQUAL]\n      );\n    } catch (e: any) {\n      return this.getMessage(e.message || this.message);\n    }\n\n    try {\n      if (\n        (isValidForGteOrLteComparison(value, comparisonPropertyValue) &&\n          isEqual(value, comparisonPropertyValue)) ||\n        isGreaterThan(value, comparisonPropertyValue)\n      )\n        return undefined;\n\n      throw new Error(options.message || this.message);\n    } catch (e: any) {\n      return this.getMessage(\n        e.message,\n        options[ValidationKeys.GREATER_THAN_OR_EQUAL]\n      );\n    }\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { LessThanValidatorOptions } from \"../types\";\nimport { isLessThan } from \"./utils\";\nimport type { PathProxy } from \"../../utils/PathProxy\";\n\n/**\n * @summary Less Than Validator\n *\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LESS_THAN}\n *\n * @class LessThanValidator\n * @extends Validator\n *\n * @category Validators\n */\n@validator(ValidationKeys.LESS_THAN)\nexport class LessThanValidator extends Validator<LessThanValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.LESS_THAN) {\n    super(message);\n  }\n\n  /**\n   * @summary Validates a model\n   *\n   * @param {string} value\n   * @param {LessThanValidatorOptions} options\n   * @param {PathProxy<any>} accessor - Proxy-like object used to resolve values from nested structures via path strings.\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: LessThanValidatorOptions,\n    accessor: PathProxy<any>\n  ): string | undefined {\n    let comparisonPropertyValue: any;\n    try {\n      comparisonPropertyValue = accessor.getValueFromPath(\n        options[ValidationKeys.LESS_THAN]\n      );\n    } catch (e: any) {\n      return this.getMessage(e.message || this.message);\n    }\n\n    try {\n      if (!isLessThan(value, comparisonPropertyValue))\n        throw new Error(options.message || this.message);\n    } catch (e: any) {\n      return this.getMessage(e.message, options[ValidationKeys.LESS_THAN]);\n    }\n\n    return undefined;\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport type { LessThanOrEqualValidatorOptions } from \"../types\";\nimport { isLessThan, isValidForGteOrLteComparison } from \"./utils\";\nimport { isEqual } from \"@decaf-ts/reflection\";\nimport type { PathProxy } from \"../../utils/PathProxy\";\n\n/**\n * @summary Less Than or Equal Validator\n *\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LESS_THAN_OR_EQUAL}\n *\n * @class LessThanOrEqualValidator\n * @extends Validator\n *\n * @category Validators\n */\n@validator(ValidationKeys.LESS_THAN_OR_EQUAL)\nexport class LessThanOrEqualValidator extends Validator<LessThanOrEqualValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.LESS_THAN_OR_EQUAL) {\n    super(message);\n  }\n\n  /**\n   * @summary Validates a model\n   *\n   * @param {string} value\n   * @param {LessThanOrEqualValidatorOptions} options\n   * @param {PathProxy<any>} accessor - Proxy-like object used to resolve values from nested structures via path strings.\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: LessThanOrEqualValidatorOptions,\n    accessor: PathProxy<any>\n  ): string | undefined {\n    let comparisonPropertyValue: any;\n    try {\n      comparisonPropertyValue = accessor.getValueFromPath(\n        options[ValidationKeys.LESS_THAN_OR_EQUAL]\n      );\n    } catch (e: any) {\n      return this.getMessage(e.message || this.message);\n    }\n\n    try {\n      if (\n        (isValidForGteOrLteComparison(value, comparisonPropertyValue) &&\n          isEqual(value, comparisonPropertyValue)) ||\n        isLessThan(value, comparisonPropertyValue)\n      )\n        return undefined;\n\n      throw new Error(options.message || this.message);\n    } catch (e: any) {\n      return this.getMessage(\n        e.message,\n        options[ValidationKeys.LESS_THAN_OR_EQUAL]\n      );\n    }\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { ListValidatorOptions } from \"../types\";\n\n/**\n * @description Validator for checking if elements in a list or set match expected types\n * @summary The ListValidator validates that all elements in an array or Set match the expected types.\n * It checks each element against a list of allowed class types and ensures type consistency.\n * This validator is typically used with the @list decorator.\n *\n * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#LIST}\n *\n * @class ListValidator\n * @extends Validator\n *\n * @example\n * ```typescript\n * // Create a list validator with default error message\n * const listValidator = new ListValidator();\n *\n * // Create a list validator with custom error message\n * const customListValidator = new ListValidator(\"All items must be of the specified type\");\n *\n * // Validate a list\n * const options = { clazz: [\"String\", \"Number\"] };\n * const result = listValidator.hasErrors([\"test\", 123], options); // undefined (valid)\n * const invalidResult = listValidator.hasErrors([new Date()], options); // Returns error message (invalid)\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant V as ListValidator\n *\n *   C->>V: new ListValidator(message)\n *   C->>V: hasErrors(value, options)\n *   alt value is empty\n *     V-->>C: undefined (valid)\n *   else value has elements\n *     V->>V: Check each element's type\n *     alt All elements match allowed types\n *       V-->>C: undefined (valid)\n *     else Some elements don't match\n *       V-->>C: Error message\n *     end\n *   end\n *\n * @category Validators\n */\n@validator(ValidationKeys.LIST)\nexport class ListValidator extends Validator<ListValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.LIST) {\n    super(message, Array.name, Set.name);\n  }\n\n  /**\n   * @description Checks if all elements in a list or set match the expected types\n   * @summary Validates that each element in the provided array or Set matches one of the\n   * class types specified in the options. For object types, it checks the constructor name,\n   * and for primitive types, it compares against the lowercase type name.\n   *\n   * @param {any[] | Set<any>} value - The array or Set to validate\n   * @param {ListValidatorOptions} options - Configuration options containing the allowed class types\n   *\n   * @return {string | undefined} Error message if validation fails, undefined if validation passes\n   *\n   * @override\n   *\n   * @see Validator#hasErrors\n   */\n  hasErrors(\n    value: any[] | Set<any>,\n    options: ListValidatorOptions\n  ): string | undefined {\n    if (!value || (Array.isArray(value) ? !value.length : !value.size)) return;\n\n    const clazz = Array.isArray(options.clazz)\n      ? options.clazz\n      : [options.clazz];\n    let val: any,\n      isValid = true;\n    for (\n      let i = 0;\n      i < (Array.isArray(value) ? value.length : value.size);\n      i++\n    ) {\n      val = (value as any)[i];\n      switch (typeof val) {\n        case \"object\":\n        case \"function\":\n          isValid = clazz.includes(((val ?? {}) as object).constructor?.name); // null is an object\n          break;\n        default:\n          isValid = clazz.some((c: string) => typeof val === c.toLowerCase());\n          break;\n      }\n    }\n\n    return isValid\n      ? undefined\n      : this.getMessage(options.message || this.message, clazz);\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { ValidationKeys, DEFAULT_ERROR_MESSAGES } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { MaxLengthValidatorOptions } from \"../types\";\n\n/**\n * @summary Maximum Length Validator\n * @description Validates strings and Arrays on their maximum length\n *\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#MAX_LENGTH}\n *\n * @class MinLengthValidator\n * @extends Validator\n *\n * @category Validators\n */\n@validator(ValidationKeys.MAX_LENGTH)\nexport class MaxLengthValidator extends Validator<MaxLengthValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.MAX_LENGTH) {\n    super(message, String.name, Array.name);\n  }\n\n  /**\n   * @summary Validates a model\n   *\n   * @param {string} value\n   * @param {MaxLengthValidatorOptions} options\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   *\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: string | any[],\n    options: MaxLengthValidatorOptions\n  ): string | undefined {\n    if (typeof value === \"undefined\") return;\n    return value.length > options.maxlength\n      ? this.getMessage(options.message || this.message, options.maxlength)\n      : undefined;\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { MaxValidatorOptions } from \"../types\";\n\n/**\n * @description Validator for checking if a value is less than or equal to a maximum\n * @summary The MaxValidator checks if a numeric value, date, or string is less than or equal to\n * a specified maximum value. It supports comparing numbers directly, dates chronologically,\n * and strings lexicographically. This validator is typically used with the @max decorator.\n * \n * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#MAX}\n * \n * @class MaxValidator\n * @extends Validator\n * \n * @example\n * ```typescript\n * // Create a max validator with default error message\n * const maxValidator = new MaxValidator();\n * \n * // Create a max validator with custom error message\n * const customMaxValidator = new MaxValidator(\"Value must not exceed {0}\");\n * \n * // Validate a number\n * const numOptions = { max: 100, message: \"Number too large\" };\n * const numResult = maxValidator.hasErrors(50, numOptions); // undefined (valid)\n * const invalidNumResult = maxValidator.hasErrors(150, numOptions); // Returns error message (invalid)\n * \n * // Validate a date\n * const dateOptions = { max: new Date(2023, 11, 31) };\n * const dateResult = maxValidator.hasErrors(new Date(2023, 5, 15), dateOptions); // undefined (valid)\n * ```\n * \n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant V as MaxValidator\n *   \n *   C->>V: new MaxValidator(message)\n *   C->>V: hasErrors(value, options)\n *   alt value is undefined\n *     V-->>C: undefined (valid)\n *   else value is Date and max is not Date\n *     V->>V: Convert max to Date\n *     alt conversion fails\n *       V-->>C: Error: Invalid Max param\n *     end\n *   end\n *   alt value > max\n *     V-->>C: Error message\n *   else value <= max\n *     V-->>C: undefined (valid)\n *   end\n * \n * @category Validators\n */\n@validator(ValidationKeys.MAX)\nexport class MaxValidator extends Validator<MaxValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.MAX) {\n    super(message, \"number\", \"Date\", \"string\");\n  }\n\n  /**\n   * @description Checks if a value is less than or equal to a maximum\n   * @summary Validates that the provided value does not exceed the maximum value\n   * specified in the options. For dates, it performs chronological comparison,\n   * converting string representations to Date objects if necessary. For numbers\n   * and strings, it performs direct comparison.\n   *\n   * @param {number | Date | string} value - The value to validate\n   * @param {MaxValidatorOptions} options - Configuration options containing the maximum value\n   *\n   * @return {string | undefined} Error message if validation fails, undefined if validation passes\n   *\n   * @override\n   *\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: number | Date | string,\n    options: MaxValidatorOptions\n  ): string | undefined {\n    if (typeof value === \"undefined\") return;\n\n    let { max } = options;\n    if (value instanceof Date && !(max instanceof Date)) {\n      max = new Date(max);\n      if (Number.isNaN(max.getDate()))\n        throw new Error(\"Invalid Max param defined\");\n    }\n\n    return value > max\n      ? this.getMessage(options.message || this.message, max)\n      : undefined;\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { MinLengthValidatorOptions } from \"../types\";\n\n/**\n * @summary Minimum Length Validator\n * @description Validates strings and Arrays on their minimum length\n *\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#MIN_LENGTH}\n *\n * @class MinLengthValidator\n * @extends Validator\n *\n * @category Validators\n */\n@validator(ValidationKeys.MIN_LENGTH)\nexport class MinLengthValidator extends Validator<MinLengthValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.MIN_LENGTH) {\n    super(message, String.name, Array.name);\n  }\n\n  /**\n   *\n   * @param {string | Array} value\n   * @param {MinLengthValidatorOptions} options\n   *\n   * @return {string | undefined}\n   *\n   * @memberOf module:decorator-validation\n   * @override\n   *\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: string | any[],\n    options: MinLengthValidatorOptions\n  ): string | undefined {\n    if (typeof value === \"undefined\") return;\n    return value.length < options.minlength\n      ? this.getMessage(options.message || this.message, options.minlength)\n      : undefined;\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { MinValidatorOptions } from \"../types\";\n\n/**\n * @description Validator for checking if a value is greater than or equal to a minimum\n * @summary The MinValidator checks if a numeric value, date, or string is greater than or equal to\n * a specified minimum value. It supports comparing numbers directly, dates chronologically,\n * and strings lexicographically. This validator is typically used with the @min decorator.\n * \n * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#MIN}\n * \n * @class MinValidator\n * @extends Validator\n * \n * @example\n * ```typescript\n * // Create a min validator with default error message\n * const minValidator = new MinValidator();\n * \n * // Create a min validator with custom error message\n * const customMinValidator = new MinValidator(\"Value must be at least {0}\");\n * \n * // Validate a number\n * const numOptions = { min: 10, message: \"Number too small\" };\n * const numResult = minValidator.hasErrors(50, numOptions); // undefined (valid)\n * const invalidNumResult = minValidator.hasErrors(5, numOptions); // Returns error message (invalid)\n * \n * // Validate a date\n * const dateOptions = { min: new Date(2023, 0, 1) };\n * const dateResult = minValidator.hasErrors(new Date(2023, 5, 15), dateOptions); // undefined (valid)\n * ```\n * \n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant V as MinValidator\n *   \n *   C->>V: new MinValidator(message)\n *   C->>V: hasErrors(value, options)\n *   alt value is undefined\n *     V-->>C: undefined (valid)\n *   else value is Date and min is not Date\n *     V->>V: Convert min to Date\n *     alt conversion fails\n *       V-->>C: Error: Invalid Min param\n *     end\n *   end\n *   alt value < min\n *     V-->>C: Error message\n *   else value >= min\n *     V-->>C: undefined (valid)\n *   end\n * \n * @category Validators\n */\n@validator(ValidationKeys.MIN)\nexport class MinValidator extends Validator<MinValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.MIN) {\n    super(message, \"number\", \"Date\", \"string\");\n  }\n\n  /**\n   * @description Checks if a value is greater than or equal to a minimum\n   * @summary Validates that the provided value is not less than the minimum value\n   * specified in the options. For dates, it performs chronological comparison,\n   * converting string representations to Date objects if necessary. For numbers\n   * and strings, it performs direct comparison.\n   *\n   * @param {number | Date | string} value - The value to validate\n   * @param {MinValidatorOptions} options - Configuration options containing the minimum value\n   *\n   * @return {string | undefined} Error message if validation fails, undefined if validation passes\n   *\n   * @override\n   *\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: number | Date | string,\n    options: MinValidatorOptions\n  ): string | undefined {\n    if (typeof value === \"undefined\") return;\n\n    let { min } = options;\n    if (value instanceof Date && !(min instanceof Date)) {\n      min = new Date(min);\n      if (Number.isNaN(min.getDate()))\n        throw new Error(\"Invalid Min param defined\");\n    }\n    return value < min\n      ? this.getMessage(options.message || this.message, min)\n      : undefined;\n  }\n}\n","import { PatternValidator } from \"./PatternValidator\";\nimport {\n  DEFAULT_ERROR_MESSAGES,\n  DEFAULT_PATTERNS,\n  ValidationKeys,\n} from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { PatternValidatorOptions } from \"../types\";\n\n/**\n * @summary Handles Password Validation\n *\n * @param {string} [errorMessage] defaults to {@link DEFAULT_ERROR_MESSAGES#PASSWORD}\n *\n * @class PasswordValidator\n * @extends PatternValidator\n *\n * @category Validators\n */\n@validator(ValidationKeys.PASSWORD)\nexport class PasswordValidator extends PatternValidator {\n  constructor(message = DEFAULT_ERROR_MESSAGES.PASSWORD) {\n    super(message);\n  }\n\n  /**\n   * @summary Validates a model\n   *\n   * @param {string} value\n   * @param {PatternValidatorOptions} [options={}]\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   *\n   * @see PatternValidator#hasErrors\n   */\n  public override hasErrors(\n    value: string,\n    options: PatternValidatorOptions = {}\n  ): string | undefined {\n    return super.hasErrors(value, {\n      ...options,\n      message: options.message || this.message,\n      [ValidationKeys.PATTERN]:\n        options?.pattern || DEFAULT_PATTERNS.PASSWORD.CHAR8_ONE_OF_EACH,\n    });\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { ValidatorOptions } from \"../types\";\n\n/**\n * @description Validator for checking if a value is present and not empty\n * @summary The RequiredValidator ensures that a value is provided and not empty.\n * It handles different types of values appropriately: for booleans and numbers,\n * it checks if they're undefined; for other types (strings, arrays, objects),\n * it checks if they're falsy. This validator is typically used with the @required decorator\n * and is often the first validation applied to important fields.\n * \n * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#REQUIRED}\n * \n * @class RequiredValidator\n * @extends Validator\n * \n * @example\n * ```typescript\n * // Create a required validator with default error message\n * const requiredValidator = new RequiredValidator();\n * \n * // Create a required validator with custom error message\n * const customRequiredValidator = new RequiredValidator(\"This field is mandatory\");\n * \n * // Validate different types of values\n * requiredValidator.hasErrors(\"Hello\"); // undefined (valid)\n * requiredValidator.hasErrors(\"\"); // Returns error message (invalid)\n * requiredValidator.hasErrors(0); // undefined (valid - 0 is a valid number)\n * requiredValidator.hasErrors(null); // Returns error message (invalid)\n * requiredValidator.hasErrors([]); // undefined (valid - empty array is still an array)\n * ```\n * \n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant V as RequiredValidator\n *   \n *   C->>V: new RequiredValidator(message)\n *   C->>V: hasErrors(value, options)\n *   alt typeof value is boolean or number\n *     alt value is undefined\n *       V-->>C: Error message\n *     else value is defined\n *       V-->>C: undefined (valid)\n *     end\n *   else other types\n *     alt value is falsy (null, undefined, empty string)\n *       V-->>C: Error message\n *     else value is truthy\n *       V-->>C: undefined (valid)\n *     end\n *   end\n * \n * @category Validators\n */\n@validator(ValidationKeys.REQUIRED)\nexport class RequiredValidator extends Validator {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.REQUIRED) {\n    super(message);\n  }\n\n  /**\n   * @description Checks if a value is present and not empty\n   * @summary Validates that the provided value exists and is not empty.\n   * The validation logic varies by type:\n   * - For booleans and numbers: checks if the value is undefined\n   * - For other types (strings, arrays, objects): checks if the value is falsy\n   *\n   * @param {any} value - The value to validate\n   * @param {ValidatorOptions} [options={}] - Optional configuration options\n   *\n   * @return {string | undefined} Error message if validation fails, undefined if validation passes\n   *\n   * @override\n   *\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: ValidatorOptions = {}\n  ): string | undefined {\n    switch (typeof value) {\n      case \"boolean\":\n      case \"number\":\n        return typeof value === \"undefined\"\n          ? this.getMessage(options.message || this.message)\n          : undefined;\n      default:\n        return !value\n          ? this.getMessage(options.message || this.message)\n          : undefined;\n    }\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { StepValidatorOptions } from \"../types\";\n\n/**\n * @summary Step Validator\n *\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#STEP}\n *\n * @class StepValidator\n * @extends Validator\n *\n * @category Validators\n */\n@validator(ValidationKeys.STEP)\nexport class StepValidator extends Validator<StepValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.STEP) {\n    super(message, \"number\", \"string\");\n  }\n\n  /**\n   * @summary Validates a model\n   *\n   * @param {string} value\n   * @param {number} step\n   * @param {StepValidatorOptions} options\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   *\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: number | string,\n    options: StepValidatorOptions\n  ): string | undefined {\n    if (typeof value === \"undefined\") return;\n    return Number(value) % Number(options.step) !== 0\n      ? this.getMessage(options.message || this.message, options.step)\n      : undefined;\n  }\n}\n","import { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { Validation } from \"../Validation\";\nimport {\n  TypeValidatorOptions,\n  ValidatorDefinition,\n  ValidatorOptions,\n} from \"../types\";\nimport { ModelKeys } from \"../../utils/constants\";\nimport { Reflection } from \"@decaf-ts/reflection\";\n\n/**\n * @description Validator for checking if a value is of the expected type(s)\n * @summary The TypeValidator ensures that a value matches one of the specified types.\n * It can validate against a single type, multiple types, or a type with a specific name.\n * This validator is typically used with the @type decorator and is fundamental for\n * ensuring type safety in validated models.\n *\n * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#TYPE}\n *\n * @class TypeValidator\n * @extends Validator\n *\n * @example\n * ```typescript\n * // Create a type validator with default error message\n * const typeValidator = new TypeValidator();\n *\n * // Create a type validator with custom error message\n * const customTypeValidator = new TypeValidator(\"Value must be of type {0}, but got {1}\");\n *\n * // Validate against a single type\n * const stringOptions = { types: \"string\" };\n * typeValidator.hasErrors(\"hello\", stringOptions); // undefined (valid)\n * typeValidator.hasErrors(123, stringOptions); // Returns error message (invalid)\n *\n * // Validate against multiple types\n * const multiOptions = { types: [\"string\", \"number\"] };\n * typeValidator.hasErrors(\"hello\", multiOptions); // undefined (valid)\n * typeValidator.hasErrors(123, multiOptions); // undefined (valid)\n * typeValidator.hasErrors(true, multiOptions); // Returns error message (invalid)\n *\n * // Validate against a class type\n * const classOptions = { types: { name: \"Date\" } };\n * typeValidator.hasErrors(new Date(), classOptions); // undefined (valid)\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant V as TypeValidator\n *   participant R as Reflection\n *\n *   C->>V: new TypeValidator(message)\n *   C->>V: hasErrors(value, options)\n *   alt value is undefined\n *     V-->>C: undefined (valid)\n *   else value is defined\n *     V->>R: evaluateDesignTypes(value, types)\n *     alt type evaluation passes\n *       V-->>C: undefined (valid)\n *     else type evaluation fails\n *       V->>V: Format error message with type info\n *       V-->>C: Error message\n *     end\n *   end\n *\n * @category Validators\n */\n@validator(ValidationKeys.TYPE)\nexport class TypeValidator extends Validator<TypeValidatorOptions> {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.TYPE) {\n    super(message);\n  }\n\n  /**\n   * @description Checks if a value is of the expected type(s)\n   * @summary Validates that the provided value matches one of the specified types.\n   * It uses the Reflection utility to evaluate if the value's type matches the expected types.\n   * The method skips validation for undefined values to avoid conflicts with the RequiredValidator.\n   *\n   * @param {any} value - The value to validate\n   * @param {TypeValidatorOptions} options - Configuration options containing the expected types\n   *\n   * @return {string | undefined} Error message if validation fails, undefined if validation passes\n   *\n   * @override\n   *\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: TypeValidatorOptions\n  ): string | undefined {\n    if (value === undefined) return; // Don't try and enforce type if undefined\n    const { types, message } = options;\n    if (!Reflection.evaluateDesignTypes(value, types))\n      return this.getMessage(\n        message || this.message,\n        typeof types === \"string\"\n          ? types\n          : Array.isArray(types)\n            ? types.join(\", \")\n            : types.name,\n        typeof value\n      );\n  }\n}\n\n/**\n * @description Register the TypeValidator with the Validation registry\n * @summary This registration associates the TypeValidator with the ModelKeys.TYPE key,\n * allowing it to be used for validating design types. The save flag is set to false\n * to prevent the validator from being saved in the standard validator registry.\n *\n * @memberOf module:decorator-validation\n */\nValidation.register({\n  validator: TypeValidator as ValidatorOptions,\n  validationKey: ModelKeys.TYPE,\n  save: false,\n} as ValidatorDefinition);\n","import {\n  ValidationKeys,\n  DEFAULT_ERROR_MESSAGES,\n  DEFAULT_PATTERNS,\n} from \"./constants\";\nimport { PatternValidator } from \"./PatternValidator\";\nimport { validator } from \"./decorators\";\nimport { PatternValidatorOptions } from \"../types\";\n\n/**\n * @description Validator for checking if a string is a valid URL\n * @summary The URLValidator checks if a string matches a standard URL pattern.\n * It extends the PatternValidator and uses a robust URL regex pattern to validate web addresses.\n * The pattern is sourced from {@link https://gist.github.com/dperini/729294} and is widely\n * recognized for its accuracy in validating URLs. This validator is typically used with the @url decorator.\n *\n * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#URL}\n *\n * @class URLValidator\n * @extends PatternValidator\n *\n * @example\n * ```typescript\n * // Create a URL validator with default error message\n * const urlValidator = new URLValidator();\n *\n * // Create a URL validator with custom error message\n * const customUrlValidator = new URLValidator(\"Please enter a valid web address\");\n *\n * // Validate a URL\n * const result = urlValidator.hasErrors(\"https://example.com\"); // undefined (valid)\n * const invalidResult = urlValidator.hasErrors(\"not-a-url\"); // Returns error message (invalid)\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant U as URLValidator\n *   participant P as PatternValidator\n *\n *   C->>U: new URLValidator(message)\n *   U->>P: super(message)\n *   C->>U: hasErrors(value, options)\n *   U->>P: super.hasErrors(value, options with URL pattern)\n *   P-->>U: validation result\n *   U-->>C: validation result\n *\n * @category Validators\n */\n@validator(ValidationKeys.URL)\nexport class URLValidator extends PatternValidator {\n  constructor(message: string = DEFAULT_ERROR_MESSAGES.URL) {\n    super(message);\n  }\n\n  /**\n   * @description Checks if a string is a valid URL\n   * @summary Validates that the provided string matches the URL pattern.\n   * This method extends the PatternValidator's hasErrors method by ensuring\n   * the URL pattern is used, even if not explicitly provided in the options.\n   *\n   * @param {string} value - The string to validate as a URL\n   * @param {PatternValidatorOptions} [options={}] - Optional configuration options\n   *\n   * @return {string | undefined} Error message if validation fails, undefined if validation passes\n   *\n   * @override\n   *\n   * @see PatternValidator#hasErrors\n   */\n  public override hasErrors(\n    value: string,\n    options: PatternValidatorOptions = {}\n  ): string | undefined {\n    return super.hasErrors(value, {\n      ...options,\n      message: options.message || this.message,\n      pattern: options.pattern || DEFAULT_PATTERNS.URL,\n    });\n  }\n}\n","import \"reflect-metadata\";\nimport {\n  DateValidatorOptions,\n  DiffValidatorOptions,\n  EqualsValidatorOptions,\n  GreaterThanOrEqualValidatorOptions,\n  GreaterThanValidatorOptions,\n  LessThanOrEqualValidatorOptions,\n  LessThanValidatorOptions,\n  ListValidatorOptions,\n  MaxLengthValidatorOptions,\n  MaxValidatorOptions,\n  MinLengthValidatorOptions,\n  MinValidatorOptions,\n  PatternValidatorOptions,\n  StepValidatorOptions,\n  ValidationMetadata,\n  ValidatorOptions,\n} from \"./types\";\nimport {\n  DEFAULT_ERROR_MESSAGES,\n  DEFAULT_PATTERNS,\n  ValidationKeys,\n} from \"./Validators/constants\";\nimport { sf } from \"../utils/strings\";\nimport { Constructor, ModelConstructor } from \"../model/types\";\nimport { parseDate } from \"../utils/dates\";\nimport { propMetadata } from \"../utils/decorators\";\nimport { Validation } from \"./Validation\";\nimport { Decoration } from \"../utils/Decoration\";\nimport { apply } from \"@decaf-ts/reflection\";\nimport { ASYNC_META_KEY } from \"../constants\";\n\n/**\n * @description Combined property decorator factory for metadata and attribute marking\n * @summary Creates a decorator that both marks a property as a model attribute and assigns metadata to it\n *\n * @template V\n * @param {PropertyDecorator} decorator - The metadata key\n * @param {string} key - The metadata key\n * @param {V} value - The metadata value to associate with the property\n * @return {Function} - Combined decorator function\n * @function validationMetadata\n * @category Property Decorators\n */\nexport function validationMetadata<V>(decorator: any, key: string, value: V) {\n  Validation.registerDecorator(key, decorator);\n  return apply(propMetadata<V>(key, value));\n}\n\nexport function async() {\n  return (model: object): void => {\n    if (!Object.prototype.hasOwnProperty.call(model, ASYNC_META_KEY))\n      (model as any)[ASYNC_META_KEY] = true;\n  };\n}\n\n/**\n * @description Property decorator that marks a field as required\n * @summary Marks the property as required, causing validation to fail if the property is undefined, null, or empty.\n * Validators to validate a decorated property must use key {@link ValidationKeys#REQUIRED}.\n * This decorator is commonly used as the first validation step for important fields.\n *\n * @param {string} [message] - The error message to display when validation fails. Defaults to {@link DEFAULT_ERROR_MESSAGES#REQUIRED}\n * @return {PropertyDecorator} A decorator function that can be applied to class properties\n *\n * @function required\n * @category Property Decorators\n *\n * @example\n * ```typescript\n * class User {\n *   @required()\n *   username: string;\n *\n *   @required(\"Email address is mandatory\")\n *   email: string;\n * }\n * ```\n */\nexport function required(message: string = DEFAULT_ERROR_MESSAGES.REQUIRED) {\n  const key = Validation.key(ValidationKeys.REQUIRED);\n  const meta: ValidatorOptions = {\n    message: message,\n    description: `defines the attribute as required`,\n    async: false,\n  };\n  return Decoration.for(key)\n    .define(validationMetadata<ValidatorOptions>(required, key, meta))\n    .apply();\n}\n\n/**\n * @description Property decorator that enforces a minimum value constraint\n * @summary Defines a minimum value for the property, causing validation to fail if the property value is less than the specified minimum.\n * Validators to validate a decorated property must use key {@link ValidationKeys#MIN}.\n * This decorator works with numeric values and dates.\n *\n * @param {number | Date | string} value - The minimum value allowed. For dates, can be a Date object or a string that can be converted to a date\n * @param {string} [message] - The error message to display when validation fails. Defaults to {@link DEFAULT_ERROR_MESSAGES#MIN}\n * @return {PropertyDecorator} A decorator function that can be applied to class properties\n *\n * @function min\n * @category Property Decorators\n *\n * @example\n * ```typescript\n * class Product {\n *   @min(0)\n *   price: number;\n *\n *   @min(new Date(2023, 0, 1), \"Date must be after January 1, 2023\")\n *   releaseDate: Date;\n * }\n * ```\n */\nexport function min(\n  value: number | Date | string,\n  message: string = DEFAULT_ERROR_MESSAGES.MIN\n) {\n  const key = Validation.key(ValidationKeys.MIN);\n  const meta: MinValidatorOptions = {\n    [ValidationKeys.MIN]: value,\n    message: message,\n    types: [Number.name, Date.name],\n    description: `defines the max value of the attribute as ${value} (applies to numbers or Dates)`,\n    async: false,\n  };\n  return Decoration.for(key)\n    .define(validationMetadata<MinValidatorOptions>(min, key, meta))\n    .apply();\n}\n\n/**\n * @summary Defines a maximum value for the property\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#MAX}\n *\n * @param {number | Date} value\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#MAX}\n *\n * @function max\n * @category Property Decorators\n */\nexport function max(\n  value: number | Date | string,\n  message: string = DEFAULT_ERROR_MESSAGES.MAX\n) {\n  const key = Validation.key(ValidationKeys.MAX);\n  const meta: MaxValidatorOptions = {\n    [ValidationKeys.MAX]: value,\n    message: message,\n    types: [Number.name, Date.name],\n    description: `defines the max value of the attribute as ${value} (applies to numbers or Dates)`,\n    async: false,\n  };\n  return Decoration.for(key)\n    .define(validationMetadata<MaxValidatorOptions>(max, key, meta))\n    .apply();\n}\n\n/**\n * @summary Defines a step value for the property\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#STEP}\n *\n * @param {number} value\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#STEP}\n *\n * @function step\n * @category Property Decorators\n */\nexport function step(\n  value: number,\n  message: string = DEFAULT_ERROR_MESSAGES.STEP\n) {\n  const key = Validation.key(ValidationKeys.STEP);\n  const meta: StepValidatorOptions = {\n    [ValidationKeys.STEP]: value,\n    message: message,\n    types: [Number.name],\n    description: `defines the step of the attribute as ${value}`,\n    async: false,\n  };\n  return Decoration.for(key)\n    .define(validationMetadata<StepValidatorOptions>(step, key, meta))\n    .apply();\n}\n\n/**\n * @summary Defines a minimum length for the property\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#MIN_LENGTH}\n *\n * @param {string} value\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#MIN_LENGTH}\n *\n * @function minlength\n * @category Property Decorators\n */\nexport function minlength(\n  value: number,\n  message: string = DEFAULT_ERROR_MESSAGES.MIN_LENGTH\n) {\n  const key = Validation.key(ValidationKeys.MIN_LENGTH);\n  const meta: MinLengthValidatorOptions = {\n    [ValidationKeys.MIN_LENGTH]: value,\n    message: message,\n    types: [String.name, Array.name, Set.name],\n    description: `defines the min length of the attribute as ${value} (applies to strings or lists)`,\n    async: false,\n  };\n  return Decoration.for(key)\n    .define(validationMetadata<MinLengthValidatorOptions>(minlength, key, meta))\n    .apply();\n}\n\n/**\n * @summary Defines a maximum length for the property\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#MAX_LENGTH}\n *\n * @param {string} value\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#MAX_LENGTH}\n *\n * @function maxlength\n * @category Property Decorators\n */\nexport function maxlength(\n  value: number,\n  message: string = DEFAULT_ERROR_MESSAGES.MAX_LENGTH\n) {\n  const key = Validation.key(ValidationKeys.MAX_LENGTH);\n  const meta: MaxLengthValidatorOptions = {\n    [ValidationKeys.MAX_LENGTH]: value,\n    message: message,\n    types: [String.name, Array.name, Set.name],\n    description: `defines the max length of the attribute as ${value} (applies to strings or lists)`,\n    async: false,\n  };\n  return Decoration.for(key)\n    .define(validationMetadata<MaxLengthValidatorOptions>(maxlength, key, meta))\n    .apply();\n}\n\n/**\n * @summary Defines a RegExp pattern the property must respect\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#PATTERN}\n *\n * @param {string} value\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#PATTERN}\n *\n * @function pattern\n * @category Property Decorators\n */\nexport function pattern(\n  value: RegExp | string,\n  message: string = DEFAULT_ERROR_MESSAGES.PATTERN\n) {\n  const key = Validation.key(ValidationKeys.PATTERN);\n  const meta: PatternValidatorOptions = {\n    [ValidationKeys.PATTERN]:\n      typeof value === \"string\" ? value : value.toString(),\n    message: message,\n    types: [String.name],\n    description: `assigns the ${value === \"string\" ? value : value.toString()} pattern to the attribute`,\n    async: false,\n  };\n  return Decoration.for(key)\n    .define(validationMetadata<PatternValidatorOptions>(pattern, key, meta))\n    .apply();\n}\n\n/**\n * @summary Defines the property as an email\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#EMAIL}\n *\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#EMAIL}\n *\n * @function email\n * @category Property Decorators\n */\nexport function email(message: string = DEFAULT_ERROR_MESSAGES.EMAIL) {\n  const key = Validation.key(ValidationKeys.EMAIL);\n  const meta: PatternValidatorOptions = {\n    [ValidationKeys.PATTERN]: DEFAULT_PATTERNS.EMAIL.toString(),\n    message: message,\n    types: [String.name],\n    description: \"marks the attribute as an email\",\n    async: false,\n  };\n  return Decoration.for(key)\n    .define(validationMetadata<PatternValidatorOptions>(email, key, meta))\n    .apply();\n}\n\n/**\n * @summary Defines the property as an URL\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#URL}\n *\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#URL}\n *\n * @function url\n * @category Property Decorators\n */\nexport function url(message: string = DEFAULT_ERROR_MESSAGES.URL) {\n  const key = Validation.key(ValidationKeys.URL);\n  const meta: PatternValidatorOptions = {\n    [ValidationKeys.PATTERN]: DEFAULT_PATTERNS.URL.toString(),\n    message: message,\n    types: [String.name],\n    description: \"marks the attribute as an url\",\n    async: false,\n  };\n  return Decoration.for(key)\n    .define(validationMetadata<PatternValidatorOptions>(url, key, meta))\n    .apply();\n}\n\nexport interface TypeMetadata extends ValidatorOptions {\n  customTypes: string[] | string;\n}\n\n/**\n * @summary Enforces type verification\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#TYPE}\n *\n * @param {string[] | string} types accepted types\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#TYPE}\n *\n * @function type\n * @category Property Decorators\n */\nexport function type(\n  types: string[] | string,\n  message: string = DEFAULT_ERROR_MESSAGES.TYPE\n) {\n  const key = Validation.key(ValidationKeys.TYPE);\n  const meta: TypeMetadata = {\n    customTypes: types,\n    message: message,\n    description: \"defines the accepted types for the attribute\",\n    async: false,\n  };\n  return Decoration.for(key)\n    .define(validationMetadata<TypeMetadata>(type, key, meta))\n    .apply();\n}\n\nexport interface DateMetadata extends DateValidatorOptions {\n  types: string[];\n}\n\n/**\n * @summary Date Handler Decorator\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#DATE}\n *\n * Will enforce serialization according to the selected format\n *\n * @param {string} format accepted format according to {@link formatDate}\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#DATE}\n *\n * @function date\n *\n * @category Property Decorators\n */\nexport function date(\n  format: string = \"dd/MM/yyyy\",\n  message: string = DEFAULT_ERROR_MESSAGES.DATE\n) {\n  const key = Validation.key(ValidationKeys.DATE);\n  const meta: DateMetadata = {\n    [ValidationKeys.FORMAT]: format,\n    message: message,\n    types: [Date.name],\n    description: `defines the attribute as a date with the format ${format}`,\n    async: false,\n  };\n  const dateDec = (target: Record<string, any>, propertyKey?: any): any => {\n    validationMetadata(date, key, meta)(target, propertyKey);\n\n    const values = new WeakMap();\n\n    Object.defineProperty(target, propertyKey, {\n      configurable: false,\n      set(this: any, newValue: string | Date) {\n        const descriptor = Object.getOwnPropertyDescriptor(this, propertyKey);\n        if (!descriptor || descriptor.configurable)\n          Object.defineProperty(this, propertyKey, {\n            enumerable: true,\n            configurable: false,\n            get: () => values.get(this),\n            set: (newValue: string | Date | number) => {\n              let val: Date | undefined;\n              try {\n                val = parseDate(format, newValue);\n                values.set(this, val);\n              } catch (e: any) {\n                console.error(sf(\"Failed to parse date: {0}\", e.message || e));\n              }\n            },\n          });\n        this[propertyKey] = newValue;\n      },\n      get() {\n        console.log(\"here\");\n      },\n    });\n  };\n  return Decoration.for(key).define(dateDec).apply();\n}\n\n/**\n * @summary Password Handler Decorator\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#PASSWORD}\n *\n * @param {RegExp} [pattern] defaults to {@link DEFAULT_PATTERNS#CHAR8_ONE_OF_EACH}\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#PASSWORD}\n *\n * @function password\n *\n * @category Property Decorators\n */\nexport function password(\n  pattern: RegExp = DEFAULT_PATTERNS.PASSWORD.CHAR8_ONE_OF_EACH,\n  message: string = DEFAULT_ERROR_MESSAGES.PASSWORD\n) {\n  const key = Validation.key(ValidationKeys.PASSWORD);\n  const meta: PatternValidatorOptions = {\n    [ValidationKeys.PATTERN]: pattern.toString(),\n    message: message,\n    types: [String.name],\n    description: `attribute as a password`,\n    async: false,\n  };\n  return Decoration.for(key)\n    .define(validationMetadata(password, key, meta))\n    .apply();\n}\n\nexport interface ListMetadata extends ListValidatorOptions {\n  type: \"Array\" | \"Set\";\n}\n\n/**\n * @summary List Decorator\n * @description Also sets the {@link type} to the provided collection\n *\n * @param {ModelConstructor} clazz\n * @param {string} [collection] The collection being used. defaults to Array\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LIST}\n *\n * @function list\n *\n * @category Property Decorators\n */\nexport function list(\n  clazz: Constructor<any> | Constructor<any>[],\n  collection: \"Array\" | \"Set\" = \"Array\",\n  message: string = DEFAULT_ERROR_MESSAGES.LIST\n) {\n  const key = Validation.key(ValidationKeys.LIST);\n  const meta: ListMetadata = {\n    clazz: Array.isArray(clazz) ? clazz.map((c) => c.name) : [clazz.name],\n    type: collection,\n    message: message,\n    async: false,\n    description: `defines the attribute as a ${collection} of ${(clazz as ModelConstructor<any>).name}`,\n  };\n  return Decoration.for(key)\n    .define(validationMetadata(list, key, meta))\n    .apply();\n}\n\n/**\n * @summary Set Decorator\n * @description Wrapper for {@link list} with the 'Set' Collection\n *\n * @param {ModelConstructor} clazz\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LIST}\n *\n * @function set\n *\n * @category Property Decorators\n */\nexport function set(\n  clazz: ModelConstructor<any>,\n  message: string = DEFAULT_ERROR_MESSAGES.LIST\n) {\n  return list(clazz, \"Set\", message);\n}\n\n/**\n * @summary Declares that the decorated property must be equal to another specified property.\n * @description Applies the {@link ValidationKeys.EQUALS} validator to ensure the decorated value matches the value of the given property.\n *\n * @param {string} propertyToCompare - The name of the property to compare equality against.\n * @param {string} [message=DEFAULT_ERROR_MESSAGES.EQUALS] - Custom error message to return if validation fails.\n *\n * @returns {PropertyDecorator} A property decorator used to register the equality validation metadata.\n *\n * @function eq\n * @category Property Decorators\n */\nexport function eq(\n  propertyToCompare: string,\n  message: string = DEFAULT_ERROR_MESSAGES.EQUALS\n) {\n  const options: EqualsValidatorOptions = {\n    message: message,\n    [ValidationKeys.EQUALS]: propertyToCompare,\n    description: `defines attribute as equal to ${propertyToCompare}`,\n  };\n\n  return validationMetadata<ValidationMetadata>(\n    eq,\n    Validation.key(ValidationKeys.EQUALS),\n    { ...options, async: false } as ValidationMetadata\n  );\n}\n\n/**\n * @summary Declares that the decorated property must be different from another specified property.\n * @description Applies the {@link ValidationKeys.DIFF} validator to ensure the decorated value is different from the value of the given property.\n *\n * @param {string} propertyToCompare - The name of the property to compare difference against.\n * @param {string} [message=DEFAULT_ERROR_MESSAGES.DIFF] - Custom error message to return if validation fails.\n *\n * @returns {PropertyDecorator} A property decorator used to register the difference validation metadata.\n *\n * @function diff\n * @category Property Decorators\n */\nexport function diff(\n  propertyToCompare: string,\n  message: string = DEFAULT_ERROR_MESSAGES.DIFF\n) {\n  const options: DiffValidatorOptions = {\n    message: message,\n    [ValidationKeys.DIFF]: propertyToCompare,\n    description: `defines attribute as different to ${propertyToCompare}`,\n  };\n\n  return validationMetadata<ValidationMetadata>(\n    diff,\n    Validation.key(ValidationKeys.DIFF),\n    {\n      ...options,\n      async: false,\n    } as ValidationMetadata\n  );\n}\n\n/**\n * @summary Declares that the decorated property must be less than another specified property.\n * @description Applies the {@link ValidationKeys.LESS_THAN} validator to ensure the decorated value is less than the value of the given property.\n *\n * @param {string} propertyToCompare - The name of the property to compare against.\n * @param {string} [message=DEFAULT_ERROR_MESSAGES.LESS_THAN] - Custom error message to return if validation fails.\n *\n * @returns {PropertyDecorator} A property decorator used to register the less than validation metadata.\n *\n * @function lt\n * @category Property Decorators\n */\nexport function lt(\n  propertyToCompare: string,\n  message: string = DEFAULT_ERROR_MESSAGES.LESS_THAN\n) {\n  const options: LessThanValidatorOptions = {\n    message: message,\n    [ValidationKeys.LESS_THAN]: propertyToCompare,\n    description: `defines attribute as less than to ${propertyToCompare}`,\n  };\n\n  return validationMetadata<ValidationMetadata>(\n    lt,\n    Validation.key(ValidationKeys.LESS_THAN),\n    { ...options, async: false } as ValidationMetadata\n  );\n}\n\n/**\n * @summary Declares that the decorated property must be equal or less than another specified property.\n * @description Applies the {@link ValidationKeys.LESS_THAN_OR_EQUAL} validator to ensure the decorated value is equal or less than the value of the given property.\n *\n * @param {string} propertyToCompare - The name of the property to compare against.\n * @param {string} [message=DEFAULT_ERROR_MESSAGES.LESS_THAN_OR_EQUAL] - Custom error message to return if validation fails.\n *\n * @returns {PropertyDecorator} A property decorator used to register the less than or equal validation metadata.\n *\n * @function lte\n * @category Property Decorators\n */\nexport function lte(\n  propertyToCompare: string,\n  message: string = DEFAULT_ERROR_MESSAGES.LESS_THAN_OR_EQUAL\n) {\n  const options: LessThanOrEqualValidatorOptions = {\n    message: message,\n    [ValidationKeys.LESS_THAN_OR_EQUAL]: propertyToCompare,\n    description: `defines attribute as less or equal to ${propertyToCompare}`,\n  };\n\n  return validationMetadata<ValidationMetadata>(\n    lte,\n    Validation.key(ValidationKeys.LESS_THAN_OR_EQUAL),\n    { ...options, async: false } as ValidationMetadata\n  );\n}\n\n/**\n * @summary Declares that the decorated property must be greater than another specified property.\n * @description Applies the {@link ValidationKeys.GREATER_THAN} validator to ensure the decorated value is greater than the value of the given property.\n *\n * @param {string} propertyToCompare - The name of the property to compare against.\n * @param {string} [message=DEFAULT_ERROR_MESSAGES.GREATER_THAN] - Custom error message to return if validation fails.\n *\n * @returns {PropertyDecorator} A property decorator used to register the greater than validation metadata.\n *\n * @function gt\n * @category Property Decorators\n */\nexport function gt(\n  propertyToCompare: string,\n  message: string = DEFAULT_ERROR_MESSAGES.GREATER_THAN\n) {\n  const options: GreaterThanValidatorOptions = {\n    message: message,\n    [ValidationKeys.GREATER_THAN]: propertyToCompare,\n    description: `defines attribute as greater than ${propertyToCompare}`,\n  };\n\n  return validationMetadata<ValidationMetadata>(\n    gt,\n    Validation.key(ValidationKeys.GREATER_THAN),\n    { ...options, async: false } as ValidationMetadata\n  );\n}\n\n/**\n * @summary Declares that the decorated property must be equal or greater than another specified property.\n * @description Applies the {@link ValidationKeys.GREATER_THAN_OR_EQUAL} validator to ensure the decorated value is equal or greater than the value of the given property.\n *\n * @param {string} propertyToCompare - The name of the property to compare against.\n * @param {string} [message=DEFAULT_ERROR_MESSAGES.GREATER_THAN_OR_EQUAL] - Custom error message to return if validation fails.\n *\n * @returns {PropertyDecorator} A property decorator used to register the greater than or equal validation metadata.\n *\n * @function gte\n * @category Property Decorators\n */\nexport function gte(\n  propertyToCompare: string,\n  message: string = DEFAULT_ERROR_MESSAGES.GREATER_THAN_OR_EQUAL\n) {\n  const options: GreaterThanOrEqualValidatorOptions = {\n    message: message,\n    [ValidationKeys.GREATER_THAN_OR_EQUAL]: propertyToCompare,\n    description: `defines attribute as greater or equal to ${propertyToCompare}`,\n  };\n\n  return validationMetadata<ValidationMetadata>(\n    gte,\n    Validation.key(ValidationKeys.GREATER_THAN_OR_EQUAL),\n    { ...options, async: false } as ValidationMetadata\n  );\n}\n","import { Model } from \"./Model\";\n\n/**\n * @summary Helper Function to override constructors\n *\n * @template M the model instance type\n *\n * @param {Function} constructor\n * @param {any[]} [args]\n * @return {M} the new instance\n *\n * @function construct\n * @memberOf module:decorator-validation\n */\nexport function construct<M extends Model>(\n  constructor: any,\n  ...args: any[]\n): M {\n  const _constr = (...argz: any[]) => new constructor(...argz);\n  _constr.prototype = constructor.prototype;\n  return _constr(...args);\n}\n\n/**\n * @summary Recursively finds the last prototype before Object\n * @param {object} obj\n *\n * @function findLastProtoBeforeObject\n * @memberOf module:decorator-validation\n */\nexport function findLastProtoBeforeObject(obj: object): object {\n  let prototype: any = Object.getPrototypeOf(obj);\n  if (prototype === Object.prototype) return obj;\n  while (prototype !== Object.prototype) {\n    prototype = Object.getPrototypeOf(prototype);\n    if (prototype === Object.prototype) return prototype;\n    if (Object.getPrototypeOf(prototype) === Object.prototype) return prototype;\n  }\n  throw new Error(\"Could not find proper prototype\");\n}\n\n/**\n * @sumary binds the {@link Model} class as a root prototype of the provided instance\n *\n * @param {unknown} obj\n *\n * @function bindModelPrototype\n * @memberOf module:decorator-validation\n */\nexport function bindModelPrototype(obj: unknown) {\n  if (obj instanceof Model) return;\n\n  function bindPrototype(objToOverride: unknown, prototype: object) {\n    Object.setPrototypeOf(objToOverride, prototype);\n  }\n\n  const prototype: any = Object.getPrototypeOf(obj);\n  if (prototype === Object.prototype) {\n    return bindPrototype(obj, Model.prototype);\n  }\n  while (prototype !== Object.prototype) {\n    const prot = Object.getPrototypeOf(prototype);\n    if (\n      prot === Object.prototype ||\n      Object.getPrototypeOf(prot) === Object.prototype\n    ) {\n      return bindPrototype(prototype, Model.prototype);\n    }\n  }\n  throw new Error(\"Could not find proper prototype to bind\");\n}\n","import { bindModelPrototype, construct } from \"./construction\";\nimport { ModelKeys } from \"../utils/constants\";\nimport { Model } from \"./Model\";\nimport { metadata } from \"@decaf-ts/reflection\";\n\n/**\n * @summary defines the tpe os an InstanceCallback function\n *\n * @memberOf module:decorator-validation\n * @category Model\n */\nexport type InstanceCallback = (instance: any, ...args: any[]) => void;\n\n/**\n * @summary Defines a class as a Model class\n * @description\n *\n * - Registers the class under the model registry so it can be easily rebuilt;\n * - Overrides the class constructor;\n * - Runs the global {@link ModelBuilderFunction} if defined;\n * - Runs the optional {@link InstanceCallback} if provided;\n *\n * @param {InstanceCallback} [instanceCallback] optional callback that will be called with the instance upon instantiation. defaults to undefined\n *\n * @function model\n *\n * @category Class Decorators\n */\nexport function model(instanceCallback?: InstanceCallback) {\n  return ((original: any) => {\n    // the new constructor behaviour\n    const newConstructor: any = function (...args: any[]) {\n      const instance: ReturnType<typeof original> = construct(\n        original,\n        ...args\n      );\n      bindModelPrototype(instance);\n      // run a builder function if defined with the first argument (The ModelArg)\n      const builder = Model.getBuilder();\n      if (builder) builder(instance, args.length ? args[0] : undefined);\n\n      metadata(Model.key(ModelKeys.MODEL), original.name)(instance.constructor);\n\n      if (instanceCallback) instanceCallback(instance, ...args);\n\n      return instance;\n    };\n\n    // copy prototype so instanceof operator still works\n    newConstructor.prototype = original.prototype;\n\n    Reflect.getMetadataKeys(original).forEach((key) => {\n      Reflect.defineMetadata(\n        key,\n        Reflect.getMetadata(key, original),\n        newConstructor\n      );\n    });\n    // Sets the proper constructor name for type verification\n    Object.defineProperty(newConstructor, \"name\", {\n      writable: false,\n      enumerable: true,\n      configurable: false,\n      value: original.prototype.constructor.name,\n    });\n\n    metadata(Model.key(ModelKeys.MODEL), original.name)(original);\n\n    Model.register(newConstructor, original.name);\n\n    // return new constructor (will override original)\n    return newConstructor;\n  }) as any;\n}\n\n/**\n * @summary Defines the hashing algorithm to use on the model\n * @description\n *\n * - Registers the class under the model registry so it can be easily rebuilt;\n * - Overrides the class constructor;\n * - Runs the global {@link ModelBuilderFunction} if defined;\n * - Runs the optional {@link InstanceCallback} if provided;\n *\n * @param {string} algorithm the algorithm to use\n *\n * @function hashedBy\n *\n * @category Class Decorators\n */\nexport function hashedBy(algorithm: string, ...args: any[]) {\n  return metadata(Model.key(ModelKeys.HASHING), {\n    algorithm: algorithm,\n    args: args,\n  });\n}\n\n/**\n * @summary Defines the serialization algorithm to use on the model\n *\n * @param {string} serializer the algorithm to use\n *\n * @function serializedBy\n *\n * @category Class Decorators\n */\nexport function serializedBy(serializer: string, ...args: any[]) {\n  return metadata(Model.key(ModelKeys.SERIALIZATION), {\n    serializer: serializer,\n    args: args,\n  });\n}\n\n/**\n * @summary Applies descriptive metadata to a class, property or method\n *\n * @param {string} description the description to apply\n *\n * @function description\n *\n * @category Decorators\n */\nexport function description(description: string) {\n  return metadata(Model.key(ModelKeys.DESCRIPTION), description);\n}\n","/**\n * @module decorator-validation\n * @description TypeScript decorator-based validation library\n * @summary This module provides a comprehensive validation framework using TypeScript decorators.\n * It exposes utility functions, validation decorators, and model-related functionality for\n * implementing type-safe, declarative validation in TypeScript applications.\n */\nexport * from \"./constants\";\nexport * from \"./utils\";\nexport * from \"./validation\";\nexport * from \"./model\";\n\n/**\n * @description Current version of the reflection package\n * @summary Stores the semantic version number of the package\n * @const VERSION\n * @memberOf module:decorator-validation\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":[],"mappings":"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"}