@decaf-ts/decorator-validation 1.19.0 → 1.21.0

package/lib/types/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/types/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/types/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/types/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/types/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/types/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/types/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>;

package/lib/types/overrides/Metadata.d.ts

@@ -1,132 +0,0 @@
-import { Model } from "../model/Model";
-import "@decaf-ts/decoration";
-import { Constructor } from "@decaf-ts/decoration";
-import { designTypeReturn, ExtendedMetadata } from "./types";
-import { ValidationMetadata } from "../validation/types";
-declare module "@decaf-ts/decoration" {
-    namespace Metadata {
-        /**
-         * @description Retrieves validation metadata for a specific property of a model
-         * @summary Fetches validation rules and constraints that were applied to a property
-         * via decorators. The optional key parameter allows drilling down to specific
-         * validation types (e.g., 'required', 'min', 'max').
-         *
-         * @template M - The model type extending from Model
-         * @param {Constructor<M>} model - The constructor of the target model class
-         * @param {keyof M} property - The property name to retrieve validation for
-         * @param {string} [key] - Optional specific validation key to retrieve (e.g., 'required', 'pattern')
-         * @return {any} The validation metadata object or value at the specified key
-         *
-         * @example
-         * class User extends Model {
-         *   @required()
-         *   @maxLength(100)
-         *   name!: string;
-         * }
-         *
-         * // Get all validation metadata for 'name'
-         * const validations = Metadata.validationFor(User, 'name');
-         *
-         * // Get specific validation metadata
-         * const required = Metadata.validationFor(User, 'name', 'required');
-         */
-        function validationFor<M extends Model, P extends keyof M = keyof M, K extends string = string>(this: Metadata, model: Constructor<M>, property?: keyof M, key?: string): (K extends string ? ValidationMetadata : P extends keyof M ? Record<string, ValidationMetadata> : Record<keyof M, Record<string, ValidationMetadata>>) | undefined;
-        /**
-         * @description Retrieves all validatable for a model
-         * @param model
-         */
-        function validatableProperties<M extends Model>(model: Constructor<M>, ...propsToIgnore: string[]): string[];
-        /**
-         * @description Retrieves extended metadata for a model or a specific key within it
-         * @summary When called with a constructor only, returns the entire metadata object
-         * associated with the model, including validation rules, property types, relationships,
-         * and other decorator-applied metadata. This override extends the base Metadata.get
-         * method with type-safe support for ExtendedMetadata.
-         *
-         * @template M - The model type
-         * @template META - The extended metadata type, defaults to ExtendedMetadata<M>
-         * @param {Constructor<M>} model - The target constructor used to locate the metadata record
-         * @param {keyof M} prop - Optional property of the model.
-         * @return {META|undefined} The complete metadata object for the model, or undefined if no metadata exists
-         *
-         * @example
-         * class Article extends Model {
-         *   @pk()
-         *   @type(Number)
-         *   id!: number;
-         *
-         *   @required()
-         *   @maxLength(200)
-         *   title!: string;
-         *
-         *   @oneToMany(() => Comment, { update: true, delete: true }, true)
-         *   comments!: Comment[];
-         * }
-         *
-         * // Get all metadata for the Article model
-         * const metadata = Metadata.get<Article>(Article);
-         * // metadata contains:
-         * // - property definitions
-         * // - validation rules
-         * // - relationship mappings
-         * // - primary key information
-         * // - column mappings
-         *
-         * @remarks
-         * The @ts-expect-error directive is used because this declaration intentionally
-         * overrides the signature from the base module to provide enhanced type information
-         * specific to the decorator-validation system.
-         */
-        function get<M, META extends ExtendedMetadata<M> = ExtendedMetadata<M>>(model: Constructor<M>, prop?: keyof M): META | undefined;
-        /**
-         * @description Retrieves the original constructor name for a model
-         * @summary Fetches the original constructor name for a model from the metadata of a model.
-         *
-         * @template M - The model type extending from Model
-         * @param {Constructor<M>} model - The constructor of the target model class
-         * @return {string} The metadata object or value
-         *
-         * @example
-         * class User extends Model {
-         *
-         * // Get the constructor name for 'User'
-         * const constName = Metadata.modelName(User);
-         */
-        function modelName<M>(model: Constructor<M>): string;
-        /**
-         * @description Retrieves all allowed types for a model or a property
-         * @summary Retrieves all allowed types for a model or a property from it's metadata.
-         *
-         * @template M - The model type extending from Model
-         * @param {Constructor<M>} model - The constructor of the target model class
-         * @param {keyof M} property - The property name to retrieve validation for
-         * @return {any[]} An array of the allowed types
-         *
-         * @example
-         * class User extends Model {
-         *
-         * // Get all validation metadata for 'User'
-         * const allowedTypes = Metadata.meallowedTypestadata(User);
-         */
-        function allowedTypes<M>(model: Constructor<M>, property?: keyof M): any[];
-        /**
-         * @description Retrieves all allowed types for a model or a property
-         * @summary Retrieves all allowed types for a model or a property from it's metadata.
-         *
-         * @template model - The model type extending from Model
-         * @param {Constructor<M>} model - The constructor of the target model class
-         * @param {keyof M} property - The property name to retrieve validation for
-         * @return {designTypeReturn} An object of the designtypes
-         *
-         * @example
-         * class User extends Model {
-         *
-         * // Get the designtypes for property name
-         * const { designTypes, designType } = Metadata.getPropDesignTypes(User.constructor, 'name');
-         */
-        function getPropDesignTypes<M>(model: Constructor<M>, property: keyof M): designTypeReturn;
-        function isModel(target: Record<string, any>): boolean;
-        function isPropertyModel<M extends Model>(target: M, attribute: string): boolean | string | undefined;
-        function getAttributes<V extends Model>(model: Constructor<V> | V): string[];
-    }
-}

package/lib/types/overrides/index.d.ts

@@ -1,4 +0,0 @@
-import "./overrides";
-export * from "./Metadata";
-export * from "./overrides";
-export * from "./types";

package/lib/types/overrides/overrides.d.ts

@@ -1 +0,0 @@
-import "./Metadata";

package/lib/types/overrides/types.d.ts

@@ -1,17 +0,0 @@
-import { BasicMetadata } from "@decaf-ts/decoration";
-import { ValidatorOptions } from "../validation/types";
-export type ExtendedMetadata<M> = BasicMetadata<M> & {
-    validation: Record<keyof M, ValidatorOptions>;
-};
-/**
- * @description Return type for design type information.
- * @summary Defines the structure of the return type for functions that provide design type information.
- * @property {any[]} designTypes An array of design types.
- * @property {any} designType The primary design type.
- * @typedef {object} designTypeReturn
- * @memberOf module:decorator-validation
- */
-export type designTypeReturn = {
-    designTypes: any[];
-    designType: any;
-};

package/lib/types/types/index.d.ts

@@ -1 +0,0 @@
-export * from "./validation";

package/lib/types/types/validation.d.ts

@@ -1,28 +0,0 @@
-import { Model } from "../model/Model";
-import { ModelErrorDefinition } from "../model/ModelErrorDefinition";
-/**
- * @description Conditionally wraps a type in a `Promise` based on the `Async` flag.
- * @summary Utility type that resolves to `T` if `Async` is `false`, or to `Promise<T>` if `Async` is `true`.
- * Used to abstract the return type of functions that may be either synchronous or asynchronous depending on a flag.
- *
- * @template Async A boolean flag indicating whether the result should be asynchronous (`true`) or synchronous (`false`).
- * @template T The base type to return directly or to wrap in a `Promise`.
- *
- * @example
- * ```typescript
- * // Synchronous result
- * type SyncResult: string | number = ConditionalAsync<false, string | number>;
- *
- * // Asynchronous result
- * type AsyncResult: Promise<string | number> = ConditionalAsync<true, string | number>;
- * ```
- * @memberOf module:decorator-validation
- */
-export type ConditionalAsync<Async extends boolean, T> = Async extends true ? Promise<T> : T;
-export type DecoratorMetadataAsync = {
-    async?: boolean;
-};
-/**
- * @deprecated
- */
-export type ModelConditionalAsync<M> = M extends Model<true> ? Promise<ModelErrorDefinition | undefined> : ModelErrorDefinition | undefined;