@decaf-ts/decorator-validation 1.15.0 → 1.17.0

package/lib/types/model/decorators.d.mts

@@ -0,0 +1,47 @@
+/**
+ * @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/types/model/index.d.cts

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

package/lib/types/model/index.d.mts

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

package/lib/types/model/types.d.cts

@@ -0,0 +1,145 @@
+import type { ConditionalAsync } from "../types/index.cjs";
+import { ModelErrorDefinition } from "./ModelErrorDefinition.cjs";
+import { Model } from "./Model.cjs";
+/**
+ * @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/types/model/types.d.mts

@@ -0,0 +1,145 @@
+import type { ConditionalAsync } from "../types/index.js";
+import { ModelErrorDefinition } from "./ModelErrorDefinition.js";
+import { Model } from "./Model.js";
+/**
+ * @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/types/model/utils.d.cts

@@ -0,0 +1,13 @@
+import { ConditionalAsync } from "../types/index.cjs";
+/**
+ * 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/types/model/utils.d.mts

@@ -0,0 +1,13 @@
+import { ConditionalAsync } from "../types/index.js";
+/**
+ * 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/types/model/validation.d.cts

@@ -0,0 +1,92 @@
+import { ModelErrorDefinition } from "./ModelErrorDefinition.cjs";
+import type { Model } from "./Model.cjs";
+import { ConditionalAsync } from "../types/index.cjs";
+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>;

package/lib/types/model/validation.d.mts

@@ -0,0 +1,92 @@
+import { ModelErrorDefinition } from "./ModelErrorDefinition.js";
+import type { Model } from "./Model.js";
+import { ConditionalAsync } from "../types/index.js";
+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>;