@decaf-ts/decorator-validation 1.7.1 → 1.7.3

package/lib/model/Model.d.ts

@@ -131,112 +131,236 @@ export declare function bulkModelRegister<M extends Model>(...models: (Construct
 export declare abstract class Model implements Validatable, Serializable, Hashable, Comparable<Model> {
     protected constructor(arg?: ModelArg<Model>);
     /**
-     * @summary Validates the object according to its decorated properties
+     * @description Validates the model object against its defined validation rules
+     * @summary Validates the object according to its decorated properties, returning any validation errors
      *
-     * @param {any[]} [exceptions] properties in the object to be ignored for the validation. Marked as 'any' to allow for extension but expects strings
+     * @param {any[]} [exceptions] - Properties in the object to be ignored for the validation. Marked as 'any' to allow for extension but expects strings
+     * @return {ModelErrorDefinition | undefined} - Returns a ModelErrorDefinition object if validation errors exist, otherwise undefined
      */
     hasErrors(...exceptions: any[]): ModelErrorDefinition | undefined;
     /**
-     * @summary Compare object equality recursively
-     * @param {any} obj object to compare to
-     * @param {string} [exceptions] property names to be excluded from the comparison
+     * @description Determines if this model is equal to another object
+     * @summary Compare object equality recursively, checking all properties unless excluded
+     *
+     * @param {any} obj - Object to compare to
+     * @param {string[]} [exceptions] - Property names to be excluded from the comparison
+     * @return {boolean} - True if objects are equal, false otherwise
      */
     equals(obj: any, ...exceptions: string[]): boolean;
     /**
+     * @description Converts the model to a serialized string representation
      * @summary Returns the serialized model according to the currently defined {@link Serializer}
+     *
+     * @return {string} - The serialized string representation of the model
      */
     serialize(): string;
     /**
-     * @summary Override the implementation for js's 'toString()' which sucks...
+     * @description Provides a human-readable string representation of the model
+     * @summary Override the implementation for js's 'toString()' to provide a more useful representation
+     *
+     * @return {string} - A string representation of the model including its class name and JSON representation
      * @override
      */
     toString(): string;
     /**
-     * @summary Defines a default implementation for object hash. Relies on a very basic implementation based on Java's string hash;
+     * @description Generates a hash string for the model object
+     * @summary Defines a default implementation for object hash, relying on a basic implementation based on Java's string hash
+     *
+     * @return {string} - A hash string representing the model
      */
     hash(): string;
     /**
-     * @summary Deserializes a Model
-     * @param {string} str
+     * @description Converts a serialized string back into a model instance
+     * @summary Deserializes a Model from its string representation
      *
+     * @param {string} str - The serialized string to convert back to a model
+     * @return {any} - The deserialized model instance
      * @throws {Error} If it fails to parse the string, or if it fails to build the model
      */
     static deserialize(str: string): any;
     /**
+     * @description Copies properties from a source object to a model instance
      * @summary Repopulates the Object properties with the ones from the new object
-     * @description Iterates all common properties of obj (if existing) and self, and copies them onto self
-     *
-     * @param {T} self
-     * @param {T | Record<string, any>} [obj]
      *
+     * @template T
+     * @param {T} self - The target model instance to update
+     * @param {T | Record<string, any>} [obj] - The source object containing properties to copy
+     * @return {T} - The updated model instance
      */
     static fromObject<T extends Model>(self: T, obj?: T | Record<string, any>): T;
     /**
-     * @summary Repopulates the instance with the ones from the new Model Object
-     * @description Iterates all common properties of obj (if existing) and self, and copies them onto self.
-     * Is aware of nested Model Objects and rebuilds them also.
-     * When List properties are decorated with {@link list}, they list items will also be rebuilt
+     * @description Copies and rebuilds properties from a source object to a model instance, handling nested models
+     * @summary Repopulates the instance with properties from the new Model Object, recursively rebuilding nested models
      *
-     * @param {T} self
-     * @param {T | Record<string, any>} [obj]
+     * @template T
+     * @param {T} self - The target model instance to update
+     * @param {T | Record<string, any>} [obj] - The source object containing properties to copy
+     * @return {T} - The updated model instance with rebuilt nested models
      *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Client
+     *   participant M as Model.fromModel
+     *   participant B as Model.build
+     *   participant R as Reflection
+     *
+     *   C->>M: fromModel(self, obj)
+     *   M->>M: Get attributes from self
+     *   loop For each property
+     *     M->>M: Copy property from obj to self
+     *     alt Property is a model
+     *       M->>M: Check if property is a model
+     *       M->>B: build(property, modelType)
+     *       B-->>M: Return built model
+     *     else Property is a complex type
+     *       M->>R: Get property decorators
+     *       R-->>M: Return decorators
+     *       M->>M: Filter type decorators
+     *       alt Property is Array/Set with list decorator
+     *         M->>M: Process each item in collection
+     *         loop For each item
+     *           M->>B: build(item, itemModelType)
+     *           B-->>M: Return built model
+     *         end
+     *       else Property is another model type
+     *         M->>B: build(property, propertyType)
+     *         B-->>M: Return built model
+     *       end
+     *     end
+     *   end
+     *   M-->>C: Return updated self
      */
     static fromModel<T extends Model>(self: T, obj?: T | Record<string, any>): T;
     /**
-     * @summary Sets the Global {@link ModelBuilderFunction}
-     * @param {ModelBuilderFunction} [builder]
+     * @description Configures the global model builder function
+     * @summary Sets the Global {@link ModelBuilderFunction} used for building model instances
+     *
+     * @param {ModelBuilderFunction} [builder] - The builder function to set as the global builder
+     * @return {void}
      */
     static setBuilder(builder?: ModelBuilderFunction): void;
     /**
-     * @summary Retrieves the current global {@link ModelBuilderFunction}
+     * @description Retrieves the currently configured global model builder function
+     * @summary Returns the current global {@link ModelBuilderFunction} used for building model instances
+     *
+     * @return {ModelBuilderFunction | undefined} - The current global builder function or undefined if not set
      */
     static getBuilder(): ModelBuilderFunction | undefined;
     /**
-     * Returns the current {@link ModelRegistryManager}
+     * @description Provides access to the current model registry
+     * @summary Returns the current {@link ModelRegistryManager} instance, creating one if it doesn't exist
      *
-     * @return ModelRegistry, defaults to {@link ModelRegistryManager}
+     * @return {ModelRegistry<any>} - The current model registry, defaults to a new {@link ModelRegistryManager} if not set
+     * @private
      */
     private static getRegistry;
     /**
-     * Returns the current actingModelRegistry
+     * @description Configures the model registry to be used by the Model system
+     * @summary Sets the current model registry to a custom implementation
      *
-     * @param {BuilderRegistry} modelRegistry the new implementation of Registry
+     * @param {BuilderRegistry<any>} modelRegistry - The new implementation of Registry to use
+     * @return {void}
      */
     static setRegistry(modelRegistry: BuilderRegistry<any>): void;
     /**
-     * @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 model registry
+     * @summary Registers new model classes to make them available for serialization and deserialization
+     *
+     * @template T
+     * @param {ModelConstructor<T>} constructor - The model constructor to register
+     * @param {string} [name] - Optional name to register the constructor under, defaults to constructor.name
+     * @return {void}
      *
      * @see ModelRegistry
      */
     static register<T extends Model>(constructor: ModelConstructor<T>, name?: string): void;
     /**
-     * @summary Gets a registered Model {@link ModelConstructor}
-     * @param {string} name
+     * @description Retrieves a registered model constructor by name
+     * @summary Gets a registered Model {@link ModelConstructor} from the model registry
+     *
+     * @template T
+     * @param {string} name - The name of the model constructor to retrieve
+     * @return {ModelConstructor<T> | undefined} - The model constructor if found, undefined otherwise
      *
      * @see ModelRegistry
      */
     static get<T extends Model>(name: string): ModelConstructor<T> | undefined;
     /**
-     * @param {Record<string, any>} obj
-     * @param {string} [clazz] when provided, it will attempt to find the matching constructor
+     * @description Creates a model instance from a plain object
+     * @summary Builds a model instance using the model registry, optionally specifying the model class
      *
-     * @throws Error If clazz is not found, or obj is not a {@link Model} meaning it has no {@link ModelKeys.ANCHOR} property
+     * @template T
+     * @param {Record<string, any>} obj - The source object to build the model from
+     * @param {string} [clazz] - When provided, it will attempt to find the matching constructor by name
+     * @return {T} - The built model instance
+     * @throws {Error} If clazz is not found, or obj is not a {@link Model} meaning it has no {@link ModelKeys.ANCHOR} property
      *
      * @see ModelRegistry
      */
     static build<T extends Model>(obj?: Record<string, any>, clazz?: string): T;
+    /**
+     * @description Retrieves the model metadata from a model instance
+     * @summary Gets the metadata associated with a model instance, typically the model class name
+     *
+     * @template M
+     * @param {M} model - The model instance to get metadata from
+     * @return {string} - The model metadata (typically the class name)
+     */
     static getMetadata<M extends Model>(model: M): any;
+    /**
+     * @description Retrieves all attribute names from a model class or instance
+     * @summary Gets all attributes defined in a model, traversing the prototype chain to include inherited attributes
+     *
+     * @template V
+     * @param {Constructor<V> | V} model - The model class or instance to get attributes from
+     * @return {string[]} - Array of attribute names defined in the model
+     */
     static getAttributes<V extends Model>(model: Constructor<V> | V): string[];
+    /**
+     * @description Compares two model instances for equality
+     * @summary Determines if two model instances are equal by comparing their properties
+     *
+     * @template M
+     * @param {M} obj1 - First model instance to compare
+     * @param {M} obj2 - Second model instance to compare
+     * @param {any[]} [exceptions] - Property names to exclude from comparison
+     * @return {boolean} - True if the models are equal, false otherwise
+     */
     static equals<M extends Model>(obj1: M, obj2: M, ...exceptions: any[]): boolean;
+    /**
+     * @description Validates a model instance against its validation rules
+     * @summary Checks if a model has validation errors, optionally ignoring specified properties
+     *
+     * @template M
+     * @param {M} model - The model instance to validate
+     * @param {string[]} [propsToIgnore] - Properties to exclude from validation
+     * @return {ModelErrorDefinition | undefined} - Returns validation errors if any, otherwise undefined
+     */
     static hasErrors<M extends Model>(model: M, ...propsToIgnore: string[]): ModelErrorDefinition | undefined;
+    /**
+     * @description Converts a model instance to a serialized string
+     * @summary Serializes a model instance using the configured serializer or the default one
+     *
+     * @template M
+     * @param {M} model - The model instance to serialize
+     * @return {string} - The serialized string representation of the model
+     */
     static serialize<M extends Model>(model: M): any;
+    /**
+     * @description Generates a hash string for a model instance
+     * @summary Creates a hash representation of a model using the configured algorithm or the default one
+     *
+     * @template M
+     * @param {M} model - The model instance to hash
+     * @return {string} - The hash string representing the model
+     */
     static hash<M extends Model>(model: M): any;
     /**
+     * @description Creates a metadata key for use with the Reflection API
      * @summary Builds the key to store as Metadata under Reflections
-     * @description concatenates {@link ModelKeys#REFLECT} with the provided key
-     * @param {string} str
+     *
+     * @param {string} str - The base key to concatenate with the model reflection prefix
+     * @return {string} - The complete metadata key
      */
     static key(str: string): string;
     /**
@@ -264,12 +388,12 @@ export declare abstract class Model implements Validatable, Serializable, Hashab
     /**
      * @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}
+     * or has a type that is registered as a model
+     *
+     * @template M
      * @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,
+     * @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<M extends Model>(target: M, attribute: string): boolean | string | undefined;

package/lib/model/construction.cjs

@@ -7,9 +7,11 @@ const Model_1 = require("./Model.cjs");
 /**
  * @summary Helper Function to override constructors
  *
+ * @template M the model instance type
+ *
  * @param {Function} constructor
  * @param {any[]} [args]
- * @return {T} the new instance
+ * @return {M} the new instance
  *
  * @function construct
  * @memberOf module:decorator-validation
@@ -66,4 +68,4 @@ function bindModelPrototype(obj) {
     }
     throw new Error("Could not find proper prototype to bind");
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RydWN0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL21vZGVsL2NvbnN0cnVjdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQVlBLDhCQU9DO0FBU0QsOERBU0M7QUFVRCxnREFxQkM7QUFwRUQsdUNBQWdDO0FBRWhDOzs7Ozs7Ozs7R0FTRztBQUNILFNBQWdCLFNBQVMsQ0FDdkIsV0FBZ0IsRUFDaEIsR0FBRyxJQUFXO0lBRWQsTUFBTSxPQUFPLEdBQUcsQ0FBQyxHQUFHLElBQVcsRUFBRSxFQUFFLENBQUMsSUFBSSxXQUFXLENBQUMsR0FBRyxJQUFJLENBQUMsQ0FBQztJQUM3RCxPQUFPLENBQUMsU0FBUyxHQUFHLFdBQVcsQ0FBQyxTQUFTLENBQUM7SUFDMUMsT0FBTyxPQUFPLENBQUMsR0FBRyxJQUFJLENBQUMsQ0FBQztBQUMxQixDQUFDO0FBRUQ7Ozs7OztHQU1HO0FBQ0gsU0FBZ0IseUJBQXlCLENBQUMsR0FBVztJQUNuRCxJQUFJLFNBQVMsR0FBUSxNQUFNLENBQUMsY0FBYyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ2hELElBQUksU0FBUyxLQUFLLE1BQU0sQ0FBQyxTQUFTO1FBQUUsT0FBTyxHQUFHLENBQUM7SUFDL0MsT0FBTyxTQUFTLEtBQUssTUFBTSxDQUFDLFNBQVMsRUFBRSxDQUFDO1FBQ3RDLFNBQVMsR0FBRyxNQUFNLENBQUMsY0FBYyxDQUFDLFNBQVMsQ0FBQyxDQUFDO1FBQzdDLElBQUksU0FBUyxLQUFLLE1BQU0sQ0FBQyxTQUFTO1lBQUUsT0FBTyxTQUFTLENBQUM7UUFDckQsSUFBSSxNQUFNLENBQUMsY0FBYyxDQUFDLFNBQVMsQ0FBQyxLQUFLLE1BQU0sQ0FBQyxTQUFTO1lBQUUsT0FBTyxTQUFTLENBQUM7SUFDOUUsQ0FBQztJQUNELE1BQU0sSUFBSSxLQUFLLENBQUMsaUNBQWlDLENBQUMsQ0FBQztBQUNyRCxDQUFDO0FBRUQ7Ozs7Ozs7R0FPRztBQUNILFNBQWdCLGtCQUFrQixDQUFDLEdBQVk7SUFDN0MsSUFBSSxHQUFHLFlBQVksYUFBSztRQUFFLE9BQU87SUFFakMsU0FBUyxhQUFhLENBQUMsYUFBc0IsRUFBRSxTQUFpQjtRQUM5RCxNQUFNLENBQUMsY0FBYyxDQUFDLGFBQWEsRUFBRSxTQUFTLENBQUMsQ0FBQztJQUNsRCxDQUFDO0lBRUQsTUFBTSxTQUFTLEdBQVEsTUFBTSxDQUFDLGNBQWMsQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUNsRCxJQUFJLFNBQVMsS0FBSyxNQUFNLENBQUMsU0FBUyxFQUFFLENBQUM7UUFDbkMsT0FBTyxhQUFhLENBQUMsR0FBRyxFQUFFLGFBQUssQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUM3QyxDQUFDO0lBQ0QsT0FBTyxTQUFTLEtBQUssTUFBTSxDQUFDLFNBQVMsRUFBRSxDQUFDO1FBQ3RDLE1BQU0sSUFBSSxHQUFHLE1BQU0sQ0FBQyxjQUFjLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDOUMsSUFDRSxJQUFJLEtBQUssTUFBTSxDQUFDLFNBQVM7WUFDekIsTUFBTSxDQUFDLGNBQWMsQ0FBQyxJQUFJLENBQUMsS0FBSyxNQUFNLENBQUMsU0FBUyxFQUNoRCxDQUFDO1lBQ0QsT0FBTyxhQUFhLENBQUMsU0FBUyxFQUFFLGFBQUssQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUNuRCxDQUFDO0lBQ0gsQ0FBQztJQUNELE1BQU0sSUFBSSxLQUFLLENBQUMseUNBQXlDLENBQUMsQ0FBQztBQUM3RCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTW9kZWwgfSBmcm9tIFwiLi9Nb2RlbFwiO1xuXG4vKipcbiAqIEBzdW1tYXJ5IEhlbHBlciBGdW5jdGlvbiB0byBvdmVycmlkZSBjb25zdHJ1Y3RvcnNcbiAqXG4gKiBAcGFyYW0ge0Z1bmN0aW9ufSBjb25zdHJ1Y3RvclxuICogQHBhcmFtIHthbnlbXX0gW2FyZ3NdXG4gKiBAcmV0dXJuIHtUfSB0aGUgbmV3IGluc3RhbmNlXG4gKlxuICogQGZ1bmN0aW9uIGNvbnN0cnVjdFxuICogQG1lbWJlck9mIG1vZHVsZTpkZWNvcmF0b3ItdmFsaWRhdGlvblxuICovXG5leHBvcnQgZnVuY3Rpb24gY29uc3RydWN0PFQgZXh0ZW5kcyBNb2RlbD4oXG4gIGNvbnN0cnVjdG9yOiBhbnksXG4gIC4uLmFyZ3M6IGFueVtdXG4pOiBUIHtcbiAgY29uc3QgX2NvbnN0ciA9ICguLi5hcmd6OiBhbnlbXSkgPT4gbmV3IGNvbnN0cnVjdG9yKC4uLmFyZ3opO1xuICBfY29uc3RyLnByb3RvdHlwZSA9IGNvbnN0cnVjdG9yLnByb3RvdHlwZTtcbiAgcmV0dXJuIF9jb25zdHIoLi4uYXJncyk7XG59XG5cbi8qKlxuICogQHN1bW1hcnkgUmVjdXJzaXZlbHkgZmluZHMgdGhlIGxhc3QgcHJvdG90eXBlIGJlZm9yZSBPYmplY3RcbiAqIEBwYXJhbSB7b2JqZWN0fSBvYmpcbiAqXG4gKiBAZnVuY3Rpb24gZmluZExhc3RQcm90b0JlZm9yZU9iamVjdFxuICogQG1lbWJlck9mIG1vZHVsZTpkZWNvcmF0b3ItdmFsaWRhdGlvblxuICovXG5leHBvcnQgZnVuY3Rpb24gZmluZExhc3RQcm90b0JlZm9yZU9iamVjdChvYmo6IG9iamVjdCk6IG9iamVjdCB7XG4gIGxldCBwcm90b3R5cGU6IGFueSA9IE9iamVjdC5nZXRQcm90b3R5cGVPZihvYmopO1xuICBpZiAocHJvdG90eXBlID09PSBPYmplY3QucHJvdG90eXBlKSByZXR1cm4gb2JqO1xuICB3aGlsZSAocHJvdG90eXBlICE9PSBPYmplY3QucHJvdG90eXBlKSB7XG4gICAgcHJvdG90eXBlID0gT2JqZWN0LmdldFByb3RvdHlwZU9mKHByb3RvdHlwZSk7XG4gICAgaWYgKHByb3RvdHlwZSA9PT0gT2JqZWN0LnByb3RvdHlwZSkgcmV0dXJuIHByb3RvdHlwZTtcbiAgICBpZiAoT2JqZWN0LmdldFByb3RvdHlwZU9mKHByb3RvdHlwZSkgPT09IE9iamVjdC5wcm90b3R5cGUpIHJldHVybiBwcm90b3R5cGU7XG4gIH1cbiAgdGhyb3cgbmV3IEVycm9yKFwiQ291bGQgbm90IGZpbmQgcHJvcGVyIHByb3RvdHlwZVwiKTtcbn1cblxuLyoqXG4gKiBAc3VtYXJ5IGJpbmRzIHRoZSB7QGxpbmsgTW9kZWx9IGNsYXNzIGFzIGEgcm9vdCBwcm90b3R5cGUgb2YgdGhlIHByb3ZpZGVkIGluc3RhbmNlXG4gKlxuICogQHBhcmFtIHt1bmtub3dufSBvYmpcbiAqXG4gKiBAZnVuY3Rpb24gYmluZE1vZGVsUHJvdG90eXBlXG4gKiBAbWVtYmVyT2YgbW9kdWxlOmRlY29yYXRvci12YWxpZGF0aW9uXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBiaW5kTW9kZWxQcm90b3R5cGUob2JqOiB1bmtub3duKSB7XG4gIGlmIChvYmogaW5zdGFuY2VvZiBNb2RlbCkgcmV0dXJuO1xuXG4gIGZ1bmN0aW9uIGJpbmRQcm90b3R5cGUob2JqVG9PdmVycmlkZTogdW5rbm93biwgcHJvdG90eXBlOiBvYmplY3QpIHtcbiAgICBPYmplY3Quc2V0UHJvdG90eXBlT2Yob2JqVG9PdmVycmlkZSwgcHJvdG90eXBlKTtcbiAgfVxuXG4gIGNvbnN0IHByb3RvdHlwZTogYW55ID0gT2JqZWN0LmdldFByb3RvdHlwZU9mKG9iaik7XG4gIGlmIChwcm90b3R5cGUgPT09IE9iamVjdC5wcm90b3R5cGUpIHtcbiAgICByZXR1cm4gYmluZFByb3RvdHlwZShvYmosIE1vZGVsLnByb3RvdHlwZSk7XG4gIH1cbiAgd2hpbGUgKHByb3RvdHlwZSAhPT0gT2JqZWN0LnByb3RvdHlwZSkge1xuICAgIGNvbnN0IHByb3QgPSBPYmplY3QuZ2V0UHJvdG90eXBlT2YocHJvdG90eXBlKTtcbiAgICBpZiAoXG4gICAgICBwcm90ID09PSBPYmplY3QucHJvdG90eXBlIHx8XG4gICAgICBPYmplY3QuZ2V0UHJvdG90eXBlT2YocHJvdCkgPT09IE9iamVjdC5wcm90b3R5cGVcbiAgICApIHtcbiAgICAgIHJldHVybiBiaW5kUHJvdG90eXBlKHByb3RvdHlwZSwgTW9kZWwucHJvdG90eXBlKTtcbiAgICB9XG4gIH1cbiAgdGhyb3cgbmV3IEVycm9yKFwiQ291bGQgbm90IGZpbmQgcHJvcGVyIHByb3RvdHlwZSB0byBiaW5kXCIpO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/lib/model/construction.d.ts

@@ -2,14 +2,16 @@ import { Model } from "./Model";
 /**
  * @summary Helper Function to override constructors
  *
+ * @template M the model instance type
+ *
  * @param {Function} constructor
  * @param {any[]} [args]
- * @return {T} the new instance
+ * @return {M} the new instance
  *
  * @function construct
  * @memberOf module:decorator-validation
  */
-export declare function construct<T extends Model>(constructor: any, ...args: any[]): T;
+export declare function construct<M extends Model>(constructor: any, ...args: any[]): M;
 /**
  * @summary Recursively finds the last prototype before Object
  * @param {object} obj

package/lib/model/decorators.cjs

@@ -20,7 +20,7 @@ const reflection_1 = require("@decaf-ts/reflection");
  *
  * @function model
  *
- * @category Decorators
+ * @category Class Decorators
  */
 function model(instanceCallback) {
     return ((original) => {
@@ -55,16 +55,40 @@ function model(instanceCallback) {
         return newConstructor;
     });
 }
+/**
+ * @summary Defines the hashing algorithm to use on the model
+ * @description
+ *
+ * - Registers the class under the model registry so it can be easily rebuilt;
+ * - Overrides the class constructor;
+ * - Runs the global {@link ModelBuilderFunction} if defined;
+ * - Runs the optional {@link InstanceCallback} if provided;
+ *
+ * @param {string} algorithm the algorithm to use
+ *
+ * @function hashedBy
+ *
+ * @category Class Decorators
+ */
 function hashedBy(algorithm, ...args) {
     return (0, reflection_1.metadata)(Model_1.Model.key(constants_1.ModelKeys.HASHING), {
         algorithm: algorithm,
         args: args,
     });
 }
+/**
+ * @summary Defines the serialization algorithm to use on the model
+ *
+ * @param {string} serializer the algorithm to use
+ *
+ * @function serializedBy
+ *
+ * @category Class Decorators
+ */
 function serializedBy(serializer, ...args) {
     return (0, reflection_1.metadata)(Model_1.Model.key(constants_1.ModelKeys.SERIALIZATION), {
         serializer: serializer,
         args: args,
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/model/decorators.d.ts

@@ -18,8 +18,32 @@ export type InstanceCallback = (instance: any, ...args: any[]) => void;
  *
  * @function model
  *
- * @category Decorators
+ * @category Class Decorators
  */
 export declare function model(instanceCallback?: InstanceCallback): any;
+/**
+ * @summary Defines the hashing algorithm to use on the model
+ * @description
+ *
+ * - Registers the class under the model registry so it can be easily rebuilt;
+ * - Overrides the class constructor;
+ * - Runs the global {@link ModelBuilderFunction} if defined;
+ * - Runs the optional {@link InstanceCallback} if provided;
+ *
+ * @param {string} algorithm the algorithm to use
+ *
+ * @function hashedBy
+ *
+ * @category Class Decorators
+ */
 export declare function hashedBy(algorithm: string, ...args: any[]): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @summary Defines the serialization algorithm to use on the model
+ *
+ * @param {string} serializer the algorithm to use
+ *
+ * @function serializedBy
+ *
+ * @category Class Decorators
+ */
 export declare function serializedBy(serializer: string, ...args: any[]): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;

package/lib/model/types.cjs

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/model/types.d.ts

@@ -1,98 +1,115 @@
 import { ModelErrorDefinition } from "./ModelErrorDefinition";
 import { Model } from "./Model";
 /**
- * @summary Typo of a Model builder function
+ * @description Function type for building model instances from objects
+ * @summary Type definition for a model builder function that populates model properties
+ * @template T
+ * @param {T} self - The target model instance to populate
+ * @param {T | Record<string, any>} [obj] - The source object containing properties to copy
+ * @return {T} - The populated model instance
+ * @typedef ModelBuilderFunction
  * @memberOf module:decorator-validation
  */
 export type ModelBuilderFunction = <T extends Model>(self: T, obj?: T | Record<string, any>) => T;
 /**
- * @summary Definition of a Model Constructor Argument
- *
+ * @description Type representing valid argument types for model constructors
+ * @summary Definition of a Model Constructor Argument that can be a complete model, partial model, or plain object
+ * @template T
+ * @typedef ModelArg
  * @memberOf module:decorator-validation
- *
  * @see ModelConstructor
  */
 export type ModelArg<T> = T | Partial<T> | Record<string, any>;
 /**
- * @summary Definition of a Class Constructor
- * @description Generic type for Constructor functions
- *
+ * @description Generic type for class constructor functions
+ * @summary Definition of a Class Constructor that can create instances of a specified type
+ * @template T
+ * @param {any[]} [args] - Constructor arguments
+ * @return {T} - An instance of the class
  * @typedef Constructor
- *
- * @param {any[]} [args]
  * @memberOf module:decorator-validation
  */
 export type Constructor<T> = {
     new (...args: any[]): T;
 };
 /**
- * @summary Definition of a Model Constructor
- * @description Generic type for all Model Constructor functions
- *
+ * @description Specialized constructor type for Model classes
+ * @summary Definition of a Model Constructor that creates instances of Model subclasses
+ * @template T
+ * @param {ModelArg<T>} [model] - Initial data to populate the model with
+ * @param {any[]} [args] - Additional constructor arguments
+ * @return {T} - An instance of the model class
  * @typedef ModelConstructor
- *
- * @param {ModelArg<T>} [model]
- * @param {any[]} [args]
  * @memberOf module:decorator-validation
  */
 export type ModelConstructor<T extends Model> = {
     new (model?: ModelArg<T>, ...args: any[]): T;
 };
 /**
+ * @description Interface for objects that can be validated
  * @summary Defines the Validation API for validatable models
  * @interface Validatable
- *
+ * @memberOf module:decorator-validation
  * @category Model
  */
 export interface Validatable {
     /**
-     * @summary Validates the model and returns the {@link ModelErrorDefinition} if any
-     * @param {any} [args]
-     *
+     * @description Validates the object against its validation rules
+     * @summary Validates the model and returns the {@link ModelErrorDefinition} if any errors exist
+     * @param {any[]} [args] - Optional arguments to control validation behavior
+     * @return {ModelErrorDefinition | undefined} - Validation errors if any, otherwise undefined
      * @method
      */
     hasErrors(...args: any[]): ModelErrorDefinition | undefined;
 }
 /**
- * @summary Serializable interface
- *
+ * @description Interface for objects that can be serialized to string
+ * @summary Defines the serialization API for model objects
  * @interface Serializable
- *
+ * @memberOf module:decorator-validation
  * @category Model
  */
 export interface Serializable {
     /**
-     * @summary serializes the model
+     * @description Converts the object to a serialized string representation
+     * @summary Serializes the model to a string format
+     * @return {string} - The serialized string representation
      * @method
      */
     serialize(): string;
 }
 /**
- * @summary Interface for objects that can be hashed
+ * @description Interface for objects that can generate a hash representation
+ * @summary Defines the hashing API for model objects
  * @interface Hashable
+ * @memberOf module:decorator-validation
  * @category Model
  */
 export interface Hashable {
     /**
-     * @summary Generates a hash string representation of the object
+     * @description Generates a unique hash string for the object
+     * @summary Creates a hash string representation of the object
+     * @return {string} - Hash value representing the object
      * @method
-     * @returns {string} Hash value representing the object
      */
     hash(): string;
 }
 /**
- * @summary Interface for objects that can be compared for equality
+ * @description Interface for objects that can be compared with other objects
+ * @summary Defines the equality comparison API for model objects
+ * @template T
  * @interface Comparable
- * @template T The type of object to compare against
+ * @memberOf module:decorator-validation
  * @category Model
  */
 export interface Comparable<T> {
     /**
+     * @description Determines if this object is equal to another object
      * @summary Compares this object with another for equality
-     * @method
      * @param {T} other - The object to compare with
-     * @param {...any[]} args - Additional arguments for comparison
-     * @returns {boolean} True if the objects are equal, false otherwise
+     * @param {any[]} [args] - Additional arguments for comparison
+     * @return {boolean} - True if the objects are equal, false otherwise
+     * @method
      */
     equals(other: T, ...args: any[]): boolean;
 }