@decaf-ts/decorator-validation 1.6.5 → 1.7.1

package/dist/decorator-validation.cjs

@@ -1,32 +1,29 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('reflect-metadata'), require('@decaf-ts/reflection')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'reflect-metadata', '@decaf-ts/reflection'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["decorator-validation"] = {}, null, global.reflection));
-})(this, (function (exports, reflectMetadata, reflection) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('reflect-metadata'), require('@decaf-ts/reflection'), require('tslib')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'reflect-metadata', '@decaf-ts/reflection', 'tslib'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["decorator-validation"] = {}, null, global.reflection, global.tslib));
+})(this, (function (exports, reflectMetadata, reflection, tslib) { 'use strict';
 
     /**
-     * Symbol used to internally track the parent object during nested validation.
-     *
-     * This key is attached to child objects to provide context about their parent
-     * in the object hierarchy, enabling validations that depend on parent values.
-     *
-     * @constant VALIDATION_PARENT_KEY
-     * @memberOf module:decorator-validation.Model
-     */
-    const VALIDATION_PARENT_KEY = Symbol("_validationParentRef");
-
-    /**
-     * @summary Defines the various Model keys used for reflection
-     *
-     * @property {string} REFLECT prefix to all other keys
-     * @property {string} TYPE type key
-     * @property {string} PARAMS method params key
-     * @property {string} RETURN method return key
-     * @property {string} MODEL model key
-     * @property {string} ANCHOR anchor key. will serve as a ghost property in the model
-     *
-     * @constant ModelKeys
-     * @memberOf module:decorator-validation.Model
+     * @description Enum containing metadata keys used for reflection in the model system
+     * @summary Defines the various Model keys used for reflection and metadata storage.
+     * These keys are used throughout the library to store and retrieve metadata about models,
+     * their properties, and their behavior.
+     *
+     * @property {string} REFLECT - Prefix to all other keys, used as a namespace
+     * @property {string} TYPE - Key for storing design type information
+     * @property {string} PARAMS - Key for storing method parameter types
+     * @property {string} RETURN - Key for storing method return type
+     * @property {string} MODEL - Key for identifying model metadata
+     * @property {string} ANCHOR - Anchor key that serves as a ghost property in the model
+     * @property {string} CONSTRUCTION - Key for storing construction information
+     * @property {string} ATTRIBUTE - Key for storing attribute metadata
+     * @property {string} HASHING - Key for storing hashing configuration
+     * @property {string} SERIALIZATION - Key for storing serialization configuration
+     *
+     * @readonly
+     * @enum {string}
+     * @memberOf module:decorator-validation
      * @category Model
      */
     exports.ModelKeys = void 0;
@@ -42,6 +39,16 @@
         ModelKeys["HASHING"] = "hashing";
         ModelKeys["SERIALIZATION"] = "serialization";
     })(exports.ModelKeys || (exports.ModelKeys = {}));
+    /**
+     * @description Default flavour identifier for the decorator system
+     * @summary Defines the default flavour used by the Decoration class when no specific flavour is provided.
+     * This constant is used throughout the library as the fallback flavour for decorators.
+     *
+     * @const {string}
+     * @memberOf module:decorator-validation
+     * @category Model
+     */
+    const DefaultFlavour = "decaf";
 
     /**
      * @summary Keys used for comparison-based validations.
@@ -228,8 +235,8 @@
      * @return {string} formatted string
      *
      * @function stringFormat
-     * @memberOf module:decorator-validation.Utils.Format
-     * @category Format
+     * @memberOf module:decorator-validation
+     * @category Model
      */
     function stringFormat(string, ...args) {
         return string.replace(/{(\d+)}/g, function (match, number) {
@@ -247,8 +254,8 @@
      * @return {string} formatted string
      *
      * @function sf
-     * @memberOf module:decorator-validation.Utils.Format
-     * @category Format
+     * @memberOf module:decorator-validation
+     * @category Model
      */
     const sf = stringFormat;
 
@@ -260,8 +267,8 @@
      * @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?)
      *
      * @function dateFromFormat
-     * @memberOf module:decorator-validation.Utils.Dates
-     * @category Format
+     * @memberOf module:decorator-validation
+     * @category Model
      */
     function dateFromFormat(date, format) {
         let formatRegexp = format;
@@ -348,11 +355,16 @@
         return new Date(year, month - 1, day, hour, minutes, seconds, ms);
     }
     /**
-     * @summary Binds a date format to a string
-     * @param {Date} [date]
-     * @param {string} [format]
-     * @memberOf module:decorator-validation.Utils.Format
-     * @category Utilities
+     * @description Binds a specific date format to a Date object's toString and toISOString methods
+     * @summary Modifies a Date object to return a formatted string when toString or toISOString is called.
+     * This function overrides the default toString and toISOString methods of the Date object to return
+     * the date formatted according to the specified format string.
+     * @param {Date} [date] The Date object to modify
+     * @param {string} [format] The format string to use for formatting the date
+     * @return {Date|undefined} The modified Date object or undefined if no date was provided
+     * @function bindDateToString
+     * @memberOf module:decorator-validation
+     * @category Model
      */
     function bindDateToString(date, format) {
         if (!date)
@@ -372,9 +384,14 @@
         return date;
     }
     /**
-     * @summary Helper function to be used instead of instanceOf Date
-     * @param date
-     * @memberOf module:decorator-validation.Utils.Dates
+     * @description Safely checks if a value is a valid Date object
+     * @summary A utility function that determines if a value is a valid Date object.
+     * This function is more reliable than using instanceof Date as it also checks
+     * that the date is not NaN, which can happen with invalid date strings.
+     * @param {any} date The value to check
+     * @return {boolean} True if the value is a valid Date object, false otherwise
+     * @function isValidDate
+     * @memberOf module:decorator-validation
      * @category Validation
      */
     function isValidDate(date) {
@@ -389,8 +406,8 @@
      * @return {string}
      *
      * @function twoDigitPad
-     * @memberOf module:decorator-validation.Utils.Format
-     * @category Format
+     * @memberOf module:decorator-validation
+     * @category Model
      */
     function twoDigitPad(num) {
         return num < 10 ? "0" + num : num.toString();
@@ -420,8 +437,8 @@
      * @return {string} the formatted date
      *
      * @function formatDate
-     * @memberOf module:decorator-validation.Utils.Dates
-     * @category Format
+     * @memberOf module:decorator-validation
+     * @category Model
      */
     function formatDate(date, patternStr = "yyyy/MM/dd") {
         const day = date.getDate(), month = date.getMonth(), year = date.getFullYear(), hour = date.getHours(), minute = date.getMinutes(), second = date.getSeconds(), miliseconds = date.getMilliseconds(), h = hour % 12, hh = twoDigitPad(h), HH = twoDigitPad(hour), mm = twoDigitPad(minute), ss = twoDigitPad(second), aaa = hour < 12 ? "AM" : "PM", EEEE = DAYS_OF_WEEK_NAMES[date.getDay()], EEE = EEEE.substr(0, 3), dd = twoDigitPad(day), M = month + 1, MM = twoDigitPad(M), MMMM = MONTH_NAMES[month], MMM = MMMM.substr(0, 3), yyyy = year + "", yy = yyyy.substr(2, 2);
@@ -455,8 +472,8 @@
      * @summary Parses a date from a specified format
      * @param {string} format
      * @param {string | Date | number} [v]
-     * @memberOf module:decorator-validation.Utils.Dates
-     * @category Format
+     * @memberOf module:decorator-validation
+     * @category Model
      */
     function parseDate(format, v) {
         let value = undefined;
@@ -493,6 +510,225 @@
         return bindDateToString(value, format);
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    function defaultFlavourResolver(target) {
+        return DefaultFlavour;
+    }
+    /**
+     * @description A decorator management class that handles flavoured decorators
+     * @summary The Decoration class provides a builder pattern for creating and managing decorators with different flavours.
+     * It supports registering, extending, and applying decorators with context-aware flavour resolution.
+     * The class implements a fluent interface for defining, extending, and applying decorators with different flavours,
+     * allowing for framework-specific decorator implementations while maintaining a consistent API.
+     * @template T Type of the decorator (ClassDecorator | PropertyDecorator | MethodDecorator)
+     * @param {string} [flavour] Optional flavour parameter for the decorator context
+     * @class
+     * @category Model
+     * @example
+     * ```typescript
+     * // Create a new decoration for 'component' with default flavour
+     * const componentDecorator = new Decoration()
+     *   .for('component')
+     *   .define(customComponentDecorator);
+     *
+     * // Create a flavoured decoration
+     * const vueComponent = new Decoration('vue')
+     *   .for('component')
+     *   .define(vueComponentDecorator);
+     *
+     * // Apply the decoration
+     * @componentDecorator
+     * class MyComponent {}
+     * ```
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Client
+     *   participant D as Decoration
+     *   participant R as FlavourResolver
+     *   participant F as DecoratorFactory
+     *
+     *   C->>D: new Decoration(flavour)
+     *   C->>D: for(key)
+     *   C->>D: define(decorators)
+     *   D->>D: register(key, flavour, decorators)
+     *   D->>F: decoratorFactory(key, flavour)
+     *   F->>R: resolve(target)
+     *   R-->>F: resolved flavour
+     *   F->>F: apply decorators
+     *   F-->>C: decorated target
+     */
+    class Decoration {
+        /**
+         * @description Static map of registered decorators
+         * @summary Stores all registered decorators organized by key and flavour
+         */
+        static { this.decorators = {}; }
+        /**
+         * @description Function to resolve flavour from a target
+         * @summary Resolver function that determines the appropriate flavour for a given target
+         */
+        static { this.flavourResolver = defaultFlavourResolver; }
+        constructor(flavour = DefaultFlavour) {
+            this.flavour = flavour;
+        }
+        /**
+         * @description Sets the key for the decoration builder
+         * @summary Initializes a new decoration chain with the specified key
+         * @param {string} key The identifier for the decorator
+         * @return {DecorationBuilderMid} Builder instance for method chaining
+         */
+        for(key) {
+            this.key = key;
+            return this;
+        }
+        /**
+         * @description Adds decorators to the current context
+         * @summary Internal method to add decorators with addon support
+         * @param {boolean} [addon=false] Whether the decorators are addons
+         * @param decorators Array of decorators
+         * @return {this} Current instance for chaining
+         */
+        decorate(addon = false, ...decorators) {
+            if (!this.key)
+                throw new Error("key must be provided before decorators can be added");
+            if ((!decorators || !decorators.length) &&
+                !addon &&
+                this.flavour !== DefaultFlavour)
+                throw new Error("Must provide overrides or addons to override or extend decaf's decorators");
+            if (this.flavour === DefaultFlavour && addon)
+                throw new Error("Default flavour cannot be extended");
+            this[addon ? "extras" : "decorators"] = new Set([
+                ...(this[addon ? "extras" : "decorators"] || new Set()).values(),
+                ...decorators,
+            ]);
+            return this;
+        }
+        /**
+         * @description Defines the base decorators
+         * @summary Sets the primary decorators for the current context
+         * @param decorators Decorators to define
+         * @return Builder instance for finishing the chain
+         */
+        define(...decorators) {
+            return this.decorate(false, ...decorators);
+        }
+        /**
+         * @description Extends existing decorators
+         * @summary Adds additional decorators to the current context
+         * @param decorators Additional decorators
+         * @return {DecorationBuilderBuild} Builder instance for building the decorator
+         */
+        extend(...decorators) {
+            return this.decorate(true, ...decorators);
+        }
+        decoratorFactory(key, f = DefaultFlavour) {
+            const contextDecorator = function contextDecorator(target, propertyKey, descriptor) {
+                const flavour = Decoration.flavourResolver(target);
+                let decorators;
+                const extras = Decoration.decorators[key][flavour]
+                    ? Decoration.decorators[key][flavour].extras
+                    : Decoration.decorators[key][DefaultFlavour].extras;
+                if (Decoration.decorators[key] &&
+                    Decoration.decorators[key][flavour] &&
+                    Decoration.decorators[key][flavour].decorators) {
+                    decorators = Decoration.decorators[key][flavour].decorators;
+                }
+                else {
+                    decorators = Decoration.decorators[key][DefaultFlavour].decorators;
+                }
+                [
+                    ...(decorators ? decorators.values() : []),
+                    ...(extras ? extras.values() : []),
+                ].forEach((d) => d(target, propertyKey, descriptor, descriptor));
+                // return apply(
+                //
+                // )(target, propertyKey, descriptor);
+            };
+            Object.defineProperty(contextDecorator, "name", {
+                value: [f, key].join("_decorator_for_"),
+                writable: false,
+            });
+            return contextDecorator;
+        }
+        /**
+         * @description Creates the final decorator function
+         * @summary Builds and returns the decorator factory function
+         * @return {function(any, any?, TypedPropertyDescriptor?): any} The generated decorator function
+         */
+        apply() {
+            if (!this.key)
+                throw new Error("No key provided for the decoration builder");
+            Decoration.register(this.key, this.flavour, this.decorators, this.extras);
+            return this.decoratorFactory(this.key, this.flavour);
+        }
+        /**
+         * @description Registers decorators for a specific key and flavour
+         * @summary Internal method to store decorators in the static registry
+         * @param {string} key Decorator key
+         * @param {string} flavour Decorator flavour
+         * @param [decorators] Primary decorators
+         * @param [extras] Additional decorators
+         */
+        static register(key, flavour, decorators, extras) {
+            if (!key)
+                throw new Error("No key provided for the decoration builder");
+            if (!decorators)
+                throw new Error("No decorators provided for the decoration builder");
+            if (!flavour)
+                throw new Error("No flavour provided for the decoration builder");
+            if (!Decoration.decorators[key])
+                Decoration.decorators[key] = {};
+            if (!Decoration.decorators[key][flavour])
+                Decoration.decorators[key][flavour] = {};
+            if (decorators)
+                Decoration.decorators[key][flavour].decorators = decorators;
+            if (extras)
+                Decoration.decorators[key][flavour].extras = extras;
+        }
+        /**
+         * @description Sets the global flavour resolver
+         * @summary Configures the function used to determine decorator flavours
+         * @param {FlavourResolver} resolver Function to resolve flavours
+         */
+        static setFlavourResolver(resolver) {
+            Decoration.flavourResolver = resolver;
+        }
+        static for(key) {
+            return new Decoration().for(key);
+        }
+        static flavouredAs(flavour) {
+            return new Decoration(flavour);
+        }
+    }
+
+    /**
+     * @description Property decorator factory for model attributes
+     * @summary Creates a decorator that marks class properties as model attributes. The decorator maintains a list
+     * of property keys under a specified metadata key in the model. If the key doesn't exist, it creates a new array;
+     * if it exists, it appends the property key to the existing array, avoiding duplicates.
+     *
+     * @param {string} [key=ModelKeys.ATTRIBUTE] - The metadata key under which to store the property name
+     * @return {function(object, any?): void} Decorator function that registers the property
+     *
+     * @function prop
+     * @category Decorators
+     *
+     * @mermaid
+     * sequenceDiagram
+     *    participant D as Decorator
+     *    participant M as Model
+     *
+     *    D->>M: Check if key exists
+     *    alt key exists
+     *        M-->>D: Return existing props array
+     *    else key doesn't exist
+     *        D->>M: Create new props array
+     *    end
+     *    D->>M: Check if property exists
+     *    alt property not in array
+     *        D->>M: Add property to array
+     *    end
+     */
     function prop(key = exports.ModelKeys.ATTRIBUTE) {
         return (model, propertyKey) => {
             let props;
@@ -506,6 +742,19 @@
                 props.push(propertyKey);
         };
     }
+    /**
+     * @description Combined property decorator factory for metadata and attribute marking
+     * @summary Creates a decorator that both marks a property as a model attribute and assigns metadata to it.
+     * Combines the functionality of prop() and metadata() decorators.
+     *
+     * @template V - The type of the metadata value
+     * @param {string} key - The metadata key
+     * @param {V} value - The metadata value to associate with the property
+     * @return {Function} Combined decorator function
+     *
+     * @function propMetadata
+     * @category Decorators
+     */
     function propMetadata(key, value) {
         return reflection.apply(prop(), reflection.metadata(key, value));
     }
@@ -517,8 +766,8 @@
      * @return {number} hash value of obj
      *
      * @function hashCode
-     * @memberOf module:decorator-validation.Utils.Hashing
-     * @category Hashing
+     * @memberOf module:decorator-validation
+     * @category Model
      */
     function hashCode(obj) {
         obj = String(obj);
@@ -537,8 +786,8 @@
      * @return {string} the resulting hash
      *
      * @function hashObj
-     * @memberOf module:decorator-validation.Utils.Hashing
-     * @category Hashing
+     * @memberOf module:decorator-validation
+     * @category Model
      */
     function hashObj(obj) {
         const hashReducer = function (h, el) {
@@ -565,17 +814,61 @@
         return (typeof result === "number" ? Math.abs(result) : result).toString();
     }
     const DefaultHashingMethod = "default";
+    /**
+     * @description Manages hashing methods and provides a unified hashing interface
+     * @summary A utility class that provides a registry for different hashing functions and methods to hash objects.
+     * The class maintains a cache of registered hashing functions and allows setting a default hashing method.
+     * It prevents direct instantiation and provides static methods for registration and hashing.
+     *
+     * @class Hashing
+     * @category Model
+     *
+     * @example
+     * ```typescript
+     * // Register a custom hashing function
+     * Hashing.register('md5', (obj) => createMD5Hash(obj), true);
+     *
+     * // Hash an object using default method
+     * const hash1 = Hashing.hash(myObject);
+     *
+     * // Hash using specific method
+     * const hash2 = Hashing.hash(myObject, 'md5');
+     * ```
+     */
     class Hashing {
+        /**
+         * @description Current default hashing method identifier
+         * @private
+         */
         static { this.current = DefaultHashingMethod; }
+        /**
+         * @description Cache of registered hashing functions
+         * @private
+         */
         static { this.cache = {
             default: hashObj,
         }; }
         constructor() { }
+        /**
+         * @description Retrieves a registered hashing function
+         * @summary Fetches a hashing function from the cache by its key. Throws an error if the method is not registered.
+         *
+         * @param {string} key - The identifier of the hashing function to retrieve
+         * @return {HashingFunction} The requested hashing function
+         * @private
+         */
         static get(key) {
             if (key in this.cache)
                 return this.cache[key];
             throw new Error(`No hashing method registered under ${key}`);
         }
+        /**
+         * @description Registers a new hashing function
+         * @summary Adds a new hashing function to the registry. Optionally sets it as the default method.
+         * Throws an error if a method with the same key is already registered.
+         *
+         * @param {string} key - The identifier for the hashing function
+         */
         static register(key, func, setDefault = false) {
             if (key in this.cache)
                 throw new Error(`Hashing method ${key} already registered`);
@@ -655,7 +948,7 @@
      * @property {string} BIGINT references the bigint primitive
      *
      * @constant Primitives
-     * @memberOf module:decorator-validation.Model
+     * @memberOf module:decorator-validation
      */
     exports.Primitives = void 0;
     (function (Primitives) {
@@ -675,7 +968,7 @@
      * @property {string} DATE
      *
      * @constant ReservedModels
-     * @memberOf module:decorator-validation.Model
+     * @memberOf module:decorator-validation
      */
     exports.ReservedModels = void 0;
     (function (ReservedModels) {
@@ -701,7 +994,7 @@
      * @property {string} BIGINT
      *
      * @constant jsTypes
-     * @memberOf module:decorator-validation.Model
+     * @memberOf module:decorator-validation
      */
     const jsTypes = [
         "string",
@@ -717,13 +1010,118 @@
     ];
 
     /**
-     * @summary Duck typing for Validators
-     * @function isValidator
-     * @param val
+     * Symbol used to internally track the parent object during nested validation.
+     *
+     * This key is attached to child objects to provide context about their parent
+     * in the object hierarchy, enabling validations that depend on parent values.
+     *
+     * @constant VALIDATION_PARENT_KEY
+     * @memberOf module:decorator-validation.Model
      */
-    function isValidator(val) {
-        return val.constructor && val["hasErrors"];
+    const VALIDATION_PARENT_KEY = Symbol("_validationParentRef");
+
+    /**
+     * @description Abstract base class for all validators in the validation framework
+     * @summary The Validator class provides the foundation for all validator implementations.
+     * It handles type checking, error message formatting, and defines the common interface
+     * that all validators must implement. This class is designed to be extended by specific
+     * validator implementations that provide concrete validation logic.
+     *
+     * @param {string} message - Default error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#DEFAULT}
+     * @param {string[]} acceptedTypes - Array of type names that this validator can validate
+     *
+     * @class Validator
+     * @abstract
+     *
+     * @example
+     * ```typescript
+     * // Example of extending the Validator class to create a custom validator
+     * class CustomValidator extends Validator<CustomValidatorOptions> {
+     *   constructor(message: string = "Custom validation failed") {
+     *     // Specify that this validator accepts String and Number types
+     *     super(message, String.name, Number.name);
+     *   }
+     *
+     *   public hasErrors(value: any, options?: CustomValidatorOptions): string | undefined {
+     *     // Implement custom validation logic
+     *     if (someCondition) {
+     *       return this.getMessage(options?.message || this.message);
+     *     }
+     *     return undefined; // No errors
+     *   }
+     * }
+     * ```
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Client
+     *   participant V as Validator Subclass
+     *   participant B as Base Validator
+     *
+     *   C->>V: new CustomValidator(message)
+     *   V->>B: super(message, acceptedTypes)
+     *   B->>B: Store message and types
+     *   B->>B: Wrap hasErrors with type checking
+     *   C->>V: hasErrors(value, options)
+     *   alt value type not in acceptedTypes
+     *     B-->>C: Type error message
+     *   else value type is accepted
+     *     V->>V: Custom validation logic
+     *     V-->>C: Validation result
+     *   end
+     *
+     * @category Validators
+     */
+    class Validator {
+        constructor(message = DEFAULT_ERROR_MESSAGES.DEFAULT, ...acceptedTypes) {
+            this.message = message;
+            if (acceptedTypes.length)
+                this.acceptedTypes = acceptedTypes;
+            if (this.acceptedTypes)
+                this.hasErrors = this.checkTypeAndHasErrors(this.hasErrors.bind(this));
+        }
+        /**
+         * @description Formats an error message with optional arguments
+         * @summary Creates a formatted error message by replacing placeholders with provided arguments.
+         * This method uses the string formatting utility to generate consistent error messages
+         * across all validators.
+         *
+         * @param {string} message - The message template with placeholders
+         * @param {...any} args - Values to insert into the message template
+         * @return {string} The formatted error message
+         * @protected
+         */
+        getMessage(message, ...args) {
+            return sf(message, ...args);
+        }
+        /**
+         * @description Creates a type-checking wrapper around the hasErrors method
+         * @summary Wraps the hasErrors method with type validation logic to ensure that
+         * the value being validated is of an accepted type before performing specific validation.
+         * This method is called during construction if acceptedTypes are provided.
+         *
+         * @param {Function} unbound - The original hasErrors method to be wrapped
+         * @return {Function} A new function that performs type checking before calling the original method
+         * @private
+         */
+        checkTypeAndHasErrors(unbound) {
+            return function (value, ...args) {
+                if (value === undefined || !this.acceptedTypes)
+                    return unbound(value, ...args);
+                if (!reflection.Reflection.checkTypes(value, this.acceptedTypes))
+                    return this.getMessage(DEFAULT_ERROR_MESSAGES.TYPE, this.acceptedTypes.join(", "), typeof value);
+                return unbound(value, ...args);
+            }.bind(this);
+        }
+        /**
+         * @summary Duck typing for Validators
+         * @param val
+         */
+        static isValidator(val) {
+            return val.constructor && !!val["hasErrors"];
+        }
     }
+
     /**
      * @summary Base Implementation of a Validator Registry
      *
@@ -762,7 +1160,7 @@
             if (!(validatorKey in this.cache))
                 return undefined;
             const classOrInstance = this.cache[validatorKey];
-            if (isValidator(classOrInstance))
+            if (Validator.isValidator(classOrInstance))
                 return classOrInstance;
             const constructor = classOrInstance.default || classOrInstance;
             const instance = new constructor();
@@ -776,7 +1174,7 @@
          */
         register(...validator) {
             validator.forEach((v) => {
-                if (isValidator(v)) {
+                if (Validator.isValidator(v)) {
                     // const k =
                     if (v.validationKey in this.cache)
                         return;
@@ -870,13 +1268,13 @@
     /**
      * @summary Analyses the decorations of the properties and validates the obj according to them
      *
-     * @typedef T extends Model
-     * @prop {T} obj Model object to validate
+     * @typedef M extends Model
+     * @prop {M} obj Model object to validate
      * @prop {string[]} [propsToIgnore] object properties to ignore in the validation
      *
      * @function validate
-     * @memberOf module:decorator-validation.Validation
-     * @category Validation
+     * @memberOf module:decorator-validation
+     * @category Model
      */
     function validate(obj, ...propsToIgnore) {
         const decoratedProperties = [];
@@ -956,7 +1354,7 @@
                         try {
                             if (value && !value[VALIDATION_PARENT_KEY])
                                 value[VALIDATION_PARENT_KEY] = obj; // TODO: freeze?
-                            return isModel(value)
+                            return Model.isModel(value)
                                 ? value.hasErrors()
                                 : allowedTypes.includes(typeof value)
                                     ? undefined
@@ -992,7 +1390,7 @@
                                     err = validate(prop, obj[prop]);
                             }
                             catch (e) {
-                                console.warn(sf("Model should be validatable but its not: " + e));
+                                console.warn(`Model should be validatable but its not: ${e}`);
                             }
                     }
                 }
@@ -1005,51 +1403,80 @@
         return result ? new ModelErrorDefinition(result) : undefined;
     }
 
-    let modelBuilderFunction;
-    let actingModelRegistry;
-    function isPropertyModel(target, attribute) {
-        if (isModel(target[attribute]))
-            return true;
-        const metadata = Reflect.getMetadata(exports.ModelKeys.TYPE, target, attribute);
-        return Model.get(metadata.name) ? metadata.name : undefined;
+    function getModelKey(str) {
+        return exports.ModelKeys.REFLECT + str;
     }
-    /**
-     * @summary For Serialization/deserialization purposes.
-     * @description Reads the {@link ModelKeys.ANCHOR} property of a {@link Model} to discover the class to instantiate
-     *
-     * @function isModel
-     * @memberOf module:decorator-validation.Validation
-     * @category Validation
-     */
-    function isModel(target) {
-        try {
-            return target instanceof Model || !!Model.getMetadata(target);
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        }
-        catch (e) {
-            return false;
-        }
+    function getMetadata(model) {
+        const metadata = Reflect.getMetadata(getModelKey(exports.ModelKeys.MODEL), model.constructor);
+        if (!metadata)
+            throw new Error("could not find metadata for provided " + model.constructor.name);
+        return metadata;
     }
+
+    let modelBuilderFunction;
+    let actingModelRegistry;
     /**
-     * @summary Util class to enable serialization and correct rebuilding
+     * @description Registry manager for model constructors that enables serialization and rebuilding
+     * @summary The ModelRegistryManager implements the ModelRegistry interface and provides
+     * functionality for registering, retrieving, and building model instances. It maintains
+     * a cache of model constructors indexed by name, allowing for efficient lookup and instantiation.
+     * This class is essential for the serialization and deserialization of model objects.
      *
-     * @param {string} anchorKey defaults to {@link ModelKeys.ANCHOR}. The property name where the registered class name is stored;
-     * @param {function(Record<string, any>): boolean} [testFunction] method to test if the provided object is a Model Object. defaults to {@link isModel}
+     * @param {function(Record<string, any>): boolean} [testFunction] - Function to test if an object is a model, defaults to {@link Model#isModel}
      *
      * @class ModelRegistryManager
-     * @implements ModelRegistry
-     *
+     * @template M Type of model that can be registered, must extend Model
+     * @implements ModelRegistry<M>
      * @category Model
+     *
+     * @example
+     * ```typescript
+     * // Create a model registry
+     * const registry = new ModelRegistryManager();
+     *
+     * // Register a model class
+     * registry.register(User);
+     *
+     * // Retrieve a model constructor by name
+     * const UserClass = registry.get("User");
+     *
+     * // Build a model instance from a plain object
+     * const userData = { name: "John", age: 30 };
+     * const user = registry.build(userData, "User");
+     * ```
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Client
+     *   participant R as ModelRegistryManager
+     *   participant M as Model Class
+     *
+     *   C->>R: new ModelRegistryManager(testFunction)
+     *   C->>R: register(ModelClass)
+     *   R->>R: Store in cache
+     *   C->>R: get("ModelName")
+     *   R-->>C: ModelClass constructor
+     *   C->>R: build(data, "ModelName")
+     *   R->>R: Get constructor from cache
+     *   R->>M: new ModelClass(data)
+     *   M-->>R: Model instance
+     *   R-->>C: Model instance
      */
     class ModelRegistryManager {
-        constructor(testFunction = isModel) {
+        constructor(testFunction = Model.isModel) {
             this.cache = {};
             this.testFunction = testFunction;
         }
         /**
-         * @summary register new Models
-         * @param {any} constructor
-         * @param {string} [name] when not defined, the name of the constructor will be used
+         * @description Registers a model constructor with the registry
+         * @summary Adds a model constructor to the registry cache, making it available for
+         * later retrieval and instantiation. If no name is provided, the constructor's name
+         * property is used as the key in the registry.
+         *
+         * @param {ModelConstructor<M>} constructor - The model constructor to register
+         * @param {string} [name] - Optional name to register the constructor under, defaults to constructor.name
+         * @return {void}
+         * @throws {Error} If the constructor is not a function
          */
         register(constructor, name) {
             if (typeof constructor !== "function")
@@ -1081,7 +1508,7 @@
                 throw new Error("Provided obj is not a Model object");
             const name = clazz || Model.getMetadata(obj);
             if (!(name in this.cache))
-                throw new Error(sf("Provided class {0} is not a registered Model object", name));
+                throw new Error(`Provided class ${name} is not a registered Model object`);
             return new this.cache[name](obj);
         }
     }
@@ -1089,9 +1516,10 @@
      * @summary Bulk Registers Models
      * @description Useful when using bundlers that might not evaluate all the code at once
      *
-     * @param {Array<Constructor<T>> | Array<{name: string, constructor: Constructor<T>}>} [models]
+     * @template M extends Model
+     * @param {Array<Constructor<M>> | Array<{name: string, constructor: Constructor<M>}>} [models]
      *
-     * @memberOf module:decorator-validation.Model
+     * @memberOf module:decorator-validation
      * @category Model
      */
     function bulkModelRegister(...models) {
@@ -1108,9 +1536,10 @@
      *  - Have all their required properties marked with '!';
      *  - Have all their optional properties marked as '?':
      *
-     * @param {Model | {}} model base object from which to populate properties from
+     * @param {ModelArg<Model>} model base object from which to populate properties from
      *
      * @class Model
+     * @category Model
      * @abstract
      * @implements Validatable
      * @implements Serializable
@@ -1209,7 +1638,7 @@
                     obj[prop] ?? undefined;
                 if (typeof self[prop] !== "object")
                     continue;
-                const propM = isPropertyModel(self, prop);
+                const propM = Model.isPropertyModel(self, prop);
                 if (propM) {
                     try {
                         self[prop] = Model.build(self[prop], typeof propM === "string" ? propM : undefined);
@@ -1222,7 +1651,7 @@
                 const allDecorators = reflection.Reflection.getPropertyDecorators(ValidationKeys.REFLECT, self, prop).decorators;
                 decorators = allDecorators.filter((d) => [exports.ModelKeys.TYPE, ValidationKeys.TYPE].indexOf(d.key) !== -1);
                 if (!decorators || !decorators.length)
-                    throw new Error(sf("failed to find decorators for property {0}", prop));
+                    throw new Error(`failed to find decorators for property ${prop}`);
                 dec = decorators.pop();
                 const clazz = dec.props.name
                     ? [dec.props.name]
@@ -1338,10 +1767,7 @@
             return Model.getRegistry().build(obj, clazz);
         }
         static getMetadata(model) {
-            const metadata = Reflect.getMetadata(Model.key(exports.ModelKeys.MODEL), model.constructor);
-            if (!metadata)
-                throw new Error("could not find metadata for provided " + model.constructor.name);
-            return metadata;
+            return getMetadata(model);
         }
         static getAttributes(model) {
             const result = [];
@@ -1381,7 +1807,54 @@
          * @param {string} str
          */
         static key(str) {
-            return exports.ModelKeys.REFLECT + str;
+            return getModelKey(str);
+        }
+        /**
+         * @description Determines if an object is a model instance or has model metadata
+         * @summary Checks whether a given object is either an instance of the Model class or
+         * has model metadata attached to it. This function is essential for serialization and
+         * deserialization processes, as it helps identify model objects that need special handling.
+         * It safely handles potential errors during metadata retrieval.
+         *
+         * @param {Record<string, any>} target - The object to check
+         * @return {boolean} True if the object is a model instance or has model metadata, false otherwise
+         *
+         * @example
+         * ```typescript
+         * // Check if an object is a model
+         * const user = new User({ name: "John" });
+         * const isUserModel = isModel(user); // true
+         *
+         * // Check a plain object
+         * const plainObject = { name: "John" };
+         * const isPlainObjectModel = isModel(plainObject); // false
+         * ```
+         */
+        static isModel(target) {
+            try {
+                return target instanceof Model || !!Model.getMetadata(target);
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            }
+            catch (e) {
+                return false;
+            }
+        }
+        /**
+         * @description Checks if a property of a model is itself a model or has a model type
+         * @summary Determines whether a specific property of a model instance is either a model instance
+         * or has a type that is registered as a model. This function is used for model serialization
+         * and deserialization to properly handle nested models.
+         * @template M extends {@link Model}
+         * @param {M} target - The model instance to check
+         * @param {string} attribute - The property name to check
+         * @return {boolean | string | undefined} Returns true if the property is a model instance,
+         * the model name if the property has a model type, or undefined if not a model
+         */
+        static isPropertyModel(target, attribute) {
+            if (Model.isModel(target[attribute]))
+                return true;
+            const metadata = Reflect.getMetadata(exports.ModelKeys.TYPE, target, attribute);
+            return Model.get(metadata.name) ? metadata.name : undefined;
         }
     }
 
@@ -1397,7 +1870,7 @@
      * @class JSONSerializer
      * @implements Serializer
      *
-     * @category Serialization
+     * @category Model
      */
     class JSONSerializer {
         constructor() { }
@@ -1412,7 +1885,7 @@
         preSerialize(model) {
             // TODO: nested preserialization (so increase performance when deserializing)
             const toSerialize = Object.assign({}, model);
-            const metadata = Model.getMetadata(model);
+            const metadata = getMetadata(model);
             toSerialize[exports.ModelKeys.ANCHOR] = metadata || model.constructor.name;
             return toSerialize;
         }
@@ -1473,84 +1946,6 @@
         }
     }
 
-    /******************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-    /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-    function __decorate(decorators, target, key, desc) {
-        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-        if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-        return c > 3 && r && Object.defineProperty(target, key, r), r;
-    }
-
-    function __metadata(metadataKey, metadataValue) {
-        if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
-    }
-
-    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-        var e = new Error(message);
-        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-    };
-
-    /**
-     * @summary Base Implementation for Validators
-     * @description Provides the underlying functionality for {@link Validator}s
-     *
-     * @param {string} validationKey the key to register the validator under
-     * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#DEFAULT}
-     * @param {string[]} [acceptedTypes] defines the value types this validator can validate
-     *
-     * @class Validator
-     * @abstract
-     * @category Validators
-     */
-    class Validator {
-        constructor(message = DEFAULT_ERROR_MESSAGES.DEFAULT, ...acceptedTypes) {
-            this.message = message;
-            if (acceptedTypes.length)
-                this.acceptedTypes = acceptedTypes;
-            if (this.acceptedTypes)
-                this.hasErrors = this.checkTypeAndHasErrors(this.hasErrors.bind(this));
-        }
-        /**
-         * @summary builds the error message
-         * @param {string} message
-         * @param {any[]} args
-         * @protected
-         */
-        getMessage(message, ...args) {
-            return sf(message, ...args);
-        }
-        /**
-         * @summary Validates type
-         * @param {any} unbound
-         * @private
-         */
-        checkTypeAndHasErrors(unbound) {
-            return function (value, ...args) {
-                if (value === undefined || !this.acceptedTypes)
-                    return unbound(value, ...args);
-                if (!reflection.Reflection.checkTypes(value, this.acceptedTypes))
-                    return this.getMessage(DEFAULT_ERROR_MESSAGES.TYPE, this.acceptedTypes.join(", "), typeof value);
-                return unbound(value, ...args);
-            }.bind(this);
-        }
-    }
-
     /**
      * @summary Marks the class as a validator for a certain key.
      * @description Registers the class in the {@link Validation} with the provided key
@@ -1575,26 +1970,58 @@
     }
 
     /**
-     * @summary Date Validator
-     *
-     * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#DATE}
-     *
+     * @description Validator for checking if a value is a valid date
+     * @summary The DateValidator checks if a value is a valid date object or a string that can be converted to a valid date.
+     * It validates that the value represents a real date and not an invalid date like "2023-02-31".
+     * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#DATE}
      * @class DateValidator
      * @extends Validator
      *
      * @category Validators
+     * @example
+     * ```typescript
+     * // Create a date validator with default error message
+     * const dateValidator = new DateValidator();
+     *
+     * // Create a date validator with custom error message
+     * const customDateValidator = new DateValidator("Please enter a valid date");
+     *
+     * // Validate a date
+     * const result = dateValidator.hasErrors(new Date()); // undefined (valid)
+     * const invalidResult = dateValidator.hasErrors("not a date"); // Returns error message (invalid)
+     * ```
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Client
+     *   participant V as DateValidator
+     *
+     *   C->>V: new DateValidator(message)
+     *   C->>V: hasErrors(value, options)
+     *   alt value is undefined
+     *     V-->>C: undefined (valid)
+     *   else value is string
+     *     V->>V: Convert to Date
+     *   end
+     *   alt Date is invalid (NaN)
+     *     V-->>C: Error message
+     *   else Date is valid
+     *     V-->>C: undefined (valid)
+     *   end
      */
     exports.DateValidator = class DateValidator extends Validator {
         constructor(message = DEFAULT_ERROR_MESSAGES.DATE) {
             super(message, Number.name, Date.name, String.name);
         }
         /**
-         * @summary Validates a model
+         * @description Checks if the provided value is a valid date
+         * @summary Validates that the given value is a valid date. If the value is a string,
+         * it attempts to convert it to a Date object. Returns an error message if the date is invalid,
+         * or undefined if the date is valid or if the value is undefined.
          *
-         * @param {Date | string} value
-         * @param {DateValidatorOptions} [options]
+         * @param {Date | string} value - The value to validate, can be a Date object or a string
+         * @param {DateValidatorOptions} [options={}] - Optional configuration options for the validator
          *
-         * @return {string | undefined}
+         * @return {string | undefined} Error message if validation fails, undefined if validation passes
          *
          * @override
          *
@@ -1611,9 +2038,9 @@
             }
         }
     };
-    exports.DateValidator = __decorate([
+    exports.DateValidator = tslib.__decorate([
         validator(ValidationKeys.DATE),
-        __metadata("design:paramtypes", [String])
+        tslib.__metadata("design:paramtypes", [String])
     ], exports.DateValidator);
 
     /**
@@ -1825,21 +2252,78 @@
                 : undefined;
         }
     };
-    exports.DiffValidator = __decorate([
+    exports.DiffValidator = tslib.__decorate([
         validator(ValidationKeys.DIFF),
-        __metadata("design:paramtypes", [String])
+        tslib.__metadata("design:paramtypes", [String])
     ], exports.DiffValidator);
 
+    /**
+     * @description Regular expression for parsing string patterns with flags
+     * @summary This regular expression is used to parse string patterns in the format "/pattern/flags".
+     * It captures the pattern and flags separately, allowing the creation of a RegExp object
+     * with the appropriate flags.
+     *
+     * @const {RegExp}
+     * @memberOf module:decorator-validation
+     * @category Validation
+     */
     const regexpParser = new RegExp("^/(.+)/([gimus]*)$");
     /**
-     * @summary Pattern Validator
+     * @description Validator for checking if a string matches a regular expression pattern
+     * @summary The PatternValidator checks if a string value matches a specified regular expression pattern.
+     * It supports both RegExp objects and string representations of patterns, including those with flags.
+     * This validator is the foundation for specialized validators like EmailValidator and URLValidator,
+     * and is typically used with the @pattern decorator.
      *
-     * @param {string} [key] defaults to {@link ValidationKeys#PATTERN}
-     * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#PATTERN}
+     * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#PATTERN}
      *
      * @class PatternValidator
      * @extends Validator
      *
+     * @example
+     * ```typescript
+     * // Create a pattern validator with default error message
+     * const patternValidator = new PatternValidator();
+     *
+     * // Create a pattern validator with custom error message
+     * const customPatternValidator = new PatternValidator("Value must match the required format");
+     *
+     * // Validate using a RegExp object
+     * const regexOptions = { pattern: /^[A-Z][a-z]+$/ };
+     * patternValidator.hasErrors("Hello", regexOptions); // undefined (valid)
+     * patternValidator.hasErrors("hello", regexOptions); // Returns error message (invalid)
+     *
+     * // Validate using a string pattern
+     * const stringOptions = { pattern: "^\\d{3}-\\d{2}-\\d{4}$" };
+     * patternValidator.hasErrors("123-45-6789", stringOptions); // undefined (valid)
+     *
+     * // Validate using a string pattern with flags
+     * const flagOptions = { pattern: "/^hello$/i" };
+     * patternValidator.hasErrors("Hello", flagOptions); // undefined (valid)
+     * ```
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Client
+     *   participant V as PatternValidator
+     *
+     *   C->>V: new PatternValidator(message)
+     *   C->>V: hasErrors(value, options)
+     *   alt value is empty
+     *     V-->>C: undefined (valid)
+     *   else pattern is missing
+     *     V-->>C: Error: Missing Pattern
+     *   else pattern is string
+     *     V->>V: getPattern(pattern)
+     *   end
+     *   V->>V: Reset pattern.lastIndex
+     *   V->>V: Test value against pattern
+     *   alt pattern test passes
+     *     V-->>C: undefined (valid)
+     *   else pattern test fails
+     *     V-->>C: Error message
+     *   end
+     *
      * @category Validators
      */
     exports.PatternValidator = class PatternValidator extends Validator {
@@ -1847,9 +2331,12 @@
             super(message, "string");
         }
         /**
-         * @summary parses and validates a pattern
+         * @description Converts a string pattern to a RegExp object
+         * @summary Parses a string representation of a regular expression and converts it to a RegExp object.
+         * It handles both simple string patterns and patterns with flags in the format "/pattern/flags".
          *
-         * @param {string} pattern
+         * @param {string} pattern - The string pattern to convert
+         * @return {RegExp} A RegExp object created from the string pattern
          * @private
          */
         getPattern(pattern) {
@@ -1859,12 +2346,18 @@
             return new RegExp(match[1], match[2]);
         }
         /**
-         * @summary Validates a Model
+         * @description Checks if a string matches a regular expression pattern
+         * @summary Validates that the provided string matches the pattern specified in the options.
+         * If the pattern is provided as a string, it's converted to a RegExp object using the getPattern method.
+         * The method resets the pattern's lastIndex property to ensure consistent validation results
+         * for patterns with the global flag.
          *
-         * @param {string} value
-         * @param {PatternValidatorOptions} options
+         * @param {string} value - The string to validate against the pattern
+         * @param {PatternValidatorOptions} options - Configuration options containing the pattern
          *
-         * @return {string | undefined}
+         * @return {string | undefined} Error message if validation fails, undefined if validation passes
+         *
+         * @throws {Error} If no pattern is provided in the options
          *
          * @override
          *
@@ -1883,19 +2376,48 @@
                 : undefined;
         }
     };
-    exports.PatternValidator = __decorate([
+    exports.PatternValidator = tslib.__decorate([
         validator(ValidationKeys.PATTERN),
-        __metadata("design:paramtypes", [String])
+        tslib.__metadata("design:paramtypes", [String])
     ], exports.PatternValidator);
 
     /**
-     * @summary Email Validator
+     * @description Validator for checking if a string is a valid email address
+     * @summary The EmailValidator checks if a string matches a standard email address pattern.
+     * It extends the PatternValidator and uses a predefined email regex pattern to validate email addresses.
+     * This validator is typically used with the @email decorator.
      *
-     * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#EMAIL}
+     * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#EMAIL}
      *
      * @class EmailValidator
      * @extends PatternValidator
      *
+     * @example
+     * ```typescript
+     * // Create an email validator with default error message
+     * const emailValidator = new EmailValidator();
+     *
+     * // Create an email validator with custom error message
+     * const customEmailValidator = new EmailValidator("Please enter a valid email address");
+     *
+     * // Validate an email
+     * const result = emailValidator.hasErrors("user@example.com"); // undefined (valid)
+     * const invalidResult = emailValidator.hasErrors("invalid-email"); // Returns error message (invalid)
+     * ```
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Client
+     *   participant E as EmailValidator
+     *   participant P as PatternValidator
+     *
+     *   C->>E: new EmailValidator(message)
+     *   E->>P: super(message)
+     *   C->>E: hasErrors(value, options)
+     *   E->>P: super.hasErrors(value, options with EMAIL pattern)
+     *   P-->>E: validation result
+     *   E-->>C: validation result
+     *
      * @category Validators
      */
     exports.EmailValidator = class EmailValidator extends exports.PatternValidator {
@@ -1903,16 +2425,19 @@
             super(message);
         }
         /**
-         * @summary Validates a model
+         * @description Checks if a string is a valid email address
+         * @summary Validates that the provided string matches the email pattern.
+         * This method extends the PatternValidator's hasErrors method by ensuring
+         * the email pattern is used, even if not explicitly provided in the options.
          *
-         * @param {string} value
-         * @param {PatternValidatorOptions} [options]
+         * @param {string} value - The string to validate as an email address
+         * @param {PatternValidatorOptions} [options={}] - Optional configuration options
          *
-         * @return {string | undefined}
+         * @return {string | undefined} Error message if validation fails, undefined if validation passes
          *
          * @override
          *
-         * @see Validator#hasErrors
+         * @see PatternValidator#hasErrors
          */
         hasErrors(value, options = {}) {
             return super.hasErrors(value, {
@@ -1921,9 +2446,9 @@
             });
         }
     };
-    exports.EmailValidator = __decorate([
+    exports.EmailValidator = tslib.__decorate([
         validator(ValidationKeys.EMAIL),
-        __metadata("design:paramtypes", [String])
+        tslib.__metadata("design:paramtypes", [String])
     ], exports.EmailValidator);
 
     /**
@@ -1964,9 +2489,9 @@
                 : this.getMessage(options.message || this.message, options[ValidationKeys.EQUALS]);
         }
     };
-    exports.EqualsValidator = __decorate([
+    exports.EqualsValidator = tslib.__decorate([
         validator(ValidationKeys.EQUALS),
-        __metadata("design:paramtypes", [String])
+        tslib.__metadata("design:paramtypes", [String])
     ], exports.EqualsValidator);
     // Validation.register({
     //   validator: EqualsValidator,
@@ -2017,9 +2542,9 @@
             return undefined;
         }
     };
-    exports.GreaterThanValidator = __decorate([
+    exports.GreaterThanValidator = tslib.__decorate([
         validator(ValidationKeys.GREATER_THAN),
-        __metadata("design:paramtypes", [String])
+        tslib.__metadata("design:paramtypes", [String])
     ], exports.GreaterThanValidator);
 
     /**
@@ -2067,9 +2592,9 @@
             }
         }
     };
-    exports.GreaterThanOrEqualValidator = __decorate([
+    exports.GreaterThanOrEqualValidator = tslib.__decorate([
         validator(ValidationKeys.GREATER_THAN_OR_EQUAL),
-        __metadata("design:paramtypes", [String])
+        tslib.__metadata("design:paramtypes", [String])
     ], exports.GreaterThanOrEqualValidator);
 
     /**
@@ -2115,9 +2640,9 @@
             return undefined;
         }
     };
-    exports.LessThanValidator = __decorate([
+    exports.LessThanValidator = tslib.__decorate([
         validator(ValidationKeys.LESS_THAN),
-        __metadata("design:paramtypes", [String])
+        tslib.__metadata("design:paramtypes", [String])
     ], exports.LessThanValidator);
 
     /**
@@ -2165,19 +2690,54 @@
             }
         }
     };
-    exports.LessThanOrEqualValidator = __decorate([
+    exports.LessThanOrEqualValidator = tslib.__decorate([
         validator(ValidationKeys.LESS_THAN_OR_EQUAL),
-        __metadata("design:paramtypes", [String])
+        tslib.__metadata("design:paramtypes", [String])
     ], exports.LessThanOrEqualValidator);
 
     /**
-     * @summary List Validator
+     * @description Validator for checking if elements in a list or set match expected types
+     * @summary The ListValidator validates that all elements in an array or Set match the expected types.
+     * It checks each element against a list of allowed class types and ensures type consistency.
+     * This validator is typically used with the @list decorator.
      *
-     * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LIST}
+     * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#LIST}
      *
      * @class ListValidator
      * @extends Validator
      *
+     * @example
+     * ```typescript
+     * // Create a list validator with default error message
+     * const listValidator = new ListValidator();
+     *
+     * // Create a list validator with custom error message
+     * const customListValidator = new ListValidator("All items must be of the specified type");
+     *
+     * // Validate a list
+     * const options = { clazz: ["String", "Number"] };
+     * const result = listValidator.hasErrors(["test", 123], options); // undefined (valid)
+     * const invalidResult = listValidator.hasErrors([new Date()], options); // Returns error message (invalid)
+     * ```
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Client
+     *   participant V as ListValidator
+     *
+     *   C->>V: new ListValidator(message)
+     *   C->>V: hasErrors(value, options)
+     *   alt value is empty
+     *     V-->>C: undefined (valid)
+     *   else value has elements
+     *     V->>V: Check each element's type
+     *     alt All elements match allowed types
+     *       V-->>C: undefined (valid)
+     *     else Some elements don't match
+     *       V-->>C: Error message
+     *     end
+     *   end
+     *
      * @category Validators
      */
     exports.ListValidator = class ListValidator extends Validator {
@@ -2185,12 +2745,15 @@
             super(message, Array.name, Set.name);
         }
         /**
-         * @summary Validates a model
+         * @description Checks if all elements in a list or set match the expected types
+         * @summary Validates that each element in the provided array or Set matches one of the
+         * class types specified in the options. For object types, it checks the constructor name,
+         * and for primitive types, it compares against the lowercase type name.
          *
-         * @param {any[] | Set<any>} value
-         * @param {ListValidatorOptions} options
+         * @param {any[] | Set<any>} value - The array or Set to validate
+         * @param {ListValidatorOptions} options - Configuration options containing the allowed class types
          *
-         * @return {string | undefined}
+         * @return {string | undefined} Error message if validation fails, undefined if validation passes
          *
          * @override
          *
@@ -2220,9 +2783,9 @@
                 : this.getMessage(options.message || this.message, clazz);
         }
     };
-    exports.ListValidator = __decorate([
+    exports.ListValidator = tslib.__decorate([
         validator(ValidationKeys.LIST),
-        __metadata("design:paramtypes", [String])
+        tslib.__metadata("design:paramtypes", [String])
     ], exports.ListValidator);
 
     /**
@@ -2260,19 +2823,61 @@
                 : undefined;
         }
     };
-    exports.MaxLengthValidator = __decorate([
+    exports.MaxLengthValidator = tslib.__decorate([
         validator(ValidationKeys.MAX_LENGTH),
-        __metadata("design:paramtypes", [String])
+        tslib.__metadata("design:paramtypes", [String])
     ], exports.MaxLengthValidator);
 
     /**
-     * @summary Max Validator
+     * @description Validator for checking if a value is less than or equal to a maximum
+     * @summary The MaxValidator checks if a numeric value, date, or string is less than or equal to
+     * a specified maximum value. It supports comparing numbers directly, dates chronologically,
+     * and strings lexicographically. This validator is typically used with the @max decorator.
      *
-     * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#MAX}
+     * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#MAX}
      *
      * @class MaxValidator
      * @extends Validator
      *
+     * @example
+     * ```typescript
+     * // Create a max validator with default error message
+     * const maxValidator = new MaxValidator();
+     *
+     * // Create a max validator with custom error message
+     * const customMaxValidator = new MaxValidator("Value must not exceed {0}");
+     *
+     * // Validate a number
+     * const numOptions = { max: 100, message: "Number too large" };
+     * const numResult = maxValidator.hasErrors(50, numOptions); // undefined (valid)
+     * const invalidNumResult = maxValidator.hasErrors(150, numOptions); // Returns error message (invalid)
+     *
+     * // Validate a date
+     * const dateOptions = { max: new Date(2023, 11, 31) };
+     * const dateResult = maxValidator.hasErrors(new Date(2023, 5, 15), dateOptions); // undefined (valid)
+     * ```
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Client
+     *   participant V as MaxValidator
+     *
+     *   C->>V: new MaxValidator(message)
+     *   C->>V: hasErrors(value, options)
+     *   alt value is undefined
+     *     V-->>C: undefined (valid)
+     *   else value is Date and max is not Date
+     *     V->>V: Convert max to Date
+     *     alt conversion fails
+     *       V-->>C: Error: Invalid Max param
+     *     end
+     *   end
+     *   alt value > max
+     *     V-->>C: Error message
+     *   else value <= max
+     *     V-->>C: undefined (valid)
+     *   end
+     *
      * @category Validators
      */
     exports.MaxValidator = class MaxValidator extends Validator {
@@ -2280,12 +2885,16 @@
             super(message, "number", "Date", "string");
         }
         /**
-         * @summary Validates a Model
+         * @description Checks if a value is less than or equal to a maximum
+         * @summary Validates that the provided value does not exceed the maximum value
+         * specified in the options. For dates, it performs chronological comparison,
+         * converting string representations to Date objects if necessary. For numbers
+         * and strings, it performs direct comparison.
          *
-         * @param {string} value
-         * @param {MaxValidatorOptions} options
+         * @param {number | Date | string} value - The value to validate
+         * @param {MaxValidatorOptions} options - Configuration options containing the maximum value
          *
-         * @return {string | undefined}
+         * @return {string | undefined} Error message if validation fails, undefined if validation passes
          *
          * @override
          *
@@ -2305,9 +2914,9 @@
                 : undefined;
         }
     };
-    exports.MaxValidator = __decorate([
+    exports.MaxValidator = tslib.__decorate([
         validator(ValidationKeys.MAX),
-        __metadata("design:paramtypes", [String])
+        tslib.__metadata("design:paramtypes", [String])
     ], exports.MaxValidator);
 
     /**
@@ -2345,19 +2954,61 @@
                 : undefined;
         }
     };
-    exports.MinLengthValidator = __decorate([
+    exports.MinLengthValidator = tslib.__decorate([
         validator(ValidationKeys.MIN_LENGTH),
-        __metadata("design:paramtypes", [String])
+        tslib.__metadata("design:paramtypes", [String])
     ], exports.MinLengthValidator);
 
     /**
-     * @summary Min Validator
+     * @description Validator for checking if a value is greater than or equal to a minimum
+     * @summary The MinValidator checks if a numeric value, date, or string is greater than or equal to
+     * a specified minimum value. It supports comparing numbers directly, dates chronologically,
+     * and strings lexicographically. This validator is typically used with the @min decorator.
      *
-     * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#MIN}
+     * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#MIN}
      *
      * @class MinValidator
      * @extends Validator
      *
+     * @example
+     * ```typescript
+     * // Create a min validator with default error message
+     * const minValidator = new MinValidator();
+     *
+     * // Create a min validator with custom error message
+     * const customMinValidator = new MinValidator("Value must be at least {0}");
+     *
+     * // Validate a number
+     * const numOptions = { min: 10, message: "Number too small" };
+     * const numResult = minValidator.hasErrors(50, numOptions); // undefined (valid)
+     * const invalidNumResult = minValidator.hasErrors(5, numOptions); // Returns error message (invalid)
+     *
+     * // Validate a date
+     * const dateOptions = { min: new Date(2023, 0, 1) };
+     * const dateResult = minValidator.hasErrors(new Date(2023, 5, 15), dateOptions); // undefined (valid)
+     * ```
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Client
+     *   participant V as MinValidator
+     *
+     *   C->>V: new MinValidator(message)
+     *   C->>V: hasErrors(value, options)
+     *   alt value is undefined
+     *     V-->>C: undefined (valid)
+     *   else value is Date and min is not Date
+     *     V->>V: Convert min to Date
+     *     alt conversion fails
+     *       V-->>C: Error: Invalid Min param
+     *     end
+     *   end
+     *   alt value < min
+     *     V-->>C: Error message
+     *   else value >= min
+     *     V-->>C: undefined (valid)
+     *   end
+     *
      * @category Validators
      */
     exports.MinValidator = class MinValidator extends Validator {
@@ -2365,12 +3016,16 @@
             super(message, "number", "Date", "string");
         }
         /**
-         * @summary Validates Model
+         * @description Checks if a value is greater than or equal to a minimum
+         * @summary Validates that the provided value is not less than the minimum value
+         * specified in the options. For dates, it performs chronological comparison,
+         * converting string representations to Date objects if necessary. For numbers
+         * and strings, it performs direct comparison.
          *
-         * @param {string} value
-         * @param {MaxValidatorOptions} options
+         * @param {number | Date | string} value - The value to validate
+         * @param {MinValidatorOptions} options - Configuration options containing the minimum value
          *
-         * @return {string | undefined}
+         * @return {string | undefined} Error message if validation fails, undefined if validation passes
          *
          * @override
          *
@@ -2390,9 +3045,9 @@
                 : undefined;
         }
     };
-    exports.MinValidator = __decorate([
+    exports.MinValidator = tslib.__decorate([
         validator(ValidationKeys.MIN),
-        __metadata("design:paramtypes", [String])
+        tslib.__metadata("design:paramtypes", [String])
     ], exports.MinValidator);
 
     /**
@@ -2428,19 +3083,61 @@
             });
         }
     };
-    exports.PasswordValidator = __decorate([
+    exports.PasswordValidator = tslib.__decorate([
         validator(ValidationKeys.PASSWORD),
-        __metadata("design:paramtypes", [Object])
+        tslib.__metadata("design:paramtypes", [Object])
     ], exports.PasswordValidator);
 
     /**
-     * @summary Required Validator
+     * @description Validator for checking if a value is present and not empty
+     * @summary The RequiredValidator ensures that a value is provided and not empty.
+     * It handles different types of values appropriately: for booleans and numbers,
+     * it checks if they're undefined; for other types (strings, arrays, objects),
+     * it checks if they're falsy. This validator is typically used with the @required decorator
+     * and is often the first validation applied to important fields.
      *
-     * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#REQUIRED}
+     * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#REQUIRED}
      *
      * @class RequiredValidator
      * @extends Validator
      *
+     * @example
+     * ```typescript
+     * // Create a required validator with default error message
+     * const requiredValidator = new RequiredValidator();
+     *
+     * // Create a required validator with custom error message
+     * const customRequiredValidator = new RequiredValidator("This field is mandatory");
+     *
+     * // Validate different types of values
+     * requiredValidator.hasErrors("Hello"); // undefined (valid)
+     * requiredValidator.hasErrors(""); // Returns error message (invalid)
+     * requiredValidator.hasErrors(0); // undefined (valid - 0 is a valid number)
+     * requiredValidator.hasErrors(null); // Returns error message (invalid)
+     * requiredValidator.hasErrors([]); // undefined (valid - empty array is still an array)
+     * ```
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Client
+     *   participant V as RequiredValidator
+     *
+     *   C->>V: new RequiredValidator(message)
+     *   C->>V: hasErrors(value, options)
+     *   alt typeof value is boolean or number
+     *     alt value is undefined
+     *       V-->>C: Error message
+     *     else value is defined
+     *       V-->>C: undefined (valid)
+     *     end
+     *   else other types
+     *     alt value is falsy (null, undefined, empty string)
+     *       V-->>C: Error message
+     *     else value is truthy
+     *       V-->>C: undefined (valid)
+     *     end
+     *   end
+     *
      * @category Validators
      */
     exports.RequiredValidator = class RequiredValidator extends Validator {
@@ -2448,12 +3145,16 @@
             super(message);
         }
         /**
-         * @summary Validates a model
+         * @description Checks if a value is present and not empty
+         * @summary Validates that the provided value exists and is not empty.
+         * The validation logic varies by type:
+         * - For booleans and numbers: checks if the value is undefined
+         * - For other types (strings, arrays, objects): checks if the value is falsy
          *
-         * @param {string} value
-         * @param {ValidatorOptions} [options={}]
+         * @param {any} value - The value to validate
+         * @param {ValidatorOptions} [options={}] - Optional configuration options
          *
-         * @return {string | undefined}
+         * @return {string | undefined} Error message if validation fails, undefined if validation passes
          *
          * @override
          *
@@ -2473,9 +3174,9 @@
             }
         }
     };
-    exports.RequiredValidator = __decorate([
+    exports.RequiredValidator = tslib.__decorate([
         validator(ValidationKeys.REQUIRED),
-        __metadata("design:paramtypes", [String])
+        tslib.__metadata("design:paramtypes", [String])
     ], exports.RequiredValidator);
 
     /**
@@ -2513,17 +3214,67 @@
                 : undefined;
         }
     };
-    exports.StepValidator = __decorate([
+    exports.StepValidator = tslib.__decorate([
         validator(ValidationKeys.STEP),
-        __metadata("design:paramtypes", [String])
+        tslib.__metadata("design:paramtypes", [String])
     ], exports.StepValidator);
 
     /**
-     * @summary Required Validator
+     * @description Validator for checking if a value is of the expected type(s)
+     * @summary The TypeValidator ensures that a value matches one of the specified types.
+     * It can validate against a single type, multiple types, or a type with a specific name.
+     * This validator is typically used with the @type decorator and is fundamental for
+     * ensuring type safety in validated models.
      *
-     * @class RequiredValidator
+     * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#TYPE}
+     *
+     * @class TypeValidator
      * @extends Validator
      *
+     * @example
+     * ```typescript
+     * // Create a type validator with default error message
+     * const typeValidator = new TypeValidator();
+     *
+     * // Create a type validator with custom error message
+     * const customTypeValidator = new TypeValidator("Value must be of type {0}, but got {1}");
+     *
+     * // Validate against a single type
+     * const stringOptions = { types: "string" };
+     * typeValidator.hasErrors("hello", stringOptions); // undefined (valid)
+     * typeValidator.hasErrors(123, stringOptions); // Returns error message (invalid)
+     *
+     * // Validate against multiple types
+     * const multiOptions = { types: ["string", "number"] };
+     * typeValidator.hasErrors("hello", multiOptions); // undefined (valid)
+     * typeValidator.hasErrors(123, multiOptions); // undefined (valid)
+     * typeValidator.hasErrors(true, multiOptions); // Returns error message (invalid)
+     *
+     * // Validate against a class type
+     * const classOptions = { types: { name: "Date" } };
+     * typeValidator.hasErrors(new Date(), classOptions); // undefined (valid)
+     * ```
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Client
+     *   participant V as TypeValidator
+     *   participant R as Reflection
+     *
+     *   C->>V: new TypeValidator(message)
+     *   C->>V: hasErrors(value, options)
+     *   alt value is undefined
+     *     V-->>C: undefined (valid)
+     *   else value is defined
+     *     V->>R: evaluateDesignTypes(value, types)
+     *     alt type evaluation passes
+     *       V-->>C: undefined (valid)
+     *     else type evaluation fails
+     *       V->>V: Format error message with type info
+     *       V-->>C: Error message
+     *     end
+     *   end
+     *
      * @category Validators
      */
     exports.TypeValidator = class TypeValidator extends Validator {
@@ -2531,11 +3282,15 @@
             super(message);
         }
         /**
-         * @summary Validates a model
-         * @param {string} value
-         * @param {TypeValidatorOptions} options
+         * @description Checks if a value is of the expected type(s)
+         * @summary Validates that the provided value matches one of the specified types.
+         * It uses the Reflection utility to evaluate if the value's type matches the expected types.
+         * The method skips validation for undefined values to avoid conflicts with the RequiredValidator.
          *
-         * @return {string | undefined}
+         * @param {any} value - The value to validate
+         * @param {TypeValidatorOptions} options - Configuration options containing the expected types
+         *
+         * @return {string | undefined} Error message if validation fails, undefined if validation passes
          *
          * @override
          *
@@ -2553,10 +3308,18 @@
                         : types.name, typeof value);
         }
     };
-    exports.TypeValidator = __decorate([
+    exports.TypeValidator = tslib.__decorate([
         validator(ValidationKeys.TYPE),
-        __metadata("design:paramtypes", [String])
+        tslib.__metadata("design:paramtypes", [String])
     ], exports.TypeValidator);
+    /**
+     * @description Register the TypeValidator with the Validation registry
+     * @summary This registration associates the TypeValidator with the ModelKeys.TYPE key,
+     * allowing it to be used for validating design types. The save flag is set to false
+     * to prevent the validator from being saved in the standard validator registry.
+     *
+     * @memberOf module:decorator-validation
+     */
     Validation.register({
         validator: exports.TypeValidator,
         validationKey: exports.ModelKeys.TYPE,
@@ -2564,12 +3327,43 @@
     });
 
     /**
-     * @summary URL Validator
-     * @description Pattern from {@link https://gist.github.com/dperini/729294}
+     * @description Validator for checking if a string is a valid URL
+     * @summary The URLValidator checks if a string matches a standard URL pattern.
+     * It extends the PatternValidator and uses a robust URL regex pattern to validate web addresses.
+     * The pattern is sourced from {@link https://gist.github.com/dperini/729294} and is widely
+     * recognized for its accuracy in validating URLs. This validator is typically used with the @url decorator.
+     *
+     * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#URL}
      *
      * @class URLValidator
      * @extends PatternValidator
      *
+     * @example
+     * ```typescript
+     * // Create a URL validator with default error message
+     * const urlValidator = new URLValidator();
+     *
+     * // Create a URL validator with custom error message
+     * const customUrlValidator = new URLValidator("Please enter a valid web address");
+     *
+     * // Validate a URL
+     * const result = urlValidator.hasErrors("https://example.com"); // undefined (valid)
+     * const invalidResult = urlValidator.hasErrors("not-a-url"); // Returns error message (invalid)
+     * ```
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Client
+     *   participant U as URLValidator
+     *   participant P as PatternValidator
+     *
+     *   C->>U: new URLValidator(message)
+     *   U->>P: super(message)
+     *   C->>U: hasErrors(value, options)
+     *   U->>P: super.hasErrors(value, options with URL pattern)
+     *   P-->>U: validation result
+     *   U-->>C: validation result
+     *
      * @category Validators
      */
     exports.URLValidator = class URLValidator extends exports.PatternValidator {
@@ -2577,16 +3371,19 @@
             super(message);
         }
         /**
-         * @summary Validates a model
+         * @description Checks if a string is a valid URL
+         * @summary Validates that the provided string matches the URL pattern.
+         * This method extends the PatternValidator's hasErrors method by ensuring
+         * the URL pattern is used, even if not explicitly provided in the options.
          *
-         * @param {string} value
-         * @param {PatternValidatorOptions} [options={}]
+         * @param {string} value - The string to validate as a URL
+         * @param {PatternValidatorOptions} [options={}] - Optional configuration options
          *
-         * @return {string | undefined}
+         * @return {string | undefined} Error message if validation fails, undefined if validation passes
          *
          * @override
          *
-         * @see Validator#hasErrors
+         * @see PatternValidator#hasErrors
          */
         hasErrors(value, options = {}) {
             return super.hasErrors(value, {
@@ -2595,43 +3392,75 @@
             });
         }
     };
-    exports.URLValidator = __decorate([
+    exports.URLValidator = tslib.__decorate([
         validator(ValidationKeys.URL),
-        __metadata("design:paramtypes", [String])
+        tslib.__metadata("design:paramtypes", [String])
     ], exports.URLValidator);
 
     /**
-     * @summary Marks the property as required.
-     * @description Validators to validate a decorated property must use key {@link ValidationKeys#REQUIRED}
+     * @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.
+     * Validators to validate a decorated property must use key {@link ValidationKeys#REQUIRED}.
+     * This decorator is commonly used as the first validation step for important fields.
      *
-     * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#REQUIRED}
+     * @param {string} [message] - The error message to display when validation fails. Defaults to {@link DEFAULT_ERROR_MESSAGES#REQUIRED}
+     * @return {PropertyDecorator} A decorator function that can be applied to class properties
      *
      * @function required
-     *
      * @category Decorators
+     *
+     * @example
+     * ```typescript
+     * class User {
+     *   @required()
+     *   username: string;
+     *
+     *   @required("Email address is mandatory")
+     *   email: string;
+     * }
+     * ```
      */
     function required(message = DEFAULT_ERROR_MESSAGES.REQUIRED) {
-        return propMetadata(Validation.key(ValidationKeys.REQUIRED), {
+        const key = Validation.key(ValidationKeys.REQUIRED);
+        return Decoration.for(key)
+            .define(propMetadata(key, {
             message: message,
-        });
+        }))
+            .apply();
     }
     /**
-     * @summary Defines a minimum value for the property
-     * @description Validators to validate a decorated property must use key {@link ValidationKeys#MIN}
+     * @description Property decorator that enforces a minimum value constraint
+     * @summary Defines a minimum value for the property, causing validation to fail if the property value is less than the specified minimum.
+     * Validators to validate a decorated property must use key {@link ValidationKeys#MIN}.
+     * This decorator works with numeric values and dates.
      *
-     * @param {number | Date} value
-     * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#MIN}
+     * @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
+     * @param {string} [message] - The error message to display when validation fails. Defaults to {@link DEFAULT_ERROR_MESSAGES#MIN}
+     * @return {PropertyDecorator} A decorator function that can be applied to class properties
      *
      * @function min
-     * @memberOf module:decorator-validation.Decorators.Validation
      * @category Decorators
+     *
+     * @example
+     * ```typescript
+     * class Product {
+     *   @min(0)
+     *   price: number;
+     *
+     *   @min(new Date(2023, 0, 1), "Date must be after January 1, 2023")
+     *   releaseDate: Date;
+     * }
+     * ```
      */
     function min(value, message = DEFAULT_ERROR_MESSAGES.MIN) {
-        return propMetadata(Validation.key(ValidationKeys.MIN), {
+        const key = Validation.key(ValidationKeys.MIN);
+        return Decoration.for(key)
+            .define(propMetadata(key, {
             [ValidationKeys.MIN]: value,
             message: message,
             types: [Number.name, Date.name],
-        });
+        }))
+            .apply();
     }
     /**
      * @summary Defines a maximum value for the property
@@ -2641,15 +3470,17 @@
      * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#MAX}
      *
      * @function max
-     * @memberOf module:decorator-validation.Decorators.Validation
      * @category Decorators
      */
     function max(value, message = DEFAULT_ERROR_MESSAGES.MAX) {
-        return propMetadata(Validation.key(ValidationKeys.MAX), {
+        const key = Validation.key(ValidationKeys.MAX);
+        return Decoration.for(key)
+            .define(propMetadata(key, {
             [ValidationKeys.MAX]: value,
             message: message,
             types: [Number.name, Date.name],
-        });
+        }))
+            .apply();
     }
     /**
      * @summary Defines a step value for the property
@@ -2659,15 +3490,17 @@
      * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#STEP}
      *
      * @function step
-     * @memberOf module:decorator-validation.Decorators.Validation
      * @category Decorators
      */
     function step(value, message = DEFAULT_ERROR_MESSAGES.STEP) {
-        return propMetadata(Validation.key(ValidationKeys.STEP), {
+        const key = Validation.key(ValidationKeys.STEP);
+        return Decoration.for(key)
+            .define(propMetadata(key, {
             [ValidationKeys.STEP]: value,
             message: message,
             types: [Number.name],
-        });
+        }))
+            .apply();
     }
     /**
      * @summary Defines a minimum length for the property
@@ -2677,15 +3510,17 @@
      * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#MIN_LENGTH}
      *
      * @function minlength
-     * @memberOf module:decorator-validation.Decorators.Validation
      * @category Decorators
      */
     function minlength(value, message = DEFAULT_ERROR_MESSAGES.MIN_LENGTH) {
-        return propMetadata(Validation.key(ValidationKeys.MIN_LENGTH), {
+        const key = Validation.key(ValidationKeys.MIN_LENGTH);
+        return Decoration.for(key)
+            .define(propMetadata(key, {
             [ValidationKeys.MIN_LENGTH]: value,
             message: message,
             types: [String.name, Array.name, Set.name],
-        });
+        }))
+            .apply();
     }
     /**
      * @summary Defines a maximum length for the property
@@ -2695,15 +3530,17 @@
      * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#MAX_LENGTH}
      *
      * @function maxlength
-     * @memberOf module:decorator-validation.Decorators.Validation
      * @category Decorators
      */
     function maxlength(value, message = DEFAULT_ERROR_MESSAGES.MAX_LENGTH) {
-        return propMetadata(Validation.key(ValidationKeys.MAX_LENGTH), {
+        const key = Validation.key(ValidationKeys.MAX_LENGTH);
+        return Decoration.for(key)
+            .define(propMetadata(key, {
             [ValidationKeys.MAX_LENGTH]: value,
             message: message,
             types: [String.name, Array.name, Set.name],
-        });
+        }))
+            .apply();
     }
     /**
      * @summary Defines a RegExp pattern the property must respect
@@ -2713,15 +3550,17 @@
      * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#PATTERN}
      *
      * @function pattern
-     * @memberOf module:decorator-validation.Decorators.Validation
      * @category Decorators
      */
     function pattern(value, message = DEFAULT_ERROR_MESSAGES.PATTERN) {
-        return propMetadata(Validation.key(ValidationKeys.PATTERN), {
+        const key = Validation.key(ValidationKeys.PATTERN);
+        return Decoration.for(key)
+            .define(propMetadata(key, {
             [ValidationKeys.PATTERN]: typeof value === "string" ? value : value.toString(),
             message: message,
             types: [String.name],
-        });
+        }))
+            .apply();
     }
     /**
      * @summary Defines the property as an email
@@ -2730,15 +3569,17 @@
      * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#EMAIL}
      *
      * @function email
-     * @memberOf module:decorator-validation.Decorators.Validation
      * @category Decorators
      */
     function email(message = DEFAULT_ERROR_MESSAGES.EMAIL) {
-        return propMetadata(Validation.key(ValidationKeys.EMAIL), {
+        const key = Validation.key(ValidationKeys.EMAIL);
+        return Decoration.for(key)
+            .define(propMetadata(key, {
             [ValidationKeys.PATTERN]: DEFAULT_PATTERNS.EMAIL,
             message: message,
             types: [String.name],
-        });
+        }))
+            .apply();
     }
     /**
      * @summary Defines the property as an URL
@@ -2747,15 +3588,17 @@
      * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#URL}
      *
      * @function url
-     * @memberOf module:decorator-validation.Decorators.Validation
      * @category Decorators
      */
     function url(message = DEFAULT_ERROR_MESSAGES.URL) {
-        return propMetadata(Validation.key(ValidationKeys.URL), {
+        const key = Validation.key(ValidationKeys.URL);
+        return Decoration.for(key)
+            .define(propMetadata(key, {
             [ValidationKeys.PATTERN]: DEFAULT_PATTERNS.URL,
             message: message,
             types: [String.name],
-        });
+        }))
+            .apply();
     }
     /**
      * @summary Enforces type verification
@@ -2765,14 +3608,16 @@
      * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#TYPE}
      *
      * @function type
-     * @memberOf module:decorator-validation.Decorators.Validation
      * @category Decorators
      */
     function type(types, message = DEFAULT_ERROR_MESSAGES.TYPE) {
-        return propMetadata(Validation.key(ValidationKeys.TYPE), {
+        const key = Validation.key(ValidationKeys.TYPE);
+        return Decoration.for(key)
+            .define(propMetadata(key, {
             customTypes: types,
             message: message,
-        });
+        }))
+            .apply();
     }
     /**
      * @summary Date Handler Decorator
@@ -2782,16 +3627,15 @@
      *
      * @param {string} format accepted format according to {@link formatDate}
      * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#DATE}
-     * @param {Constructor<Validator>} [validator] the Validator to be used. Defaults to {@link DateValidator}
      *
      * @function date
      *
-     * @memberOf module:decorator-validation.Decorators.Validation
      * @category Decorators
      */
     function date(format = "dd/MM/yyyy", message = DEFAULT_ERROR_MESSAGES.DATE) {
-        return (target, propertyKey) => {
-            propMetadata(Validation.key(ValidationKeys.DATE), {
+        const key = Validation.key(ValidationKeys.DATE);
+        const dateDec = (target, propertyKey) => {
+            propMetadata(key, {
                 [ValidationKeys.FORMAT]: format,
                 message: message,
                 types: [Date.name],
@@ -2824,26 +3668,28 @@
                 },
             });
         };
+        return Decoration.for(key).define(dateDec).apply();
     }
     /**
      * @summary Password Handler Decorator
      * @description Validators to validate a decorated property must use key {@link ValidationKeys#PASSWORD}
      *
-     * @param {RegExp} [pattern] defaults to {@link PasswordPatterns#CHAR8_ONE_OF_EACH}
+     * @param {RegExp} [pattern] defaults to {@link DEFAULT_PATTERNS#CHAR8_ONE_OF_EACH}
      * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#PASSWORD}
-     * @param {Constructor<Validator>} [validator] Defaults to {@link PasswordValidator}
      *
      * @function password
      *
-     * @memberOf module:decorator-validation.Decorators.Validation
      * @category Decorators
      */
     function password(pattern = DEFAULT_PATTERNS.PASSWORD.CHAR8_ONE_OF_EACH, message = DEFAULT_ERROR_MESSAGES.PASSWORD) {
-        return propMetadata(Validation.key(ValidationKeys.PASSWORD), {
+        const key = Validation.key(ValidationKeys.PASSWORD);
+        return Decoration.for(key)
+            .define(propMetadata(key, {
             [ValidationKeys.PATTERN]: pattern,
             message: message,
             types: [String.name],
-        });
+        }))
+            .apply();
     }
     /**
      * @summary List Decorator
@@ -2852,19 +3698,20 @@
      * @param {ModelConstructor} clazz
      * @param {string} [collection] The collection being used. defaults to Array
      * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LIST}
-     * @param {Constructor<Validator>} [validator] defaults to {@link ListValidator}
      *
      * @function list
      *
-     * @memberOf module:decorator-validation.Decorators.Validation
      * @category Decorators
      */
     function list(clazz, collection = "Array", message = DEFAULT_ERROR_MESSAGES.LIST) {
-        return propMetadata(Validation.key(ValidationKeys.LIST), {
+        const key = Validation.key(ValidationKeys.LIST);
+        return Decoration.for(key)
+            .define(propMetadata(key, {
             clazz: Array.isArray(clazz) ? clazz.map((c) => c.name) : [clazz.name],
             type: collection,
             message: message,
-        });
+        }))
+            .apply();
     }
     /**
      * @summary Set Decorator
@@ -2872,11 +3719,9 @@
      *
      * @param {ModelConstructor} clazz
      * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LIST}
-     * @param {Constructor<Validator>} [validator]
      *
      * @function set
      *
-     * @memberOf module:decorator-validation.Decorators.Validation
      * @category Decorators
      */
     function set(clazz, message = DEFAULT_ERROR_MESSAGES.LIST) {
@@ -3011,7 +3856,7 @@
      * @return {T} the new instance
      *
      * @function construct
-     * @memberOf module:decorator-validation.Construction
+     * @memberOf module:decorator-validation
      */
     function construct(constructor, ...args) {
         const _constr = (...argz) => new constructor(...argz);
@@ -3023,7 +3868,7 @@
      * @param {object} obj
      *
      * @function findLastProtoBeforeObject
-     * @memberOf module:decorator-validation.Construction
+     * @memberOf module:decorator-validation
      */
     function findLastProtoBeforeObject(obj) {
         let prototype = Object.getPrototypeOf(obj);
@@ -3044,7 +3889,7 @@
      * @param {unknown} obj
      *
      * @function bindModelPrototype
-     * @memberOf module:decorator-validation.Construction
+     * @memberOf module:decorator-validation
      */
     function bindModelPrototype(obj) {
         if (obj instanceof Model)
@@ -3079,8 +3924,7 @@
      *
      * @function model
      *
-     * @memberOf module:decorator-validation.Model
-     *
+     * @category Decorators
      */
     function model(instanceCallback) {
         return ((original) => {
@@ -3099,6 +3943,9 @@
             };
             // copy prototype so instanceof operator still works
             newConstructor.prototype = original.prototype;
+            Reflect.getMetadataKeys(original).forEach((key) => {
+                Reflect.defineMetadata(key, Reflect.getMetadata(key, original), newConstructor);
+            });
             // Sets the proper constructor name for type verification
             Object.defineProperty(newConstructor, "name", {
                 writable: false,
@@ -3127,49 +3974,20 @@
 
     /**
      * @module decorator-validation
+     * @description TypeScript decorator-based validation library
+     * @summary This module provides a comprehensive validation framework using TypeScript decorators.
+     * It exposes utility functions, validation decorators, and model-related functionality for
+     * implementing type-safe, declarative validation in TypeScript applications.
      */
-    /**
-     * @summary Model definition functionality
-     * @description defines the base class and related functionality
-     *
-     * @namespace Model
-     * @memberOf module:decorator-validation
-     */
-    /**
-     * @summary Holds all the supported decorators
-     * @namespace Decorators
-     * @memberOf module:decorator-validation
-     */
-    /**
-     * @summary Validation related functionality
-     * @description Defines the Model validation apis and base classes for validators
-     *
-     * @namespace Validation
-     * @memberOf module:decorator-validation
-     */
-    /**
-     * @namespace Dates
-     * @memberOf module:decorator-validation
-     */
-    /**
-     * @namespace Hashing
-     * @memberOf module:decorator-validation
-     */
-    /**
-     * @namespace Serialization
-     * @memberOf module:decorator-validation
-     */
-    /**
-     * @namespace Format
-     * @memberOf module:decorator-validation
-     */
-    const VERSION = "1.6.5";
+    const VERSION = "1.7.1";
 
     exports.COMPARISON_ERROR_MESSAGES = COMPARISON_ERROR_MESSAGES;
     exports.ComparisonValidationKeys = ComparisonValidationKeys;
     exports.DAYS_OF_WEEK_NAMES = DAYS_OF_WEEK_NAMES;
     exports.DEFAULT_ERROR_MESSAGES = DEFAULT_ERROR_MESSAGES;
     exports.DEFAULT_PATTERNS = DEFAULT_PATTERNS;
+    exports.Decoration = Decoration;
+    exports.DefaultFlavour = DefaultFlavour;
     exports.DefaultHashingMethod = DefaultHashingMethod;
     exports.DefaultSerializationMethod = DefaultSerializationMethod;
     exports.Hashing = Hashing;
@@ -3179,7 +3997,6 @@
     exports.ModelErrorDefinition = ModelErrorDefinition;
     exports.ModelRegistryManager = ModelRegistryManager;
     exports.Serialization = Serialization;
-    exports.VALIDATION_PARENT_KEY = VALIDATION_PARENT_KEY;
     exports.VERSION = VERSION;
     exports.Validation = Validation;
     exports.ValidationKeys = ValidationKeys;
@@ -3196,6 +4013,8 @@
     exports.eq = eq;
     exports.findLastProtoBeforeObject = findLastProtoBeforeObject;
     exports.formatDate = formatDate;
+    exports.getMetadata = getMetadata;
+    exports.getModelKey = getModelKey;
     exports.getValueByPath = getValueByPath;
     exports.gt = gt;
     exports.gte = gte;
@@ -3204,11 +4023,8 @@
     exports.hashedBy = hashedBy;
     exports.isGreaterThan = isGreaterThan;
     exports.isLessThan = isLessThan;
-    exports.isModel = isModel;
-    exports.isPropertyModel = isPropertyModel;
     exports.isValidDate = isValidDate;
     exports.isValidForGteOrLteComparison = isValidForGteOrLteComparison;
-    exports.isValidator = isValidator;
     exports.jsTypes = jsTypes;
     exports.list = list;
     exports.lt = lt;
@@ -3237,4 +4053,4 @@
     exports.validator = validator;
 
 }));
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"decorator-validation.cjs","sources":["../src/constants/validation.ts","../src/utils/constants.ts","../src/validation/Validators/constants.ts","../src/utils/strings.ts","../src/utils/dates.ts","../src/utils/decorators.ts","../src/utils/hashing.ts","../src/model/ModelErrorDefinition.ts","../src/model/constants.ts","../src/validation/Validators/ValidatorRegistry.ts","../src/validation/Validation.ts","../src/model/validation.ts","../src/model/Model.ts","../src/utils/serialization.ts","../node_modules/tslib/tslib.es6.js","../src/validation/Validators/Validator.ts","../src/validation/Validators/decorators.ts","../src/validation/Validators/DateValidator.ts","../src/validation/Validators/utils.ts","../src/validation/Validators/DiffValidator.ts","../src/validation/Validators/PatternValidator.ts","../src/validation/Validators/EmailValidator.ts","../src/validation/Validators/EqualsValidator.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":["/**\n * Symbol used to internally track the parent object during nested validation.\n *\n * This key is attached to child objects to provide context about their parent\n * in the object hierarchy, enabling validations that depend on parent values.\n *\n * @constant VALIDATION_PARENT_KEY\n * @memberOf module:decorator-validation.Model\n */\nexport const VALIDATION_PARENT_KEY = Symbol(\"_validationParentRef\");\n","/**\n * @summary Defines the various Model keys used for reflection\n *\n * @property {string} REFLECT prefix to all other keys\n * @property {string} TYPE type key\n * @property {string} PARAMS method params key\n * @property {string} RETURN method return key\n * @property {string} MODEL model key\n * @property {string} ANCHOR anchor key. will serve as a ghost property in the model\n *\n * @constant ModelKeys\n * @memberOf module:decorator-validation.Model\n * @category Model\n */\nexport enum ModelKeys {\n  REFLECT = \"decaf.model.\",\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","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\nexport 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  NO_PARENT_COMPARISON:\n    \"Unable to access parent at level {0} for path '{1}': no parent available\",\n  PROPERTY_NOT_FOUND:\n    \"Failed to resolve path {0}: property '{1}' does not exist.\",\n  PROPERTY_NOT_FOUND_ON_PARENT:\n    \"Failed to resolve path {0}: property '{1}' does not exist on parent.\",\n  PROPERTY_NOT_FOUND_AFTER_PARENT:\n    \"Failed to resolve path {0}: property '{1}' does not exist after {2} parent level(s).\",\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};\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.Utils.Format\n * @category Format\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.Utils.Format\n * @category Format\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.Utils.Dates\n * @category Format\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 * @summary Binds a date format to a string\n * @param {Date} [date]\n * @param {string} [format]\n * @memberOf module:decorator-validation.Utils.Format\n * @category Utilities\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 * @summary Helper function to be used instead of instanceOf Date\n * @param date\n * @memberOf module:decorator-validation.Utils.Dates\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.Utils.Format\n * @category Format\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.Utils.Dates\n * @category Format\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.Utils.Dates\n * @category Format\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 { apply, metadata } from \"@decaf-ts/reflection\";\nimport { ModelKeys } from \"./constants\";\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\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.Utils.Hashing\n * @category Hashing\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.Utils.Hashing\n * @category Hashing\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.Utils.Hashing\n * @category Hashing\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\nexport class Hashing {\n  private static current: string = DefaultHashingMethod;\n\n  private static cache: Record<string, HashingFunction> = {\n    default: hashObj,\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 hashing method registered under ${key}`);\n  }\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 { 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.Model\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.Model\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.Model\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 { ValidatorDefinition } from \"../types\";\nimport { IValidatorRegistry } from \"../types\";\nimport type { Validator } from \"./Validator\";\n\n/**\n * @summary Duck typing for Validators\n * @function isValidator\n * @param val\n */\nexport function isValidator(val: any) {\n  return val.constructor && val[\"hasErrors\"];\n}\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 (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 (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 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","import { ModelErrorDefinition } from \"./ModelErrorDefinition\";\nimport { DecoratorMetadata, Reflection } from \"@decaf-ts/reflection\";\nimport { ModelKeys } from \"../utils/constants\";\nimport { sf } from \"../utils/strings\";\nimport { ReservedModels } from \"./constants\";\nimport { VALIDATION_PARENT_KEY } from \"../constants\";\nimport { Validatable } from \"./types\";\nimport { isModel, 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\";\n\n/**\n * @summary Analyses the decorations of the properties and validates the obj according to them\n *\n * @typedef T extends Model\n * @prop {T} 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.Validation\n * @category Validation\n */\nexport function validate<T extends Model>(\n  obj: T,\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        Reflection.getPropertyDecorators(\n          ValidationKeys.REFLECT,\n          obj,\n          prop\n        ) as ValidationPropertyDecoratorDefinition\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        obj // TODO: Assert type and deep Object.freeze\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 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: any) {\n              console.warn(sf(\"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 { 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 { sf } from \"../utils/strings\";\nimport { jsTypes, ReservedModels } from \"./constants\";\n\nlet modelBuilderFunction: ModelBuilderFunction | undefined;\nlet actingModelRegistry: BuilderRegistry<any>;\n\nexport function isPropertyModel<M extends Model>(\n  target: M,\n  attribute: string\n): boolean | string | undefined {\n  if (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/**\n * @summary For Serialization/deserialization purposes.\n * @description Reads the {@link ModelKeys.ANCHOR} property of a {@link Model} to discover the class to instantiate\n *\n * @function isModel\n * @memberOf module:decorator-validation.Validation\n * @category Validation\n */\nexport function 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 * @summary ModelRegistry Interface\n *\n * @interface ModelRegistry\n * @extends BuilderRegistry<Model>\n *\n * @category Model\n */\nexport type ModelRegistry<T extends Model> = BuilderRegistry<T>;\n\n/**\n * @summary Util class to enable serialization and correct rebuilding\n *\n * @param {string} anchorKey defaults to {@link ModelKeys.ANCHOR}. The property name where the registered class name is stored;\n * @param {function(Record<string, any>): boolean} [testFunction] method to test if the provided object is a Model Object. defaults to {@link isModel}\n *\n * @class ModelRegistryManager\n * @implements ModelRegistry\n *\n * @category Model\n */\nexport class ModelRegistryManager<T extends Model> implements ModelRegistry<T> {\n  private cache: Record<string, ModelConstructor<T>> = {};\n  private readonly testFunction: (obj: object) => boolean;\n\n  constructor(testFunction: (obj: Record<string, any>) => boolean = isModel) {\n    this.testFunction = testFunction;\n  }\n\n  /**\n   * @summary register new Models\n   * @param {any} constructor\n   * @param {string} [name] when not defined, the name of the constructor will be used\n   */\n  register(constructor: ModelConstructor<T>, 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<T> | 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): T {\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        sf(\"Provided class {0} is not a registered Model object\", name)\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 * @param {Array<Constructor<T>> | Array<{name: string, constructor: Constructor<T>}>} [models]\n *\n * @memberOf module:decorator-validation.Model\n * @category Model\n */\nexport function bulkModelRegister<T extends Model>(\n  ...models: (Constructor<T> | { name: string; constructor: Constructor<T> })[]\n) {\n  models.forEach(\n    (m: Constructor<T> | { name: string; constructor: Constructor<T> }) => {\n      const constructor: Constructor<T> = (\n        m.constructor ? m.constructor : m\n      ) as Constructor<T>;\n      Model.register(constructor, (m as Constructor<T>).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 {Model | {}} model base object from which to populate properties from\n *\n * @class 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   * @summary Validates the object according to its decorated properties\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   */\n  public hasErrors(...exceptions: any[]): ModelErrorDefinition | undefined {\n    return validate(this, ...exceptions);\n  }\n\n  /**\n   * @summary Compare object equality recursively\n   * @param {any} obj object to compare to\n   * @param {string} [exceptions] property names to be excluded from the comparison\n   */\n  public equals(obj: any, ...exceptions: string[]): boolean {\n    return isEqual(this, obj, ...exceptions);\n  }\n\n  /**\n   * @summary Returns the serialized model according to the currently defined {@link Serializer}\n   */\n  serialize(): string {\n    return Model.serialize(this);\n  }\n\n  /**\n   * @summary Override the implementation for js's 'toString()' which sucks...\n   * @override\n   */\n  public toString(): string {\n    return this.constructor.name + \": \" + JSON.stringify(this, undefined, 2);\n  }\n\n  /**\n   * @summary Defines a default implementation for object hash. Relies on a very basic implementation based on Java's string hash;\n   */\n  public hash(): string {\n    return Model.hash(this);\n  }\n\n  /**\n   * @summary Deserializes a Model\n   * @param {string} str\n   *\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   * @summary Repopulates the Object properties with the ones from the new object\n   * @description Iterates all common properties of obj (if existing) and self, and copies them onto self\n   *\n   * @param {T} self\n   * @param {T | Record<string, any>} [obj]\n   *\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   * @summary Repopulates the instance with the ones from the new Model Object\n   * @description Iterates all common properties of obj (if existing) and self, and copies them onto self.\n   * Is aware of nested Model Objects and rebuilds them also.\n   * When List properties are decorated with {@link list}, they list items will also be rebuilt\n   *\n   * @param {T} self\n   * @param {T | Record<string, any>} [obj]\n   *\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 = 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(sf(\"failed to find decorators for property {0}\", 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 ((self as Record<string, any>)[prop])\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   * @summary Sets the Global {@link ModelBuilderFunction}\n   * @param {ModelBuilderFunction} [builder]\n   */\n  static setBuilder(builder?: ModelBuilderFunction) {\n    modelBuilderFunction = builder;\n  }\n\n  /**\n   * @summary Retrieves the current global {@link ModelBuilderFunction}\n   */\n  static getBuilder(): ModelBuilderFunction | undefined {\n    return modelBuilderFunction;\n  }\n\n  /**\n   * Returns the current {@link ModelRegistryManager}\n   *\n   * @return ModelRegistry, defaults to {@link ModelRegistryManager}\n   */\n  private static getRegistry() {\n    if (!actingModelRegistry) actingModelRegistry = new ModelRegistryManager();\n    return actingModelRegistry;\n  }\n\n  /**\n   * Returns the current actingModelRegistry\n   *\n   * @param {BuilderRegistry} modelRegistry the new implementation of Registry\n   */\n  static setRegistry(modelRegistry: BuilderRegistry<any>) {\n    actingModelRegistry = modelRegistry;\n  }\n\n  /**\n   * @summary register new Models\n   * @param {any} constructor\n   * @param {string} [name] when not defined, the name of the constructor will be used\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   * @summary Gets a registered Model {@link ModelConstructor}\n   * @param {string} name\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   * @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   * @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  static getMetadata<V extends Model>(model: V) {\n    const metadata = Reflect.getMetadata(\n      Model.key(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  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  static equals<V extends Model>(obj1: V, obj2: V, ...exceptions: any[]) {\n    return isEqual(obj1, obj2, ...exceptions);\n  }\n\n  static hasErrors<V extends Model>(model: V, ...propsToIgnore: string[]) {\n    return validate(model, ...propsToIgnore);\n  }\n\n  static serialize<V extends Model>(model: V) {\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  static hash<V extends Model>(model: V) {\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   * @summary Builds the key to store as Metadata under Reflections\n   * @description concatenates {@link ModelKeys#REFLECT} with the provided key\n   * @param {string} str\n   */\n  static key(str: string) {\n    return ModelKeys.REFLECT + str;\n  }\n}\n","import { Constructor } from \"../model/types\";\nimport { Serializer } from \"./types\";\nimport { Model } from \"../model/Model\";\nimport { ModelKeys } from \"./constants\";\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 Serialization\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 = Model.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","/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise, SuppressedError, Symbol, Iterator */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n    function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n    var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n    var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n    var _, done = false;\r\n    for (var i = decorators.length - 1; i >= 0; i--) {\r\n        var context = {};\r\n        for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n        for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n        context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n        var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n        if (kind === \"accessor\") {\r\n            if (result === void 0) continue;\r\n            if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n            if (_ = accept(result.get)) descriptor.get = _;\r\n            if (_ = accept(result.set)) descriptor.set = _;\r\n            if (_ = accept(result.init)) initializers.unshift(_);\r\n        }\r\n        else if (_ = accept(result)) {\r\n            if (kind === \"field\") initializers.unshift(_);\r\n            else descriptor[key] = _;\r\n        }\r\n    }\r\n    if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n    done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n    var useValue = arguments.length > 2;\r\n    for (var i = 0; i < initializers.length; i++) {\r\n        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n    }\r\n    return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n    return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n    if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n    return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\r\n};\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === \"function\" ? Iterator : Object).prototype);\r\n    return g.next = verb(0), g[\"throw\"] = verb(1), g[\"return\"] = verb(2), typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = Object.create((typeof AsyncIterator === \"function\" ? AsyncIterator : Object).prototype), verb(\"next\"), verb(\"throw\"), verb(\"return\", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }\r\n    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nvar ownKeys = function(o) {\r\n    ownKeys = Object.getOwnPropertyNames || function (o) {\r\n        var ar = [];\r\n        for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;\r\n        return ar;\r\n    };\r\n    return ownKeys(o);\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== \"default\") __createBinding(result, mod, k[i]);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n\r\nexport function __addDisposableResource(env, value, async) {\r\n    if (value !== null && value !== void 0) {\r\n        if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\r\n        var dispose, inner;\r\n        if (async) {\r\n            if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\r\n            dispose = value[Symbol.asyncDispose];\r\n        }\r\n        if (dispose === void 0) {\r\n            if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\r\n            dispose = value[Symbol.dispose];\r\n            if (async) inner = dispose;\r\n        }\r\n        if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\r\n        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };\r\n        env.stack.push({ value: value, dispose: dispose, async: async });\r\n    }\r\n    else if (async) {\r\n        env.stack.push({ async: true });\r\n    }\r\n    return value;\r\n\r\n}\r\n\r\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\r\n    var e = new Error(message);\r\n    return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\r\n};\r\n\r\nexport function __disposeResources(env) {\r\n    function fail(e) {\r\n        env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\r\n        env.hasError = true;\r\n    }\r\n    var r, s = 0;\r\n    function next() {\r\n        while (r = env.stack.pop()) {\r\n            try {\r\n                if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);\r\n                if (r.dispose) {\r\n                    var result = r.dispose.call(r.value);\r\n                    if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\r\n                }\r\n                else s |= 1;\r\n            }\r\n            catch (e) {\r\n                fail(e);\r\n            }\r\n        }\r\n        if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();\r\n        if (env.hasError) throw env.error;\r\n    }\r\n    return next();\r\n}\r\n\r\nexport function __rewriteRelativeImportExtension(path, preserveJsx) {\r\n    if (typeof path === \"string\" && /^\\.\\.?\\//.test(path)) {\r\n        return path.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+?)?)\\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {\r\n            return tsx ? preserveJsx ? \".jsx\" : \".js\" : d && (!ext || !cm) ? m : (d + ext + \".\" + cm.toLowerCase() + \"js\");\r\n        });\r\n    }\r\n    return path;\r\n}\r\n\r\nexport default {\r\n    __extends: __extends,\r\n    __assign: __assign,\r\n    __rest: __rest,\r\n    __decorate: __decorate,\r\n    __param: __param,\r\n    __esDecorate: __esDecorate,\r\n    __runInitializers: __runInitializers,\r\n    __propKey: __propKey,\r\n    __setFunctionName: __setFunctionName,\r\n    __metadata: __metadata,\r\n    __awaiter: __awaiter,\r\n    __generator: __generator,\r\n    __createBinding: __createBinding,\r\n    __exportStar: __exportStar,\r\n    __values: __values,\r\n    __read: __read,\r\n    __spread: __spread,\r\n    __spreadArrays: __spreadArrays,\r\n    __spreadArray: __spreadArray,\r\n    __await: __await,\r\n    __asyncGenerator: __asyncGenerator,\r\n    __asyncDelegator: __asyncDelegator,\r\n    __asyncValues: __asyncValues,\r\n    __makeTemplateObject: __makeTemplateObject,\r\n    __importStar: __importStar,\r\n    __importDefault: __importDefault,\r\n    __classPrivateFieldGet: __classPrivateFieldGet,\r\n    __classPrivateFieldSet: __classPrivateFieldSet,\r\n    __classPrivateFieldIn: __classPrivateFieldIn,\r\n    __addDisposableResource: __addDisposableResource,\r\n    __disposeResources: __disposeResources,\r\n    __rewriteRelativeImportExtension: __rewriteRelativeImportExtension,\r\n};\r\n","import { DEFAULT_ERROR_MESSAGES } from \"./constants\";\nimport { sf } from \"../../utils/strings\";\nimport { Reflection } from \"@decaf-ts/reflection\";\nimport { ValidatorOptions } from \"../types\";\n\n/**\n * @summary Base Implementation for Validators\n * @description Provides the underlying functionality for {@link Validator}s\n *\n * @param {string} validationKey the key to register the validator under\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#DEFAULT}\n * @param {string[]} [acceptedTypes] defines the value types this validator can validate\n *\n * @class Validator\n * @abstract\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   * @summary builds the error message\n   * @param {string} message\n   * @param {any[]} args\n   * @protected\n   */\n  protected getMessage(message: string, ...args: any[]) {\n    return sf(message, ...args);\n  }\n\n  /**\n   * @summary Validates type\n   * @param {any} unbound\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   * @summary Validates an attribute\n   * @param {any} value - The value to be validated.\n   * @param {ValidatorOptions} [options] Validate options for customizing the model validation behavior\n   * @param {any} [instanceObj] - The object instance that contains the key-value being validated. Used for cross-field validation. Defaults to an empty object.\n   *\n   * @returns An error message string if validation fails; otherwise, `undefined`.\n   *\n   * @abstract\n   *\n   * @see Model#hasErrors\n   */\n  public abstract hasErrors(\n    value: any,\n    options?: V,\n    instanceObj?: any\n  ): 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 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 * @summary Date Validator\n *\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#DATE}\n *\n * @class DateValidator\n * @extends Validator\n *\n * @category Validators\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   * @summary Validates a model\n   *\n   * @param {Date | string} value\n   * @param {DateValidatorOptions} [options]\n   *\n   * @return {string | undefined}\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 { VALIDATION_PARENT_KEY } from \"../../constants\";\nimport { sf } from \"../../utils/strings\";\nimport { COMPARISON_ERROR_MESSAGES } from \"./constants\";\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 */\nexport 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 */\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 */\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 */\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 { DiffValidatorOptions } from \"../types\";\nimport { isEqual } from \"@decaf-ts/reflection\";\nimport { getValueByPath } 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 {ComparisonValidatorOptions} options\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: DiffValidatorOptions,\n    instance: any\n  ): string | undefined {\n    let comparisonPropertyValue: any;\n    try {\n      comparisonPropertyValue = getValueByPath(\n        instance,\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\nexport const regexpParser: RegExp = new RegExp(\"^/(.+)/([gimus]*)$\");\n\n/**\n * @summary Pattern Validator\n *\n * @param {string} [key] defaults to {@link ValidationKeys#PATTERN}\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#PATTERN}\n *\n * @class PatternValidator\n * @extends Validator\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   * @summary parses and validates a pattern\n   *\n   * @param {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   * @summary Validates a Model\n   *\n   * @param {string} value\n   * @param {PatternValidatorOptions} options\n   *\n   * @return {string | undefined}\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 * @summary Email Validator\n *\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#EMAIL}\n *\n * @class EmailValidator\n * @extends PatternValidator\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   * @summary Validates a model\n   *\n   * @param {string} value\n   * @param {PatternValidatorOptions} [options]\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   *\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: string,\n    options: PatternValidatorOptions = {}\n  ): string | undefined {\n    return super.hasErrors(value, {\n      ...options,\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 { getValueByPath } 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 {ComparisonValidatorOptions} options\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: EqualsValidatorOptions,\n    instance: any\n  ): string | undefined {\n    let comparisonPropertyValue: any;\n    try {\n      comparisonPropertyValue = getValueByPath(\n        instance,\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 { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { GreaterThanValidatorOptions } from \"../types\";\nimport { getValueByPath, isGreaterThan } from \"./utils\";\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 {ComparisonValidatorOptions} options\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: GreaterThanValidatorOptions,\n    instance: any\n  ): string | undefined {\n    let comparisonPropertyValue: any;\n    try {\n      comparisonPropertyValue = getValueByPath(\n        instance,\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 {\n  getValueByPath,\n  isGreaterThan,\n  isValidForGteOrLteComparison,\n} from \"./utils\";\nimport { isEqual } from \"@decaf-ts/reflection\";\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 {ComparisonValidatorOptions} options\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: GreaterThanOrEqualValidatorOptions,\n    instance: any\n  ): string | undefined {\n    let comparisonPropertyValue: any;\n    try {\n      comparisonPropertyValue = getValueByPath(\n        instance,\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 { getValueByPath, isLessThan } from \"./utils\";\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 {ComparisonValidatorOptions} options\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: LessThanValidatorOptions,\n    instance: any\n  ): string | undefined {\n    let comparisonPropertyValue: any;\n    try {\n      comparisonPropertyValue = getValueByPath(\n        instance,\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 {\n  getValueByPath,\n  isLessThan,\n  isValidForGteOrLteComparison,\n} from \"./utils\";\nimport { isEqual } from \"@decaf-ts/reflection\";\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 {ComparisonValidatorOptions} options\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: LessThanOrEqualValidatorOptions,\n    instance: any\n  ): string | undefined {\n    let comparisonPropertyValue: any;\n    try {\n      comparisonPropertyValue = getValueByPath(\n        instance,\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 * @summary List Validator\n *\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LIST}\n *\n * @class ListValidator\n * @extends Validator\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   * @summary Validates a model\n   *\n   * @param {any[] | Set<any>} value\n   * @param {ListValidatorOptions} options\n   *\n   * @return {string | undefined}\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 * @summary Max Validator\n *\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#MAX}\n *\n * @class MaxValidator\n * @extends Validator\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   * @summary Validates a Model\n   *\n   * @param {string} value\n   * @param {MaxValidatorOptions} options\n   *\n   * @return {string | undefined}\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 * @summary Min Validator\n *\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#MIN}\n *\n * @class MinValidator\n * @extends Validator\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   * @summary Validates Model\n   *\n   * @param {string} value\n   * @param {MaxValidatorOptions} options\n   *\n   * @return {string | undefined}\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 { DEFAULT_ERROR_MESSAGES, ValidationKeys } 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 hasErrors(\n    value: string,\n    options: PatternValidatorOptions = {}\n  ): string | undefined {\n    return super.hasErrors(value, {\n      ...options,\n      message: options.message || this.message,\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 * @summary Required Validator\n *\n * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#REQUIRED}\n *\n * @class RequiredValidator\n * @extends Validator\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   * @summary Validates a model\n   *\n   * @param {string} value\n   * @param {ValidatorOptions} [options={}]\n   *\n   * @return {string | undefined}\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 * @summary Required Validator\n *\n * @class RequiredValidator\n * @extends Validator\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   * @summary Validates a model\n   * @param {string} value\n   * @param {TypeValidatorOptions} options\n   *\n   * @return {string | undefined}\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\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 * @summary URL Validator\n * @description Pattern from {@link https://gist.github.com/dperini/729294}\n *\n * @class URLValidator\n * @extends PatternValidator\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   * @summary Validates a model\n   *\n   * @param {string} value\n   * @param {PatternValidatorOptions} [options={}]\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   *\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: string,\n    options: PatternValidatorOptions = {}\n  ): string | undefined {\n    return super.hasErrors(value, {\n      ...options,\n      pattern: options.pattern || DEFAULT_PATTERNS.URL,\n    });\n  }\n}\n","import \"reflect-metadata\";\nimport {\n  DiffValidatorOptions,\n  EqualsValidatorOptions,\n  GreaterThanOrEqualValidatorOptions,\n  GreaterThanValidatorOptions,\n  LessThanOrEqualValidatorOptions,\n  LessThanValidatorOptions,\n  ValidationMetadata,\n} from \"./types\";\nimport {\n  DEFAULT_ERROR_MESSAGES,\n  DEFAULT_PATTERNS,\n  ValidationKeys,\n} from \"./Validators/constants\";\nimport { sf } from \"../utils/strings\";\nimport { ModelConstructor } from \"../model/types\";\nimport { parseDate } from \"../utils/dates\";\nimport { propMetadata } from \"../utils/decorators\";\nimport { Validation } from \"./Validation\";\n\n/**\n * @summary Marks the property as required.\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#REQUIRED}\n *\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#REQUIRED}\n *\n * @function required\n *\n * @category Decorators\n */\nexport function required(message: string = DEFAULT_ERROR_MESSAGES.REQUIRED) {\n  return propMetadata<ValidationMetadata>(\n    Validation.key(ValidationKeys.REQUIRED),\n    {\n      message: message,\n    }\n  );\n}\n\n/**\n * @summary Defines a minimum value for the property\n * @description Validators to validate a decorated property must use key {@link ValidationKeys#MIN}\n *\n * @param {number | Date} value\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#MIN}\n *\n * @function min\n * @memberOf module:decorator-validation.Decorators.Validation\n * @category Decorators\n */\nexport function min(\n  value: number | Date | string,\n  message: string = DEFAULT_ERROR_MESSAGES.MIN\n) {\n  return propMetadata<ValidationMetadata>(Validation.key(ValidationKeys.MIN), {\n    [ValidationKeys.MIN]: value,\n    message: message,\n    types: [Number.name, Date.name],\n  });\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 * @memberOf module:decorator-validation.Decorators.Validation\n * @category Decorators\n */\nexport function max(\n  value: number | Date | string,\n  message: string = DEFAULT_ERROR_MESSAGES.MAX\n) {\n  return propMetadata<ValidationMetadata>(Validation.key(ValidationKeys.MAX), {\n    [ValidationKeys.MAX]: value,\n    message: message,\n    types: [Number.name, Date.name],\n  });\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 * @memberOf module:decorator-validation.Decorators.Validation\n * @category Decorators\n */\nexport function step(\n  value: number,\n  message: string = DEFAULT_ERROR_MESSAGES.STEP\n) {\n  return propMetadata<ValidationMetadata>(Validation.key(ValidationKeys.STEP), {\n    [ValidationKeys.STEP]: value,\n    message: message,\n    types: [Number.name],\n  });\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 * @memberOf module:decorator-validation.Decorators.Validation\n * @category Decorators\n */\nexport function minlength(\n  value: number,\n  message: string = DEFAULT_ERROR_MESSAGES.MIN_LENGTH\n) {\n  return propMetadata<ValidationMetadata>(\n    Validation.key(ValidationKeys.MIN_LENGTH),\n    {\n      [ValidationKeys.MIN_LENGTH]: value,\n      message: message,\n      types: [String.name, Array.name, Set.name],\n    }\n  );\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 * @memberOf module:decorator-validation.Decorators.Validation\n * @category Decorators\n */\nexport function maxlength(\n  value: number,\n  message: string = DEFAULT_ERROR_MESSAGES.MAX_LENGTH\n) {\n  return propMetadata<ValidationMetadata>(\n    Validation.key(ValidationKeys.MAX_LENGTH),\n    {\n      [ValidationKeys.MAX_LENGTH]: value,\n      message: message,\n      types: [String.name, Array.name, Set.name],\n    }\n  );\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 * @memberOf module:decorator-validation.Decorators.Validation\n * @category Decorators\n */\nexport function pattern(\n  value: RegExp | string,\n  message: string = DEFAULT_ERROR_MESSAGES.PATTERN\n) {\n  return propMetadata<ValidationMetadata>(\n    Validation.key(ValidationKeys.PATTERN),\n    {\n      [ValidationKeys.PATTERN]:\n        typeof value === \"string\" ? value : value.toString(),\n      message: message,\n      types: [String.name],\n    }\n  );\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 * @memberOf module:decorator-validation.Decorators.Validation\n * @category Decorators\n */\nexport function email(message: string = DEFAULT_ERROR_MESSAGES.EMAIL) {\n  return propMetadata<ValidationMetadata>(\n    Validation.key(ValidationKeys.EMAIL),\n    {\n      [ValidationKeys.PATTERN]: DEFAULT_PATTERNS.EMAIL,\n      message: message,\n      types: [String.name],\n    }\n  );\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 * @memberOf module:decorator-validation.Decorators.Validation\n * @category Decorators\n */\nexport function url(message: string = DEFAULT_ERROR_MESSAGES.URL) {\n  return propMetadata<ValidationMetadata>(Validation.key(ValidationKeys.URL), {\n    [ValidationKeys.PATTERN]: DEFAULT_PATTERNS.URL,\n    message: message,\n    types: [String.name],\n  });\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 * @memberOf module:decorator-validation.Decorators.Validation\n * @category Decorators\n */\nexport function type(\n  types: string[] | string,\n  message: string = DEFAULT_ERROR_MESSAGES.TYPE\n) {\n  return propMetadata<ValidationMetadata>(Validation.key(ValidationKeys.TYPE), {\n    customTypes: types,\n    message: message,\n  });\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 * @param {Constructor<Validator>} [validator] the Validator to be used. Defaults to {@link DateValidator}\n *\n * @function date\n *\n * @memberOf module:decorator-validation.Decorators.Validation\n * @category Decorators\n */\nexport function date(\n  format: string = \"dd/MM/yyyy\",\n  message: string = DEFAULT_ERROR_MESSAGES.DATE\n) {\n  return (target: Record<string, any>, propertyKey?: any): any => {\n    propMetadata(Validation.key(ValidationKeys.DATE), {\n      [ValidationKeys.FORMAT]: format,\n      message: message,\n      types: [Date.name],\n    })(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}\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 PasswordPatterns#CHAR8_ONE_OF_EACH}\n * @param {string} [message] the error message. Defaults to {@link DEFAULT_ERROR_MESSAGES#PASSWORD}\n * @param {Constructor<Validator>} [validator] Defaults to {@link PasswordValidator}\n *\n * @function password\n *\n * @memberOf module:decorator-validation.Decorators.Validation\n * @category Decorators\n */\nexport function password(\n  pattern: RegExp = DEFAULT_PATTERNS.PASSWORD.CHAR8_ONE_OF_EACH,\n  message: string = DEFAULT_ERROR_MESSAGES.PASSWORD\n) {\n  return propMetadata(Validation.key(ValidationKeys.PASSWORD), {\n    [ValidationKeys.PATTERN]: pattern,\n    message: message,\n    types: [String.name],\n  });\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 * @param {Constructor<Validator>} [validator] defaults to {@link ListValidator}\n *\n * @function list\n *\n * @memberOf module:decorator-validation.Decorators.Validation\n * @category Decorators\n */\nexport function list(\n  clazz: ModelConstructor<any> | ModelConstructor<any>[],\n  collection: \"Array\" | \"Set\" = \"Array\",\n  message: string = DEFAULT_ERROR_MESSAGES.LIST\n) {\n  return propMetadata(Validation.key(ValidationKeys.LIST), {\n    clazz: Array.isArray(clazz) ? clazz.map((c) => c.name) : [clazz.name],\n    type: collection,\n    message: message,\n  });\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 * @param {Constructor<Validator>} [validator]\n *\n * @function set\n *\n * @memberOf module:decorator-validation.Decorators.Validation\n * @category 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 * @memberOf module:decorator-validation.Decorators.Validation\n * @category 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  };\n\n  return propMetadata<ValidationMetadata>(\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 * @memberOf module:decorator-validation.Decorators.Validation\n * @category 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  };\n\n  return propMetadata<ValidationMetadata>(\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 * @memberOf module:decorator-validation.Decorators.Validation\n * @category 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  };\n\n  return propMetadata<ValidationMetadata>(\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 * @memberOf module:decorator-validation.Decorators.Validation\n * @category 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  };\n\n  return propMetadata<ValidationMetadata>(\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 * @memberOf module:decorator-validation.Decorators.Validation\n * @category 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  };\n\n  return propMetadata<ValidationMetadata>(\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 * @memberOf module:decorator-validation.Decorators.Validation\n * @category 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  };\n\n  return propMetadata<ValidationMetadata>(\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 * @param {Function} constructor\n * @param {any[]} [args]\n * @return {T} the new instance\n *\n * @function construct\n * @memberOf module:decorator-validation.Construction\n */\nexport function construct<T extends Model>(\n  constructor: any,\n  ...args: any[]\n): T {\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.Construction\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.Construction\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.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 * @memberOf module:decorator-validation.Model\n *\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    // 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\nexport function hashedBy(algorithm: string, ...args: any[]) {\n  return metadata(Model.key(ModelKeys.HASHING), {\n    algorithm: algorithm,\n    args: args,\n  });\n}\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 * @module decorator-validation\n */\n\n/**\n * @summary Model definition functionality\n * @description defines the base class and related functionality\n *\n * @namespace Model\n * @memberOf module:decorator-validation\n */\n\n/**\n * @summary Holds all the supported decorators\n * @namespace Decorators\n * @memberOf module:decorator-validation\n */\n\n/**\n * @summary Validation related functionality\n * @description Defines the Model validation apis and base classes for validators\n *\n * @namespace Validation\n * @memberOf module:decorator-validation\n */\n\n/**\n * @namespace Dates\n * @memberOf module:decorator-validation\n */\n\n/**\n * @namespace Hashing\n * @memberOf module:decorator-validation\n */\n\n/**\n * @namespace Serialization\n * @memberOf module:decorator-validation\n */\n\n/**\n * @namespace Format\n * @memberOf module:decorator-validation\n */\n\nexport * from \"./constants\";\nexport * from \"./utils\";\nexport * from \"./validation\";\nexport * from \"./model\";\n\nexport const VERSION = \"##VERSION##\";\n"],"names":["ModelKeys","apply","metadata","Primitives","ReservedModels","Reflection","isEqual","DateValidator","DiffValidator","PatternValidator","EmailValidator","EqualsValidator","GreaterThanValidator","GreaterThanOrEqualValidator","LessThanValidator","LessThanOrEqualValidator","ListValidator","MaxLengthValidator","MaxValidator","MinLengthValidator","MinValidator","PasswordValidator","RequiredValidator","StepValidator","TypeValidator","URLValidator"],"mappings":";;;;;;IAAA;;;;;;;;IAQG;UACU,qBAAqB,GAAG,MAAM,CAAC,sBAAsB;;ICTlE;;;;;;;;;;;;;IAaG;AACSA;IAAZ,CAAA,UAAY,SAAS,EAAA;IACnB,IAAA,SAAA,CAAA,SAAA,CAAA,GAAA,cAAwB;IACxB,IAAA,SAAA,CAAA,MAAA,CAAA,GAAA,aAAoB;IACpB,IAAA,SAAA,CAAA,QAAA,CAAA,GAAA,mBAA4B;IAC5B,IAAA,SAAA,CAAA,QAAA,CAAA,GAAA,mBAA4B;IAC5B,IAAA,SAAA,CAAA,OAAA,CAAA,GAAA,OAAe;IACf,IAAA,SAAA,CAAA,QAAA,CAAA,GAAA,SAAkB;IAClB,IAAA,SAAA,CAAA,cAAA,CAAA,GAAA,gBAA+B;IAC/B,IAAA,SAAA,CAAA,WAAA,CAAA,GAAA,cAA0B;IAC1B,IAAA,SAAA,CAAA,SAAA,CAAA,GAAA,SAAmB;IACnB,IAAA,SAAA,CAAA,eAAA,CAAA,GAAA,eAA+B;IACjC,CAAC,EAXWA,iBAAS,KAATA,iBAAS,GAWpB,EAAA,CAAA,CAAA;;ICvBD;;;;;;;;;;;;;IAaG;AACU,UAAA,wBAAwB,GAAG;IACtC,IAAA,MAAM,EAAE,QAAQ;IAChB,IAAA,IAAI,EAAE,WAAW;IACjB,IAAA,SAAS,EAAE,UAAU;IACrB,IAAA,kBAAkB,EAAE,iBAAiB;IACrC,IAAA,YAAY,EAAE,aAAa;IAC3B,IAAA,qBAAqB,EAAE,oBAAoB;;IAG7C;;;;;;;;;;;;;;;;;;;;;IAqBG;AACU,UAAA,cAAc,GAAG;IAC5B,IAAA,OAAO,EAAE,CAAA,EAAGA,iBAAS,CAAC,OAAO,CAAa,WAAA,CAAA;IAC1C,IAAA,SAAS,EAAE,WAAW;IACtB,IAAA,QAAQ,EAAE,UAAU;IACpB,IAAA,GAAG,EAAE,KAAK;IACV,IAAA,GAAG,EAAE,KAAK;IACV,IAAA,IAAI,EAAE,MAAM;IACZ,IAAA,UAAU,EAAE,WAAW;IACvB,IAAA,UAAU,EAAE,WAAW;IACvB,IAAA,OAAO,EAAE,SAAS;IAClB,IAAA,KAAK,EAAE,OAAO;IACd,IAAA,GAAG,EAAE,KAAK;IACV,IAAA,IAAI,EAAE,MAAM;IACZ,IAAA,IAAI,EAAE,MAAM;IACZ,IAAA,QAAQ,EAAE,UAAU;IACpB,IAAA,IAAI,EAAE,MAAM;IACZ,IAAA,MAAM,EAAE,QAAQ;IAChB,IAAA,GAAG,wBAAwB;;IAG7B;;;;;;;IAOG;AACU,UAAA,WAAW,GAAG;QACzB,SAAS;QACT,UAAU;QACV,OAAO;QACP,OAAO;QACP,KAAK;QACL,MAAM;QACN,MAAM;QACN,QAAQ;QACR,WAAW;QACX,SAAS;QACT,UAAU;QACV,UAAU;;IAGZ;;;;;;;IAOG;AACU,UAAA,kBAAkB,GAAG;QAChC,QAAQ;QACR,QAAQ;QACR,SAAS;QACT,WAAW;QACX,UAAU;QACV,QAAQ;QACR,UAAU;;IAGZ;;;;;;;;;;;;;;;;;;;;;;;IAuBG;AACU,UAAA,sBAAsB,GAA2B;IAC5D,IAAA,QAAQ,EAAE,wBAAwB;IAClC,IAAA,GAAG,EAAE,0BAA0B;IAC/B,IAAA,GAAG,EAAE,0BAA0B;IAC/B,IAAA,UAAU,EAAE,2BAA2B;IACvC,IAAA,UAAU,EAAE,2BAA2B;IACvC,IAAA,OAAO,EAAE,sCAAsC;IAC/C,IAAA,KAAK,EAAE,gCAAgC;IACvC,IAAA,GAAG,EAAE,8BAA8B;IACnC,IAAA,IAAI,EAAE,0CAA0C;IAChD,IAAA,IAAI,EAAE,kCAAkC;IACxC,IAAA,IAAI,EAAE,iCAAiC;IACvC,IAAA,OAAO,EAAE,mBAAmB;IAC5B,IAAA,QAAQ,EACN,4HAA4H;IAC9H,IAAA,IAAI,EAAE,qBAAqB;IAC3B,IAAA,eAAe,EAAE,+BAA+B;IAChD,IAAA,MAAM,EAAE,uCAAuC;IAC/C,IAAA,IAAI,EAAE,6CAA6C;IACnD,IAAA,SAAS,EAAE,wCAAwC;IACnD,IAAA,kBAAkB,EAAE,oDAAoD;IACxE,IAAA,YAAY,EAAE,2CAA2C;IACzD,IAAA,qBAAqB,EACnB,uDAAuD;;AAG9C,UAAA,yBAAyB,GAAG;IACvC,IAAA,YAAY,EACV,sEAAsE;IACxE,IAAA,6BAA6B,EAC3B,uFAAuF;IACzF,IAAA,oBAAoB,EAClB,0EAA0E;IAC5E,IAAA,kBAAkB,EAChB,4DAA4D;IAC9D,IAAA,4BAA4B,EAC1B,sEAAsE;IACxE,IAAA,+BAA+B,EAC7B,sFAAsF;IACxF,IAAA,4BAA4B,EAC1B,mDAAmD;IACrD,IAAA,4BAA4B,EAC1B,kDAAkD;IACpD,IAAA,uBAAuB,EAAE,yCAAyC;IAClE,IAAA,wBAAwB,EACtB,wDAAwD;IAC1D,IAAA,cAAc,EAAE,yCAAyC;;IAG3D;;;;;;IAMG;AACU,UAAA,gBAAgB,GAAG;IAC9B,IAAA,KAAK,EACH,4JAA4J;IAC9J,IAAA,GAAG,EAAE,yaAAya;IAC9a,IAAA,QAAQ,EAAE;IACR,QAAA,iBAAiB,EACf,iFAAiF;IACpF,KAAA;;;ICnMH;;;;;;;;;;IAUG;aACa,YAAY,CAAC,MAAc,EAAE,GAAG,IAAyB,EAAA;QACvE,OAAO,MAAM,CAAC,OAAO,CAAC,UAAU,EAAE,UAAU,KAAK,EAAE,MAAM,EAAA;IACvD,QAAA,OAAO,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK;IAC7B,cAAE,IAAI,CAAC,MAAM,CAAC,CAAC,QAAQ;kBACrB,WAAW;IACjB,KAAC,CAAC;IACJ;IAEA;;;;;;;;;;;IAWG;AACI,UAAM,EAAE,GAAG;;ICxBlB;;;;;;;;;;IAUG;IACa,SAAA,cAAc,CAAC,IAAY,EAAE,MAAc,EAAA;QACzD,IAAI,YAAY,GAAW,MAAM;;IAGjC,IAAA,IAAI,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC;YAC1B,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACzD,SAAA,IAAI,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC;YAC9B,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,GAAG,EAAE,mBAAmB,CAAC;IAC1D,SAAA,IAAI,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC;YAC/B,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACzD,SAAA,IAAI,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC;YAC9B,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,GAAG,EAAE,mBAAmB,CAAC;;IAG/D,IAAA,IAAI,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC;YAC1B,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,IAAI,EAAE,oBAAoB,CAAC;IAC5D,SAAA,IAAI,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC;YAC9B,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,GAAG,EAAE,sBAAsB,CAAC;;IAGlE,IAAA,IAAI,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC;YAC1B,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,IAAI,EAAE,oBAAoB,CAAC;IAC5D,SAAA,IAAI,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC;YAC9B,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,GAAG,EAAE,sBAAsB,CAAC;;IAGlE,IAAA,IAAI,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC;YAC1B,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,IAAI,EAAE,gBAAgB,CAAC;IACxD,SAAA,IAAI,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC;YAC9B,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,GAAG,EAAE,kBAAkB,CAAC;;IAG9D,IAAA,IAAI,YAAY,CAAC,KAAK,CAAC,MAAM,CAAC;YAC5B,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,MAAM,EAAE,oBAAoB,CAAC;;IAE9D,SAAA,IAAI,YAAY,CAAC,KAAK,CAAC,MAAM,CAAC;YACjC,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,KAAK,EAAE,oBAAoB,CAAC;;IAGlE,IAAA,IAAI,YAAY,CAAC,KAAK,CAAC,MAAM,CAAC;YAC5B,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,MAAM,EAAE,iBAAiB,CAAC;IAC3D,SAAA,IAAI,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC;YAC/B,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,IAAI,EAAE,iBAAiB,CAAC;;IAG9D,IAAA,IAAI,YAAY,CAAC,KAAK,CAAC,MAAM,CAAC;YAC5B,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,MAAM,EAAE,oBAAoB,CAAC;IAC9D,SAAA,IAAI,YAAY,CAAC,KAAK,CAAC,KAAK,CAAC;YAChC,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,KAAK,EAAE,yBAAyB,CAAC;IACvE,IAAA,IAAI,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC;YAC1B,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAC1D,SAAA,IAAI,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC;YAC9B,YAAY,GAAG,YAAY,CAAC,OAAO,CAAC,GAAG,EAAE,oBAAoB,CAAC;;IAGhE,IAAA,YAAY,GAAG;IACZ,SAAA,OAAO,CAAC,GAAG,EAAE,oBAAoB;IACjC,SAAA,OAAO,CAAC,KAAK,EAAE,iBAAiB,CAAC;QAEpC,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,YAAY,EAAE,GAAG,CAAC;QAE5C,MAAM,KAAK,GAaP,MAAM,CAAC,IAAI,CAAC,IAAI,CAAQ;IAE5B,IAAA,IAAI,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,MAAM;IAAE,QAAA,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC;QAElD,MAAM,YAAY,GAAG,UAAU,CAAU,EAAA;IACvC,QAAA,IAAI,CAAC,CAAC;IAAE,YAAA,OAAO,CAAC;IAChB,QAAA,MAAM,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC;IAE1B,QAAA,OAAO,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,MAAM;IACnC,KAAC;QAED,MAAM,IAAI,GAAG,YAAY,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC;QAC5C,MAAM,GAAG,GAAG,YAAY,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC;IAE1C,IAAA,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,IAAI;QAC9B,IAAI,IAAI,GAAG,YAAY,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC;IAE1C,IAAA,IAAI,IAAI;IAAE,QAAA,IAAI,GAAG,IAAI,KAAK,IAAI,GAAG,IAAI,GAAG,EAAE,GAAG,IAAI;QAEjD,MAAM,OAAO,GAAG,YAAY,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC;QAClD,MAAM,OAAO,GAAG,YAAY,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC;QAClD,MAAM,EAAE,GAAG,YAAY,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC;IAE3C,IAAA,MAAM,SAAS,GAAG,KAAK,CAAC,MAAM,CAAC,SAAS;IACxC,IAAA,MAAM,cAAc,GAAG,KAAK,CAAC,MAAM,CAAC,cAAc;IAClD,IAAA,IAAI,KAAK,GAAoB,KAAK,CAAC,MAAM,CAAC,KAAe;IACzD,IAAA,IAAI,SAAS;IAAE,QAAA,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,SAAS,CAAC;aAChD,IAAI,cAAc,EAAE;YACvB,MAAM,CAAC,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,KAC3B,CAAC,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,cAAc,CAAC,WAAW,EAAE,CAAC,CACzD;IACD,QAAA,IAAI,CAAC,CAAC;IAAE,YAAA,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC;IAC7B,QAAA,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC;;;IACzB,QAAA,KAAK,GAAG,YAAY,CAAC,GAAG,KAAK,CAAA,CAAE,CAAC;IAEvC,IAAA,OAAO,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,GAAG,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,CAAC;IACnE;IAEA;;;;;;IAMG;IACa,SAAA,gBAAgB,CAAC,IAAsB,EAAE,MAAc,EAAA;IACrE,IAAA,IAAI,CAAC,IAAI;YAAE;QACX,MAAM,IAAI,GAAG,MAAM,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC;IAC3C,IAAA,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,aAAa,EAAE;IACzC,QAAA,UAAU,EAAE,KAAK;IACjB,QAAA,YAAY,EAAE,KAAK;IACnB,QAAA,KAAK,EAAE,IAAI;IACZ,KAAA,CAAC;IACF,IAAA,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE;IACtC,QAAA,UAAU,EAAE,KAAK;IACjB,QAAA,YAAY,EAAE,KAAK;IACnB,QAAA,KAAK,EAAE,IAAI;IACZ,KAAA,CAAC;;IAEF,IAAA,OAAO,IAAI;IACb;IAEA;;;;;IAKG;IACG,SAAU,WAAW,CAAC,IAAS,EAAA;IACnC,IAAA,QACE,IAAI;YACJ,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,eAAe;IACxD,QAAA,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC;IAEvB;IAEA;;;;;;;;;IASG;IACG,SAAU,WAAW,CAAC,GAAW,EAAA;IACrC,IAAA,OAAO,GAAG,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,QAAQ,EAAE;IAC9C;IAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;IA2BG;aACa,UAAU,CAAC,IAAU,EAAE,aAAqB,YAAY,EAAA;IACtE,IAAA,MAAM,GAAG,GAAW,IAAI,CAAC,OAAO,EAAE,EAChC,KAAK,GAAW,IAAI,CAAC,QAAQ,EAAE,EAC/B,IAAI,GAAW,IAAI,CAAC,WAAW,EAAE,EACjC,IAAI,GAAW,IAAI,CAAC,QAAQ,EAAE,EAC9B,MAAM,GAAW,IAAI,CAAC,UAAU,EAAE,EAClC,MAAM,GAAW,IAAI,CAAC,UAAU,EAAE,EAClC,WAAW,GAAW,IAAI,CAAC,eAAe,EAAE,EAC5C,CAAC,GAAW,IAAI,GAAG,EAAE,EACrB,EAAE,GAAW,WAAW,CAAC,CAAC,CAAC,EAC3B,EAAE,GAAW,WAAW,CAAC,IAAI,CAAC,EAC9B,EAAE,GAAW,WAAW,CAAC,MAAM,CAAC,EAChC,EAAE,GAAW,WAAW,CAAC,MAAM,CAAC,EAChC,GAAG,GAAW,IAAI,GAAG,EAAE,GAAG,IAAI,GAAG,IAAI,EACrC,IAAI,GAAW,kBAAkB,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,EAChD,GAAG,GAAW,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EAC/B,EAAE,GAAW,WAAW,CAAC,GAAG,CAAC,EAC7B,CAAC,GAAW,KAAK,GAAG,CAAC,EACrB,EAAE,GAAW,WAAW,CAAC,CAAC,CAAC,EAC3B,IAAI,GAAW,WAAW,CAAC,KAAK,CAAC,EACjC,GAAG,GAAW,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EAC/B,IAAI,GAAW,IAAI,GAAG,EAAE,EACxB,EAAE,GAAW,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC;;IAEhC,IAAA,UAAU,GAAG;IACV,SAAA,OAAO,CAAC,IAAI,EAAE,EAAE;IAChB,SAAA,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC,QAAQ,EAAE;IACzB,SAAA,OAAO,CAAC,IAAI,EAAE,EAAE;IAChB,SAAA,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,QAAQ,EAAE;IAC5B,SAAA,OAAO,CAAC,IAAI,EAAE,EAAE;IAChB,SAAA,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,QAAQ,EAAE;IAC9B,SAAA,OAAO,CAAC,IAAI,EAAE,EAAE;IAChB,SAAA,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,QAAQ,EAAE;IAC9B,SAAA,OAAO,CAAC,GAAG,EAAE,WAAW,CAAC,QAAQ,EAAE;IACnC,SAAA,OAAO,CAAC,IAAI,EAAE,EAAE;IAChB,SAAA,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,QAAQ,EAAE;IAE3B,SAAA,OAAO,CAAC,MAAM,EAAE,IAAI;IACpB,SAAA,OAAO,CAAC,KAAK,EAAE,GAAG;IAClB,SAAA,OAAO,CAAC,MAAM,EAAE,IAAI;IACpB,SAAA,OAAO,CAAC,IAAI,EAAE,EAAE;IAChB,SAAA,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;QACtB,IAAI,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,EAAE,EAAE;IAClC,QAAA,UAAU,GAAG,UAAU,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;;aAC5D;IACL,QAAA,UAAU,GAAG,UAAU,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC;;IAEtE,IAAA,OAAO,UAAU;IACnB;IAEA;;;;;;IAMG;IACa,SAAA,SAAS,CAAC,MAAc,EAAE,CAA0B,EAAA;QAClE,IAAI,KAAK,GAAqB,SAAS;IAEvC,IAAA,IAAI,CAAC,CAAC;IAAE,QAAA,OAAO,SAAS;QAExB,IAAI,CAAC,YAAY,IAAI;IACnB,QAAA,IAAI;IACF,YAAA,KAAK,GAAG,cAAc,CAAC,UAAU,CAAC,CAAS,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC;;;YAE7D,OAAO,CAAM,EAAE;IACf,YAAA,MAAM,IAAI,KAAK,CACb,EAAE,CAAC,2CAA2C,EAAE,CAAC,CAAC,QAAQ,EAAE,EAAE,MAAM,CAAC,CACtE;;IAEA,SAAA,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE;IAC9B,QAAA,KAAK,GAAG,cAAc,CAAC,CAAC,EAAE,MAAM,CAAC;;IAC5B,SAAA,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE;IAChC,QAAA,MAAM,CAAC,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC;IACrB,QAAA,KAAK,GAAG,cAAc,CAAC,UAAU,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC;;IAChD,SAAA,IAAI,WAAW,CAAC,CAAC,CAAC,EAAE;IACzB,QAAA,IAAI;IACF,YAAA,MAAM,CAAC,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC;IACrB,YAAA,KAAK,GAAG,cAAc,CAAC,UAAU,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC;;;YAErD,OAAO,CAAC,EAAE;IACV,YAAA,MAAM,IAAI,KAAK,CACb,EAAE,CAAC,2CAA2C,EAAE,CAAC,EAAE,MAAM,CAAC,CAC3D;;;aAEE;IACL,QAAA,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAA,CAAE,CAAC;;IAEhD,IAAA,OAAO,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC;IACxC;;aCzSgB,IAAI,CAAC,GAAc,GAAAA,iBAAS,CAAC,SAAS,EAAA;IACpD,IAAA,OAAO,CAAC,KAAa,EAAE,WAAiB,KAAU;IAChD,QAAA,IAAI,KAAe;IACnB,QAAA,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE;IACpD,YAAA,KAAK,GAAI,KAAa,CAAC,GAAG,CAAC;;iBACtB;IACL,YAAA,KAAK,GAAI,KAAa,CAAC,GAAG,CAAC,GAAG,EAAE;;IAElC,QAAA,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,WAAqB,CAAC;IACxC,YAAA,KAAK,CAAC,IAAI,CAAC,WAAqB,CAAC;IACrC,KAAC;IACH;IAEgB,SAAA,YAAY,CAAI,GAAW,EAAE,KAAQ,EAAA;IACnD,IAAA,OAAOC,gBAAK,CAAC,IAAI,EAAE,EAAEC,mBAAQ,CAAI,GAAG,EAAE,KAAK,CAAC,CAAC;IAC/C;;IClBA;;;;;;;;;IASG;IACG,SAAU,QAAQ,CAAC,GAAoC,EAAA;IAC3D,IAAA,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC;QACjB,IAAI,IAAI,GAAG,CAAC;IACZ,IAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACnC,MAAM,SAAS,GAAG,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC;YACnC,IAAI,GAAG,CAAC,IAAI,IAAI,CAAC,IAAI,IAAI,GAAG,SAAS;IACrC,QAAA,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;;IAErB,IAAA,OAAO,IAAI,CAAC,QAAQ,EAAE;IACxB;IASA;;;;;;;;;IASG;IACG,SAAU,OAAO,CAAC,GAAgC,EAAA;IACtD,IAAA,MAAM,WAAW,GAAG,UAAU,CAAkB,EAAE,EAAO,EAAA;IACvD,QAAA,MAAM,MAAM,GAAG,YAAY,CAAC,EAAE,CAAC;YAE/B,IAAI,OAAO,MAAM,KAAK,QAAQ;IAC5B,YAAA,OAAO,YAAY,CAAC,CAAE,CAAY,IAAI,EAAE,IAAI,YAAY,CAAC,EAAE,CAAC,CAAC;IAE/D,QAAA,CAAC,GAAG,CAAC,IAAI,CAAC;YACV,CAAC,GAAG,CAAE,CAAY,IAAI,CAAC,IAAK,CAAY,GAAG,MAAM;YACjD,OAAO,CAAC,GAAG,CAAC;IACd,KAAC;QAED,MAAM,IAAI,GAAoB,QAAQ;QAEtC,MAAM,YAAY,GAAG,UAAU,KAAU,EAAA;YACvC,IAAI,OAAO,KAAK,KAAK,WAAW;IAAE,YAAA,OAAO,EAAE;IAC3C,QAAA,IAAI,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,OAAO,CAAC,OAAO,KAAK,CAAC,KAAK,EAAE;IAC7D,YAAA,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;YAC/B,IAAI,KAAK,YAAY,IAAI;IAAE,YAAA,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;IACvD,QAAA,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;gBAAE,OAAO,KAAK,CAAC,MAAM,CAAC,WAAW,EAAE,SAAS,CAAC;IACrE,QAAA,OAAQ,MAAM,CAAC,MAAM,CAAC,KAAK,CAAyB,CAAC,MAAM,CACzD,WAAW,EACX,SAAuC,CACxC;IACH,KAAC;IAED,IAAA,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC;QAExD,OAAO,CAAC,OAAO,MAAM,KAAK,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,QAAQ,EAAE;IAC5E;AAEO,UAAM,oBAAoB,GAAG;UAEvB,OAAO,CAAA;iBACH,IAAO,CAAA,OAAA,GAAW,oBAAoB,CAAC;IAEvC,IAAA,SAAA,IAAA,CAAA,KAAK,GAAoC;IACtD,QAAA,OAAO,EAAE,OAAO;SACjB,CAAC;IAEF,IAAA,WAAA,GAAA;QAEQ,OAAO,GAAG,CAAC,GAAW,EAAA;IAC5B,QAAA,IAAI,GAAG,IAAI,IAAI,CAAC,KAAK;IAAE,YAAA,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC;IAC7C,QAAA,MAAM,IAAI,KAAK,CAAC,sCAAsC,GAAG,CAAA,CAAE,CAAC;;QAG9D,OAAO,QAAQ,CACb,GAAW,EACX,IAAqB,EACrB,UAAU,GAAG,KAAK,EAAA;IAElB,QAAA,IAAI,GAAG,IAAI,IAAI,CAAC,KAAK;IACnB,YAAA,MAAM,IAAI,KAAK,CAAC,kBAAkB,GAAG,CAAA,mBAAA,CAAqB,CAAC;IAC7D,QAAA,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI;IACtB,QAAA,IAAI,UAAU;IAAE,YAAA,IAAI,CAAC,OAAO,GAAG,GAAG;;QAGpC,OAAO,IAAI,CAAC,GAAQ,EAAE,MAAe,EAAE,GAAG,IAAW,EAAA;IACnD,QAAA,IAAI,CAAC,MAAM;IAAE,YAAA,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;IACxD,QAAA,OAAO,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;;QAGvC,OAAO,UAAU,CAAC,MAAc,EAAA;YAC9B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC;;;;ICpGnC;;;;;;;;;;IAUG;UACU,oBAAoB,CAAA;IAK/B,IAAA,WAAA,CAAY,MAAmB,EAAA;IAC7B,QAAA,KAAK,MAAM,IAAI,IAAI,MAAM,EAAE;IACzB,YAAA,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC;IACpE,gBAAA,MAAM,CAAC,cAAc,CAAC,IAAW,EAAE,IAAI,EAAE;IACvC,oBAAA,UAAU,EAAE,IAAI;IAChB,oBAAA,YAAY,EAAE,KAAK;IACnB,oBAAA,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC;IACnB,oBAAA,QAAQ,EAAE,KAAK;IAChB,iBAAA,CAAC;;;IAIR;;;;IAIG;QACH,QAAQ,GAAA;YACN,MAAM,IAAI,GAAQ,IAAW;IAC7B,QAAA,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI;IACpB,aAAA,MAAM,CACL,CAAC,CAAC,KACA,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;IAC7C,YAAA,OAAO,IAAI,CAAC,CAAC,CAAC,KAAK,UAAU;IAEhC,aAAA,MAAM,CAAC,CAAC,KAAa,EAAE,IAAI,KAAI;IAC9B,YAAA,IAAI,SAAS,GAAuB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAChE,CAAC,SAA6B,EAAE,GAAG,KAAI;IACrC,gBAAA,IAAI,CAAC,SAAS;wBAAE,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC;;wBACtC,SAAS,IAAI,CAAK,EAAA,EAAA,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAA,CAAE;IACxC,gBAAA,OAAO,SAAS;iBACjB,EACD,SAAS,CACV;gBAED,IAAI,SAAS,EAAE;IACb,gBAAA,SAAS,GAAG,CAAG,EAAA,IAAI,CAAM,GAAA,EAAA,SAAS,EAAE;IACpC,gBAAA,IAAI,CAAC,KAAK;wBAAE,KAAK,GAAG,SAAS;;IACxB,oBAAA,KAAK,IAAI,CAAA,EAAA,EAAK,SAAS,CAAA,CAAE;;IAGhC,YAAA,OAAO,KAAK;aACb,EAAE,EAAE,CAAC;;IAEX;;IC9DD;;;;;;;;;;IAUG;AACSC;IAAZ,CAAA,UAAY,UAAU,EAAA;IACpB,IAAA,UAAA,CAAA,QAAA,CAAA,GAAA,QAAiB;IACjB,IAAA,UAAA,CAAA,QAAA,CAAA,GAAA,QAAiB;IACjB,IAAA,UAAA,CAAA,SAAA,CAAA,GAAA,SAAmB;IACnB,IAAA,UAAA,CAAA,QAAA,CAAA,GAAA,QAAiB;IACnB,CAAC,EALWA,kBAAU,KAAVA,kBAAU,GAKrB,EAAA,CAAA,CAAA;IAED;;;;;;;;;;;;IAYG;AACSC;IAAZ,CAAA,UAAY,cAAc,EAAA;IACxB,IAAA,cAAA,CAAA,QAAA,CAAA,GAAA,QAAiB;IACjB,IAAA,cAAA,CAAA,QAAA,CAAA,GAAA,QAAiB;IACjB,IAAA,cAAA,CAAA,QAAA,CAAA,GAAA,QAAiB;IACjB,IAAA,cAAA,CAAA,SAAA,CAAA,GAAA,SAAmB;IACnB,IAAA,cAAA,CAAA,QAAA,CAAA,GAAA,QAAiB;IACjB,IAAA,cAAA,CAAA,MAAA,CAAA,GAAA,MAAa;IACf,CAAC,EAPWA,sBAAc,KAAdA,sBAAc,GAOzB,EAAA,CAAA,CAAA;IAED;;;;;;;;;;;;;;;;IAgBG;AACU,UAAA,OAAO,GAAG;QACrB,QAAQ;QACR,OAAO;QACP,QAAQ;QACR,SAAS;QACT,QAAQ;QACR,UAAU;QACV,QAAQ;QACR,WAAW;QACX,MAAM;QACN,QAAQ;;;IC/DV;;;;IAIG;IACG,SAAU,WAAW,CAAC,GAAQ,EAAA;QAClC,OAAO,GAAG,CAAC,WAAW,IAAI,GAAG,CAAC,WAAW,CAAC;IAC5C;IAEA;;;;;;;;;IASG;UACU,iBAAiB,CAAA;IAM5B,IAAA,WAAA,CAAY,GAAG,UAA+C,EAAA;YAHtD,IAAK,CAAA,KAAA,GAAQ,EAAE;IAIrB,QAAA,IAAI,CAAC,cAAc,GAAG,EAAE;IACxB,QAAA,IAAI,CAAC,QAAQ,CAAC,GAAG,UAAU,CAAC;;IAG9B;;IAEG;QACH,aAAa,GAAA;YACX,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,CAAC,cAAc,CAAC;;IAG/C;;IAEG;QACH,OAAO,GAAA;YACL,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC;;IAGhC;;;;;IAKG;IACH,IAAA,GAAG,CAAsB,YAAoB,EAAA;IAC3C,QAAA,IAAI,EAAE,YAAY,IAAI,IAAI,CAAC,KAAK,CAAC;IAAE,YAAA,OAAO,SAAS;YAEnD,MAAM,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC;YAChD,IAAI,WAAW,CAAC,eAAe,CAAC;IAAE,YAAA,OAAO,eAAoB;IAC7D,QAAA,MAAM,WAAW,GAAG,eAAe,CAAC,OAAO,IAAI,eAAe;IAC9D,QAAA,MAAM,QAAQ,GAAG,IAAI,WAAW,EAAE;IAClC,QAAA,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,QAAQ;IACnC,QAAA,OAAO,QAAQ;;IAGjB;;;;IAIG;QACH,QAAQ,CACN,GAAG,SAAsC,EAAA;IAEzC,QAAA,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,KAAI;IACtB,YAAA,IAAI,WAAW,CAAC,CAAC,CAAC,EAAE;;IAGlB,gBAAA,IAAK,CAAyB,CAAC,aAAa,IAAI,IAAI,CAAC,KAAK;wBAAE;oBAC5D,IAAI,CAAC,KAAK,CAAE,CAAyB,CAAC,aAAa,CAAC,GAAG,CAAC;;qBACnD;oBACL,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,CAAwB;IACnE,gBAAA,IAAI,aAAa,IAAI,IAAI,CAAC,KAAK;wBAAE;IACjC,gBAAA,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,GAAG,SAAS;IACrC,gBAAA,IAAI,CAAC,IAAI;wBAAE;oBACX,MAAM,GAAG,GAA2B,EAAE;oBACtC,GAAG,CAAC,aAAa,CAAC,WAAW,EAAE,CAAC,GAAG,aAAa;IAEhD,gBAAA,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,CAAC,cAAc,EAAE,GAAG,CAAC;;IAErE,SAAC,CAAC;;IAEL;;ICtFD;;;;;;;IAOG;UACU,UAAU,CAAA;iBACN,IAAuB,CAAA,uBAAA,GACpC,SAAS,CAAC;IAEZ,IAAA,WAAA,GAAA;IAEA;;;;;IAKG;IACH,IAAA,OAAO,WAAW,CAChB,iBAAgD,EAChD,gBAAsD,EAAA;IAEtD,QAAA,IAAI,gBAAgB,IAAI,UAAU,CAAC,uBAAuB;gBACxD,UAAU,CAAC,uBAAuB,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,CAAC,CAAS,KAAI;oBACjE,MAAM,SAAS,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC;IAC1C,gBAAA,IAAI,SAAS;wBAAE,iBAAiB,CAAC,QAAQ,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC;IACxE,aAAC,CAAC;IACJ,QAAA,UAAU,CAAC,uBAAuB,GAAG,iBAAiB;;IAGxD;;;;IAIG;IACK,IAAA,OAAO,WAAW,GAAA;YACxB,IAAI,CAAC,UAAU,CAAC,uBAAuB;IACrC,YAAA,UAAU,CAAC,uBAAuB,GAAG,IAAI,iBAAiB,EAAE;YAC9D,OAAO,UAAU,CAAC,uBAAuB;;IAG3C;;;;;IAKG;QACH,OAAO,GAAG,CAAsB,YAAoB,EAAA;YAClD,OAAO,UAAU,CAAC,WAAW,EAAE,CAAC,GAAG,CAAC,YAAY,CAAC;;IAGnD;;;;IAIG;IACH,IAAA,OAAO,QAAQ,CACb,GAAG,SAAsC,EAAA;YAEzC,OAAO,UAAU,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC;;IAGxD;;;;;IAKG;QACH,OAAO,GAAG,CAAC,GAAW,EAAA;IACpB,QAAA,OAAO,cAAc,CAAC,OAAO,GAAG,GAAG;;IAGrC;;IAEG;IACH,IAAA,OAAO,IAAI,GAAA;IACT,QAAA,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE;;;;ICnEvC;;;;;;;;;;IAUG;aACa,QAAQ,CACtB,GAAM,EACN,GAAG,aAAuB,EAAA;QAE1B,MAAM,mBAAmB,GAA4C,EAAE;QACvE,KAAK,MAAM,IAAI,IAAI,GAAG;YACpB,IACE,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC;IAC/C,YAAA,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,EAAE;IAElC,YAAA,mBAAmB,CAAC,IAAI,CACtBC,qBAAU,CAAC,qBAAqB,CAC9B,cAAc,CAAC,OAAO,EACtB,GAAG,EACH,IAAI,CACoC,CAC3C;QAEL,IAAI,MAAM,GAA4B,SAAS;IAE/C,IAAA,KAAK,MAAM,iBAAiB,IAAI,mBAAmB,EAAE;IACnD,QAAA,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,iBAAiB;IAE9C,QAAA,IAAI,CAAC,UAAU,IAAI,CAAC,UAAU,CAAC,MAAM;gBAAE;IAEvC,QAAA,MAAM,oBAAoB,GAAsB,UAAU,CAAC,CAAC,CAAC;;IAG7D,QAAA,IACE,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,KAAI;IACpB,YAAA,IAAI,CAAC,CAAC,GAAG,KAAK,cAAc,CAAC,IAAI;IAAE,gBAAA,OAAO,IAAI;gBAC9C,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,CAC1B,CAAC,CAAC,KAAK,CAAC,KAAK,oBAAoB,CAAC,KAAK,CAAC,IAAI,CAC7C;aACF,CAAC,EACF;IACA,YAAA,UAAU,CAAC,KAAK,EAAE,CAAC;;YAGrB,IAAI,IAAI,GAAmD,SAAS;IAEpE,QAAA,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE;gBAClC,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC;gBAC/C,IAAI,CAAC,SAAS,EAAE;oBACd,MAAM,IAAI,KAAK,CAAC,CAAA,sBAAA,EAAyB,SAAS,CAAC,GAAG,CAAE,CAAA,CAAC;;gBAG3D,MAAM,cAAc,GAClB,SAAS,CAAC,GAAG,KAAKL,iBAAS,CAAC;IAC1B,kBAAE,CAAC,SAAS,CAAC,KAAK;IAClB,kBAAE,SAAS,CAAC,KAAK,IAAI,EAAE;IAE3B,YAAA,MAAM,GAAG,GAAuB,SAAS,CAAC,SAAS,CAChD,GAAW,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,EAC7B,cAAkC,EAClC,GAAG;iBACJ;gBAED,IAAI,GAAG,EAAE;IACP,gBAAA,IAAI,GAAG,IAAI,IAAI,EAAE;IACjB,gBAAA,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,GAAG;;;YAI7B,IAAI,IAAI,EAAE;IACR,YAAA,MAAM,GAAG,MAAM,IAAI,EAAE;gBACrB,MAAM,CAAC,iBAAiB,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,GAAG,IAAI;;;;QAKpD,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE;IACxE,QAAA,IAAI,GAAuB;;IAE3B,QAAA,MAAM,aAAa,GAAGK,qBAAU,CAAC,qBAAqB,CACpD,cAAc,CAAC,OAAO,EACtB,GAAG,EACH,IAAI,CACL,CAAC,UAAU;YACZ,MAAM,UAAU,GAAGA,qBAAU,CAAC,qBAAqB,CACjD,cAAc,CAAC,OAAO,EACtB,GAAG,EACH,IAAI,CACL,CAAC,UAAU,CAAC,MAAM,CACjB,CAAC,CAAkB,KACjB,CAACL,iBAAS,CAAC,IAAI,EAAE,cAAc,CAAC,IAAc,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,EAAE,CACxE;IACD,QAAA,IAAI,CAAC,UAAU,IAAI,CAAC,UAAU,CAAC,MAAM;gBAAE;IACvC,QAAA,MAAM,GAAG,GAAG,UAAU,CAAC,GAAG,EAAuB;IACjD,QAAA,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC;IACtB,cAAE,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI;kBACf,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW;IACnC,kBAAE,GAAG,CAAC,KAAK,CAAC;sBACV,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW,CAAC;YAC7B,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAACI,sBAAc,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KACnD,CAAC,CAAC,WAAW,EAAE,CACJ;IAEb,QAAA,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE;IACrB,YAAA,IAAI,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,EAAE;oBAC5C,MAAM,gBAAgB,GAAG,KAAK,CAAC,OAAO,CAAE,GAAW,CAAC,IAAI,CAAC;0BACrD,cAAc,CAAC;IACjB,sBAAE,cAAc,CAAC,IAAI;IACvB,gBAAA,MAAM,KAAK,GACT,aAAa,CAAC,IAAI,CAChB,CAAC,CAAkB,KAAK,CAAC,CAAC,GAAG,KAAK,gBAAgB,CACnD,IAAI,EAAE;oBACT,IAAI,YAAY,GAAa,EAAE;IAC/B,gBAAA,IAAI,KAAK,IAAI,KAAK,CAAC,KAAK,EAAE;wBACxB,MAAM,WAAW,GAAG,KAAK,CAAC,OAAO,CAAE,GAAW,CAAC,IAAI,CAAC;IAClD,0BAAE,KAAK,CAAC,KAAK,CAAC;IACd,0BAAE,KAAK,CAAC,KAAK,CAAC,WAAW;IAC3B,oBAAA,IAAI,WAAW;IACb,wBAAA,YAAY,GAAG,KAAK,CAAC,OAAO,CAAC,WAAW;IACtC,8BAAE,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAA,CAAE,CAAC,WAAW,EAAE;IAC7C,8BAAE,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC;;IAGnC,gBAAA,MAAM,QAAQ,GAAG,CAAC,IAAY,EAAE,KAAU,KAAS;wBACjD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,UAAU;IAC1D,wBAAA,OAAO,SAAS;IAElB,oBAAA,IAAI;IACF,wBAAA,IAAI,KAAK,IAAI,CAAC,KAAK,CAAC,qBAAqB,CAAC;IACxC,4BAAA,KAAK,CAAC,qBAAqB,CAAC,GAAG,GAAG,CAAC;4BAErC,OAAO,OAAO,CAAC,KAAK;IAClB,8BAAE,KAAK,CAAC,SAAS;IACjB,8BAAE,YAAY,CAAC,QAAQ,CAAC,OAAO,KAAK;IAClC,kCAAE;sCACA,+BAA+B;;gCAC7B;IACR,wBAAA,IAAI,KAAK,IAAI,KAAK,CAAC,qBAAqB,CAAC;IACvC,4BAAA,OAAO,KAAK,CAAC,qBAAqB,CAAC;;IAEzC,iBAAC;oBAED,QAAQ,CAAC;wBACP,KAAK,KAAK,CAAC,IAAI;wBACf,KAAK,GAAG,CAAC,IAAI;IACX,wBAAA,IAAI,aAAa,CAAC,MAAM,EAAE;IACxB,4BAAA,MAAM,OAAO,GAAG,aAAa,CAAC,IAAI,CAChC,CAAC,CAAkB,KAAK,CAAC,CAAC,GAAG,KAAK,cAAc,CAAC,IAAI,CACtD;gCACD,IAAI,OAAO,EAAE;IACX,gCAAA,GAAG,GAAG,CACJ,CAAC,KAAK,KAAK,CAAC;IACV,sCAAG,GAA2B,CAAC,IAAI;IACnC;IACG,wCAAA,GAA2B,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE;IAE9C,qCAAA,GAAG,CAAC,CAAC,CAAc,KAAK,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;yCACzC,MAAM,CAAC,CAAC,CAAM,KAAK,CAAC,CAAC,CAAC,CAAQ;IACjC,gCAAA,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE;;wCAEhB,GAAG,GAAG,SAAS;;;;4BAIrB;IACF,oBAAA;IACE,wBAAA,IAAI;gCACF,IAAK,GAA2B,CAAC,IAAI,CAAC;oCACpC,GAAG,GAAG,QAAQ,CAAC,IAAI,EAAG,GAAW,CAAC,IAAI,CAAC,CAAC;;4BAC1C,OAAO,CAAM,EAAE;gCACf,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,2CAA2C,GAAG,CAAC,CAAC,CAAC;;;;gBAIzE,IAAI,GAAG,EAAE;IACP,gBAAA,MAAM,GAAG,MAAM,IAAI,EAAE;IACrB,gBAAA,MAAM,CAAC,IAAI,CAAC,GAAG,GAAU;;;;IAK/B,IAAA,OAAO,MAAM,GAAG,IAAI,oBAAoB,CAAC,MAAM,CAAC,GAAG,SAAS;IAC9D;;ICvLA,IAAI,oBAAsD;IAC1D,IAAI,mBAAyC;IAE7B,SAAA,eAAe,CAC7B,MAAS,EACT,SAAiB,EAAA;IAEjB,IAAA,IAAI,OAAO,CAAE,MAA8B,CAAC,SAAS,CAAC,CAAC;IAAE,QAAA,OAAO,IAAI;IACpE,IAAA,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAACJ,iBAAS,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC;IACvE,IAAA,OAAO,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,IAAI,GAAG,SAAS;IAC7D;IAEA;;;;;;;IAOG;IACG,SAAU,OAAO,CAAC,MAA2B,EAAA;IACjD,IAAA,IAAI;IACF,QAAA,OAAO,MAAM,YAAY,KAAK,IAAI,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC,MAAa,CAAC;;;QAEpE,OAAO,CAAM,EAAE;IACf,QAAA,OAAO,KAAK;;IAEhB;IAYA;;;;;;;;;;IAUG;UACU,oBAAoB,CAAA;IAI/B,IAAA,WAAA,CAAY,eAAsD,OAAO,EAAA;YAHjE,IAAK,CAAA,KAAA,GAAwC,EAAE;IAIrD,QAAA,IAAI,CAAC,YAAY,GAAG,YAAY;;IAGlC;;;;IAIG;QACH,QAAQ,CAAC,WAAgC,EAAE,IAAa,EAAA;YACtD,IAAI,OAAO,WAAW,KAAK,UAAU;IACnC,YAAA,MAAM,IAAI,KAAK,CACb,6DAA6D,CAC9D;IACH,QAAA,IAAI,GAAG,IAAI,IAAI,WAAW,CAAC,IAAI;IAC/B,QAAA,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,WAAW;;IAGhC;;;IAGG;IACH,IAAA,GAAG,CAAC,IAAY,EAAA;IACd,QAAA,IAAI;IACF,YAAA,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;;;YAEvB,OAAO,CAAM,EAAE;IACf,YAAA,OAAO,SAAS;;;IAIpB;;;;;IAKG;IACH,IAAA,KAAK,CAAC,GAAA,GAA2B,EAAE,EAAE,KAAc,EAAA;YACjD,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC;IACnC,YAAA,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC;YACvD,MAAM,IAAI,GAAG,KAAK,IAAI,KAAK,CAAC,WAAW,CAAC,GAAU,CAAC;IACnD,QAAA,IAAI,EAAE,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC;gBACvB,MAAM,IAAI,KAAK,CACb,EAAE,CAAC,qDAAqD,EAAE,IAAI,CAAC,CAChE;YACH,OAAO,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC;;IAEnC;IAED;;;;;;;;IAQG;IACa,SAAA,iBAAiB,CAC/B,GAAG,MAA0E,EAAA;IAE7E,IAAA,MAAM,CAAC,OAAO,CACZ,CAAC,CAAiE,KAAI;IACpE,QAAA,MAAM,WAAW,IACf,CAAC,CAAC,WAAW,GAAG,CAAC,CAAC,WAAW,GAAG,CAAC,CAChB;YACnB,KAAK,CAAC,QAAQ,CAAC,WAAW,EAAG,CAAoB,CAAC,IAAI,CAAC;IACzD,KAAC,CACF;IACH;IAEA;;;;;;;;;;;;;;;;;;;;;;IAsBG;UACmB,KAAK,CAAA;;QAIzB,WAAsB,CAAA,GAAqB;IAE3C;;;;IAIG;QACI,SAAS,CAAC,GAAG,UAAiB,EAAA;IACnC,QAAA,OAAO,QAAQ,CAAC,IAAI,EAAE,GAAG,UAAU,CAAC;;IAGtC;;;;IAIG;IACI,IAAA,MAAM,CAAC,GAAQ,EAAE,GAAG,UAAoB,EAAA;YAC7C,OAAOM,kBAAO,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,UAAU,CAAC;;IAG1C;;IAEG;QACH,SAAS,GAAA;IACP,QAAA,OAAO,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC;;IAG9B;;;IAGG;QACI,QAAQ,GAAA;IACb,QAAA,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;;IAG1E;;IAEG;QACI,IAAI,GAAA;IACT,QAAA,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC;;IAGzB;;;;;IAKG;QACH,OAAO,WAAW,CAAC,GAAW,EAAA;IAC5B,QAAA,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAClC,KAAK,CAAC,GAAG,CAACN,iBAAS,CAAC,aAAa,CAAC,EAClC,IAAI,CAAC,WAAW,CACjB;IAED,QAAA,IAAI,QAAQ,IAAI,QAAQ,CAAC,UAAU;IACjC,YAAA,OAAO,aAAa,CAAC,WAAW,CAC9B,GAAG,EACH,QAAQ,CAAC,UAAU,EACnB,IAAI,QAAQ,CAAC,IAAI,IAAI,EAAE,CAAC,CACzB;IACH,QAAA,OAAO,aAAa,CAAC,WAAW,CAAC,GAAG,CAAC;;IAGvC;;;;;;;IAOG;IACH,IAAA,OAAO,UAAU,CACf,IAAO,EACP,GAA6B,EAAA;IAE7B,QAAA,IAAI,CAAC,GAAG;gBAAE,GAAG,GAAG,EAAE;YAClB,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,EAAE;gBAC3C,IAAY,CAAC,IAAI,CAAC,GAAI,GAAW,CAAC,IAAI,CAAC,IAAI,SAAS;;IAEvD,QAAA,OAAO,IAAI;;IAGb;;;;;;;;;IASG;IACH,IAAA,OAAO,SAAS,CAAkB,IAAO,EAAE,GAA6B,EAAA;IACtE,QAAA,IAAI,CAAC,GAAG;gBAAE,GAAG,GAAG,EAAE;YAElB,IAAI,UAA+B,EAAE,GAAsB;YAE3D,MAAM,KAAK,GAAG,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC;IAEvC,QAAA,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;gBACvB,IAA4B,CAAC,IAAI,CAAC;IAChC,gBAAA,GAA2B,CAAC,IAAI,CAAC,IAAI,SAAS;IACjD,YAAA,IAAI,OAAQ,IAAY,CAAC,IAAI,CAAC,KAAK,QAAQ;oBAAE;gBAC7C,MAAM,KAAK,GAAG,eAAe,CAAC,IAAI,EAAE,IAAI,CAAC;gBACzC,IAAI,KAAK,EAAE;IACT,gBAAA,IAAI;wBACD,IAA4B,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,KAAK,CAC9C,IAA4B,CAAC,IAAI,CAAC,EACnC,OAAO,KAAK,KAAK,QAAQ,GAAG,KAAK,GAAG,SAAS,CAC9C;;oBACD,OAAO,CAAM,EAAE;IACf,oBAAA,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;;oBAEhB;;IAGF,YAAA,MAAM,aAAa,GACjBK,qBAAU,CAAC,qBAAqB,CAC9B,cAAc,CAAC,OAAO,EACtB,IAAI,EACJ,IAAI,CACL,CAAC,UAAU;IACd,YAAA,UAAU,GAAG,aAAa,CAAC,MAAM,CAC/B,CAAC,CAAoB,KACnB,CAACL,iBAAS,CAAC,IAAI,EAAE,cAAc,CAAC,IAAc,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,EAAE,CACxE;IACD,YAAA,IAAI,CAAC,UAAU,IAAI,CAAC,UAAU,CAAC,MAAM;oBACnC,MAAM,IAAI,KAAK,CAAC,EAAE,CAAC,4CAA4C,EAAE,IAAI,CAAC,CAAC;IACzE,YAAA,GAAG,GAAG,UAAU,CAAC,GAAG,EAAuB;IAC3C,YAAA,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC;IACtB,kBAAE,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI;sBACf,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW;IACnC,sBAAE,GAAG,CAAC,KAAK,CAAC;0BACV,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW,CAAC;gBAC7B,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAACI,sBAAc,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KACnD,CAAC,CAAC,WAAW,EAAE,CACJ;IAEb,YAAA,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,KAAI;oBAClB,IAAI,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE;IAC1C,oBAAA,IAAI;4BACF,QAAQ,CAAC;IACP,4BAAA,KAAK,OAAO;IACZ,4BAAA,KAAK,KAAK;IACR,gCAAA,IAAI,aAAa,CAAC,MAAM,EAAE;IACxB,oCAAA,MAAM,OAAO,GAAG,aAAa,CAAC,IAAI,CAChC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,KAAK,cAAc,CAAC,IAAI,CACrC;wCACD,IAAI,OAAO,EAAE;4CACX,MAAM,SAAS,GAAI,OAAO,CAAC,KAAK,CAAC,KAAkB,CAAC,IAAI,CACtD,CAAC,CAAS,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAClD;4CACD,IAAI,CAAC,KAAK,OAAO;IACd,4CAAA,IAA4B,CAAC,IAAI,CAAC,GACjC,IACD,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,EAAO,KAAI;oDACtB,OAAO,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;wDAC/C;0DACE,KAAK,CAAC,KAAK,CAAC,EAAE,EAAE,SAAS;0DACzB,EAAE;IACR,6CAAC,CAAC;IACJ,wCAAA,IAAI,CAAC,KAAK,KAAK,EAAE;IACf,4CAAA,MAAM,CAAC,GAAG,IAAI,GAAG,EAAE;gDACnB,KAAK,MAAM,CAAC,IAAK,IAA4B,CAAC,IAAI,CAAC,EAAE;oDACnD,IACE,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IACzC,oDAAA,SAAS,EACT;IACA,oDAAA,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;;yDAC3B;IACL,oDAAA,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;;;IAGX,4CAAA,IAA4B,CAAC,IAAI,CAAC,GAAG,CAAC;;;;oCAI7C;IACF,4BAAA;oCACE,IAAK,IAA4B,CAAC,IAAI,CAAC;IACpC,oCAAA,IAA4B,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,KAAK,CAC9C,IAAY,CAAC,IAAI,CAAC,EACnB,CAAC,CACF;;;wBAEP,OAAO,CAAM,EAAE;IACf,wBAAA,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;;;IAGpB,aAAC,CAAC;;IAEJ,QAAA,OAAO,IAAI;;IAGb;;;IAGG;QACH,OAAO,UAAU,CAAC,OAA8B,EAAA;YAC9C,oBAAoB,GAAG,OAAO;;IAGhC;;IAEG;IACH,IAAA,OAAO,UAAU,GAAA;IACf,QAAA,OAAO,oBAAoB;;IAG7B;;;;IAIG;IACK,IAAA,OAAO,WAAW,GAAA;IACxB,QAAA,IAAI,CAAC,mBAAmB;IAAE,YAAA,mBAAmB,GAAG,IAAI,oBAAoB,EAAE;IAC1E,QAAA,OAAO,mBAAmB;;IAG5B;;;;IAIG;QACH,OAAO,WAAW,CAAC,aAAmC,EAAA;YACpD,mBAAmB,GAAG,aAAa;;IAGrC;;;;;;IAMG;IACH,IAAA,OAAO,QAAQ,CACb,WAAgC,EAChC,IAAa,EAAA;YAEb,OAAO,KAAK,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,WAAW,EAAE,IAAI,CAAC;;IAGxD;;;;;IAKG;QACH,OAAO,GAAG,CAAkB,IAAY,EAAA;YACtC,OAAO,KAAK,CAAC,WAAW,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC;;IAGtC;;;;;;;IAOG;IACH,IAAA,OAAO,KAAK,CACV,GAA2B,GAAA,EAAE,EAC7B,KAAc,EAAA;YAEd,OAAO,KAAK,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC;;QAG9C,OAAO,WAAW,CAAkB,KAAQ,EAAA;IAC1C,QAAA,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAClC,KAAK,CAAC,GAAG,CAACJ,iBAAS,CAAC,KAAK,CAAC,EAC1B,KAAK,CAAC,WAAW,CAClB;IACD,QAAA,IAAI,CAAC,QAAQ;gBACX,MAAM,IAAI,KAAK,CACb,uCAAuC,GAAG,KAAK,CAAC,WAAW,CAAC,IAAI,CACjE;IACH,QAAA,OAAO,QAAQ;;QAGjB,OAAO,aAAa,CAAkB,KAAyB,EAAA;YAC7D,MAAM,MAAM,GAAa,EAAE;IAC3B,QAAA,IAAI,SAAS,GACX,KAAK,YAAY;IACf,cAAE,MAAM,CAAC,cAAc,CAAC,KAAK;IAC7B,cAAG,KAAa,CAAC,SAAS;IAC9B,QAAA,OAAO,SAAS,IAAI,IAAI,EAAE;gBACxB,MAAM,KAAK,GAAa,SAAS,CAACA,iBAAS,CAAC,SAAS,CAAC;gBACtD,IAAI,KAAK,EAAE;IACT,gBAAA,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;;IAEvB,YAAA,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC;;IAE9C,QAAA,OAAO,MAAM;;QAGf,OAAO,MAAM,CAAkB,IAAO,EAAE,IAAO,EAAE,GAAG,UAAiB,EAAA;YACnE,OAAOM,kBAAO,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,UAAU,CAAC;;IAG3C,IAAA,OAAO,SAAS,CAAkB,KAAQ,EAAE,GAAG,aAAuB,EAAA;IACpE,QAAA,OAAO,QAAQ,CAAC,KAAK,EAAE,GAAG,aAAa,CAAC;;QAG1C,OAAO,SAAS,CAAkB,KAAQ,EAAA;IACxC,QAAA,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAClC,KAAK,CAAC,GAAG,CAACN,iBAAS,CAAC,aAAa,CAAC,EAClC,KAAK,CAAC,WAAW,CAClB;IAED,QAAA,IAAI,QAAQ,IAAI,QAAQ,CAAC,UAAU;IACjC,YAAA,OAAO,aAAa,CAAC,SAAS,CAC5B,IAAI,EACJ,QAAQ,CAAC,UAAU,EACnB,IAAI,QAAQ,CAAC,IAAI,IAAI,EAAE,CAAC,CACzB;IACH,QAAA,OAAO,aAAa,CAAC,SAAS,CAAC,KAAK,CAAC;;QAGvC,OAAO,IAAI,CAAkB,KAAQ,EAAA;IACnC,QAAA,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAClC,KAAK,CAAC,GAAG,CAACA,iBAAS,CAAC,OAAO,CAAC,EAC5B,KAAK,CAAC,WAAW,CAClB;IAED,QAAA,IAAI,QAAQ,IAAI,QAAQ,CAAC,SAAS;IAChC,YAAA,OAAO,OAAO,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,EAAE,IAAI,QAAQ,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;IAC1E,QAAA,OAAO,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC;;IAE5B;;;;IAIG;QACH,OAAO,GAAG,CAAC,GAAW,EAAA;IACpB,QAAA,OAAOA,iBAAS,CAAC,OAAO,GAAG,GAAG;;IAEjC;;ACxfM,UAAM,0BAA0B,GAAG;IAE1C;;;;;;;;;;;;IAYG;UACU,cAAc,CAAA;IACzB,IAAA,WAAA,GAAA;IACA;;;;;;;IAOG;IACO,IAAA,YAAY,CAAC,KAAQ,EAAA;;YAE7B,MAAM,WAAW,GAAwB,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC;YACjE,MAAM,QAAQ,GAAG,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC;IACzC,QAAA,WAAW,CAACA,iBAAS,CAAC,MAAM,CAAC,GAAG,QAAQ,IAAI,KAAK,CAAC,WAAW,CAAC,IAAI;IAClE,QAAA,OAAO,WAAW;;IAGpB;;;;;IAKG;IACH,IAAA,WAAW,CAAC,GAAW,EAAA;YACrB,MAAM,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC;YACvC,MAAM,SAAS,GAAG,eAAe,CAACA,iBAAS,CAAC,MAAM,CAAC;IACnD,QAAA,IAAI,CAAC,SAAS;IACZ,YAAA,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC;YACvE,MAAM,KAAK,GAAM,KAAK,CAAC,KAAK,CAAC,eAAe,EAAE,SAAS,CAAiB;IACxE,QAAA,OAAO,KAAK;;IAGd;;;;;IAKG;IACH,IAAA,SAAS,CAAC,KAAQ,EAAA;YAChB,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;;IAElD;UAEY,aAAa,CAAA;iBACT,IAAO,CAAA,OAAA,GAAW,0BAA0B,CAAC;IAE7C,IAAA,SAAA,IAAA,CAAA,KAAK,GAAoC;YACtD,IAAI,EAAE,IAAI,cAAc,EAAE;SAC3B,CAAC;IAEF,IAAA,WAAA,GAAA;QAEQ,OAAO,GAAG,CAAC,GAAW,EAAA;IAC5B,QAAA,IAAI,GAAG,IAAI,IAAI,CAAC,KAAK;IAAE,YAAA,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC;IAC7C,QAAA,MAAM,IAAI,KAAK,CAAC,4CAA4C,GAAG,CAAA,CAAE,CAAC;;QAGpE,OAAO,QAAQ,CACb,GAAW,EACX,IAAkC,EAClC,UAAU,GAAG,KAAK,EAAA;IAElB,QAAA,IAAI,GAAG,IAAI,IAAI,CAAC,KAAK;IACnB,YAAA,MAAM,IAAI,KAAK,CAAC,wBAAwB,GAAG,CAAA,mBAAA,CAAqB,CAAC;YACnE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,IAAI,EAAE;IAC5B,QAAA,IAAI,UAAU;IAAE,YAAA,IAAI,CAAC,OAAO,GAAG,GAAG;;QAGpC,OAAO,SAAS,CAAC,GAAQ,EAAE,MAAe,EAAE,GAAG,IAAW,EAAA;IACxD,QAAA,IAAI,CAAC,MAAM;IAAE,YAAA,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;IAClE,QAAA,OAAO,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;;QAGjD,OAAO,WAAW,CAAC,GAAW,EAAE,MAAe,EAAE,GAAG,IAAW,EAAA;IAC7D,QAAA,IAAI,CAAC,MAAM;IAAE,YAAA,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;IACpE,QAAA,OAAO,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;;QAGnD,OAAO,UAAU,CAAC,MAAc,EAAA;YAC9B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC;;;;ICpGnC;IACA;AACA;IACA;IACA;AACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;AACA;AAsCA;IACO,SAAS,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE;IAC1D,IAAI,IAAI,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,MAAM,GAAG,IAAI,KAAK,IAAI,GAAG,IAAI,GAAG,MAAM,CAAC,wBAAwB,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC;IACjI,IAAI,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,OAAO,CAAC,QAAQ,KAAK,UAAU,EAAE,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;IACnI,SAAS,KAAK,IAAI,CAAC,GAAG,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,IAAI,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC;IACtJ,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;IAClE,CAAC;AAkDD;IACO,SAAS,UAAU,CAAC,WAAW,EAAE,aAAa,EAAE;IACvD,IAAI,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,OAAO,CAAC,QAAQ,KAAK,UAAU,EAAE,OAAO,OAAO,CAAC,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC;IACnI,CAAC;AAuND;IACuB,OAAO,eAAe,KAAK,UAAU,GAAG,eAAe,GAAG,UAAU,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE;IACvH,IAAI,IAAI,CAAC,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;IAC/B,IAAI,OAAO,CAAC,CAAC,IAAI,GAAG,iBAAiB,EAAE,CAAC,CAAC,KAAK,GAAG,KAAK,EAAE,CAAC,CAAC,UAAU,GAAG,UAAU,EAAE,CAAC,CAAC;IACrF;;ICtUA;;;;;;;;;;;IAWG;UACmB,SAAS,CAAA;IAI7B,IAAA,WAAA,CACE,UAAkB,sBAAsB,CAAC,OAAO,EAChD,GAAG,aAAuB,EAAA;IAE1B,QAAA,IAAI,CAAC,OAAO,GAAG,OAAO;YAEtB,IAAI,aAAa,CAAC,MAAM;IAAE,YAAA,IAAI,CAAC,aAAa,GAAG,aAAa;YAC5D,IAAI,IAAI,CAAC,aAAa;IACpB,YAAA,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;;IAG1E;;;;;IAKG;IACO,IAAA,UAAU,CAAC,OAAe,EAAE,GAAG,IAAW,EAAA;IAClD,QAAA,OAAO,EAAE,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC;;IAG7B;;;;IAIG;IACK,IAAA,qBAAqB,CAC3B,OAA2D,EAAA;IAE3D,QAAA,OAAO,UAEL,KAAU,EACV,GAAG,IAAW,EAAA;IAEd,YAAA,IAAI,KAAK,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,aAAa;IAC5C,gBAAA,OAAO,OAAO,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC;gBAChC,IAAI,CAACK,qBAAU,CAAC,UAAU,CAAC,KAAK,EAAE,IAAI,CAAC,aAAa,CAAC;oBACnD,OAAO,IAAI,CAAC,UAAU,CACpB,sBAAsB,CAAC,IAAI,EAC3B,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,EAC7B,OAAO,KAAK,CACb;IACH,YAAA,OAAO,OAAO,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC;IAChC,SAAC,CAAC,IAAI,CAAC,IAAI,CAAC;;IAoBf;;IC7ED;;;;;;;;;IASG;IACa,SAAA,SAAS,CAAsB,GAAG,IAAc,EAAA;IAC9D,IAAA,OAAOJ,gBAAK,EACT,CAAC,QAAwB,KAAI;IAC5B,QAAA,IAAI,CAAC,OAAO,CAAC,CAAC,CAAS,KAAI;gBACzB,UAAU,CAAC,QAAQ,CAAC;IAClB,gBAAA,SAAS,EAAE,QAAQ;IACnB,gBAAA,aAAa,EAAE,CAAC;IAChB,gBAAA,IAAI,EAAE,IAAI;IACY,aAAA,CAAC;IAC3B,SAAC,CAAC;IACF,QAAA,OAAO,QAAQ;IACjB,KAAC,GACDC,mBAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC,SAAS,CAAC,EAAE,IAAI,CAAC,CACzD;IACH;;IC1BA;;;;;;;;;IASG;AAEUK,yBAAa,GAAnB,MAAM,aAAc,SAAQ,SAA+B,CAAA;QAChE,WAAY,CAAA,OAAA,GAAkB,sBAAsB,CAAC,IAAI,EAAA;IACvD,QAAA,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC;;IAGrD;;;;;;;;;;;IAWG;IACI,IAAA,SAAS,CACd,KAAoB,EACpB,OAAA,GAAgC,EAAE,EAAA;YAElC,IAAI,KAAK,KAAK,SAAS;gBAAE;YAEzB,IAAI,OAAO,KAAK,KAAK,QAAQ;IAAE,YAAA,KAAK,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC;YAEtD,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,EAAE;IACjC,YAAA,MAAM,EAAE,OAAO,GAAG,EAAE,EAAE,GAAG,OAAO;gBAChC,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC;;;;AA3BxCA,yBAAa,GAAA,UAAA,CAAA;IADzB,IAAA,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC;;IAClB,CAAA,EAAAA,qBAAa,CA8BzB;;IC1CD;;;;;;;;;;;IAWG;IACa,SAAA,cAAc,CAAI,GAAwB,EAAE,IAAY,EAAA;QACtE,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE;IAC5C,QAAA,MAAM,IAAI,KAAK,CAAC,EAAE,CAAC,yBAAyB,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;;;QAInE,MAAM,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE;IACnD,IAAA,MAAM,WAAW,GAAG,eAAe,CAAC,MAAM;QAC1C,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC;;QAG7C,IAAI,cAAc,GAAQ,GAAG;IAC7B,IAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,EAAE,CAAC,EAAE,EAAE;YACpC,IAAI,CAAC,cAAc,IAAI,OAAO,cAAc,KAAK,QAAQ,EAAE;IACzD,YAAA,MAAM,IAAI,KAAK,CACb,EAAE,CAAC,yBAAyB,CAAC,6BAA6B,EAAE,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,CACzE;;IAGH,QAAA,IAAI,CAAC,cAAc,CAAC,qBAAqB,CAAC,EAAE;IAC1C,YAAA,MAAM,IAAI,KAAK,CACb,EAAE,CAAC,yBAAyB,CAAC,oBAAoB,EAAE,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,CAChE;;IAGH,QAAA,cAAc,GAAG,cAAc,CAAC,qBAAqB,CAAC;;;QAIxD,MAAM,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC;QAClC,IAAI,YAAY,GAAQ,cAAc;IAEtC,IAAA,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;YACxB,IACE,YAAY,KAAK,IAAI;gBACrB,OAAO,YAAY,KAAK,QAAQ;gBAChC,IAAI,IAAI,YAAY,EACpB;IACA,YAAA,YAAY,GAAI,YAAoC,CAAC,IAAI,CAAC;;iBACrD;IACL,YAAA,MAAM,gBAAgB,GACpB,WAAW,KAAK;sBACZ,yBAAyB,CAAC;sBAC1B,WAAW,KAAK;0BACd,yBAAyB,CAAC;IAC5B,sBAAE,yBAAyB,CAAC,+BAA+B;IAEjE,YAAA,MAAM,IAAI,KAAK,CAAC,EAAE,CAAC,gBAAgB,EAAE,IAAI,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC;;;IAIlE,IAAA,OAAO,YAAiB;IAC1B;IAEA,MAAM,WAAW,GAAG,CAAC,KAAc,KAAY;QAC7C,IAAI,KAAK,KAAK,IAAI;IAAE,QAAA,OAAO,MAAM;QACjC,IAAI,KAAK,YAAY,IAAI;IAAE,QAAA,OAAO,MAAM;IACxC,IAAA,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC;IAAE,QAAA,OAAO,KAAK;QACrC,IAAI,KAAK,KAAK,QAAQ;IAAE,QAAA,OAAO,UAAU;QACzC,IAAI,KAAK,KAAK,CAAC,QAAQ;IAAE,QAAA,OAAO,WAAW;IAC3C,IAAA,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;IAAE,QAAA,OAAO,OAAO;QACxC,OAAO,OAAO,KAAK;IACrB,CAAC;IAED,MAAM,WAAW,GAAG,CAClB,KAAc,KACiC;IAC/C,IAAA,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,YAAY,IAAI;IAAE,QAAA,OAAO,IAAI;QAE7D,IAAI,OAAO,KAAK,KAAK,QAAQ;IAAE,QAAA,OAAO,IAAI;;QAG1C,IAAI,OAAO,KAAK,KAAK,QAAQ;IAAE,QAAA,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;IAE5D,IAAA,OAAO,KAAK;IACd,CAAC;IAED;;;;;;;;;;;IAWG;IACa,SAAA,4BAA4B,CAAC,CAAM,EAAE,CAAM,EAAA;QACzD,IAAI,WAAW,CAAC,CAAC,CAAC,IAAI,WAAW,CAAC,CAAC,CAAC;IAAE,QAAA,OAAO,IAAI;QAEjD,MAAM,IAAI,SAAS,CACjB,EAAE,CACA,yBAAyB,CAAC,4BAA4B,EACtD,WAAW,CAAC,CAAC,CAAC,EACd,WAAW,CAAC,CAAC,CAAC,CACf,CACF;IACH;IAEA;;;;;;;;;;;IAWG;IACa,SAAA,UAAU,CAAC,CAAM,EAAE,CAAM,EAAA;QACvC,IAAI,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;IAChE,QAAA,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,4BAA4B,CAAC;;IAGzE,IAAA,MAAM,KAAK,GAAG,OAAO,CAAC;IACtB,IAAA,MAAM,KAAK,GAAG,OAAO,CAAC;IAEtB,IAAA,IAAI,KAAK,KAAK,KAAK,EAAE;;IAEnB,QAAA,IAAI,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,QAAQ;IAC1C,YAAA,OAAO,MAAM,CAAC,CAAC,CAAC,GAAI,CAAY;IAClC,QAAA,IAAI,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,QAAQ;IAC1C,YAAA,OAAQ,CAAY,GAAG,MAAM,CAAC,CAAC,CAAC;IAClC,QAAA,MAAM,IAAI,SAAS,CACjB,EAAE,CAAC,yBAAyB,CAAC,wBAAwB,EAAE,KAAK,EAAE,KAAK,CAAC,CACrE;;QAGH,IACE,CAAC,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,QAAQ;aACxC,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,QAAQ,CAAC,EAC1C;IACA,QAAA,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IACpC,YAAA,MAAM,IAAI,SAAS,CAAC,yBAAyB,CAAC,cAAc,CAAC;YAC/D,OAAO,CAAC,GAAG,CAAC;;QAGd,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,YAAY,IAAI,EAAE;IAC1C,QAAA,IAAI,KAAK,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;IAC1C,YAAA,MAAM,IAAI,SAAS,CAAC,yBAAyB,CAAC,uBAAuB,CAAC;YACxE,OAAO,CAAC,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,OAAO,EAAE;;QAGlC,MAAM,IAAI,SAAS,CACjB,EAAE,CACA,yBAAyB,CAAC,4BAA4B,EACtD,WAAW,CAAC,CAAC,CAAC,EACd,WAAW,CAAC,CAAC,CAAC,CACf,CACF;IACH;IAEA;;;;;;;;;;;IAWG;IACa,SAAA,aAAa,CAAC,CAAM,EAAE,CAAM,EAAA;QAC1C,IAAI,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;IAChE,QAAA,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,4BAA4B,CAAC;IAEzE,IAAA,MAAM,KAAK,GAAG,OAAO,CAAC;IACtB,IAAA,MAAM,KAAK,GAAG,OAAO,CAAC;IAEtB,IAAA,IAAI,KAAK,KAAK,KAAK,EAAE;;IAEnB,QAAA,IAAI,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,QAAQ;IAC1C,YAAA,OAAO,MAAM,CAAC,CAAC,CAAC,GAAI,CAAY;IAClC,QAAA,IAAI,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,QAAQ;IAC1C,YAAA,OAAQ,CAAY,GAAG,MAAM,CAAC,CAAC,CAAC;IAClC,QAAA,MAAM,IAAI,KAAK,CACb,EAAE,CAAC,yBAAyB,CAAC,wBAAwB,EAAE,KAAK,EAAE,KAAK,CAAC,CACrE;;QAGH,IACE,CAAC,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,QAAQ;aACxC,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,QAAQ,CAAC,EAC1C;IACA,QAAA,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IACpC,YAAA,MAAM,IAAI,SAAS,CAAC,yBAAyB,CAAC,cAAc,CAAC;YAC/D,OAAO,CAAC,GAAG,CAAC;;QAGd,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,YAAY,IAAI,EAAE;IAC1C,QAAA,IAAI,KAAK,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;IAC1C,YAAA,MAAM,IAAI,SAAS,CAAC,yBAAyB,CAAC,uBAAuB,CAAC;YACxE,OAAO,CAAC,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,OAAO,EAAE;;QAGlC,MAAM,IAAI,SAAS,CACjB,EAAE,CACA,yBAAyB,CAAC,4BAA4B,EACtD,WAAW,CAAC,CAAC,CAAC,EACd,WAAW,CAAC,CAAC,CAAC,CACf,CACF;IACH;;ICzNA;;;;;;;;;IASG;AAEUC,yBAAa,GAAnB,MAAM,aAAc,SAAQ,SAA+B,CAAA;QAChE,WAAY,CAAA,OAAA,GAAkB,sBAAsB,CAAC,IAAI,EAAA;YACvD,KAAK,CAAC,OAAO,CAAC;;IAGhB;;;;;;;;;;IAUG;IACI,IAAA,SAAS,CACd,KAAU,EACV,OAA6B,EAC7B,QAAa,EAAA;IAEb,QAAA,IAAI,uBAA4B;IAChC,QAAA,IAAI;IACF,YAAA,uBAAuB,GAAG,cAAc,CACtC,QAAQ,EACR,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,CAC7B;;YACD,OAAO,CAAM,EAAE;IACf,YAAA,OAAO,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC;;IAGnD,QAAA,OAAOF,kBAAO,CAAC,KAAK,EAAE,uBAAuB;IAC3C,cAAE,IAAI,CAAC,UAAU,CACb,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,EAC/B,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC;kBAE9B,SAAS;;;AApCJE,yBAAa,GAAA,UAAA,CAAA;IADzB,IAAA,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC;;IAClB,CAAA,EAAAA,qBAAa,CAsCzB;;UCnDY,YAAY,GAAW,IAAI,MAAM,CAAC,oBAAoB;IAEnE;;;;;;;;;;IAUG;AAEUC,4BAAgB,GAAtB,MAAM,gBAAiB,SAAQ,SAAkC,CAAA;QACtE,WAAY,CAAA,OAAA,GAAkB,sBAAsB,CAAC,OAAO,EAAA;IAC1D,QAAA,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC;;IAG1B;;;;;IAKG;IACK,IAAA,UAAU,CAAC,OAAe,EAAA;IAChC,QAAA,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC;IAAE,YAAA,OAAO,IAAI,MAAM,CAAC,OAAO,CAAC;YAC3D,MAAM,KAAK,GAAQ,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC;IAC9C,QAAA,OAAO,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;;IAGvC;;;;;;;;;;;IAWG;QACI,SAAS,CACd,KAAa,EACb,OAAgC,EAAA;IAEhC,QAAA,IAAI,CAAC,KAAK;gBAAE;IAEZ,QAAA,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO;IACzB,QAAA,IAAI,CAAC,OAAO;IAAE,YAAA,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC;IAChD,QAAA,OAAO,GAAG,OAAO,OAAO,KAAK,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,OAAO;IAC1E,QAAA,OAAO,CAAC,SAAS,GAAG,CAAC,CAAC;IACtB,QAAA,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK;IACxB,cAAE,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO;kBAC/C,SAAS;;;AAzCJA,4BAAgB,GAAA,UAAA,CAAA;IAD5B,IAAA,SAAS,CAAC,cAAc,CAAC,OAAO,CAAC;;IACrB,CAAA,EAAAA,wBAAgB,CA2C5B;;ICrDD;;;;;;;;;IASG;AAEUC,0BAAc,GAApB,MAAM,cAAe,SAAQD,wBAAgB,CAAA;QAClD,WAAY,CAAA,OAAA,GAAkB,sBAAsB,CAAC,KAAK,EAAA;YACxD,KAAK,CAAC,OAAO,CAAC;;IAGhB;;;;;;;;;;;IAWG;IACI,IAAA,SAAS,CACd,KAAa,EACb,OAAA,GAAmC,EAAE,EAAA;IAErC,QAAA,OAAO,KAAK,CAAC,SAAS,CAAC,KAAK,EAAE;IAC5B,YAAA,GAAG,OAAO;IACV,YAAA,OAAO,EAAE,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,KAAK;IACpD,SAAA,CAAC;;;AAxBOC,0BAAc,GAAA,UAAA,CAAA;IAD1B,IAAA,SAAS,CAAC,cAAc,CAAC,KAAK,CAAC;;IACnB,CAAA,EAAAA,sBAAc,CA0B1B;;ICvCD;;;;;;;;;IASG;AAEUC,2BAAe,GAArB,MAAM,eAAgB,SAAQ,SAAiC,CAAA;QACpE,WAAY,CAAA,OAAA,GAAkB,sBAAsB,CAAC,MAAM,EAAA;YACzD,KAAK,CAAC,OAAO,CAAC;;IAGhB;;;;;;;;;;IAUG;IACI,IAAA,SAAS,CACd,KAAU,EACV,OAA+B,EAC/B,QAAa,EAAA;IAEb,QAAA,IAAI,uBAA4B;IAChC,QAAA,IAAI;IACF,YAAA,uBAAuB,GAAG,cAAc,CACtC,QAAQ,EACR,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAC/B;;YACD,OAAO,CAAM,EAAE;IACf,YAAA,OAAO,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC;;IAGnD,QAAA,OAAOL,kBAAO,CAAC,KAAK,EAAE,uBAAuB;IAC3C,cAAE;kBACA,IAAI,CAAC,UAAU,CACb,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,EAC/B,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAC/B;;;AApCIK,2BAAe,GAAA,UAAA,CAAA;IAD3B,IAAA,SAAS,CAAC,cAAc,CAAC,MAAM,CAAC;;IACpB,CAAA,EAAAA,uBAAe,CAsC3B;IAED;IACA;IACA;IACA;IACA;;ICxDA;;;;;;;;;IASG;AAEUC,gCAAoB,GAA1B,MAAM,oBAAqB,SAAQ,SAAsC,CAAA;QAC9E,WAAY,CAAA,OAAA,GAAkB,sBAAsB,CAAC,YAAY,EAAA;YAC/D,KAAK,CAAC,OAAO,CAAC;;IAGhB;;;;;;;;;;IAUG;IACI,IAAA,SAAS,CACd,KAAU,EACV,OAAoC,EACpC,QAAa,EAAA;IAEb,QAAA,IAAI,uBAA4B;IAChC,QAAA,IAAI;IACF,YAAA,uBAAuB,GAAG,cAAc,CACtC,QAAQ,EACR,OAAO,CAAC,cAAc,CAAC,YAAY,CAAC,CACrC;;YACD,OAAO,CAAM,EAAE;IACf,YAAA,OAAO,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC;;IAGnD,QAAA,IAAI;IACF,YAAA,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,uBAAuB,CAAC;oBAChD,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC;;YAClD,OAAO,CAAM,EAAE;IACf,YAAA,OAAO,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC;;IAGzE,QAAA,OAAO,SAAS;;;AAtCPA,gCAAoB,GAAA,UAAA,CAAA;IADhC,IAAA,SAAS,CAAC,cAAc,CAAC,YAAY,CAAC;;IAC1B,CAAA,EAAAA,4BAAoB,CAwChC;;IC9CD;;;;;;;;;IASG;AAEUC,uCAA2B,GAAjC,MAAM,2BAA4B,SAAQ,SAA6C,CAAA;QAC5F,WAAY,CAAA,OAAA,GAAkB,sBAAsB,CAAC,qBAAqB,EAAA;YACxE,KAAK,CAAC,OAAO,CAAC;;IAGhB;;;;;;;;;;IAUG;IACI,IAAA,SAAS,CACd,KAAU,EACV,OAA2C,EAC3C,QAAa,EAAA;IAEb,QAAA,IAAI,uBAA4B;IAChC,QAAA,IAAI;IACF,YAAA,uBAAuB,GAAG,cAAc,CACtC,QAAQ,EACR,OAAO,CAAC,cAAc,CAAC,qBAAqB,CAAC,CAC9C;;YACD,OAAO,CAAM,EAAE;IACf,YAAA,OAAO,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC;;IAGnD,QAAA,IAAI;IACF,YAAA,IACE,CAAC,4BAA4B,CAAC,KAAK,EAAE,uBAAuB,CAAC;IAC3D,gBAAAP,kBAAO,CAAC,KAAK,EAAE,uBAAuB,CAAC;IACzC,gBAAA,aAAa,CAAC,KAAK,EAAE,uBAAuB,CAAC;IAE7C,gBAAA,OAAO,SAAS;gBAElB,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC;;YAChD,OAAO,CAAM,EAAE;IACf,YAAA,OAAO,IAAI,CAAC,UAAU,CACpB,CAAC,CAAC,OAAO,EACT,OAAO,CAAC,cAAc,CAAC,qBAAqB,CAAC,CAC9C;;;;AA5CMO,uCAA2B,GAAA,UAAA,CAAA;IADvC,IAAA,SAAS,CAAC,cAAc,CAAC,qBAAqB,CAAC;;IACnC,CAAA,EAAAA,mCAA2B,CA+CvC;;IC/DD;;;;;;;;;IASG;AAEUC,6BAAiB,GAAvB,MAAM,iBAAkB,SAAQ,SAAmC,CAAA;QACxE,WAAY,CAAA,OAAA,GAAkB,sBAAsB,CAAC,SAAS,EAAA;YAC5D,KAAK,CAAC,OAAO,CAAC;;IAGhB;;;;;;;;;;IAUG;IACI,IAAA,SAAS,CACd,KAAU,EACV,OAAiC,EACjC,QAAa,EAAA;IAEb,QAAA,IAAI,uBAA4B;IAChC,QAAA,IAAI;IACF,YAAA,uBAAuB,GAAG,cAAc,CACtC,QAAQ,EACR,OAAO,CAAC,cAAc,CAAC,SAAS,CAAC,CAClC;;YACD,OAAO,CAAM,EAAE;IACf,YAAA,OAAO,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC;;IAGnD,QAAA,IAAI;IACF,YAAA,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,uBAAuB,CAAC;oBAC7C,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC;;YAClD,OAAO,CAAM,EAAE;IACf,YAAA,OAAO,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;;IAGtE,QAAA,OAAO,SAAS;;;AAtCPA,6BAAiB,GAAA,UAAA,CAAA;IAD7B,IAAA,SAAS,CAAC,cAAc,CAAC,SAAS,CAAC;;IACvB,CAAA,EAAAA,yBAAiB,CAwC7B;;IC9CD;;;;;;;;;IASG;AAEUC,oCAAwB,GAA9B,MAAM,wBAAyB,SAAQ,SAA0C,CAAA;QACtF,WAAY,CAAA,OAAA,GAAkB,sBAAsB,CAAC,kBAAkB,EAAA;YACrE,KAAK,CAAC,OAAO,CAAC;;IAGhB;;;;;;;;;;IAUG;IACI,IAAA,SAAS,CACd,KAAU,EACV,OAAwC,EACxC,QAAa,EAAA;IAEb,QAAA,IAAI,uBAA4B;IAChC,QAAA,IAAI;IACF,YAAA,uBAAuB,GAAG,cAAc,CACtC,QAAQ,EACR,OAAO,CAAC,cAAc,CAAC,kBAAkB,CAAC,CAC3C;;YACD,OAAO,CAAM,EAAE;IACf,YAAA,OAAO,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC;;IAGnD,QAAA,IAAI;IACF,YAAA,IACE,CAAC,4BAA4B,CAAC,KAAK,EAAE,uBAAuB,CAAC;IAC3D,gBAAAT,kBAAO,CAAC,KAAK,EAAE,uBAAuB,CAAC;IACzC,gBAAA,UAAU,CAAC,KAAK,EAAE,uBAAuB,CAAC;IAE1C,gBAAA,OAAO,SAAS;gBAElB,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,CAAC;;YAChD,OAAO,CAAM,EAAE;IACf,YAAA,OAAO,IAAI,CAAC,UAAU,CACpB,CAAC,CAAC,OAAO,EACT,OAAO,CAAC,cAAc,CAAC,kBAAkB,CAAC,CAC3C;;;;AA5CMS,oCAAwB,GAAA,UAAA,CAAA;IADpC,IAAA,SAAS,CAAC,cAAc,CAAC,kBAAkB,CAAC;;IAChC,CAAA,EAAAA,gCAAwB,CA+CpC;;IChED;;;;;;;;;IASG;AAEUC,yBAAa,GAAnB,MAAM,aAAc,SAAQ,SAA+B,CAAA;QAChE,WAAY,CAAA,OAAA,GAAkB,sBAAsB,CAAC,IAAI,EAAA;YACvD,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC;;IAGtC;;;;;;;;;;;IAWG;QACH,SAAS,CACP,KAAuB,EACvB,OAA6B,EAAA;YAE7B,IAAI,CAAC,KAAK,KAAK,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC;gBAAE;YAEpE,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK;kBACrC,OAAO,CAAC;IACV,cAAE,CAAC,OAAO,CAAC,KAAK,CAAC;IACnB,QAAA,IAAI,GAAQ,EACV,OAAO,GAAG,IAAI;IAChB,QAAA,KACE,IAAI,CAAC,GAAG,CAAC,EACT,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,EACtD,CAAC,EAAE,EACH;IACA,YAAA,GAAG,GAAI,KAAa,CAAC,CAAC,CAAC;gBACvB,QAAQ,OAAO,GAAG;IAChB,gBAAA,KAAK,QAAQ;IACb,gBAAA,KAAK,UAAU;wBACb,OAAO,GAAG,KAAK,CAAC,QAAQ,CAAE,GAAc,CAAC,WAAW,EAAE,IAAI,CAAC;wBAC3D;IACF,gBAAA;IACE,oBAAA,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAS,KAAK,OAAO,GAAG,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC;wBACnE;;;IAIN,QAAA,OAAO;IACL,cAAE;IACF,cAAE,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC;;;AA/ClDA,yBAAa,GAAA,UAAA,CAAA;IADzB,IAAA,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC;;IAClB,CAAA,EAAAA,qBAAa,CAiDzB;;IC5DD;;;;;;;;;;IAUG;AAEUC,8BAAkB,GAAxB,MAAM,kBAAmB,SAAQ,SAAoC,CAAA;QAC1E,WAAY,CAAA,OAAA,GAAkB,sBAAsB,CAAC,UAAU,EAAA;YAC7D,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC;;IAGzC;;;;;;;;;;;IAWG;QACI,SAAS,CACd,KAAqB,EACrB,OAAkC,EAAA;YAElC,IAAI,OAAO,KAAK,KAAK,WAAW;gBAAE;IAClC,QAAA,OAAO,KAAK,CAAC,MAAM,GAAG,OAAO,CAAC;IAC5B,cAAE,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,SAAS;kBAClE,SAAS;;;AAxBJA,8BAAkB,GAAA,UAAA,CAAA;IAD9B,IAAA,SAAS,CAAC,cAAc,CAAC,UAAU,CAAC;;IACxB,CAAA,EAAAA,0BAAkB,CA0B9B;;ICtCD;;;;;;;;;IASG;AAEUC,wBAAY,GAAlB,MAAM,YAAa,SAAQ,SAA8B,CAAA;QAC9D,WAAY,CAAA,OAAA,GAAkB,sBAAsB,CAAC,GAAG,EAAA;YACtD,KAAK,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC;;IAG5C;;;;;;;;;;;IAWG;QACI,SAAS,CACd,KAA6B,EAC7B,OAA4B,EAAA;YAE5B,IAAI,OAAO,KAAK,KAAK,WAAW;gBAAE;IAElC,QAAA,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO;YACrB,IAAI,KAAK,YAAY,IAAI,IAAI,EAAE,GAAG,YAAY,IAAI,CAAC,EAAE;IACnD,YAAA,GAAG,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC;gBACnB,IAAI,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;IAC7B,gBAAA,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC;;YAGhD,OAAO,KAAK,GAAG;IACb,cAAE,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,EAAE,GAAG;kBACpD,SAAS;;;AAhCJA,wBAAY,GAAA,UAAA,CAAA;IADxB,IAAA,SAAS,CAAC,cAAc,CAAC,GAAG,CAAC;;IACjB,CAAA,EAAAA,oBAAY,CAkCxB;;IC7CD;;;;;;;;;;IAUG;AAEUC,8BAAkB,GAAxB,MAAM,kBAAmB,SAAQ,SAAoC,CAAA;QAC1E,WAAY,CAAA,OAAA,GAAkB,sBAAsB,CAAC,UAAU,EAAA;YAC7D,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC;;IAGzC;;;;;;;;;;;IAWG;QACI,SAAS,CACd,KAAqB,EACrB,OAAkC,EAAA;YAElC,IAAI,OAAO,KAAK,KAAK,WAAW;gBAAE;IAClC,QAAA,OAAO,KAAK,CAAC,MAAM,GAAG,OAAO,CAAC;IAC5B,cAAE,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,SAAS;kBAClE,SAAS;;;AAxBJA,8BAAkB,GAAA,UAAA,CAAA;IAD9B,IAAA,SAAS,CAAC,cAAc,CAAC,UAAU,CAAC;;IACxB,CAAA,EAAAA,0BAAkB,CA0B9B;;ICtCD;;;;;;;;;IASG;AAEUC,wBAAY,GAAlB,MAAM,YAAa,SAAQ,SAA8B,CAAA;QAC9D,WAAY,CAAA,OAAA,GAAkB,sBAAsB,CAAC,GAAG,EAAA;YACtD,KAAK,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC;;IAG5C;;;;;;;;;;;IAWG;QACI,SAAS,CACd,KAA6B,EAC7B,OAA4B,EAAA;YAE5B,IAAI,OAAO,KAAK,KAAK,WAAW;gBAAE;IAElC,QAAA,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO;YACrB,IAAI,KAAK,YAAY,IAAI,IAAI,EAAE,GAAG,YAAY,IAAI,CAAC,EAAE;IACnD,YAAA,GAAG,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC;gBACnB,IAAI,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;IAC7B,gBAAA,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC;;YAEhD,OAAO,KAAK,GAAG;IACb,cAAE,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,EAAE,GAAG;kBACpD,SAAS;;;AA/BJA,wBAAY,GAAA,UAAA,CAAA;IADxB,IAAA,SAAS,CAAC,cAAc,CAAC,GAAG,CAAC;;IACjB,CAAA,EAAAA,oBAAY,CAiCxB;;IC5CD;;;;;;;;;IASG;AAEUC,6BAAiB,GAAvB,MAAM,iBAAkB,SAAQZ,wBAAgB,CAAA;IACrD,IAAA,WAAA,CAAY,OAAO,GAAG,sBAAsB,CAAC,QAAQ,EAAA;YACnD,KAAK,CAAC,OAAO,CAAC;;IAGhB;;;;;;;;;;;IAWG;IACI,IAAA,SAAS,CACd,KAAa,EACb,OAAA,GAAmC,EAAE,EAAA;IAErC,QAAA,OAAO,KAAK,CAAC,SAAS,CAAC,KAAK,EAAE;IAC5B,YAAA,GAAG,OAAO;IACV,YAAA,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO;IACzC,SAAA,CAAC;;;AAxBOY,6BAAiB,GAAA,UAAA,CAAA;IAD7B,IAAA,SAAS,CAAC,cAAc,CAAC,QAAQ,CAAC;;IACtB,CAAA,EAAAA,yBAAiB,CA0B7B;;ICrCD;;;;;;;;;IASG;AAEUC,6BAAiB,GAAvB,MAAM,iBAAkB,SAAQ,SAAS,CAAA;QAC9C,WAAY,CAAA,OAAA,GAAkB,sBAAsB,CAAC,QAAQ,EAAA;YAC3D,KAAK,CAAC,OAAO,CAAC;;IAGhB;;;;;;;;;;;IAWG;IACI,IAAA,SAAS,CACd,KAAU,EACV,OAAA,GAA4B,EAAE,EAAA;YAE9B,QAAQ,OAAO,KAAK;IAClB,YAAA,KAAK,SAAS;IACd,YAAA,KAAK,QAAQ;oBACX,OAAO,OAAO,KAAK,KAAK;IACtB,sBAAE,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO;0BAC/C,SAAS;IACf,YAAA;IACE,gBAAA,OAAO,CAAC;IACN,sBAAE,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO;0BAC/C,SAAS;;;;AA9BRA,6BAAiB,GAAA,UAAA,CAAA;IAD7B,IAAA,SAAS,CAAC,cAAc,CAAC,QAAQ,CAAC;;IACtB,CAAA,EAAAA,yBAAiB,CAiC7B;;IC5CD;;;;;;;;;IASG;AAEUC,yBAAa,GAAnB,MAAM,aAAc,SAAQ,SAA+B,CAAA;QAChE,WAAY,CAAA,OAAA,GAAkB,sBAAsB,CAAC,IAAI,EAAA;IACvD,QAAA,KAAK,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC;;IAGpC;;;;;;;;;;;;IAYG;QACI,SAAS,CACd,KAAsB,EACtB,OAA6B,EAAA;YAE7B,IAAI,OAAO,KAAK,KAAK,WAAW;gBAAE;IAClC,QAAA,OAAO,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK;IAC9C,cAAE,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI;kBAC7D,SAAS;;;AAzBJA,yBAAa,GAAA,UAAA,CAAA;IADzB,IAAA,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC;;IAClB,CAAA,EAAAA,qBAAa,CA2BzB;;ICnCD;;;;;;;IAOG;AAEUC,yBAAa,GAAnB,MAAM,aAAc,SAAQ,SAA+B,CAAA;QAChE,WAAY,CAAA,OAAA,GAAkB,sBAAsB,CAAC,IAAI,EAAA;YACvD,KAAK,CAAC,OAAO,CAAC;;IAGhB;;;;;;;;;;IAUG;QACI,SAAS,CACd,KAAU,EACV,OAA6B,EAAA;YAE7B,IAAI,KAAK,KAAK,SAAS;IAAE,YAAA,OAAO;IAChC,QAAA,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO;YAClC,IAAI,CAACnB,qBAAU,CAAC,mBAAmB,CAAC,KAAK,EAAE,KAAK,CAAC;IAC/C,YAAA,OAAO,IAAI,CAAC,UAAU,CACpB,OAAO,IAAI,IAAI,CAAC,OAAO,EACvB,OAAO,KAAK,KAAK;IACf,kBAAE;IACF,kBAAE,KAAK,CAAC,OAAO,CAAC,KAAK;IACnB,sBAAE,KAAK,CAAC,IAAI,CAAC,IAAI;0BACf,KAAK,CAAC,IAAI,EAChB,OAAO,KAAK,CACb;;;AA/BMmB,yBAAa,GAAA,UAAA,CAAA;IADzB,IAAA,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC;;IAClB,CAAA,EAAAA,qBAAa,CAiCzB;IAED,UAAU,CAAC,QAAQ,CAAC;IAClB,IAAA,SAAS,EAAEA,qBAAa;QACxB,aAAa,EAAExB,iBAAS,CAAC,IAAI;IAC7B,IAAA,IAAI,EAAE,KAAK;IACW,CAAA,CAAC;;IC/CzB;;;;;;;;IAQG;AAEUyB,wBAAY,GAAlB,MAAM,YAAa,SAAQhB,wBAAgB,CAAA;QAChD,WAAY,CAAA,OAAA,GAAkB,sBAAsB,CAAC,GAAG,EAAA;YACtD,KAAK,CAAC,OAAO,CAAC;;IAGhB;;;;;;;;;;;IAWG;IACI,IAAA,SAAS,CACd,KAAa,EACb,OAAA,GAAmC,EAAE,EAAA;IAErC,QAAA,OAAO,KAAK,CAAC,SAAS,CAAC,KAAK,EAAE;IAC5B,YAAA,GAAG,OAAO;IACV,YAAA,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,gBAAgB,CAAC,GAAG;IACjD,SAAA,CAAC;;;AAxBOgB,wBAAY,GAAA,UAAA,CAAA;IADxB,IAAA,SAAS,CAAC,cAAc,CAAC,GAAG,CAAC;;IACjB,CAAA,EAAAA,oBAAY,CA0BxB;;ICxBD;;;;;;;;;IASG;aACa,QAAQ,CAAC,OAAkB,GAAA,sBAAsB,CAAC,QAAQ,EAAA;QACxE,OAAO,YAAY,CACjB,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC,QAAQ,CAAC,EACvC;IACE,QAAA,OAAO,EAAE,OAAO;IACjB,KAAA,CACF;IACH;IAEA;;;;;;;;;;IAUG;IACG,SAAU,GAAG,CACjB,KAA6B,EAC7B,OAAkB,GAAA,sBAAsB,CAAC,GAAG,EAAA;QAE5C,OAAO,YAAY,CAAqB,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE;IAC1E,QAAA,CAAC,cAAc,CAAC,GAAG,GAAG,KAAK;IAC3B,QAAA,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC;IAChC,KAAA,CAAC;IACJ;IAEA;;;;;;;;;;IAUG;IACG,SAAU,GAAG,CACjB,KAA6B,EAC7B,OAAkB,GAAA,sBAAsB,CAAC,GAAG,EAAA;QAE5C,OAAO,YAAY,CAAqB,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE;IAC1E,QAAA,CAAC,cAAc,CAAC,GAAG,GAAG,KAAK;IAC3B,QAAA,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC;IAChC,KAAA,CAAC;IACJ;IAEA;;;;;;;;;;IAUG;IACG,SAAU,IAAI,CAClB,KAAa,EACb,OAAkB,GAAA,sBAAsB,CAAC,IAAI,EAAA;QAE7C,OAAO,YAAY,CAAqB,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE;IAC3E,QAAA,CAAC,cAAc,CAAC,IAAI,GAAG,KAAK;IAC5B,QAAA,OAAO,EAAE,OAAO;IAChB,QAAA,KAAK,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC;IACrB,KAAA,CAAC;IACJ;IAEA;;;;;;;;;;IAUG;IACG,SAAU,SAAS,CACvB,KAAa,EACb,OAAkB,GAAA,sBAAsB,CAAC,UAAU,EAAA;QAEnD,OAAO,YAAY,CACjB,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC,UAAU,CAAC,EACzC;IACE,QAAA,CAAC,cAAc,CAAC,UAAU,GAAG,KAAK;IAClC,QAAA,OAAO,EAAE,OAAO;IAChB,QAAA,KAAK,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC;IAC3C,KAAA,CACF;IACH;IAEA;;;;;;;;;;IAUG;IACG,SAAU,SAAS,CACvB,KAAa,EACb,OAAkB,GAAA,sBAAsB,CAAC,UAAU,EAAA;QAEnD,OAAO,YAAY,CACjB,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC,UAAU,CAAC,EACzC;IACE,QAAA,CAAC,cAAc,CAAC,UAAU,GAAG,KAAK;IAClC,QAAA,OAAO,EAAE,OAAO;IAChB,QAAA,KAAK,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC;IAC3C,KAAA,CACF;IACH;IAEA;;;;;;;;;;IAUG;IACG,SAAU,OAAO,CACrB,KAAsB,EACtB,OAAkB,GAAA,sBAAsB,CAAC,OAAO,EAAA;QAEhD,OAAO,YAAY,CACjB,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC,OAAO,CAAC,EACtC;IACE,QAAA,CAAC,cAAc,CAAC,OAAO,GACrB,OAAO,KAAK,KAAK,QAAQ,GAAG,KAAK,GAAG,KAAK,CAAC,QAAQ,EAAE;IACtD,QAAA,OAAO,EAAE,OAAO;IAChB,QAAA,KAAK,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC;IACrB,KAAA,CACF;IACH;IAEA;;;;;;;;;IASG;aACa,KAAK,CAAC,OAAkB,GAAA,sBAAsB,CAAC,KAAK,EAAA;QAClE,OAAO,YAAY,CACjB,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC,KAAK,CAAC,EACpC;IACE,QAAA,CAAC,cAAc,CAAC,OAAO,GAAG,gBAAgB,CAAC,KAAK;IAChD,QAAA,OAAO,EAAE,OAAO;IAChB,QAAA,KAAK,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC;IACrB,KAAA,CACF;IACH;IAEA;;;;;;;;;IASG;aACa,GAAG,CAAC,OAAkB,GAAA,sBAAsB,CAAC,GAAG,EAAA;QAC9D,OAAO,YAAY,CAAqB,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE;IAC1E,QAAA,CAAC,cAAc,CAAC,OAAO,GAAG,gBAAgB,CAAC,GAAG;IAC9C,QAAA,OAAO,EAAE,OAAO;IAChB,QAAA,KAAK,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC;IACrB,KAAA,CAAC;IACJ;IAEA;;;;;;;;;;IAUG;IACG,SAAU,IAAI,CAClB,KAAwB,EACxB,OAAkB,GAAA,sBAAsB,CAAC,IAAI,EAAA;QAE7C,OAAO,YAAY,CAAqB,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE;IAC3E,QAAA,WAAW,EAAE,KAAK;IAClB,QAAA,OAAO,EAAE,OAAO;IACjB,KAAA,CAAC;IACJ;IAEA;;;;;;;;;;;;;;IAcG;IACG,SAAU,IAAI,CAClB,MAAA,GAAiB,YAAY,EAC7B,OAAA,GAAkB,sBAAsB,CAAC,IAAI,EAAA;IAE7C,IAAA,OAAO,CAAC,MAA2B,EAAE,WAAiB,KAAS;YAC7D,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE;IAChD,YAAA,CAAC,cAAc,CAAC,MAAM,GAAG,MAAM;IAC/B,YAAA,OAAO,EAAE,OAAO;IAChB,YAAA,KAAK,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC;IACnB,SAAA,CAAC,CAAC,MAAM,EAAE,WAAW,CAAC;IAEvB,QAAA,MAAM,MAAM,GAAG,IAAI,OAAO,EAAE;IAE5B,QAAA,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE;IACzC,YAAA,YAAY,EAAE,KAAK;IACnB,YAAA,GAAG,CAAY,QAAuB,EAAA;oBACpC,MAAM,UAAU,GAAG,MAAM,CAAC,wBAAwB,CAAC,IAAI,EAAE,WAAW,CAAC;IACrE,gBAAA,IAAI,CAAC,UAAU,IAAI,UAAU,CAAC,YAAY;IACxC,oBAAA,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,WAAW,EAAE;IACvC,wBAAA,UAAU,EAAE,IAAI;IAChB,wBAAA,YAAY,EAAE,KAAK;4BACnB,GAAG,EAAE,MAAM,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC;IAC3B,wBAAA,GAAG,EAAE,CAAC,QAAgC,KAAI;IACxC,4BAAA,IAAI,GAAqB;IACzB,4BAAA,IAAI;IACF,gCAAA,GAAG,GAAG,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC;IACjC,gCAAA,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC;;gCACrB,OAAO,CAAM,EAAE;IACf,gCAAA,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,2BAA2B,EAAE,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC;;6BAEjE;IACF,qBAAA,CAAC;IACJ,gBAAA,IAAI,CAAC,WAAW,CAAC,GAAG,QAAQ;iBAC7B;gBACD,GAAG,GAAA;IACD,gBAAA,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC;iBACpB;IACF,SAAA,CAAC;IACJ,KAAC;IACH;IAEA;;;;;;;;;;;;IAYG;IACa,SAAA,QAAQ,CACtB,OAAA,GAAkB,gBAAgB,CAAC,QAAQ,CAAC,iBAAiB,EAC7D,OAAkB,GAAA,sBAAsB,CAAC,QAAQ,EAAA;QAEjD,OAAO,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE;IAC3D,QAAA,CAAC,cAAc,CAAC,OAAO,GAAG,OAAO;IACjC,QAAA,OAAO,EAAE,OAAO;IAChB,QAAA,KAAK,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC;IACrB,KAAA,CAAC;IACJ;IAEA;;;;;;;;;;;;;IAaG;IACG,SAAU,IAAI,CAClB,KAAsD,EACtD,UAA8B,GAAA,OAAO,EACrC,OAAA,GAAkB,sBAAsB,CAAC,IAAI,EAAA;QAE7C,OAAO,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE;IACvD,QAAA,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC;IACrE,QAAA,IAAI,EAAE,UAAU;IAChB,QAAA,OAAO,EAAE,OAAO;IACjB,KAAA,CAAC;IACJ;IAEA;;;;;;;;;;;;IAYG;IACG,SAAU,GAAG,CACjB,KAA4B,EAC5B,OAAkB,GAAA,sBAAsB,CAAC,IAAI,EAAA;QAE7C,OAAO,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC;IACpC;IAEA;;;;;;;;;;;;IAYG;IACG,SAAU,EAAE,CAChB,iBAAyB,EACzB,OAAkB,GAAA,sBAAsB,CAAC,MAAM,EAAA;IAE/C,IAAA,MAAM,OAAO,GAA2B;IACtC,QAAA,OAAO,EAAE,OAAO;IAChB,QAAA,CAAC,cAAc,CAAC,MAAM,GAAG,iBAAiB;SAC3C;IAED,IAAA,OAAO,YAAY,CACjB,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC,MAAM,CAAC,EACrC,OAA6B,CAC9B;IACH;IAEA;;;;;;;;;;;;IAYG;IACG,SAAU,IAAI,CAClB,iBAAyB,EACzB,OAAkB,GAAA,sBAAsB,CAAC,IAAI,EAAA;IAE7C,IAAA,MAAM,OAAO,GAAyB;IACpC,QAAA,OAAO,EAAE,OAAO;IAChB,QAAA,CAAC,cAAc,CAAC,IAAI,GAAG,iBAAiB;SACzC;IAED,IAAA,OAAO,YAAY,CACjB,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC,IAAI,CAAC,EACnC,OAA6B,CAC9B;IACH;IAEA;;;;;;;;;;;;IAYG;IACG,SAAU,EAAE,CAChB,iBAAyB,EACzB,OAAkB,GAAA,sBAAsB,CAAC,SAAS,EAAA;IAElD,IAAA,MAAM,OAAO,GAA6B;IACxC,QAAA,OAAO,EAAE,OAAO;IAChB,QAAA,CAAC,cAAc,CAAC,SAAS,GAAG,iBAAiB;SAC9C;IAED,IAAA,OAAO,YAAY,CACjB,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC,SAAS,CAAC,EACxC,OAA6B,CAC9B;IACH;IAEA;;;;;;;;;;;;IAYG;IACG,SAAU,GAAG,CACjB,iBAAyB,EACzB,OAAkB,GAAA,sBAAsB,CAAC,kBAAkB,EAAA;IAE3D,IAAA,MAAM,OAAO,GAAoC;IAC/C,QAAA,OAAO,EAAE,OAAO;IAChB,QAAA,CAAC,cAAc,CAAC,kBAAkB,GAAG,iBAAiB;SACvD;IAED,IAAA,OAAO,YAAY,CACjB,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC,kBAAkB,CAAC,EACjD,OAA6B,CAC9B;IACH;IAEA;;;;;;;;;;;;IAYG;IACG,SAAU,EAAE,CAChB,iBAAyB,EACzB,OAAkB,GAAA,sBAAsB,CAAC,YAAY,EAAA;IAErD,IAAA,MAAM,OAAO,GAAgC;IAC3C,QAAA,OAAO,EAAE,OAAO;IAChB,QAAA,CAAC,cAAc,CAAC,YAAY,GAAG,iBAAiB;SACjD;IAED,IAAA,OAAO,YAAY,CACjB,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC,YAAY,CAAC,EAC3C,OAA6B,CAC9B;IACH;IAEA;;;;;;;;;;;;IAYG;IACG,SAAU,GAAG,CACjB,iBAAyB,EACzB,OAAkB,GAAA,sBAAsB,CAAC,qBAAqB,EAAA;IAE9D,IAAA,MAAM,OAAO,GAAuC;IAClD,QAAA,OAAO,EAAE,OAAO;IAChB,QAAA,CAAC,cAAc,CAAC,qBAAqB,GAAG,iBAAiB;SAC1D;IAED,IAAA,OAAO,YAAY,CACjB,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC,qBAAqB,CAAC,EACpD,OAA6B,CAC9B;IACH;;ICphBA;;;;;;;;;IASG;aACa,SAAS,CACvB,WAAgB,EAChB,GAAG,IAAW,EAAA;IAEd,IAAA,MAAM,OAAO,GAAG,CAAC,GAAG,IAAW,KAAK,IAAI,WAAW,CAAC,GAAG,IAAI,CAAC;IAC5D,IAAA,OAAO,CAAC,SAAS,GAAG,WAAW,CAAC,SAAS;IACzC,IAAA,OAAO,OAAO,CAAC,GAAG,IAAI,CAAC;IACzB;IAEA;;;;;;IAMG;IACG,SAAU,yBAAyB,CAAC,GAAW,EAAA;QACnD,IAAI,SAAS,GAAQ,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC;IAC/C,IAAA,IAAI,SAAS,KAAK,MAAM,CAAC,SAAS;IAAE,QAAA,OAAO,GAAG;IAC9C,IAAA,OAAO,SAAS,KAAK,MAAM,CAAC,SAAS,EAAE;IACrC,QAAA,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC;IAC5C,QAAA,IAAI,SAAS,KAAK,MAAM,CAAC,SAAS;IAAE,YAAA,OAAO,SAAS;YACpD,IAAI,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC,KAAK,MAAM,CAAC,SAAS;IAAE,YAAA,OAAO,SAAS;;IAE7E,IAAA,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC;IACpD;IAEA;;;;;;;IAOG;IACG,SAAU,kBAAkB,CAAC,GAAY,EAAA;QAC7C,IAAI,GAAG,YAAY,KAAK;YAAE;IAE1B,IAAA,SAAS,aAAa,CAAC,aAAsB,EAAE,SAAiB,EAAA;IAC9D,QAAA,MAAM,CAAC,cAAc,CAAC,aAAa,EAAE,SAAS,CAAC;;QAGjD,MAAM,SAAS,GAAQ,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC;IACjD,IAAA,IAAI,SAAS,KAAK,MAAM,CAAC,SAAS,EAAE;YAClC,OAAO,aAAa,CAAC,GAAG,EAAE,KAAK,CAAC,SAAS,CAAC;;IAE5C,IAAA,OAAO,SAAS,KAAK,MAAM,CAAC,SAAS,EAAE;YACrC,MAAM,IAAI,GAAG,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC;IAC7C,QAAA,IACE,IAAI,KAAK,MAAM,CAAC,SAAS;gBACzB,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,MAAM,CAAC,SAAS,EAChD;gBACA,OAAO,aAAa,CAAC,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC;;;IAGpD,IAAA,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC;IAC5D;;ICxDA;;;;;;;;;;;;;;;IAeG;IACG,SAAU,KAAK,CAAC,gBAAmC,EAAA;IACvD,IAAA,QAAQ,CAAC,QAAa,KAAI;;IAExB,QAAA,MAAM,cAAc,GAAQ,UAAU,GAAG,IAAW,EAAA;gBAClD,MAAM,QAAQ,GAAgC,SAAS,CACrD,QAAQ,EACR,GAAG,IAAI,CACR;gBACD,kBAAkB,CAAC,QAAQ,CAAC;;IAE5B,YAAA,MAAM,OAAO,GAAG,KAAK,CAAC,UAAU,EAAE;IAClC,YAAA,IAAI,OAAO;IAAE,gBAAA,OAAO,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IAEjE,YAAAvB,mBAAQ,CAAC,KAAK,CAAC,GAAG,CAACF,iBAAS,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC;IAEzE,YAAA,IAAI,gBAAgB;IAAE,gBAAA,gBAAgB,CAAC,QAAQ,EAAE,GAAG,IAAI,CAAC;IAEzD,YAAA,OAAO,QAAQ;IACjB,SAAC;;IAGD,QAAA,cAAc,CAAC,SAAS,GAAG,QAAQ,CAAC,SAAS;;IAE7C,QAAA,MAAM,CAAC,cAAc,CAAC,cAAc,EAAE,MAAM,EAAE;IAC5C,YAAA,QAAQ,EAAE,KAAK;IACf,YAAA,UAAU,EAAE,IAAI;IAChB,YAAA,YAAY,EAAE,KAAK;IACnB,YAAA,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI;IAC3C,SAAA,CAAC;IAEF,QAAAE,mBAAQ,CAAC,KAAK,CAAC,GAAG,CAACF,iBAAS,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC;YAE7D,KAAK,CAAC,QAAQ,CAAC,cAAc,EAAE,QAAQ,CAAC,IAAI,CAAC;;IAG7C,QAAA,OAAO,cAAc;IACvB,KAAC;IACH;aAEgB,QAAQ,CAAC,SAAiB,EAAE,GAAG,IAAW,EAAA;QACxD,OAAOE,mBAAQ,CAAC,KAAK,CAAC,GAAG,CAACF,iBAAS,CAAC,OAAO,CAAC,EAAE;IAC5C,QAAA,SAAS,EAAE,SAAS;IACpB,QAAA,IAAI,EAAE,IAAI;IACX,KAAA,CAAC;IACJ;aAEgB,YAAY,CAAC,UAAkB,EAAE,GAAG,IAAW,EAAA;QAC7D,OAAOE,mBAAQ,CAAC,KAAK,CAAC,GAAG,CAACF,iBAAS,CAAC,aAAa,CAAC,EAAE;IAClD,QAAA,UAAU,EAAE,UAAU;IACtB,QAAA,IAAI,EAAE,IAAI;IACX,KAAA,CAAC;IACJ;;IC/EA;;IAEG;IAEH;;;;;;IAMG;IAEH;;;;IAIG;IAEH;;;;;;IAMG;IAEH;;;IAGG;IAEH;;;IAGG;IAEH;;;IAGG;IAEH;;;IAGG;AAOI,UAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","x_google_ignoreList":[14]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"decorator-validation.cjs","sources":["../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/model/ModelErrorDefinition.ts","../src/model/constants.ts","../src/constants/validation.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/utils.ts","../src/validation/Validators/DiffValidator.ts","../src/validation/Validators/PatternValidator.ts","../src/validation/Validators/EmailValidator.ts","../src/validation/Validators/EqualsValidator.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":["/**\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  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\nexport 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  NO_PARENT_COMPARISON:\n    \"Unable to access parent at level {0} for path '{1}': no parent available\",\n  PROPERTY_NOT_FOUND:\n    \"Failed to resolve path {0}: property '{1}' does not exist.\",\n  PROPERTY_NOT_FOUND_ON_PARENT:\n    \"Failed to resolve path {0}: property '{1}' does not exist on parent.\",\n  PROPERTY_NOT_FOUND_AFTER_PARENT:\n    \"Failed to resolve path {0}: property '{1}' does not exist after {2} parent level(s).\",\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};\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      [\n        ...(decorators ? decorators.values() : []),\n        ...(extras ? extras.values() : []),\n      ].forEach((d) => (d as any)(target, propertyKey, descriptor, descriptor));\n      // return apply(\n      //\n      // )(target, propertyKey, descriptor);\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. The decorator maintains a list\n * of property keys under a specified metadata key in the model. If the key doesn't exist, it creates a new array;\n * if it exists, it appends the property key to the existing array, avoiding duplicates.\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 *\n * @function prop\n * @category 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 * Combines the functionality of prop() and metadata() decorators.\n *\n * @template V - The type of the metadata value\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 *\n * @function propMetadata\n * @category 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 { 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","/**\n * Symbol used to internally track the parent object during nested validation.\n *\n * This key is attached to child objects to provide context about their parent\n * in the object hierarchy, enabling validations that depend on parent values.\n *\n * @constant VALIDATION_PARENT_KEY\n * @memberOf module:decorator-validation.Model\n */\nexport const VALIDATION_PARENT_KEY = Symbol(\"_validationParentRef\");\n","import { DEFAULT_ERROR_MESSAGES } from \"./constants\";\nimport { sf } from \"../../utils/strings\";\nimport { Reflection } from \"@decaf-ts/reflection\";\nimport { ValidatorOptions } from \"../types\";\n\n/**\n * @description Abstract base class for all validators in the validation framework\n * @summary The Validator class provides the foundation for all validator implementations.\n * It handles type checking, error message formatting, and defines the common interface\n * that all validators must implement. This class is designed to be extended by specific\n * validator implementations that provide concrete validation logic.\n *\n * @param {string} message - Default error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#DEFAULT}\n * @param {string[]} acceptedTypes - Array of type names that this validator can validate\n *\n * @class Validator\n * @abstract\n *\n * @example\n * ```typescript\n * // Example of extending the Validator class to create a custom validator\n * class CustomValidator extends Validator<CustomValidatorOptions> {\n *   constructor(message: string = \"Custom validation failed\") {\n *     // Specify that this validator accepts String and Number types\n *     super(message, String.name, Number.name);\n *   }\n *\n *   public hasErrors(value: any, options?: CustomValidatorOptions): string | undefined {\n *     // Implement custom validation logic\n *     if (someCondition) {\n *       return this.getMessage(options?.message || this.message);\n *     }\n *     return undefined; // No errors\n *   }\n * }\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant V as Validator Subclass\n *   participant B as Base Validator\n *\n *   C->>V: new CustomValidator(message)\n *   V->>B: super(message, acceptedTypes)\n *   B->>B: Store message and types\n *   B->>B: Wrap hasErrors with type checking\n *   C->>V: hasErrors(value, options)\n *   alt value type not in acceptedTypes\n *     B-->>C: Type error message\n *   else value type is accepted\n *     V->>V: Custom validation logic\n *     V-->>C: Validation result\n *   end\n *\n * @category Validators\n */\nexport abstract class Validator<V extends ValidatorOptions = ValidatorOptions> {\n  readonly message: string;\n  readonly acceptedTypes?: string[];\n\n  protected constructor(\n    message: string = DEFAULT_ERROR_MESSAGES.DEFAULT,\n    ...acceptedTypes: string[]\n  ) {\n    this.message = message;\n\n    if (acceptedTypes.length) this.acceptedTypes = acceptedTypes;\n    if (this.acceptedTypes)\n      this.hasErrors = this.checkTypeAndHasErrors(this.hasErrors.bind(this));\n  }\n\n  /**\n   * @description Formats an error message with optional arguments\n   * @summary Creates a formatted error message by replacing placeholders with provided arguments.\n   * This method uses the string formatting utility to generate consistent error messages\n   * across all validators.\n   *\n   * @param {string} message - The message template with placeholders\n   * @param {...any} args - Values to insert into the message template\n   * @return {string} The formatted error message\n   * @protected\n   */\n  protected getMessage(message: string, ...args: any[]) {\n    return sf(message, ...args);\n  }\n\n  /**\n   * @description Creates a type-checking wrapper around the hasErrors method\n   * @summary Wraps the hasErrors method with type validation logic to ensure that\n   * the value being validated is of an accepted type before performing specific validation.\n   * This method is called during construction if acceptedTypes are provided.\n   *\n   * @param {Function} unbound - The original hasErrors method to be wrapped\n   * @return {Function} A new function that performs type checking before calling the original method\n   * @private\n   */\n  private checkTypeAndHasErrors(\n    unbound: (value: any, ...args: any[]) => string | undefined\n  ) {\n    return function (\n      this: Validator,\n      value: any,\n      ...args: any[]\n    ): string | undefined {\n      if (value === undefined || !this.acceptedTypes)\n        return unbound(value, ...args);\n      if (!Reflection.checkTypes(value, this.acceptedTypes))\n        return this.getMessage(\n          DEFAULT_ERROR_MESSAGES.TYPE,\n          this.acceptedTypes.join(\", \"),\n          typeof value\n        );\n      return unbound(value, ...args);\n    }.bind(this);\n  }\n\n  /**\n   * @description Validates a value against specific validation rules\n   * @summary Abstract method that must be implemented by all validator subclasses.\n   * This method contains the core validation logic that determines whether a value\n   * is valid according to the specific rules of the validator. If the value is valid,\n   * the method returns undefined; otherwise, it returns an error message.\n   *\n   * @template V - Type of the options object that can be passed to the validator\n   * @param {any} value - The value to validate\n   * @param {V} [options] - Optional configuration options for customizing validation behavior\n   *\n   * @return {string | undefined} Error message if validation fails, undefined if validation passes\n   *\n   * @abstract\n   *\n   * @see Model#validate\n   */\n  public abstract hasErrors(\n    value: any,\n    options?: V,\n    instanceObj?: 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 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","import { ModelErrorDefinition } from \"./ModelErrorDefinition\";\nimport { DecoratorMetadata, Reflection } 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\";\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        Reflection.getPropertyDecorators(\n          ValidationKeys.REFLECT,\n          obj,\n          prop\n        ) as ValidationPropertyDecoratorDefinition\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        obj // TODO: Assert type and deep Object.freeze\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   * @summary Validates the object according to its decorated properties\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   */\n  public hasErrors(...exceptions: any[]): ModelErrorDefinition | undefined {\n    return validate(this, ...exceptions);\n  }\n\n  /**\n   * @summary Compare object equality recursively\n   * @param {any} obj object to compare to\n   * @param {string} [exceptions] property names to be excluded from the comparison\n   */\n  public equals(obj: any, ...exceptions: string[]): boolean {\n    return isEqual(this, obj, ...exceptions);\n  }\n\n  /**\n   * @summary Returns the serialized model according to the currently defined {@link Serializer}\n   */\n  serialize(): string {\n    return Model.serialize(this);\n  }\n\n  /**\n   * @summary Override the implementation for js's 'toString()' which sucks...\n   * @override\n   */\n  public toString(): string {\n    return this.constructor.name + \": \" + JSON.stringify(this, undefined, 2);\n  }\n\n  /**\n   * @summary Defines a default implementation for object hash. Relies on a very basic implementation based on Java's string hash;\n   */\n  public hash(): string {\n    return Model.hash(this);\n  }\n\n  /**\n   * @summary Deserializes a Model\n   * @param {string} str\n   *\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   * @summary Repopulates the Object properties with the ones from the new object\n   * @description Iterates all common properties of obj (if existing) and self, and copies them onto self\n   *\n   * @param {T} self\n   * @param {T | Record<string, any>} [obj]\n   *\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   * @summary Repopulates the instance with the ones from the new Model Object\n   * @description Iterates all common properties of obj (if existing) and self, and copies them onto self.\n   * Is aware of nested Model Objects and rebuilds them also.\n   * When List properties are decorated with {@link list}, they list items will also be rebuilt\n   *\n   * @param {T} self\n   * @param {T | Record<string, any>} [obj]\n   *\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 ((self as Record<string, any>)[prop])\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   * @summary Sets the Global {@link ModelBuilderFunction}\n   * @param {ModelBuilderFunction} [builder]\n   */\n  static setBuilder(builder?: ModelBuilderFunction) {\n    modelBuilderFunction = builder;\n  }\n\n  /**\n   * @summary Retrieves the current global {@link ModelBuilderFunction}\n   */\n  static getBuilder(): ModelBuilderFunction | undefined {\n    return modelBuilderFunction;\n  }\n\n  /**\n   * Returns the current {@link ModelRegistryManager}\n   *\n   * @return ModelRegistry, defaults to {@link ModelRegistryManager}\n   */\n  private static getRegistry() {\n    if (!actingModelRegistry) actingModelRegistry = new ModelRegistryManager();\n    return actingModelRegistry;\n  }\n\n  /**\n   * Returns the current actingModelRegistry\n   *\n   * @param {BuilderRegistry} modelRegistry the new implementation of Registry\n   */\n  static setRegistry(modelRegistry: BuilderRegistry<any>) {\n    actingModelRegistry = modelRegistry;\n  }\n\n  /**\n   * @summary register new Models\n   * @param {any} constructor\n   * @param {string} [name] when not defined, the name of the constructor will be used\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   * @summary Gets a registered Model {@link ModelConstructor}\n   * @param {string} name\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   * @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   * @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  static getMetadata<M extends Model>(model: M) {\n    return getMetadata<M>(model);\n  }\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  static equals<M extends Model>(obj1: M, obj2: M, ...exceptions: any[]) {\n    return isEqual(obj1, obj2, ...exceptions);\n  }\n\n  static hasErrors<M extends Model>(model: M, ...propsToIgnore: string[]) {\n    return validate(model, ...propsToIgnore);\n  }\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  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   * @summary Builds the key to store as Metadata under Reflections\n   * @description concatenates {@link ModelKeys#REFLECT} with the provided key\n   * @param {string} str\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. This function is used for model serialization\n   * and deserialization to properly handle nested models.\n   * @template M extends {@link Model}\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","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 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 { VALIDATION_PARENT_KEY } from \"../../constants\";\nimport { sf } from \"../../utils/strings\";\nimport { COMPARISON_ERROR_MESSAGES } from \"./constants\";\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 */\nexport 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 */\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 */\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 */\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 { DiffValidatorOptions } from \"../types\";\nimport { isEqual } from \"@decaf-ts/reflection\";\nimport { getValueByPath } 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 {ComparisonValidatorOptions} options\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: DiffValidatorOptions,\n    instance: any\n  ): string | undefined {\n    let comparisonPropertyValue: any;\n    try {\n      comparisonPropertyValue = getValueByPath(\n        instance,\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      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 { getValueByPath } 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 {ComparisonValidatorOptions} options\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: EqualsValidatorOptions,\n    instance: any\n  ): string | undefined {\n    let comparisonPropertyValue: any;\n    try {\n      comparisonPropertyValue = getValueByPath(\n        instance,\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 { Validator } from \"./Validator\";\nimport { DEFAULT_ERROR_MESSAGES, ValidationKeys } from \"./constants\";\nimport { validator } from \"./decorators\";\nimport { GreaterThanValidatorOptions } from \"../types\";\nimport { getValueByPath, isGreaterThan } from \"./utils\";\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 {ComparisonValidatorOptions} options\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: GreaterThanValidatorOptions,\n    instance: any\n  ): string | undefined {\n    let comparisonPropertyValue: any;\n    try {\n      comparisonPropertyValue = getValueByPath(\n        instance,\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 {\n  getValueByPath,\n  isGreaterThan,\n  isValidForGteOrLteComparison,\n} from \"./utils\";\nimport { isEqual } from \"@decaf-ts/reflection\";\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 {ComparisonValidatorOptions} options\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: GreaterThanOrEqualValidatorOptions,\n    instance: any\n  ): string | undefined {\n    let comparisonPropertyValue: any;\n    try {\n      comparisonPropertyValue = getValueByPath(\n        instance,\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 { getValueByPath, isLessThan } from \"./utils\";\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 {ComparisonValidatorOptions} options\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: LessThanValidatorOptions,\n    instance: any\n  ): string | undefined {\n    let comparisonPropertyValue: any;\n    try {\n      comparisonPropertyValue = getValueByPath(\n        instance,\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 {\n  getValueByPath,\n  isLessThan,\n  isValidForGteOrLteComparison,\n} from \"./utils\";\nimport { isEqual } from \"@decaf-ts/reflection\";\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 {ComparisonValidatorOptions} options\n   *\n   * @return {string | undefined}\n   *\n   * @override\n   * @see Validator#hasErrors\n   */\n  public hasErrors(\n    value: any,\n    options: LessThanOrEqualValidatorOptions,\n    instance: any\n  ): string | undefined {\n    let comparisonPropertyValue: any;\n    try {\n      comparisonPropertyValue = getValueByPath(\n        instance,\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 { DEFAULT_ERROR_MESSAGES, ValidationKeys } 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    });\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      pattern: options.pattern || DEFAULT_PATTERNS.URL,\n    });\n  }\n}\n","import \"reflect-metadata\";\nimport {\n  DiffValidatorOptions,\n  EqualsValidatorOptions,\n  GreaterThanOrEqualValidatorOptions,\n  GreaterThanValidatorOptions,\n  LessThanOrEqualValidatorOptions,\n  LessThanValidatorOptions,\n  ValidationMetadata,\n} from \"./types\";\nimport {\n  DEFAULT_ERROR_MESSAGES,\n  DEFAULT_PATTERNS,\n  ValidationKeys,\n} from \"./Validators/constants\";\nimport { sf } from \"../utils/strings\";\nimport { ModelConstructor } from \"../model/types\";\nimport { parseDate } from \"../utils/dates\";\nimport { propMetadata } from \"../utils/decorators\";\nimport { Validation } from \"./Validation\";\nimport { Decoration } from \"../utils/Decoration\";\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 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  return Decoration.for(key)\n    .define(\n      propMetadata<ValidationMetadata>(key, {\n        message: message,\n      })\n    )\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 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  return Decoration.for(key)\n    .define(\n      propMetadata<ValidationMetadata>(key, {\n        [ValidationKeys.MIN]: value,\n        message: message,\n        types: [Number.name, Date.name],\n      })\n    )\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 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  return Decoration.for(key)\n    .define(\n      propMetadata<ValidationMetadata>(key, {\n        [ValidationKeys.MAX]: value,\n        message: message,\n        types: [Number.name, Date.name],\n      })\n    )\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 Decorators\n */\nexport function step(\n  value: number,\n  message: string = DEFAULT_ERROR_MESSAGES.STEP\n) {\n  const key = Validation.key(ValidationKeys.STEP);\n  return Decoration.for(key)\n    .define(\n      propMetadata<ValidationMetadata>(key, {\n        [ValidationKeys.STEP]: value,\n        message: message,\n        types: [Number.name],\n      })\n    )\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 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  return Decoration.for(key)\n    .define(\n      propMetadata<ValidationMetadata>(key, {\n        [ValidationKeys.MIN_LENGTH]: value,\n        message: message,\n        types: [String.name, Array.name, Set.name],\n      })\n    )\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 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  return Decoration.for(key)\n    .define(\n      propMetadata<ValidationMetadata>(key, {\n        [ValidationKeys.MAX_LENGTH]: value,\n        message: message,\n        types: [String.name, Array.name, Set.name],\n      })\n    )\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 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  return Decoration.for(key)\n    .define(\n      propMetadata<ValidationMetadata>(key, {\n        [ValidationKeys.PATTERN]:\n          typeof value === \"string\" ? value : value.toString(),\n        message: message,\n        types: [String.name],\n      })\n    )\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 Decorators\n */\nexport function email(message: string = DEFAULT_ERROR_MESSAGES.EMAIL) {\n  const key = Validation.key(ValidationKeys.EMAIL);\n  return Decoration.for(key)\n    .define(\n      propMetadata<ValidationMetadata>(key, {\n        [ValidationKeys.PATTERN]: DEFAULT_PATTERNS.EMAIL,\n        message: message,\n        types: [String.name],\n      })\n    )\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 Decorators\n */\nexport function url(message: string = DEFAULT_ERROR_MESSAGES.URL) {\n  const key = Validation.key(ValidationKeys.URL);\n  return Decoration.for(key)\n    .define(\n      propMetadata<ValidationMetadata>(key, {\n        [ValidationKeys.PATTERN]: DEFAULT_PATTERNS.URL,\n        message: message,\n        types: [String.name],\n      })\n    )\n    .apply();\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 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  return Decoration.for(key)\n    .define(\n      propMetadata<ValidationMetadata>(key, {\n        customTypes: types,\n        message: message,\n      })\n    )\n    .apply();\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 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 dateDec = (target: Record<string, any>, propertyKey?: any): any => {\n    propMetadata(key, {\n      [ValidationKeys.FORMAT]: format,\n      message: message,\n      types: [Date.name],\n    })(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 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  return Decoration.for(key)\n    .define(\n      propMetadata(key, {\n        [ValidationKeys.PATTERN]: pattern,\n        message: message,\n        types: [String.name],\n      })\n    )\n    .apply();\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 Decorators\n */\nexport function list(\n  clazz: ModelConstructor<any> | ModelConstructor<any>[],\n  collection: \"Array\" | \"Set\" = \"Array\",\n  message: string = DEFAULT_ERROR_MESSAGES.LIST\n) {\n  const key = Validation.key(ValidationKeys.LIST);\n  return Decoration.for(key)\n    .define(\n      propMetadata(key, {\n        clazz: Array.isArray(clazz) ? clazz.map((c) => c.name) : [clazz.name],\n        type: collection,\n        message: message,\n      })\n    )\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 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 * @memberOf module:decorator-validation.Decorators.Validation\n * @category 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  };\n\n  return propMetadata<ValidationMetadata>(\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 * @memberOf module:decorator-validation.Decorators.Validation\n * @category 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  };\n\n  return propMetadata<ValidationMetadata>(\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 * @memberOf module:decorator-validation.Decorators.Validation\n * @category 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  };\n\n  return propMetadata<ValidationMetadata>(\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 * @memberOf module:decorator-validation.Decorators.Validation\n * @category 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  };\n\n  return propMetadata<ValidationMetadata>(\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 * @memberOf module:decorator-validation.Decorators.Validation\n * @category 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  };\n\n  return propMetadata<ValidationMetadata>(\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 * @memberOf module:decorator-validation.Decorators.Validation\n * @category 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  };\n\n  return propMetadata<ValidationMetadata>(\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 * @param {Function} constructor\n * @param {any[]} [args]\n * @return {T} the new instance\n *\n * @function construct\n * @memberOf module:decorator-validation\n */\nexport function construct<T extends Model>(\n  constructor: any,\n  ...args: any[]\n): T {\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 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\nexport function hashedBy(algorithm: string, ...args: any[]) {\n  return metadata(Model.key(ModelKeys.HASHING), {\n    algorithm: algorithm,\n    args: args,\n  });\n}\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 * @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 \"./utils\";\nexport * from \"./validation\";\nexport * from \"./model\";\n\nexport const VERSION = \"##VERSION##\";\n"],"names":["ModelKeys","apply","metadata","Primitives","ReservedModels","Reflection","isEqual","DateValidator","__decorate","DiffValidator","PatternValidator","EmailValidator","EqualsValidator","GreaterThanValidator","GreaterThanOrEqualValidator","LessThanValidator","LessThanOrEqualValidator","ListValidator","MaxLengthValidator","MaxValidator","MinLengthValidator","MinValidator","PasswordValidator","RequiredValidator","StepValidator","TypeValidator","URLValidator"],"mappings":"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"}