@decaf-ts/decorator-validation 1.15.0 → 1.16.0

package/lib/types/validation/Validators/TypeValidator.d.cts

@@ -0,0 +1,79 @@
+import { Validator } from "./Validator.cjs";
+import { TypeValidatorOptions } from "../types.cjs";
+/**
+ * @description Validator for checking if a value is of the expected type(s)
+ * @summary The TypeValidator ensures that a value matches one of the specified types.
+ * It can validate against a single type, multiple types, or a type with a specific name.
+ * This validator is typically used with the @type decorator and is fundamental for
+ * ensuring type safety in validated models.
+ *
+ * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#TYPE}
+ *
+ * @class TypeValidator
+ * @extends Validator
+ *
+ * @example
+ * ```typescript
+ * // Create a type validator with default error message
+ * const typeValidator = new TypeValidator();
+ *
+ * // Create a type validator with custom error message
+ * const customTypeValidator = new TypeValidator("Value must be of type {0}, but got {1}");
+ *
+ * // Validate against a single type
+ * const stringOptions = { types: "string" };
+ * typeValidator.hasErrors("hello", stringOptions); // undefined (valid)
+ * typeValidator.hasErrors(123, stringOptions); // Returns error message (invalid)
+ *
+ * // Validate against multiple types
+ * const multiOptions = { types: ["string", "number"] };
+ * typeValidator.hasErrors("hello", multiOptions); // undefined (valid)
+ * typeValidator.hasErrors(123, multiOptions); // undefined (valid)
+ * typeValidator.hasErrors(true, multiOptions); // Returns error message (invalid)
+ *
+ * // Validate against a class type
+ * const classOptions = { types: { name: "Date" } };
+ * typeValidator.hasErrors(new Date(), classOptions); // undefined (valid)
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant V as TypeValidator
+ *   participant R as Reflection
+ *
+ *   C->>V: new TypeValidator(message)
+ *   C->>V: hasErrors(value, options)
+ *   alt value is undefined
+ *     V-->>C: undefined (valid)
+ *   else value is defined
+ *     V->>R: evaluateDesignTypes(value, types)
+ *     alt type evaluation passes
+ *       V-->>C: undefined (valid)
+ *     else type evaluation fails
+ *       V->>V: Format error message with type info
+ *       V-->>C: Error message
+ *     end
+ *   end
+ *
+ * @category Validators
+ */
+export declare class TypeValidator extends Validator<TypeValidatorOptions> {
+    constructor(message?: string);
+    /**
+     * @description Checks if a value is of the expected type(s)
+     * @summary Validates that the provided value matches one of the specified types.
+     * It uses the Reflection utility to evaluate if the value's type matches the expected types.
+     * The method skips validation for undefined values to avoid conflicts with the RequiredValidator.
+     *
+     * @param {any} value - The value to validate
+     * @param {TypeValidatorOptions} options - Configuration options containing the expected types
+     *
+     * @return {string | undefined} Error message if validation fails, undefined if validation passes
+     *
+     * @override
+     *
+     * @see Validator#hasErrors
+     */
+    hasErrors(value: any, options: TypeValidatorOptions): string | undefined;
+}

package/lib/types/validation/Validators/TypeValidator.d.mts

@@ -0,0 +1,79 @@
+import { Validator } from "./Validator.js";
+import { TypeValidatorOptions } from "../types.js";
+/**
+ * @description Validator for checking if a value is of the expected type(s)
+ * @summary The TypeValidator ensures that a value matches one of the specified types.
+ * It can validate against a single type, multiple types, or a type with a specific name.
+ * This validator is typically used with the @type decorator and is fundamental for
+ * ensuring type safety in validated models.
+ *
+ * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#TYPE}
+ *
+ * @class TypeValidator
+ * @extends Validator
+ *
+ * @example
+ * ```typescript
+ * // Create a type validator with default error message
+ * const typeValidator = new TypeValidator();
+ *
+ * // Create a type validator with custom error message
+ * const customTypeValidator = new TypeValidator("Value must be of type {0}, but got {1}");
+ *
+ * // Validate against a single type
+ * const stringOptions = { types: "string" };
+ * typeValidator.hasErrors("hello", stringOptions); // undefined (valid)
+ * typeValidator.hasErrors(123, stringOptions); // Returns error message (invalid)
+ *
+ * // Validate against multiple types
+ * const multiOptions = { types: ["string", "number"] };
+ * typeValidator.hasErrors("hello", multiOptions); // undefined (valid)
+ * typeValidator.hasErrors(123, multiOptions); // undefined (valid)
+ * typeValidator.hasErrors(true, multiOptions); // Returns error message (invalid)
+ *
+ * // Validate against a class type
+ * const classOptions = { types: { name: "Date" } };
+ * typeValidator.hasErrors(new Date(), classOptions); // undefined (valid)
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant V as TypeValidator
+ *   participant R as Reflection
+ *
+ *   C->>V: new TypeValidator(message)
+ *   C->>V: hasErrors(value, options)
+ *   alt value is undefined
+ *     V-->>C: undefined (valid)
+ *   else value is defined
+ *     V->>R: evaluateDesignTypes(value, types)
+ *     alt type evaluation passes
+ *       V-->>C: undefined (valid)
+ *     else type evaluation fails
+ *       V->>V: Format error message with type info
+ *       V-->>C: Error message
+ *     end
+ *   end
+ *
+ * @category Validators
+ */
+export declare class TypeValidator extends Validator<TypeValidatorOptions> {
+    constructor(message?: string);
+    /**
+     * @description Checks if a value is of the expected type(s)
+     * @summary Validates that the provided value matches one of the specified types.
+     * It uses the Reflection utility to evaluate if the value's type matches the expected types.
+     * The method skips validation for undefined values to avoid conflicts with the RequiredValidator.
+     *
+     * @param {any} value - The value to validate
+     * @param {TypeValidatorOptions} options - Configuration options containing the expected types
+     *
+     * @return {string | undefined} Error message if validation fails, undefined if validation passes
+     *
+     * @override
+     *
+     * @see Validator#hasErrors
+     */
+    hasErrors(value: any, options: TypeValidatorOptions): string | undefined;
+}

package/lib/types/validation/Validators/URLValidator.d.cts

@@ -0,0 +1,61 @@
+import { PatternValidator } from "./PatternValidator.cjs";
+import { PatternValidatorOptions } from "../types.cjs";
+/**
+ * @description Validator for checking if a string is a valid URL
+ * @summary The URLValidator checks if a string matches a standard URL pattern.
+ * It extends the PatternValidator and uses a robust URL regex pattern to validate web addresses.
+ * The pattern is sourced from {@link https://gist.github.com/dperini/729294} and is widely
+ * recognized for its accuracy in validating URLs. This validator is typically used with the @url decorator.
+ *
+ * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#URL}
+ *
+ * @class URLValidator
+ * @extends PatternValidator
+ *
+ * @example
+ * ```typescript
+ * // Create a URL validator with default error message
+ * const urlValidator = new URLValidator();
+ *
+ * // Create a URL validator with custom error message
+ * const customUrlValidator = new URLValidator("Please enter a valid web address");
+ *
+ * // Validate a URL
+ * const result = urlValidator.hasErrors("https://example.com"); // undefined (valid)
+ * const invalidResult = urlValidator.hasErrors("not-a-url"); // Returns error message (invalid)
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant U as URLValidator
+ *   participant P as PatternValidator
+ *
+ *   C->>U: new URLValidator(message)
+ *   U->>P: super(message)
+ *   C->>U: hasErrors(value, options)
+ *   U->>P: super.hasErrors(value, options with URL pattern)
+ *   P-->>U: validation result
+ *   U-->>C: validation result
+ *
+ * @category Validators
+ */
+export declare class URLValidator extends PatternValidator {
+    constructor(message?: string);
+    /**
+     * @description Checks if a string is a valid URL
+     * @summary Validates that the provided string matches the URL pattern.
+     * This method extends the PatternValidator's hasErrors method by ensuring
+     * the URL pattern is used, even if not explicitly provided in the options.
+     *
+     * @param {string} value - The string to validate as a URL
+     * @param {PatternValidatorOptions} [options={}] - Optional configuration options
+     *
+     * @return {string | undefined} Error message if validation fails, undefined if validation passes
+     *
+     * @override
+     *
+     * @see PatternValidator#hasErrors
+     */
+    hasErrors(value: string, options?: PatternValidatorOptions): string | undefined;
+}

package/lib/types/validation/Validators/URLValidator.d.mts

@@ -0,0 +1,61 @@
+import { PatternValidator } from "./PatternValidator.js";
+import { PatternValidatorOptions } from "../types.js";
+/**
+ * @description Validator for checking if a string is a valid URL
+ * @summary The URLValidator checks if a string matches a standard URL pattern.
+ * It extends the PatternValidator and uses a robust URL regex pattern to validate web addresses.
+ * The pattern is sourced from {@link https://gist.github.com/dperini/729294} and is widely
+ * recognized for its accuracy in validating URLs. This validator is typically used with the @url decorator.
+ *
+ * @param {string} [message] - Custom error message to display when validation fails, defaults to {@link DEFAULT_ERROR_MESSAGES#URL}
+ *
+ * @class URLValidator
+ * @extends PatternValidator
+ *
+ * @example
+ * ```typescript
+ * // Create a URL validator with default error message
+ * const urlValidator = new URLValidator();
+ *
+ * // Create a URL validator with custom error message
+ * const customUrlValidator = new URLValidator("Please enter a valid web address");
+ *
+ * // Validate a URL
+ * const result = urlValidator.hasErrors("https://example.com"); // undefined (valid)
+ * const invalidResult = urlValidator.hasErrors("not-a-url"); // Returns error message (invalid)
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant U as URLValidator
+ *   participant P as PatternValidator
+ *
+ *   C->>U: new URLValidator(message)
+ *   U->>P: super(message)
+ *   C->>U: hasErrors(value, options)
+ *   U->>P: super.hasErrors(value, options with URL pattern)
+ *   P-->>U: validation result
+ *   U-->>C: validation result
+ *
+ * @category Validators
+ */
+export declare class URLValidator extends PatternValidator {
+    constructor(message?: string);
+    /**
+     * @description Checks if a string is a valid URL
+     * @summary Validates that the provided string matches the URL pattern.
+     * This method extends the PatternValidator's hasErrors method by ensuring
+     * the URL pattern is used, even if not explicitly provided in the options.
+     *
+     * @param {string} value - The string to validate as a URL
+     * @param {PatternValidatorOptions} [options={}] - Optional configuration options
+     *
+     * @return {string | undefined} Error message if validation fails, undefined if validation passes
+     *
+     * @override
+     *
+     * @see PatternValidator#hasErrors
+     */
+    hasErrors(value: string, options?: PatternValidatorOptions): string | undefined;
+}

package/lib/types/validation/Validators/Validator.d.cts

@@ -0,0 +1,65 @@
+import { ValidatorOptions } from "../types.cjs";
+import type { PathProxy } from "../../utils/index.cjs";
+import { BaseValidator } from "./BaseValidator.cjs";
+/**
+ * @description
+ * Abstract class for defining synchronous validators.
+ *
+ * This class extends the base {@link BaseValidator} and enforces that any implementation of `hasErrors` must be synchronous.
+ *
+ * Use this when the validation process is immediate and does not require asynchronous operations.
+ *
+ * @example
+ * ```typescript
+ * // Example of a synchronous validator that checks if a number is greater than
+ * class GreaterThanValidator extends Validator<{ gt?: number }> {
+ *   constructor(message: string = "Value must be greater than {0}") {
+ *     super(message);
+ *   }
+ *
+ *   hasErrors(value: number, options?: { gt?: number }) {
+ *     const minValue = options?.gt ?? 0;
+ *     if (value <= minValue) {
+ *       return this.getMessage();
+ *     }
+ *     return undefined;
+ *   }
+ * }
+ *
+ * // Example usage:
+ * const validator = new GreaterThanValidator();
+ * const error = validator.hasErrors(10, { gt: 15 });
+ * if (error) {
+ *   console.log('Value must be greater than 15')
+ * } else {
+ *   console.log('Value is valid');
+ * }
+ * ```
+ *
+ * - If `value` is less than or equal to `gt`, returns the error message.
+ * - Otherwise, returns `undefined` indicating validation success.
+ *
+ * @see {@link BaseValidator} For the base validator.
+ * @see {@link ValidatorOptions} For the base validator options.
+ */
+export declare abstract class Validator<V extends ValidatorOptions = ValidatorOptions> extends BaseValidator<V, false> {
+    protected constructor(message?: string, ...acceptedTypes: string[]);
+    /**
+     * @description Validates a value against specific validation rules
+     * @summary Abstract method that must be implemented by all validator subclasses.
+     * This method contains the core validation logic that determines whether a value
+     * is valid according to the specific rules of the validator. If the value is valid,
+     * the method returns undefined; otherwise, it returns an error message.
+     *
+     * @template V - Type of the options object that can be passed to the validator
+     * @param {any} value - The value to validate
+     * @param {V} [options] - Optional configuration options for customizing validation behavior
+     * @param {PathProxy<any>} proxy -
+     * @return {string | undefined} Error message if validation fails, undefined if validation passes
+     *
+     * @abstract
+     *
+     * @see Model#validate
+     */
+    abstract hasErrors(value: any, options?: V, proxy?: PathProxy<any>): string | undefined;
+}

package/lib/types/validation/Validators/Validator.d.mts

@@ -0,0 +1,65 @@
+import { ValidatorOptions } from "../types.js";
+import type { PathProxy } from "../../utils/index.js";
+import { BaseValidator } from "./BaseValidator.js";
+/**
+ * @description
+ * Abstract class for defining synchronous validators.
+ *
+ * This class extends the base {@link BaseValidator} and enforces that any implementation of `hasErrors` must be synchronous.
+ *
+ * Use this when the validation process is immediate and does not require asynchronous operations.
+ *
+ * @example
+ * ```typescript
+ * // Example of a synchronous validator that checks if a number is greater than
+ * class GreaterThanValidator extends Validator<{ gt?: number }> {
+ *   constructor(message: string = "Value must be greater than {0}") {
+ *     super(message);
+ *   }
+ *
+ *   hasErrors(value: number, options?: { gt?: number }) {
+ *     const minValue = options?.gt ?? 0;
+ *     if (value <= minValue) {
+ *       return this.getMessage();
+ *     }
+ *     return undefined;
+ *   }
+ * }
+ *
+ * // Example usage:
+ * const validator = new GreaterThanValidator();
+ * const error = validator.hasErrors(10, { gt: 15 });
+ * if (error) {
+ *   console.log('Value must be greater than 15')
+ * } else {
+ *   console.log('Value is valid');
+ * }
+ * ```
+ *
+ * - If `value` is less than or equal to `gt`, returns the error message.
+ * - Otherwise, returns `undefined` indicating validation success.
+ *
+ * @see {@link BaseValidator} For the base validator.
+ * @see {@link ValidatorOptions} For the base validator options.
+ */
+export declare abstract class Validator<V extends ValidatorOptions = ValidatorOptions> extends BaseValidator<V, false> {
+    protected constructor(message?: string, ...acceptedTypes: string[]);
+    /**
+     * @description Validates a value against specific validation rules
+     * @summary Abstract method that must be implemented by all validator subclasses.
+     * This method contains the core validation logic that determines whether a value
+     * is valid according to the specific rules of the validator. If the value is valid,
+     * the method returns undefined; otherwise, it returns an error message.
+     *
+     * @template V - Type of the options object that can be passed to the validator
+     * @param {any} value - The value to validate
+     * @param {V} [options] - Optional configuration options for customizing validation behavior
+     * @param {PathProxy<any>} proxy -
+     * @return {string | undefined} Error message if validation fails, undefined if validation passes
+     *
+     * @abstract
+     *
+     * @see Model#validate
+     */
+    abstract hasErrors(value: any, options?: V, proxy?: PathProxy<any>): string | undefined;
+}

package/lib/types/validation/Validators/ValidatorRegistry.d.cts

@@ -0,0 +1,41 @@
+import { ValidatorDefinition } from "../types.cjs";
+import { IValidatorRegistry } from "../types.cjs";
+import { Validator } from "./Validator.cjs";
+/**
+ * @summary Base Implementation of a Validator Registry
+ *
+ * @prop {Validator[]} [validators] the initial validators to register
+ *
+ * @class ValidatorRegistry
+ * @implements IValidatorRegistry<T>
+ *
+ * @category Validation
+ */
+export declare class ValidatorRegistry<T extends Validator> implements IValidatorRegistry<T> {
+    private cache;
+    private customKeyCache;
+    constructor(...validators: (ValidatorDefinition | Validator)[]);
+    /**
+     * @summary retrieves the custom keys
+     */
+    getCustomKeys(): {
+        [indexer: string]: string;
+    };
+    /**
+     * @summary retrieves the registered validators keys
+     */
+    getKeys(): string[];
+    /**
+     * @summary Retrieves a validator
+     *
+     * @param {string} validatorKey one of the {@link ValidationKeys}
+     * @return {Validator | undefined} the registered Validator or undefined if there is nono matching the provided key
+     */
+    get<T extends Validator>(validatorKey: string): T | undefined;
+    /**
+     * @summary Registers the provided validators onto the registry
+     *
+     * @param {T[] | ValidatorDefinition[]} validator
+     */
+    register<T extends Validator>(...validator: (ValidatorDefinition | T)[]): void;
+}

package/lib/types/validation/Validators/ValidatorRegistry.d.mts

@@ -0,0 +1,41 @@
+import { ValidatorDefinition } from "../types.js";
+import { IValidatorRegistry } from "../types.js";
+import { Validator } from "./Validator.js";
+/**
+ * @summary Base Implementation of a Validator Registry
+ *
+ * @prop {Validator[]} [validators] the initial validators to register
+ *
+ * @class ValidatorRegistry
+ * @implements IValidatorRegistry<T>
+ *
+ * @category Validation
+ */
+export declare class ValidatorRegistry<T extends Validator> implements IValidatorRegistry<T> {
+    private cache;
+    private customKeyCache;
+    constructor(...validators: (ValidatorDefinition | Validator)[]);
+    /**
+     * @summary retrieves the custom keys
+     */
+    getCustomKeys(): {
+        [indexer: string]: string;
+    };
+    /**
+     * @summary retrieves the registered validators keys
+     */
+    getKeys(): string[];
+    /**
+     * @summary Retrieves a validator
+     *
+     * @param {string} validatorKey one of the {@link ValidationKeys}
+     * @return {Validator | undefined} the registered Validator or undefined if there is nono matching the provided key
+     */
+    get<T extends Validator>(validatorKey: string): T | undefined;
+    /**
+     * @summary Registers the provided validators onto the registry
+     *
+     * @param {T[] | ValidatorDefinition[]} validator
+     */
+    register<T extends Validator>(...validator: (ValidatorDefinition | T)[]): void;
+}

package/lib/types/validation/Validators/constants.d.cts

@@ -0,0 +1,157 @@
+/**
+ * @description Object-like set of keys used for comparison-based validations.
+ * @summary Provides canonical names for validators that compare two values (equality and ordering checks).
+ * @typedef {Object} ComparisonValidationKeysDef
+ * @property {"equals"} EQUALS Validates if two values are equal.
+ * @property {"different"} DIFF Validates if two values are different.
+ * @property {"lessThan"} LESS_THAN Validates if a value is less than another.
+ * @property {"lessThanOrEqual"} LESS_THAN_OR_EQUAL Validates if a value is less than or equal to another.
+ * @property {"greaterThan"} GREATER_THAN Validates if a value is greater than another.
+ * @property {"greaterThanOrEqual"} GREATER_THAN_OR_EQUAL Validates if a value is greater than or equal to another.
+ * @memberOf module:decorator-validation.Validation
+ */
+/**
+ * @description Keys used for comparison-based validations.
+ * @summary Canonical key names for comparison validators.
+ * @const ComparisonValidationKeys
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ * @type {ComparisonValidationKeysDef}
+ */
+export declare const ComparisonValidationKeys: {
+    readonly EQUALS: "equals";
+    readonly DIFF: "different";
+    readonly LESS_THAN: "lessThan";
+    readonly LESS_THAN_OR_EQUAL: "lessThanOrEqual";
+    readonly GREATER_THAN: "greaterThan";
+    readonly GREATER_THAN_OR_EQUAL: "greaterThanOrEqual";
+};
+/**
+ * @description Object-like set of keys used across all validators in the system.
+ * @summary Defines the canonical namespaced key prefix and the individual validation flags for rules such as required, min/max, length, patterns, types, lists and more.
+ * @typedef {Object} ValidationKeysDef
+ * @property {string} REFLECT prefixes others (namespace prefix)
+ * @property {"required"} REQUIRED sets as required
+ * @property {"min"} MIN defines min value
+ * @property {"max"} MAX defines max value
+ * @property {"step"} STEP defines step
+ * @property {"minlength"} MIN_LENGTH defines min length
+ * @property {"maxlength"} MAX_LENGTH defines max length
+ * @property {"pattern"} PATTERN defines pattern
+ * @property {"email"} EMAIL defines email
+ * @property {"url"} URL defines url
+ * @property {"date"} DATE defines date
+ * @property {"type"} TYPE defines type
+ * @property {"password"} PASSWORD defines password
+ * @property {"list"} LIST defines list
+ * @property {"unique"} UNIQUE flags uniqueness
+ * @property {"validator"} VALIDATOR custom validator id
+ * @memberOf module:decorator-validation.Validation
+ */
+/**
+ * @description The keys used for validation.
+ * @summary A namespaced collection of validation key strings used throughout the library.
+ * @const ValidationKeys
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ * @type {ValidationKeysDef}
+ */
+export declare const ValidationKeys: {
+    readonly EQUALS: "equals";
+    readonly DIFF: "different";
+    readonly LESS_THAN: "lessThan";
+    readonly LESS_THAN_OR_EQUAL: "lessThanOrEqual";
+    readonly GREATER_THAN: "greaterThan";
+    readonly GREATER_THAN_OR_EQUAL: "greaterThanOrEqual";
+    readonly REFLECT: "validation";
+    readonly DATE: "date";
+    readonly EMAIL: "email";
+    readonly FORMAT: "format";
+    readonly LIST: "list";
+    readonly MAX: "max";
+    readonly MAX_LENGTH: "maxlength";
+    readonly MIN: "min";
+    readonly MIN_LENGTH: "minlength";
+    readonly PASSWORD: "password";
+    readonly PATTERN: "pattern";
+    readonly REQUIRED: "required";
+    readonly STEP: "step";
+    readonly TYPE: "type";
+    readonly UNIQUE: "unique";
+    readonly URL: "url";
+    readonly VALIDATOR: "validator";
+    readonly ENUM: "enum";
+};
+/**
+ * @description list of month names
+ * @summary Stores month names. Can be changed for localization purposes
+ * @const MONTH_NAMES
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+export declare const MONTH_NAMES: string[];
+/**
+ * @description list of names of days of the week
+ * @summary Stores names for days of the week. Can be changed for localization purposes
+ * @const DAYS_OF_WEEK_NAMES
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+export declare const DAYS_OF_WEEK_NAMES: string[];
+/**
+ * @description Type definition for default error message strings keyed by validation type.
+ * @summary Enumerates the supported error message keys with their intended meaning; used to localize or override default messages.
+ * @typedef {Object} DefaultErrorMessages
+ * @property {string} REQUIRED default error message
+ * @property {string} MIN default error message
+ * @property {string} MAX default error message
+ * @property {string} MIN_LENGTH default error message
+ * @property {string} MAX_LENGTH default error message
+ * @property {string} PATTERN default error message
+ * @property {string} EMAIL default error message
+ * @property {string} URL default error message
+ * @property {string} TYPE default error message
+ * @property {string} STEP default error message
+ * @property {string} DATE default error message
+ * @property {string} DEFAULT default error message
+ * @property {string} PASSWORD default error message
+ * @property {string} LIST default error message
+ * @property {string} LIST_INSIDE default error message
+ * @property {string} MODEL_NOT_FOUND default error message
+ * @memberOf module:decorator-validation.Validation
+ */
+/**
+ * @description Defines the default error messages
+ * @summary Mapping between validation keys and their default human-readable error messages.
+ * @const DEFAULT_ERROR_MESSAGES
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ * @type {DefaultErrorMessages}
+ */
+export declare const DEFAULT_ERROR_MESSAGES: Record<string, string>;
+/**
+ * @description Type definition for default regular expression patterns used in validation.
+ * @summary Captures common regex patterns for email, URL, and password policies, including nested grouping for password-related rules.
+ * @typedef {Object} DefaultPatterns
+ * @property {RegExp} EMAIL Email address validation pattern
+ * @property {RegExp} URL URL validation pattern
+ * @property {Object} PASSWORD Password-related regex patterns
+ * @property {RegExp} PASSWORD.CHAR8_ONE_OF_EACH At least 8 chars with lower, upper, number, and special char
+ * @memberOf module:decorator-validation.Validation
+ */
+/**
+ * @description Defines the various default regexp patterns used
+ * @summary Collection of frequently used validation patterns grouped under semantic keys.
+ * @const DEFAULT_PATTERNS
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ * @type {DefaultPatterns}
+ */
+export declare const DEFAULT_PATTERNS: {
+    EMAIL: RegExp;
+    URL: RegExp;
+    PASSWORD: {
+        CHAR8_ONE_OF_EACH: RegExp;
+    };
+    asd: string;
+};