@decaf-ts/decorator-validation 1.11.24 → 1.12.0

package/lib/model/ModelRegistry.d.ts

@@ -1,181 +0,0 @@
-import { Constructor } from "@decaf-ts/decoration";
-import { ModelBuilderFunction, ModelConstructor } from "./types";
-import { type Model } from "./Model";
-import { BuilderRegistry } from "../utils/registry";
-/**
- * @description Registry type for storing and retrieving model constructors
- * @summary The ModelRegistry type defines a registry for model constructors that extends
- * the BuilderRegistry interface. It provides a standardized way to register, retrieve,
- * and build model instances, enabling the model system to work with different types of models.
- *
- * @interface ModelRegistry
- * @template T Type of model that can be registered, must extend Model
- * @extends BuilderRegistry<T>
- * @memberOf module:decorator-validation
- * @category Model
- */
-export type ModelRegistry<T extends Model> = BuilderRegistry<T>;
-/**
- * @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 {function(Record<string, any>): boolean} [testFunction] - Function to test if an object is a model, defaults to {@link Model#isModel}
- *
- * @class ModelRegistryManager
- * @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
- */
-export declare class ModelRegistryManager<M extends Model<true | false>> implements ModelRegistry<M> {
-    private cache;
-    private readonly testFunction;
-    constructor(testFunction?: (obj: Record<string, any>) => boolean);
-    /**
-     * @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: ModelConstructor<M>, name?: string): void;
-    /**
-     * @summary Gets a registered Model {@link ModelConstructor}
-     * @param {string} name
-     */
-    get(name: string): ModelConstructor<M> | undefined;
-    /**
-     * @param {Record<string, any>} obj
-     * @param {string} [clazz] when provided, it will attempt to find the matching constructor
-     *
-     * @throws Error If clazz is not found, or obj is not a {@link Model} meaning it has no {@link ModelKeys.ANCHOR} property
-     */
-    build(obj?: Record<string, any>, clazz?: string): M;
-    /**
-     * @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;
-    /**
-     * @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;
-    /**
-     * @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
-     *
-     * @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;
-    /**
-     * @description Provides access to the current model registry
-     * @summary Returns the current {@link ModelRegistryManager} instance, creating one if it doesn't exist
-     *
-     * @return {ModelRegistry<any>} - The current model registry, defaults to a new {@link ModelRegistryManager} if not set
-     * @private
-     */
-    static getRegistry(): BuilderRegistry<any>;
-    /**
-     * @description Configures the model registry to be used by the Model system
-     * @summary Sets the current model registry to a custom implementation
-     *
-     * @param {BuilderRegistry<any>} modelRegistry - The new implementation of Registry to use
-     * @return {void}
-     */
-    static setRegistry(modelRegistry: BuilderRegistry<any>): void;
-}
-/**
- * @summary Bulk Registers Models
- * @description Useful when using bundlers that might not evaluate all the code at once
- *
- * @template M extends Model
- * @param {Array<Constructor<M>> | Array<{name: string, constructor: Constructor<M>}>} [models]
- *
- * @memberOf module:decorator-validation
- * @category Model
- */
-export declare function bulkModelRegister<M extends Model>(...models: (Constructor<M> | {
-    name: string;
-    constructor: Constructor<M>;
-})[]): void;

package/lib/model/ModelRegistry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ModelRegistry.js","sourceRoot":"","sources":["../../src/model/ModelRegistry.ts"],"names":[],"mappings":"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"}

package/lib/model/constants.d.ts

@@ -1,65 +0,0 @@
-/**
- * @description Enumeration of JavaScript primitive type identifiers used by the model system.
- * @summary References the relevant JS primitives and standardizes their string representations across the library.
- * @property {string} STRING references the string primitive
- * @property {string} NUMBER references the number primitive
- * @property {string} BOOLEAN references the boolean primitive
- * @property {string} BIGINT references the bigint primitive
- * @enum Primitives
- * @readonly
- * @memberOf module:decorator-validation
- */
-export declare enum Primitives {
-    /** references the string primitive */
-    STRING = "string",
-    /** references the number primitive */
-    NUMBER = "number",
-    /** references the boolean primitive */
-    BOOLEAN = "boolean",
-    /** references the bigint primitive */
-    BIGINT = "bigint"
-}
-/**
- * @description Reserved model names which are excluded from model rebuilding.
- * @summary References the Reserved model names to ignore during Model rebuilding to avoid interfering with native types and special cases.
- * @property {string} STRING
- * @property {string} OBJECT
- * @property {string} NUMBER
- * @property {string} BOOLEAN
- * @property {string} BIGINT
- * @property {string} DATE
- * @enum ReservedModels
- * @readonly
- * @memberOf module:decorator-validation
- */
-export declare const ReservedModels: {
-    /** reserved name for string */
-    STRING: StringConstructor;
-    /** reserved name for object */
-    OBJECT: ObjectConstructor;
-    /** reserved name for number */
-    NUMBER: NumberConstructor;
-    /** reserved name for boolean */
-    BOOLEAN: BooleanConstructor;
-    /** reserved name for bigint */
-    BIGINT: BigIntConstructor;
-    /** reserved name for Date */
-    DATE: DateConstructor;
-};
-/**
- * @description Basic supported JavaScript types used by the validation system.
- * @summary References the basic supported JS types as strings that can be used for type checking and metadata.
- * @typedef {Object} JsTypes
- * @property {"string"} string String primitive identifier
- * @property {"array"} array Array type identifier
- * @property {"number"} number Number primitive identifier
- * @property {"boolean"} boolean Boolean primitive identifier
- * @property {"symbol"} symbol Symbol primitive identifier
- * @property {"function"} function Function type identifier
- * @property {"object"} object Object type identifier
- * @property {"undefined"} undefined Undefined type identifier
- * @property {"null"} null Null value identifier
- * @property {"bigint"} BIGINT BigInt primitive identifier
- * @memberOf module:decorator-validation
- */
-export declare const jsTypes: string[];

package/lib/model/constants.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/model/constants.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;GAUG;AACH,IAAY,UASX;AATD,WAAY,UAAU;IACpB,sCAAsC;IACtC,+BAAiB,CAAA;IACjB,sCAAsC;IACtC,+BAAiB,CAAA;IACjB,uCAAuC;IACvC,iCAAmB,CAAA;IACnB,sCAAsC;IACtC,+BAAiB,CAAA;AACnB,CAAC,EATW,UAAU,0BAAV,UAAU,QASrB;AAED;;;;;;;;;;;;GAYG;AACU,QAAA,cAAc,GAAG;IAC5B,+BAA+B;IAC/B,MAAM,EAAE,MAAM;IACd,+BAA+B;IAC/B,MAAM,EAAE,MAAM;IACd,+BAA+B;IAC/B,MAAM,EAAE,MAAM;IACd,gCAAgC;IAChC,OAAO,EAAE,OAAO;IAChB,+BAA+B;IAC/B,MAAM,EAAE,MAAM;IACd,6BAA6B;IAC7B,IAAI,EAAE,IAAI;CACX,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACU,QAAA,OAAO,GAAG;IACrB,QAAQ;IACR,OAAO;IACP,QAAQ;IACR,SAAS;IACT,QAAQ;IACR,UAAU;IACV,QAAQ;IACR,WAAW;IACX,MAAM;IACN,QAAQ;CACT,CAAC"}

package/lib/model/construction.d.ts

@@ -1,46 +0,0 @@
-import { Model } from "./Model";
-/**
- * @description Helper function to create an instance by invoking a constructor with dynamic arguments.
- * @summary Overrides standard construction patterns by wrapping the given constructor to allow spread argument invocation while preserving the prototype chain.
- * @template M the model instance type
- * @param {any} constructor The constructor function to invoke.
- * @param {...any[]} args Optional arguments to pass to the constructor.
- * @return {M} The newly constructed instance.
- * @function construct
- * @memberOf module:decorator-validation
- */
-export declare function construct<M extends Model>(constructor: any, ...args: any[]): M;
-/**
- * @description Recursively finds the last prototype in the chain before reaching Object.prototype.
- * @summary Walks up the prototype chain to locate the most derived prototype that still precedes the base Object prototype.
- * @param {object} obj The object whose prototype chain will be inspected.
- * @return {object} The last prototype before Object.prototype, or the input object if its prototype is Object.prototype.
- * @function findLastProtoBeforeObject
- * @memberOf module:decorator-validation
- */
-export declare function findLastProtoBeforeObject(obj: object): object;
-/**
- * @description Binds the Model class as the root prototype of the provided instance when not already a Model.
- * @summary Ensures objects created outside of the Model inheritance chain gain Model as their ultimate prototype to access model utilities.
- * @param {unknown} obj The object to bind to the Model prototype chain.
- * @return {void}
- * @function bindModelPrototype
- * @mermaid
- * sequenceDiagram
- *   participant Caller
- *   participant Fn as bindModelPrototype
- *   participant M as Model.prototype
- *   Caller->>Fn: obj
- *   alt obj instanceof Model
- *     Fn-->>Caller: return
- *   else obj chain ends at Object.prototype
- *     Fn->>Fn: setPrototypeOf(obj, M)
- *     Fn-->>Caller: return
- *   else deep prototype chain
- *     Fn->>Fn: walk prototypes
- *     Fn->>Fn: setPrototypeOf(last, M)
- *     Fn-->>Caller: return
- *   end
- * @memberOf module:decorator-validation
- */
-export declare function bindModelPrototype(obj: unknown): void;

package/lib/model/construction.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"construction.js","sourceRoot":"","sources":["../../src/model/construction.ts"],"names":[],"mappings":";;AAYA,8BAOC;AAUD,8DASC;AA0BD,gDAqBC;AArFD,uCAAgC;AAEhC;;;;;;;;;GASG;AACH,SAAgB,SAAS,CACvB,WAAgB,EAChB,GAAG,IAAW;IAEd,MAAM,OAAO,GAAG,CAAC,GAAG,IAAW,EAAE,EAAE,CAAC,IAAI,WAAW,CAAC,GAAG,IAAI,CAAC,CAAC;IAC7D,OAAO,CAAC,SAAS,GAAG,WAAW,CAAC,SAAS,CAAC;IAC1C,OAAO,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC;AAC1B,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,yBAAyB,CAAC,GAAW;IACnD,IAAI,SAAS,GAAQ,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;IAChD,IAAI,SAAS,KAAK,MAAM,CAAC,SAAS;QAAE,OAAO,GAAG,CAAC;IAC/C,OAAO,SAAS,KAAK,MAAM,CAAC,SAAS,EAAE,CAAC;QACtC,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;QAC7C,IAAI,SAAS,KAAK,MAAM,CAAC,SAAS;YAAE,OAAO,SAAS,CAAC;QACrD,IAAI,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC,KAAK,MAAM,CAAC,SAAS;YAAE,OAAO,SAAS,CAAC;IAC9E,CAAC;IACD,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;AACrD,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,SAAgB,kBAAkB,CAAC,GAAY;IAC7C,IAAI,GAAG,YAAY,aAAK;QAAE,OAAO;IAEjC,SAAS,aAAa,CAAC,aAAsB,EAAE,SAAiB;QAC9D,MAAM,CAAC,cAAc,CAAC,aAAa,EAAE,SAAS,CAAC,CAAC;IAClD,CAAC;IAED,MAAM,SAAS,GAAQ,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;IAClD,IAAI,SAAS,KAAK,MAAM,CAAC,SAAS,EAAE,CAAC;QACnC,OAAO,aAAa,CAAC,GAAG,EAAE,aAAK,CAAC,SAAS,CAAC,CAAC;IAC7C,CAAC;IACD,OAAO,SAAS,KAAK,MAAM,CAAC,SAAS,EAAE,CAAC;QACtC,MAAM,IAAI,GAAG,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;QAC9C,IACE,IAAI,KAAK,MAAM,CAAC,SAAS;YACzB,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,MAAM,CAAC,SAAS,EAChD,CAAC;YACD,OAAO,aAAa,CAAC,SAAS,EAAE,aAAK,CAAC,SAAS,CAAC,CAAC;QACnD,CAAC;IACH,CAAC;IACD,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;AAC7D,CAAC"}

package/lib/model/decorators.d.ts

@@ -1,47 +0,0 @@
-/**
- * @description Base decorator for model classes.
- * @summary This decorator wraps the original constructor to bind the Model prototype, run a builder function, and register the model.
- * @param {any} original The original constructor of the class.
- * @return {any} The new constructor with added model functionality.
- * @function modelBaseDecorator
- * @memberOf module:decorator-validation
- */
-export declare function modelBaseDecorator(original: any): any;
-/**
- * @summary Defines a class as a Model class
- * @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;
- *
- * @function model
- *
- * @category Class Decorators
- */
-export declare function model(): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => 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;
- *
- * @param {string} algorithm the algorithm to use
- *
- * @function hashedBy
- *
- * @category Class Decorators
- */
-export declare function hashedBy(algorithm: string, ...args: any[]): (model: any, prop?: any, descriptor?: PropertyDescriptor | number) => 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[]): (model: any, prop?: any, descriptor?: PropertyDescriptor | number) => void;

package/lib/model/decorators.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../src/model/decorators.ts"],"names":[],"mappings":";;AAaA,gDA6BC;AAcD,sBAGC;AAgBD,4BAKC;AAWD,oCAKC;AAhGD,qDAA+D;AAC/D,wDAA+C;AAC/C,uCAAgC;AAChC,qDAA4D;AAE5D;;;;;;;GAOG;AACH,SAAgB,kBAAkB,CAAC,QAAa;IAC9C,gCAAgC;IAChC,MAAM,cAAc,GAAQ,UAAU,GAAG,IAAW;QAClD,MAAM,QAAQ,GAAgC,IAAA,wBAAS,EAAC,QAAQ,EAAE,GAAG,IAAI,CAAC,CAAC;QAC3E,IAAA,iCAAkB,EAAC,QAAQ,CAAC,CAAC;QAE7B,2EAA2E;QAC3E,MAAM,OAAO,GAAG,aAAK,CAAC,UAAU,EAAE,CAAC;QACnC,IAAI,OAAO;YAAE,OAAO,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;QAElE,OAAO,QAAQ,CAAC;IAClB,CAAC,CAAC;IAEF,oDAAoD;IACpD,cAAc,CAAC,SAAS,GAAG,QAAQ,CAAC,SAAS,CAAC;IAE9C,yDAAyD;IACzD,MAAM,CAAC,cAAc,CAAC,cAAc,EAAE,MAAM,EAAE;QAC5C,QAAQ,EAAE,KAAK;QACf,UAAU,EAAE,IAAI;QAChB,YAAY,EAAE,KAAK;QACnB,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI;KAC3C,CAAC,CAAC;IAEH,IAAA,qBAAQ,EAAC,qBAAS,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC,cAAc,CAAC,CAAC;IAE1D,aAAK,CAAC,QAAQ,CAAC,cAAc,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC9C,kDAAkD;IAClD,OAAO,cAAc,CAAC;AACxB,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,KAAK;IACnB,MAAM,GAAG,GAAG,qBAAS,CAAC,KAAK,CAAC;IAC5B,OAAO,uBAAU,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,KAAK,EAAE,CAAC;AAChE,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,QAAQ,CAAC,SAAiB,EAAE,GAAG,IAAW;IACxD,OAAO,IAAA,qBAAQ,EAAC,qBAAS,CAAC,OAAO,EAAE;QACjC,SAAS,EAAE,SAAS;QACpB,IAAI,EAAE,IAAI;KACX,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,YAAY,CAAC,UAAkB,EAAE,GAAG,IAAW;IAC7D,OAAO,IAAA,qBAAQ,EAAC,qBAAS,CAAC,aAAa,EAAE;QACvC,UAAU,EAAE,UAAU;QACtB,IAAI,EAAE,IAAI;KACX,CAAC,CAAC;AACL,CAAC"}

package/lib/model/index.d.ts

@@ -1,10 +0,0 @@
-export * from "./constants";
-export * from "./construction";
-export * from "./decorators";
-export * from "./ModelRegistry";
-export * from "./Model";
-export * from "./ModelErrorDefinition";
-export * from "./Builder";
-export * from "./types";
-export * from "./validation";
-export * from "./utils";

package/lib/model/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/model/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,kDAA4B;AAC5B,qDAA+B;AAC/B,mDAA6B;AAC7B,sDAAgC,CAAC,mCAAmC;AACpE,8CAAwB;AACxB,6DAAuC;AACvC,gDAA0B;AAC1B,8CAAwB;AACxB,mDAA6B;AAC7B,8CAAwB"}

package/lib/model/types.d.ts

@@ -1,145 +0,0 @@
-import type { ConditionalAsync } from "../types";
-import { ModelErrorDefinition } from "./ModelErrorDefinition";
-import { Model } from "./Model";
-/**
- * @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;
-/**
- * @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>;
-/**
- * @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
- * @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 validation behavior on models, supporting both synchronous and asynchronous validations.
- * Implementers must provide a `hasErrors` method that performs the validation and returns either validation errors or undefined if validation passes.
- *
- * @template Async - A boolean flag indicating whether the validation is asynchronous (`true`) or synchronous (`false`).
- *
- * @param {any[]} [args] - Optional arguments to control validation behavior passed to the validation method.
- *
- * @interface Validatable
- * @category Model
- * @memberOf module:decorator-validation
- *
- * @example
- * ```typescript
- * // Synchronous validation example
- * class SyncModel implements Validatable<false> {
- *   hasErrors(...args: any[]): ModelErrorDefinition | undefined {
- *     // perform synchronous validation logic
- *     return undefined; // or return errors if invalid
- *   }
- * }
- *
- * // Asynchronous validation example
- * class AsyncModel implements Validatable<true> {
- *   async hasErrors(...args: any[]): Promise<ModelErrorDefinition | undefined> {
- *     // perform asynchronous validation logic
- *     return undefined; // or return errors if invalid
- *   }
- * }
- * ```
- */
-export interface Validatable<Async extends boolean = false> {
-    /**
-     * @description Validates the object against its validation rules.
-     * @summary Validates the model and returns the {@link ModelErrorDefinition} if any errors exist, or `undefined` if no errors.
-     *
-     * @param {any[]} [args] - Optional arguments that may influence validation logic.
-     * @return {ConditionalAsync<Async, ModelErrorDefinition | undefined>} Validation errors or undefined, conditionally wrapped in a Promise if asynchronous.
-     *
-     * @method
-     */
-    hasErrors(...args: any[]): ConditionalAsync<Async, ModelErrorDefinition | undefined>;
-}
-/**
- * @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 {
-    /**
-     * @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(...args: any[]): string;
-}
-/**
- * @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 {
-    /**
-     * @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
-     */
-    hash(...args: any[]): string;
-}
-/**
- * @description Interface for objects that can be compared with other objects
- * @summary Defines the equality comparison API for model objects
- * @template T
- * @interface Comparable
- * @memberOf module:decorator-validation
- * @category Model
- */
-export interface Comparable {
-    /**
-     * @description Determines if this object is equal to another object
-     * @summary Compares this object with another for equality
-     * @param {T} other - The object to compare with
-     * @param {any[]} [args] - Additional arguments for comparison
-     * @return {boolean} - True if the objects are equal, false otherwise
-     * @method
-     */
-    equals<T extends Model>(this: T, other: T, ...args: any[]): boolean;
-    compare<T extends Model>(this: T, other: T, ...args: any[]): Comparison<T> | undefined;
-}
-export type SetterKeyFor<OBJ, K extends keyof OBJ> = `set${Capitalize<string & K>}`;
-export type SetterFor<OBJ, K extends keyof OBJ, R> = (value: OBJ[K]) => R;
-export type Builder<OUT, ARGS extends any[] = any[], IN = OUT> = {
-    [K in keyof OUT as K extends keyof Model | "build" ? never : K]: OUT[K];
-} & {
-    [K in keyof OUT as K extends keyof Model | "build" ? never : SetterKeyFor<OUT, K>]: SetterFor<OUT, K, IN>;
-} & {
-    build: (...args: ARGS) => OUT | Promise<OUT>;
-};
-export type Comparison<M, K extends keyof M = keyof M> = Record<K, {
-    other: M[K] | undefined;
-    current: M[K] | undefined;
-}>;

package/lib/model/utils.d.ts

@@ -1,13 +0,0 @@
-import { ConditionalAsync } from "../types";
-/**
- * Wraps a value in a Promise if the `async` flag is true.
- *
- * @template T - The type of the value being wrapped.
- * @template Async - A boolean type that determines if the result should be wrapped in a Promise.
- *
- * @param value - The value to return directly or wrap in a Promise.
- * @param async - If true, the value is wrapped in a resolved Promise. If false or undefined, the value is returned as-is.
- *
- * @returns The original value or a Promise resolving to it, depending on the `async` flag.
- */
-export declare function toConditionalPromise<T, Async extends boolean>(value: T, async?: Async): ConditionalAsync<Async, T>;

package/lib/model/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/model/utils.ts"],"names":[],"mappings":";;AAaA,oDAKC;AAhBD;;;;;;;;;;GAUG;AACH,SAAgB,oBAAoB,CAClC,KAAQ,EACR,KAAa;IAEb,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAA+B,CAAC;AAChF,CAAC"}

package/lib/model/validation.d.ts

@@ -1,92 +0,0 @@
-import { ModelErrorDefinition } from "./ModelErrorDefinition";
-import type { Model } from "./Model";
-import { ConditionalAsync } from "../types";
-export declare function validateChildValue<M extends Model>(prop: string, childValue: any, parentModel: M, allowedTypes: string[], async: boolean, ...propsToIgnore: string[]): string | undefined | ModelErrorDefinition | Promise<string | undefined | ModelErrorDefinition>;
-/**
- * @description Retrieves nested properties to ignore for child validation
- * @param parentProp - The property of the parent model
- * @param propsToIgnore - Properties to ignore from the parent model
- * @returns An array of properties to ignore for the child model
- */
-export declare function getChildNestedPropsToIgnore(parentProp: string, ...propsToIgnore: string[]): string[];
-export declare function validateDecorator<M extends Model, Async extends boolean = false>(model: M, value: any, decorator: any, async?: Async): ConditionalAsync<Async, string | undefined>;
-/**
- * @description
- * Executes validation logic for a set of decorators applied to a model's property, handling both
- * synchronous and asynchronous validations, including support for nested validations and lists.
- *
- * @summary
- * Iterates over an array of decorator metadata objects and applies each validation rule to the
- * provided value. For list decorators (`ValidationKeys.LIST`), it performs element-wise validation,
- * supporting nested model validation and type checks. If the `async` flag is set, asynchronous
- * validation is supported using `Promise.all`. The result is a record mapping validation keys to
- * error messages, or `undefined` if no errors are found.
- *
- * @template M - A type parameter extending `Model`, representing the model type being validated.
- * @template Async - A boolean indicating whether validation should be performed asynchronously.
- *
- * @param {M} model - The model instance that the validation is associated with.
- * @param {string} prop - The model field name
- * @param {any} value - The value to be validated against the provided decorators.
- * @param {DecoratorMetadataAsync} decorators - An object of metadata representing validation decorators.
- * @param {Async} [async] - Optional flag indicating whether validation should be performed asynchronously.
- *
- * @return {ConditionalAsync<Async, Record<string, string>> | undefined}
- * Returns either a record of validation errors (keyed by the decorator key) or `undefined` if no errors are found.
- * If `async` is true, the return value is a Promise resolving to the same structure.
- *
- * @function validateDecorators
- */
-export declare function validateDecorators<M extends Model, Async extends boolean = false>(model: M, prop: string, value: any, decorators: any, async?: Async, ...propsToIgnore: string[]): ConditionalAsync<Async, Record<string, string> | undefined>;
-/**
- * @function validate
- * @template M
- * @template Async
- * @memberOf module:decorator-validation
- * @category Model
- *
- * @description
- * Validates the properties of a {@link Model} instance using registered decorators.
- * Supports both synchronous and asynchronous validation flows, depending on the `async` flag.
- *
- * @summary
- * This function inspects a given model object, identifies decorated properties that require validation,
- * and applies the corresponding validation rules. It also supports nested model validation and gracefully
- * merges any validation errors. For collections (Array/Set), it enforces the presence of the `@list` decorator
- * and checks the type of elements. If a property is a nested model, it will call `hasErrors` on it and flatten
- * the nested error keys using dot notation.
- *
- * @param {M} model - The model instance to be validated. Must extend from {@link Model}.
- * @param {Async} [async] - A flag indicating whether validation should be asynchronous.
- * @param {...string} propsToIgnore - A variadic list of property names that should be skipped during validation.
- *
- * @returns {ConditionalAsync<Async, ModelErrorDefinition | undefined>}
- * Returns either a {@link ModelErrorDefinition} containing validation errors,
- * or `undefined` if no errors are found. When `async` is `true`, returns a Promise.
- *
- * @see {@link Model}
- * @see {@link ModelErrorDefinition}
- * @see {@link validateDecorators}
- * @see {@link getValidatableProperties}
- *
- * @mermaid
- * sequenceDiagram
- *     participant Caller
- *     participant validate
- *     participant getValidatableProperties
- *     participant validateDecorators
- *     participant ModelInstance
- *     Caller->>validate: call with obj, async, propsToIgnore
- *     validate->>getValidatableProperties: retrieve decorated props
- *     loop for each property
- *         validate->>validateDecorators: validate using decorators
- *         alt is nested model
- *             validate->>ModelInstance: call hasErrors()
- *         end
- *     end
- *     alt async
- *         validate->>validate: Promise.allSettled for errors
- *     end
- *     validate-->>Caller: return ModelErrorDefinition | undefined
- */
-export declare function validate<M extends Model<boolean>, Async extends boolean = false>(model: M, async: Async, ...propsToIgnore: string[]): ConditionalAsync<Async, ModelErrorDefinition | undefined>;