@decaf-ts/decorator-validation 1.6.0 → 1.6.2

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

@@ -1,2 +1,43 @@
+/**
+ * @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
+ */
 export declare function prop(key?: string): (model: object, propertyKey?: any) => void;
+/**
+ * @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
+ */
 export declare function propMetadata<V>(key: string, value: V): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;

package/lib/esm/utils/decorators.js

@@ -1,5 +1,33 @@
 import { apply, metadata } from "@decaf-ts/reflection";
 import { ModelKeys } from "./constants";
+/**
+ * @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
+ */
 export function prop(key = ModelKeys.ATTRIBUTE) {
     return (model, propertyKey) => {
         let props;
@@ -13,7 +41,20 @@ export function prop(key = ModelKeys.ATTRIBUTE) {
             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
+ */
 export function propMetadata(key, value) {
     return apply(prop(), metadata(key, value));
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVjb3JhdG9ycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy91dGlscy9kZWNvcmF0b3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLEVBQUUsUUFBUSxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDdkQsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUV4QyxNQUFNLFVBQVUsSUFBSSxDQUFDLE1BQWMsU0FBUyxDQUFDLFNBQVM7SUFDcEQsT0FBTyxDQUFDLEtBQWEsRUFBRSxXQUFpQixFQUFRLEVBQUU7UUFDaEQsSUFBSSxLQUFlLENBQUM7UUFDcEIsSUFBSSxNQUFNLENBQUMsU0FBUyxDQUFDLGNBQWMsQ0FBQyxJQUFJLENBQUMsS0FBSyxFQUFFLEdBQUcsQ0FBQyxFQUFFLENBQUM7WUFDckQsS0FBSyxHQUFJLEtBQWEsQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUM5QixDQUFDO2FBQU0sQ0FBQztZQUNOLEtBQUssR0FBSSxLQUFhLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxDQUFDO1FBQ25DLENBQUM7UUFDRCxJQUFJLENBQUMsS0FBSyxDQUFDLFFBQVEsQ0FBQyxXQUFxQixDQUFDO1lBQ3hDLEtBQUssQ0FBQyxJQUFJLENBQUMsV0FBcUIsQ0FBQyxDQUFDO0lBQ3RDLENBQUMsQ0FBQztBQUNKLENBQUM7QUFFRCxNQUFNLFVBQVUsWUFBWSxDQUFJLEdBQVcsRUFBRSxLQUFRO0lBQ25ELE9BQU8sS0FBSyxDQUFDLElBQUksRUFBRSxFQUFFLFFBQVEsQ0FBSSxHQUFHLEVBQUUsS0FBSyxDQUFDLENBQUMsQ0FBQztBQUNoRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgYXBwbHksIG1ldGFkYXRhIH0gZnJvbSBcIkBkZWNhZi10cy9yZWZsZWN0aW9uXCI7XG5pbXBvcnQgeyBNb2RlbEtleXMgfSBmcm9tIFwiLi9jb25zdGFudHNcIjtcblxuZXhwb3J0IGZ1bmN0aW9uIHByb3Aoa2V5OiBzdHJpbmcgPSBNb2RlbEtleXMuQVRUUklCVVRFKSB7XG4gIHJldHVybiAobW9kZWw6IG9iamVjdCwgcHJvcGVydHlLZXk/OiBhbnkpOiB2b2lkID0+IHtcbiAgICBsZXQgcHJvcHM6IHN0cmluZ1tdO1xuICAgIGlmIChPYmplY3QucHJvdG90eXBlLmhhc093blByb3BlcnR5LmNhbGwobW9kZWwsIGtleSkpIHtcbiAgICAgIHByb3BzID0gKG1vZGVsIGFzIGFueSlba2V5XTtcbiAgICB9IGVsc2Uge1xuICAgICAgcHJvcHMgPSAobW9kZWwgYXMgYW55KVtrZXldID0gW107XG4gICAgfVxuICAgIGlmICghcHJvcHMuaW5jbHVkZXMocHJvcGVydHlLZXkgYXMgc3RyaW5nKSlcbiAgICAgIHByb3BzLnB1c2gocHJvcGVydHlLZXkgYXMgc3RyaW5nKTtcbiAgfTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIHByb3BNZXRhZGF0YTxWPihrZXk6IHN0cmluZywgdmFsdWU6IFYpIHtcbiAgcmV0dXJuIGFwcGx5KHByb3AoKSwgbWV0YWRhdGE8Vj4oa2V5LCB2YWx1ZSkpO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVjb3JhdG9ycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy91dGlscy9kZWNvcmF0b3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLEVBQUUsUUFBUSxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDdkQsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUV4Qzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBMkJHO0FBQ0gsTUFBTSxVQUFVLElBQUksQ0FBQyxNQUFjLFNBQVMsQ0FBQyxTQUFTO0lBQ3BELE9BQU8sQ0FBQyxLQUFhLEVBQUUsV0FBaUIsRUFBUSxFQUFFO1FBQ2hELElBQUksS0FBZSxDQUFDO1FBQ3BCLElBQUksTUFBTSxDQUFDLFNBQVMsQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLEtBQUssRUFBRSxHQUFHLENBQUMsRUFBRSxDQUFDO1lBQ3JELEtBQUssR0FBSSxLQUFhLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDOUIsQ0FBQzthQUFNLENBQUM7WUFDTixLQUFLLEdBQUksS0FBYSxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsQ0FBQztRQUNuQyxDQUFDO1FBQ0QsSUFBSSxDQUFDLEtBQUssQ0FBQyxRQUFRLENBQUMsV0FBcUIsQ0FBQztZQUN4QyxLQUFLLENBQUMsSUFBSSxDQUFDLFdBQXFCLENBQUMsQ0FBQztJQUN0QyxDQUFDLENBQUM7QUFDSixDQUFDO0FBRUQ7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gsTUFBTSxVQUFVLFlBQVksQ0FBSSxHQUFXLEVBQUUsS0FBUTtJQUNuRCxPQUFPLEtBQUssQ0FBQyxJQUFJLEVBQUUsRUFBRSxRQUFRLENBQUksR0FBRyxFQUFFLEtBQUssQ0FBQyxDQUFDLENBQUM7QUFDaEQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGFwcGx5LCBtZXRhZGF0YSB9IGZyb20gXCJAZGVjYWYtdHMvcmVmbGVjdGlvblwiO1xuaW1wb3J0IHsgTW9kZWxLZXlzIH0gZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIFByb3BlcnR5IGRlY29yYXRvciBmYWN0b3J5IGZvciBtb2RlbCBhdHRyaWJ1dGVzXG4gKiBAc3VtbWFyeSBDcmVhdGVzIGEgZGVjb3JhdG9yIHRoYXQgbWFya3MgY2xhc3MgcHJvcGVydGllcyBhcyBtb2RlbCBhdHRyaWJ1dGVzLiBUaGUgZGVjb3JhdG9yIG1haW50YWlucyBhIGxpc3RcbiAqIG9mIHByb3BlcnR5IGtleXMgdW5kZXIgYSBzcGVjaWZpZWQgbWV0YWRhdGEga2V5IGluIHRoZSBtb2RlbC4gSWYgdGhlIGtleSBkb2Vzbid0IGV4aXN0LCBpdCBjcmVhdGVzIGEgbmV3IGFycmF5O1xuICogaWYgaXQgZXhpc3RzLCBpdCBhcHBlbmRzIHRoZSBwcm9wZXJ0eSBrZXkgdG8gdGhlIGV4aXN0aW5nIGFycmF5LCBhdm9pZGluZyBkdXBsaWNhdGVzLlxuICpcbiAqIEBwYXJhbSB7c3RyaW5nfSBba2V5PU1vZGVsS2V5cy5BVFRSSUJVVEVdIC0gVGhlIG1ldGFkYXRhIGtleSB1bmRlciB3aGljaCB0byBzdG9yZSB0aGUgcHJvcGVydHkgbmFtZVxuICogQHJldHVybiB7ZnVuY3Rpb24ob2JqZWN0LCBhbnk/KTogdm9pZH0gRGVjb3JhdG9yIGZ1bmN0aW9uIHRoYXQgcmVnaXN0ZXJzIHRoZSBwcm9wZXJ0eVxuICpcbiAqIEBmdW5jdGlvbiBwcm9wXG4gKiBAY2F0ZWdvcnkgRGVjb3JhdG9yc1xuICpcbiAqIEBtZXJtYWlkXG4gKiBzZXF1ZW5jZURpYWdyYW1cbiAqICAgIHBhcnRpY2lwYW50IEQgYXMgRGVjb3JhdG9yXG4gKiAgICBwYXJ0aWNpcGFudCBNIGFzIE1vZGVsXG4gKlxuICogICAgRC0+Pk06IENoZWNrIGlmIGtleSBleGlzdHNcbiAqICAgIGFsdCBrZXkgZXhpc3RzXG4gKiAgICAgICAgTS0tPj5EOiBSZXR1cm4gZXhpc3RpbmcgcHJvcHMgYXJyYXlcbiAqICAgIGVsc2Uga2V5IGRvZXNuJ3QgZXhpc3RcbiAqICAgICAgICBELT4+TTogQ3JlYXRlIG5ldyBwcm9wcyBhcnJheVxuICogICAgZW5kXG4gKiAgICBELT4+TTogQ2hlY2sgaWYgcHJvcGVydHkgZXhpc3RzXG4gKiAgICBhbHQgcHJvcGVydHkgbm90IGluIGFycmF5XG4gKiAgICAgICAgRC0+Pk06IEFkZCBwcm9wZXJ0eSB0byBhcnJheVxuICogICAgZW5kXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBwcm9wKGtleTogc3RyaW5nID0gTW9kZWxLZXlzLkFUVFJJQlVURSkge1xuICByZXR1cm4gKG1vZGVsOiBvYmplY3QsIHByb3BlcnR5S2V5PzogYW55KTogdm9pZCA9PiB7XG4gICAgbGV0IHByb3BzOiBzdHJpbmdbXTtcbiAgICBpZiAoT2JqZWN0LnByb3RvdHlwZS5oYXNPd25Qcm9wZXJ0eS5jYWxsKG1vZGVsLCBrZXkpKSB7XG4gICAgICBwcm9wcyA9IChtb2RlbCBhcyBhbnkpW2tleV07XG4gICAgfSBlbHNlIHtcbiAgICAgIHByb3BzID0gKG1vZGVsIGFzIGFueSlba2V5XSA9IFtdO1xuICAgIH1cbiAgICBpZiAoIXByb3BzLmluY2x1ZGVzKHByb3BlcnR5S2V5IGFzIHN0cmluZykpXG4gICAgICBwcm9wcy5wdXNoKHByb3BlcnR5S2V5IGFzIHN0cmluZyk7XG4gIH07XG59XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIENvbWJpbmVkIHByb3BlcnR5IGRlY29yYXRvciBmYWN0b3J5IGZvciBtZXRhZGF0YSBhbmQgYXR0cmlidXRlIG1hcmtpbmdcbiAqIEBzdW1tYXJ5IENyZWF0ZXMgYSBkZWNvcmF0b3IgdGhhdCBib3RoIG1hcmtzIGEgcHJvcGVydHkgYXMgYSBtb2RlbCBhdHRyaWJ1dGUgYW5kIGFzc2lnbnMgbWV0YWRhdGEgdG8gaXQuXG4gKiBDb21iaW5lcyB0aGUgZnVuY3Rpb25hbGl0eSBvZiBwcm9wKCkgYW5kIG1ldGFkYXRhKCkgZGVjb3JhdG9ycy5cbiAqXG4gKiBAdGVtcGxhdGUgViAtIFRoZSB0eXBlIG9mIHRoZSBtZXRhZGF0YSB2YWx1ZVxuICogQHBhcmFtIHtzdHJpbmd9IGtleSAtIFRoZSBtZXRhZGF0YSBrZXlcbiAqIEBwYXJhbSB7Vn0gdmFsdWUgLSBUaGUgbWV0YWRhdGEgdmFsdWUgdG8gYXNzb2NpYXRlIHdpdGggdGhlIHByb3BlcnR5XG4gKiBAcmV0dXJuIHtGdW5jdGlvbn0gQ29tYmluZWQgZGVjb3JhdG9yIGZ1bmN0aW9uXG4gKlxuICogQGZ1bmN0aW9uIHByb3BNZXRhZGF0YVxuICogQGNhdGVnb3J5IERlY29yYXRvcnNcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHByb3BNZXRhZGF0YTxWPihrZXk6IHN0cmluZywgdmFsdWU6IFYpIHtcbiAgcmV0dXJuIGFwcGx5KHByb3AoKSwgbWV0YWRhdGE8Vj4oa2V5LCB2YWx1ZSkpO1xufVxuIl19

package/lib/esm/utils/hashing.d.ts

@@ -5,14 +5,14 @@
  * @return {number} hash value of obj
  *
  * @function hashCode
- * @memberOf module:decorator-validation.Utils.Hashing
- * @category Hashing
+ * @memberOf module:decorator-validation
+ * @category Model
  */
 export declare function hashCode(obj: string | number | symbol | Date): string;
 /**
  * @summary Defines teh type for a Hashing function
- * @memberOf module:decorator-validation.Utils.Hashing
- * @category Hashing
+ * @memberOf module:decorator-validation
+ * @category Model
  */
 export type HashingFunction = (value: any, ...args: any[]) => string;
 /**
@@ -22,16 +22,60 @@ export type HashingFunction = (value: any, ...args: any[]) => string;
  * @return {string} the resulting hash
  *
  * @function hashObj
- * @memberOf module:decorator-validation.Utils.Hashing
- * @category Hashing
+ * @memberOf module:decorator-validation
+ * @category Model
  */
 export declare function hashObj(obj: Record<string, any> | any[]): string;
 export declare 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');
+ * ```
+ */
 export declare class Hashing {
+    /**
+     * @description Current default hashing method identifier
+     * @private
+     */
     private static current;
+    /**
+     * @description Cache of registered hashing functions
+     * @private
+     */
     private static cache;
     private 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
+     */
     private static get;
+    /**
+     * @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: string, func: HashingFunction, setDefault?: boolean): void;
     static hash(obj: any, method?: string, ...args: any[]): any;
     static setDefault(method: string): void;

package/lib/esm/utils/hashing.js

@@ -5,8 +5,8 @@
  * @return {number} hash value of obj
  *
  * @function hashCode
- * @memberOf module:decorator-validation.Utils.Hashing
- * @category Hashing
+ * @memberOf module:decorator-validation
+ * @category Model
  */
 export function hashCode(obj) {
     obj = String(obj);
@@ -25,8 +25,8 @@ export function hashCode(obj) {
  * @return {string} the resulting hash
  *
  * @function hashObj
- * @memberOf module:decorator-validation.Utils.Hashing
- * @category Hashing
+ * @memberOf module:decorator-validation
+ * @category Model
  */
 export function hashObj(obj) {
     const hashReducer = function (h, el) {
@@ -53,17 +53,61 @@ export function hashObj(obj) {
     return (typeof result === "number" ? Math.abs(result) : result).toString();
 }
 export 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');
+ * ```
+ */
 export 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`);
@@ -80,4 +124,4 @@ export class Hashing {
         this.current = this.get(method);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hashing.js","sourceRoot":"","sources":["../../../src/utils/hashing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,UAAU,QAAQ,CAAC,GAAoC;IAC3D,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IAClB,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACpC,MAAM,SAAS,GAAG,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QACpC,IAAI,GAAG,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC;QACtC,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC,CAAC,2BAA2B;IACjD,CAAC;IACD,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;AACzB,CAAC;AASD;;;;;;;;;GASG;AACH,MAAM,UAAU,OAAO,CAAC,GAAgC;IACtD,MAAM,WAAW,GAAG,UAAU,CAAkB,EAAE,EAAO;QACvD,MAAM,MAAM,GAAG,YAAY,CAAC,EAAE,CAAC,CAAC;QAEhC,IAAI,OAAO,MAAM,KAAK,QAAQ;YAC5B,OAAO,YAAY,CAAC,CAAE,CAAY,IAAI,EAAE,CAAC,GAAG,YAAY,CAAC,EAAE,CAAC,CAAC,CAAC;QAEhE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACX,CAAC,GAAG,CAAE,CAAY,IAAI,CAAC,CAAC,GAAI,CAAY,GAAG,MAAM,CAAC;QAClD,OAAO,CAAC,GAAG,CAAC,CAAC;IACf,CAAC,CAAC;IAEF,MAAM,IAAI,GAAoB,QAAQ,CAAC;IAEvC,MAAM,YAAY,GAAG,UAAU,KAAU;QACvC,IAAI,OAAO,KAAK,KAAK,WAAW;YAAE,OAAO,EAAE,CAAC;QAC5C,IAAI,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,OAAO,CAAC,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC;YAC7D,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;QAChC,IAAI,KAAK,YAAY,IAAI;YAAE,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;QACxD,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC,MAAM,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;QACtE,OAAQ,MAAM,CAAC,MAAM,CAAC,KAAK,CAAyB,CAAC,MAAM,CACzD,WAAW,EACX,SAAuC,CACxC,CAAC;IACJ,CAAC,CAAC;IAEF,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;IAEzD,OAAO,CAAC,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,CAAC;AAC7E,CAAC;AAED,MAAM,CAAC,MAAM,oBAAoB,GAAG,SAAS,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,OAAO,OAAO;IAClB;;;OAGG;aACY,YAAO,GAAW,oBAAoB,CAAC;IAEtD;;;OAGG;aACY,UAAK,GAAoC;QACtD,OAAO,EAAE,OAAO;KACjB,CAAC;IAEF,gBAAuB,CAAC;IAExB;;;;;;;OAOG;IACK,MAAM,CAAC,GAAG,CAAC,GAAW;QAC5B,IAAI,GAAG,IAAI,IAAI,CAAC,KAAK;YAAE,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC9C,MAAM,IAAI,KAAK,CAAC,sCAAsC,GAAG,EAAE,CAAC,CAAC;IAC/D,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,QAAQ,CACb,GAAW,EACX,IAAqB,EACrB,UAAU,GAAG,KAAK;QAElB,IAAI,GAAG,IAAI,IAAI,CAAC,KAAK;YACnB,MAAM,IAAI,KAAK,CAAC,kBAAkB,GAAG,qBAAqB,CAAC,CAAC;QAC9D,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;QACvB,IAAI,UAAU;YAAE,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC;IACrC,CAAC;IAED,MAAM,CAAC,IAAI,CAAC,GAAQ,EAAE,MAAe,EAAE,GAAG,IAAW;QACnD,IAAI,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC;QACzD,OAAO,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC;IACxC,CAAC;IAED,MAAM,CAAC,UAAU,CAAC,MAAc;QAC9B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAClC,CAAC","sourcesContent":["/**\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"]}

package/lib/esm/utils/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./constants";
 export * from "./dates";
+export * from "./Decoration";
 export * from "./decorators";
 export * from "./hashing";
 export * from "./registry";

package/lib/esm/utils/index.js

@@ -1,9 +1,10 @@
 export * from "./constants";
 export * from "./dates";
+export * from "./Decoration";
 export * from "./decorators";
 export * from "./hashing";
 export * from "./registry";
 export * from "./serialization";
 export * from "./strings";
 export * from "./types";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2NvbnN0YW50c1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGF0ZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2RlY29yYXRvcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2hhc2hpbmdcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3JlZ2lzdHJ5XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zZXJpYWxpemF0aW9uXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zdHJpbmdzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90eXBlc1wiO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2NvbnN0YW50c1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGF0ZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0RlY29yYXRpb25cIjtcbmV4cG9ydCAqIGZyb20gXCIuL2RlY29yYXRvcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2hhc2hpbmdcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3JlZ2lzdHJ5XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zZXJpYWxpemF0aW9uXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zdHJpbmdzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90eXBlc1wiO1xuIl19

package/lib/esm/utils/registry.d.ts

@@ -4,7 +4,7 @@ import { Constructor } from "../model/types";
  *
  * @interface IRegistry
  *
- * @category Utilities
+ * @category Model
  */
 export interface IRegistry<T> {
     /**
@@ -33,7 +33,7 @@ export interface IRegistry<T> {
  * @typedef T
  * @interface BuilderRegistry<T>
  *
- * @category Construction
+ * @category Model
  */
 export interface BuilderRegistry<T> extends IRegistry<Constructor<T>> {
     /**

package/lib/esm/utils/registry.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaXN0cnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdXRpbHMvcmVnaXN0cnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbnN0cnVjdG9yIH0gZnJvbSBcIi4uL21vZGVsL3R5cGVzXCI7XG5cbi8qKlxuICogQHN1bW1hcnkgQmFzaWMgaW50ZXJmYWNlIGZvciBSZWdpc3RyaWVzXG4gKlxuICogQGludGVyZmFjZSBJUmVnaXN0cnlcbiAqXG4gKiBAY2F0ZWdvcnkgVXRpbGl0aWVzXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgSVJlZ2lzdHJ5PFQ+IHtcbiAgLyoqXG4gICAqIEBzdW1tYXJ5IFJlZ2lzdGVycyBhbiBPYmplY3RcbiAgICpcbiAgICogQHBhcmFtIHtUfSBvYmpcbiAgICogQHBhcmFtIHthbnlbXX0gYXJnc1xuICAgKlxuICAgKiBAbWV0aG9kXG4gICAqL1xuICByZWdpc3RlcihvYmo6IFQgfCBhbnksIC4uLmFyZ3M6IGFueVtdKTogdm9pZDtcblxuICAvKipcbiAgICogQHN1bW1hcnkgUmV0cmlldmVzIGFuIE9iamVjdCBpZiBpdCBjYW4gZmluZCBpdFxuICAgKlxuICAgKiBAcGFyYW0ge2FueX0ga2V5XG4gICAqIEBwYXJhbSB7YW55W119IGFyZ3NcbiAgICogQHJldHVybiB7VCB8IHVuZGVmaW5lZH1cbiAgICpcbiAgICogQG1ldGhvZFxuICAgKi9cbiAgZ2V0KGtleTogYW55LCAuLi5hcmdzOiBhbnlbXSk6IFQgfCB1bmRlZmluZWQ7XG59XG5cbi8qKlxuICogQHN1bW1hcnkgQmFzaWMgQnVpbGRlciBSZWdpc3RyeSBJbnRlcmZhY2VcbiAqXG4gKiBAdHlwZWRlZiBUXG4gKiBAaW50ZXJmYWNlIEJ1aWxkZXJSZWdpc3RyeTxUPlxuICpcbiAqIEBjYXRlZ29yeSBDb25zdHJ1Y3Rpb25cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBCdWlsZGVyUmVnaXN0cnk8VD4gZXh0ZW5kcyBJUmVnaXN0cnk8Q29uc3RydWN0b3I8VD4+IHtcbiAgLyoqXG4gICAqIEBzdW1tYXJ5IFJldHJpZXZlcyBhbiBCdWlsZGVyIE9iamVjdCBieSBuYW1lIGlmIGl0IGNhblxuICAgKlxuICAgKiBAcGFyYW0ge3N0cmluZ30gbmFtZVxuICAgKiBAcGFyYW0ge2FueVtdfSBhcmdzXG4gICAqXG4gICAqIEBtZXRob2RcbiAgICovXG4gIGdldChuYW1lOiBzdHJpbmcsIC4uLmFyZ3M6IGFueVtdKTogQ29uc3RydWN0b3I8VD4gfCB1bmRlZmluZWQ7XG5cbiAgLyoqXG4gICAqIEBzdW1tYXJ5IFJlZ2lzdGVycyBhIGNvbnN0cnVjdG9yIGJ5IG5hbWVcbiAgICpcbiAgICogQHBhcmFtIHtDb25zdHJ1Y3RvcjxUPn0gW2NvbnN0cnVjdG9yXVxuICAgKiBAcGFyYW0ge25hbWV9IG5hbWVcbiAgICogQHBhcmFtIHthbnlbXX0gYXJnc1xuICAgKlxuICAgKiBAbWV0aG9kXG4gICAqL1xuICByZWdpc3Rlcihjb25zdHJ1Y3RvcjogQ29uc3RydWN0b3I8VD4sIG5hbWU/OiBzdHJpbmcsIC4uLmFyZ3M6IGFueVtdKTogdm9pZDtcblxuICAvKipcbiAgICogQHN1bW1hcnkgQnVpbGRzIGFuIE9iamVjdCBieSBuYW1lXG4gICAqXG4gICAqIEBwYXJhbSB7e319IG9ialxuICAgKiBAcGFyYW0ge2FueVtdfSBhcmdzXG4gICAqIEByZXR1cm4gVFxuICAgKlxuICAgKiBAbWV0aG9kXG4gICAqL1xuICBidWlsZChvYmo6IFJlY29yZDxzdHJpbmcsIGFueT4gfCBULCAuLi5hcmdzOiBhbnlbXSk6IFQ7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/utils/serialization.d.ts

@@ -13,7 +13,7 @@ export declare const DefaultSerializationMethod = "json";
  * @class JSONSerializer
  * @implements Serializer
  *
- * @category Serialization
+ * @category Model
  */
 export declare class JSONSerializer<T extends Model> implements Serializer<T> {
     constructor();

package/lib/esm/utils/serialization.js

@@ -12,7 +12,7 @@ export const DefaultSerializationMethod = "json";
  * @class JSONSerializer
  * @implements Serializer
  *
- * @category Serialization
+ * @category Model
  */
 export class JSONSerializer {
     constructor() { }
@@ -87,4 +87,4 @@ export class Serialization {
         this.current = this.get(method);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/utils/strings.d.ts

@@ -6,8 +6,8 @@
  * @return {string} formatted string
  *
  * @function stringFormat
- * @memberOf module:decorator-validation.Utils.Format
- * @category Format
+ * @memberOf module:decorator-validation
+ * @category Model
  */
 export declare function stringFormat(string: string, ...args: (string | number)[]): string;
 /**
@@ -19,7 +19,7 @@ export declare function stringFormat(string: string, ...args: (string | number)[
  * @return {string} formatted string
  *
  * @function sf
- * @memberOf module:decorator-validation.Utils.Format
- * @category Format
+ * @memberOf module:decorator-validation
+ * @category Model
  */
 export declare const sf: typeof stringFormat;

package/lib/esm/utils/strings.js

@@ -6,8 +6,8 @@
  * @return {string} formatted string
  *
  * @function stringFormat
- * @memberOf module:decorator-validation.Utils.Format
- * @category Format
+ * @memberOf module:decorator-validation
+ * @category Model
  */
 export function stringFormat(string, ...args) {
     return string.replace(/{(\d+)}/g, function (match, number) {
@@ -25,8 +25,8 @@ export function stringFormat(string, ...args) {
  * @return {string} formatted string
  *
  * @function sf
- * @memberOf module:decorator-validation.Utils.Format
- * @category Format
+ * @memberOf module:decorator-validation
+ * @category Model
  */
 export const sf = stringFormat;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/utils/types.d.ts

@@ -1,29 +1,136 @@
 import { Model } from "../model";
 /**
- * @summary Helper in serialization
+ * @description Interface for the final stage of the decoration builder pattern
+ * @summary Represents the build stage of the decoration builder, providing the ability to apply
+ * the configured decorator to a target. This is the final stage in the builder chain.
  *
- * @interface Serializer
- * @category Serialization
+ * @interface DecorationBuilderBuild
+ * @memberOf module:decorator-validation
+ * @category Model
  */
-export interface Serializer<T extends Model> {
+export interface DecorationBuilderBuild {
     /**
-     * @summary Serializes a model
-     * @param {T} model
+     * @description Creates and returns the decorator function
+     * @summary Finalizes the builder process and returns a decorator function that can be applied to a class,
+     * property, or method.
      *
-     * @param args
-     * @method
+     * @returns {function} A decorator function that can be applied to a target
+     */
+    apply(): (target: object, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+}
+/**
+ * @description Interface for the extension stage of the decoration builder pattern
+ * @summary Represents the extension stage of the decoration builder, providing the ability to add
+ * additional decorators to the existing configuration.
+ *
+ * @interface DecorationBuilderEnd
+ * @memberOf module:decorator-validation
+ * @category Model
+ */
+export interface DecorationBuilderEnd {
+    /**
+     * @description Adds additional decorators to the existing configuration
+     * @summary Extends the current decorator configuration with additional decorators.
+     * This is useful for adding behavior to existing decorators.
      *
-     * @throws {Error}
+     * @param {...(ClassDecorator|PropertyDecorator|MethodDecorator)} decorators - Additional decorators to add
+     * @returns {DecorationBuilderBuild} The build stage of the builder pattern
+     */
+    extend(...decorators: (ClassDecorator | PropertyDecorator | MethodDecorator)[]): DecorationBuilderBuild;
+}
+/**
+ * @description Interface for the middle stage of the decoration builder pattern
+ * @summary Represents the middle stage of the decoration builder, extending the end stage
+ * and providing the ability to define the primary decorators for the configuration.
+ *
+ * @interface DecorationBuilderMid
+ * @memberOf module:decorator-validation
+ * @category Model
+ */
+export interface DecorationBuilderMid extends DecorationBuilderEnd {
+    /**
+     * @description Defines the primary decorators for the configuration
+     * @summary Sets the main decorators for the current context. This is typically
+     * called after specifying the key with the 'for' method.
      */
-    serialize(model: T, ...args: any[]): string;
+    define(...decorators: (ClassDecorator | PropertyDecorator | MethodDecorator)[]): DecorationBuilderEnd & DecorationBuilderBuild;
+}
+/**
+ * @description Interface for the starting stage of the decoration builder pattern
+ * @summary Represents the initial stage of the decoration builder, providing the entry point
+ * for the builder pattern by specifying the key for the decorator.
+ *
+ * @interface DecorationBuilderStart
+ * @memberOf module:decorator-validation
+ * @category Model
+ */
+export interface DecorationBuilderStart {
     /**
-     * @summary Rebuilds a model from serialization
-     * @param {string} str
+     * @description Specifies the key for the decorator
+     * @summary Sets the identifier for the decorator, which is used to register and retrieve
+     * the decorator in the decoration registry.
      *
-     * @param args
-     * @method
+     * @param {string} id - The identifier for the decorator
+     * @return {DecorationBuilderMid} The middle stage of the builder pattern
+     */
+    for(id: string): DecorationBuilderMid;
+}
+/**
+ * @description Comprehensive interface for the complete decoration builder pattern
+ * @summary A unified interface that combines all stages of the decoration builder pattern,
+ * providing a complete API for creating, configuring, and applying decorators.
+ * This interface is implemented by the Decoration class.
+ *
+ * @interface IDecorationBuilder
+ * @memberOf module:decorator-validation
+ * @category Model
+ */
+export interface IDecorationBuilder extends DecorationBuilderStart, DecorationBuilderMid, DecorationBuilderEnd, DecorationBuilderBuild {
+}
+/**
+ * @description Type definition for a function that resolves the flavour for a target
+ * @summary Defines a function type that determines the appropriate flavour for a given target object.
+ * This is used by the Decoration class to resolve which flavour of decorator to apply based on the target.
+ *
+ * @typedef {function(object): string} FlavourResolver
+ *
+ * @param {object} target - The target object to resolve the flavour for
+ * @return {string} The resolved flavour identifier
+ * @memberOf module:decorator-validation
+ * @category Model
+ */
+export type FlavourResolver = (target: object) => string;
+/**
+ * @description Interface for serializing and deserializing model objects
+ * @summary Defines the contract for classes that can convert model objects to and from string representations.
+ * Serializers are used to persist models or transmit them over networks.
+ *
+ * @interface Serializer
+ * @template T Type of model that can be serialized, must extend Model
+ * @memberOf module:decorator-validation
+ * @category Model
+ */
+export interface Serializer<M extends Model> {
+    /**
+     * @description Converts a model object to a string representation
+     * @summary Serializes a model instance into a string format that can be stored or transmitted.
+     * Additional arguments can be provided to customize the serialization process.
+     *
+     * @param {T} model - The model instance to serialize
+     * @param {...any} args - Additional arguments for the serialization process
+     * @return {string} The serialized representation of the model
+     * @throws {Error} If the model cannot be serialized
+     */
+    serialize(model: M, ...args: any[]): string;
+    /**
+     * @description Reconstructs a model object from its string representation
+     * @summary Deserializes a string back into a model instance.
+     * Additional arguments can be provided to customize the deserialization process.
      *
-     * @throws {Error}
+     * @param {string} str - The serialized string to convert back to a model
+     * @param {...any} args - Additional arguments for the deserialization process
+     * @return {T} The reconstructed model instance
+     * @throws {Error} If the string cannot be deserialized into a valid model
      */
-    deserialize(str: string, ...args: any[]): T;
+    deserialize(str: string, ...args: any[]): M;
 }