@decaf-ts/decorator-validation 1.0.7

package/lib/esm/utils/general.d.ts

@@ -0,0 +1,193 @@
+import "reflect-metadata";
+import { DecoratorMetadata } from "../validation";
+import { Model } from "../model";
+/**
+ * @summary Util function to retrieve the decorators for the provided Property
+ *
+ * @param {string} annotationPrefix
+ * @param {any} target
+ * @param {string | symbol} propertyName
+ * @param {boolean} [ignoreType] defaults to false. decides if the {@link ModelKeys.TYPE} is ignored or not
+ * @param {boolean} [recursive] defaults to true. decides if it should climb the prototypal tree searching for more decorators on that property
+ * @param {DecoratorMetadata[]} [accumulator] used when recursive is true, to cache decorators while it climbs the prototypal tree
+ *
+ * @function getPropertyDecorators
+ * @memberOf module:decorator-validation.Reflection
+ * @category Reflection
+ */
+export declare function getPropertyDecorators(annotationPrefix: string, target: any, propertyName: string | symbol, ignoreType?: boolean, recursive?: boolean, accumulator?: DecoratorMetadata[]): {
+    prop: string;
+    decorators: DecoratorMetadata[];
+};
+/**
+ * @summary gets the prop type from the decorator
+ * @param {any} model
+ * @param {string | symbol} propKey
+ * @return {string | undefined}
+ *
+ * @function geTypeFromDecorators
+ *
+ * @memberOf module:decorator-validation.Reflection
+ */
+export declare function getTypeFromDecorator(model: any, propKey: string | symbol): string | undefined;
+/**
+ * @summary Retrieves the decorators for an object's properties prefixed by {@param prefixes}
+ *
+ * @param {T} model
+ * @param {string[]} prefixes
+ *
+ * @function getAllPropertyDecorators
+ *
+ * @memberOf module:db-decorators.Reflection
+ */
+export declare const getAllPropertyDecorators: <T extends Model>(model: T, ...prefixes: string[]) => Record<string, any> | undefined;
+/**
+ * @summary Retrieves all properties of an object
+ * @description
+ *  - and of all its prototypes if {@param climbTree} until it reaches {@param stopAt} (or ends the prototype chain)
+ *
+ * @param obj
+ * @param {boolean} [climbTree] default to true
+ * @param {string} [stopAt] defaults to 'Object'
+ *
+ * @function getAllProperties
+ *
+ * @memberOf module:decorator-validation.Model
+ */
+export declare function getAllProperties(obj: Record<any, any>, climbTree?: boolean, stopAt?: string): string[];
+/**
+ * @summary Util function to provide string format functionality similar to C#'s string.format
+ *
+ * @param {string} string
+ * @param {string} args replacements made by order of appearance (replacement0 wil replace {0} and so on)
+ * @return {string} formatted string
+ *
+ * @function stringFormat
+ * @memberOf module:decorator-validation.Utils.Format
+ * @category Format
+ */
+export declare function stringFormat(string: string, ...args: string[]): string;
+/**
+ * @summary Deep Object Comparison
+ * @description algorithm from {@link https://stackoverflow.com/questions/30476150/javascript-deep-comparison-recursively-objects-and-properties}
+ * but with optional ignored properties
+ *
+ * @param {any} a
+ * @param {any} b
+ * @param {string} [propsToIgnore]
+ *
+ * @function isEqual
+ * @memberOf module:decorator-validation.Utils.Equality
+ * @category Validation
+ */
+export declare function isEqual(a: any, b: any, ...propsToIgnore: string[]): boolean;
+/**
+ * @summary Mimics Java's String's Hash implementation
+ *
+ * @param {string | number | symbol | Date} obj
+ * @return {number} hash value of obj
+ *
+ * @function hashCode
+ * @memberOf module:decorator-validation.Utils.Hashing
+ * @category Hashing
+ */
+export declare function hashCode(obj: string | number | symbol | Date): number;
+/**
+ * @summary Defines teh type for a Hashing function
+ * @memberOf module:decorator-validation.Utils.Hashing
+ * @category Hashing
+ */
+export type HashingFunction = (value: any) => string | number;
+/**
+ * @summary Hashes an object serializing it and then hashing the string
+ * @description The Serialization algorithm used by default (JSON.stringify)
+ * is not deterministic and should not be used for hashing
+ *
+ * @param {Record<string, any>} obj
+ * @return {string} the resulting hash
+ *
+ * @function hashSerialization
+ * @memberOf module:decorator-validation.Utils.Hashing
+ *
+ * @category Hashing
+ */
+export declare function hashSerialization(obj: Record<string, any> | any[]): number;
+/**
+ * @summary Hashes an object by combining the hash of all its properties
+ *
+ * @param {Record<string, any>} obj
+ * @return {string} the resulting hash
+ *
+ * @function hashObj
+ * @memberOf module:decorator-validation.Utils.Hashing
+ * @category Hashing
+ */
+export declare function hashObj(obj: Record<string, any> | any[]): string | number;
+/**
+ * @summary For Serialization/deserialization purposes.
+ * @description Reads the {@link ModelKeys.ANCHOR} property of a {@link Model} to discover the class to instantiate
+ *
+ * @function isModel
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+export declare function isModel(target: Record<string, any>): boolean;
+/**
+ * @summary Util function to retrieve the Class decorators
+ *
+ * @function getClassDecorators
+ * @memberOf module:decorator-validation.Reflection
+ * @category Reflection
+ */
+export declare function getClassDecorators(annotationPrefix: string, target: any): {
+    key: string;
+    props: any;
+}[];
+/**
+ * @summary Util function to check a type according to a typeName
+ *
+ * @param {any} value
+ * @param {string} acceptedType
+ * @return {boolean} true for a match, false otherwise
+ *
+ * @function checkType
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+export declare function checkType(value: any, acceptedType: string): any;
+/**
+ * @summary Util function to check a type according multiple possibilities
+ * @param {any} value
+ * @param {string[]} acceptedTypes
+ * @return {boolean} true if any is a match, false otherwise
+ *
+ * @function checkTypes
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+export declare function checkTypes(value: any, acceptedTypes: string[]): boolean;
+/**
+ * @summary The model type
+ *
+ * @param {any} value
+ * @param {string | string[] | {name: string}} types
+ *
+ * @function evaluateDesignTypes
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+export declare function evaluateDesignTypes(value: any, types: string | string[] | {
+    name: string;
+}): any;
+/**
+ * @summary Reverses the process from {@link formatDate}
+ *
+ * @param {string} date the date string to be converted back into date
+ * @param {string} format the date format
+ * @return {Date} the date from the format or the standard new Date({@prop date}) if the string couldn't be parsed (are you sure the format matches the string?)
+ *
+ * @function dateFromFormat
+ * @memberOf module:decorator-validation.Utils.Dates
+ * @category Format
+ */
+export declare function dateFromFormat(date: string, format: string): Date;

package/lib/esm/utils/general.js

@@ -0,0 +1 @@
+import"reflect-metadata";import{MONTH_NAMES}from"../validation";import{ModelKeys}from"./constants";import{Model}from"../model";function getPropertyDecorators(e,r,t,o=!1,a=!0,n){o=function(r,o,a,t=!1,e){e=Reflect.getMetadataKeys(o,a).filter(e=>!t&&e===ModelKeys.TYPE||e.toString().startsWith(r)).reduce((e,t)=>{t={key:t!==ModelKeys.TYPE?t.substring(r.length):t,props:Reflect.getMetadata(t,o,a)};return e.concat(t)},e||[]);return{prop:a.toString(),decorators:e}}(e,r,t,o,n);return a&&Object.getPrototypeOf(r)!==Object.prototype?getPropertyDecorators(e,Object.getPrototypeOf(r.constructor),t,!0,a,o.decorators):{prop:o.prop,decorators:function(e){const t={};return e.filter(e=>e.key in t?(isEqual(e.props,t[e.key])||console.log(stringFormat("Found a similar decorator for the {0} property of a {1} model but with different attributes. The original one will be kept",e.key,r.constructor.name)),!1):(t[e.key.toString()]=e.props,!0))}(o.decorators)}}function getTypeFromDecorator(e,t){var e=getPropertyDecorators(ModelKeys.REFLECT,e,t,!1);return e&&e.decorators&&"Function"!==(e=(t=e.decorators.shift()).props?t.props.name:void 0)?e:void 0}const getAllPropertyDecorators=function(n,...e){if(e&&e.length)return Object.getOwnPropertyNames(n).reduce((o,a)=>(e.forEach((e,t)=>{var r,e=getPropertyDecorators(e,n,a,0!==t);t=o=o||{},r=a,(e=e.decorators)&&e.length&&(t[r]||(t[r]=[]),t[r].push(...e))}),o),void 0)};function getAllProperties(e,t=!0,r="Object"){const o=[];let a=e;do{Object.getOwnPropertyNames(a).forEach(function(e){-1===o.indexOf(e)&&o.push(e)})}while(function(){if(t){var e=Object.getPrototypeOf(a);if(e&&e.constructor.name!==r)return a=e}}());return o}function stringFormat(e,...r){return e.replace(/{(\d+)}/g,function(e,t){return void 0!==r[t]?r[t]:e})}function isEqual(t,r,...o){var e;return t===r||(t instanceof Date&&r instanceof Date?t.getTime()===r.getTime():!t||!r||"object"!=typeof t&&"object"!=typeof r?t===r:null!=t&&null!=r&&typeof t==typeof r&&t.prototype===r.prototype&&(e=Object.keys(t).filter(e=>-1===o.indexOf(e))).length===Object.keys(r).filter(e=>-1===o.indexOf(e)).length&&e.every(e=>-1!==o.indexOf(e)||isEqual(t[e],r[e],...o)))}function hashCode(t){t=String(t);let r=0;for(let e=0;e<t.length;e++){var o=t.charCodeAt(e);r=(r<<5)-r+o,r&=r}return r}function hashSerialization(e){return hashCode(Model.serialize(e))}function hashObj(e){function o(e){return void 0===e?"":-1!==["string","number","symbol"].indexOf(typeof e)?r(e.toString()):e instanceof Date?r(e.getTime()):(Array.isArray(e)?e:Object.values(e)).reduce(t,void 0)}const t=function(e,t){var r=o(t);return"string"==typeof r?o((e||"")+o(t)):(e=((e=e||0)<<5)-e+r)&e},r=hashCode;e=Object.values(e).reduce(t,0);return"number"==typeof e?Math.abs(e):e}function isModel(e){return!!e[ModelKeys.ANCHOR]||!!getClassDecorators(ModelKeys.REFLECT,e).find(e=>e.key===ModelKeys.MODEL&&e.props&&e.props.class)}function getClassDecorators(r,o){return Reflect.getOwnMetadataKeys(o.constructor).filter(e=>e.toString().startsWith(r)).reduce((e,t)=>{t={key:t.substring(r.length),props:Reflect.getMetadata(t,o.constructor)};return e.concat(t)},[])}function checkType(e,t){return typeof e===t||e.constructor&&e.constructor.name.toLowerCase()===t.toLowerCase()}function checkTypes(t,e){return!e.every(e=>!checkType(t,e))}function evaluateDesignTypes(e,t){switch(typeof t){case"string":return checkType(e,t);case"object":return Array.isArray(t)?checkTypes(e,t):!0;case"function":return t.name&&"Object"!==t.name?checkType(e,t.name):!0;default:return!0}}function dateFromFormat(e,t){let r=t;r.match(/hh/)?r=r.replace("hh","(?<hour>\\d{2})"):r.match(/h/)?r=r.replace("h","(?<hour>\\d{1,2})"):r.match(/HH/)?r=r.replace("HH","(?<hour>\\d{2})"):r.match(/H/)&&(r=r.replace("H","(?<hour>\\d{1,2})")),r.match(/mm/)?r=r.replace("mm","(?<minutes>\\d{2})"):r.match(/m/)&&(r=r.replace("m","(?<minutes>\\d{1,2})")),r.match(/ss/)?r=r.replace("ss","(?<seconds>\\d{2})"):r.match(/s/)&&(r=r.replace("s","(?<seconds>\\d{1,2})")),r.match(/dd/)?r=r.replace("dd","(?<day>\\d{2})"):r.match(/d/)&&(r=r.replace("d","(?<day>\\d{1,2})")),r.match(/EEEE/)?r=r.replace("EEEE","(?<dayofweek>\\w+)"):r.match(/EEEE/)&&(r=r.replace("EEE","(?<dayofweek>\\w+)")),r.match(/yyyy/)?r=r.replace("yyyy","(?<year>\\d{4})"):r.match(/yy/)&&(r=r.replace("yy","(?<year>\\d{2})")),r.match(/MMMM/)?r=r.replace("MMMM","(?<monthname>\\w+)"):r.match(/MMM/)&&(r=r.replace("MMM","(?<monthnamesmall>\\w+)")),r.match(/MM/)?r=r.replace("MM","(?<month>\\d{2})"):r.match(/M/)&&(r=r.replace("M","(?<month>\\d{1,2})")),r=r.replace("S","(?<milis>\\d{1,3})").replace("aaa","(?<ampm>\\w{2})");t=new RegExp(r,"g").exec(e);if(!t||!t.groups)return new Date(e);function o(e){return!e||(e=parseInt(e),isNaN(e))?0:e}var a=o(t.groups.year),n=o(t.groups.day),c=t.groups.ampm;let s=o(t.groups.hour);c&&(s="PM"===c?s+12:s);var c=o(t.groups.minutes),i=o(t.groups.seconds),p=o(t.groups.milis),u=t.groups.monthname;const l=t.groups.monthnamesmall;let d=t.groups.month;if(u)d=MONTH_NAMES.indexOf(u);else if(l){t=MONTH_NAMES.find(e=>e.toLowerCase().startsWith(l.toLowerCase()));if(!t)return new Date(e);d=MONTH_NAMES.indexOf(t)}else d=o(""+d);return new Date(a,d-1,n,s,c,i,p)}export{getPropertyDecorators,getTypeFromDecorator,getAllPropertyDecorators,getAllProperties,stringFormat,isEqual,hashCode,hashSerialization,hashObj,isModel,getClassDecorators,checkType,checkTypes,evaluateDesignTypes,dateFromFormat};

package/lib/esm/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./general";
+export * from "./registry";
+export * from "./serialization";
+export * from "./constants";

package/lib/esm/utils/index.js

@@ -0,0 +1 @@
+export*from"./general";export*from"./registry";export*from"./serialization";export*from"./constants";

package/lib/esm/utils/registry.d.ts

@@ -0,0 +1,68 @@
+import { Constructor } from "../model/types";
+/**
+ * @summary Basic interface for Registries
+ *
+ * @interface IRegistry
+ *
+ * @category Utilities
+ */
+export interface IRegistry<T> {
+    /**
+     * @summary Registers an Object
+     *
+     * @param {T} obj
+     * @param {any[]} args
+     *
+     * @method
+     */
+    register(obj: T | any, ...args: any[]): void;
+    /**
+     * @summary Retrieves an Object if it can find it
+     *
+     * @param {any} key
+     * @param {any[]} args
+     * @return {T | undefined}
+     *
+     * @method
+     */
+    get(key: any, ...args: any[]): T | undefined;
+}
+/**
+ * @summary Basic Builder Registry Interface
+ *
+ * @typedef T
+ * @interface BuilderRegistry<T>
+ *
+ * @category Construction
+ */
+export interface BuilderRegistry<T> extends IRegistry<Constructor<T>> {
+    /**
+     * @summary Retrieves an Builder Object by name if it can
+     *
+     * @param {string} name
+     * @param {any[]} args
+     *
+     * @method
+     */
+    get(name: string, ...args: any[]): Constructor<T> | undefined;
+    /**
+     * @summary Registers a constructor by name
+     *
+     * @param {Constructor<T>} [constructor]
+     * @param {name} name
+     * @param {any[]} args
+     *
+     * @method
+     */
+    register(constructor: Constructor<T>, name?: string, ...args: any[]): void;
+    /**
+     * @summary Builds an Object by name
+     *
+     * @param {{}} obj
+     * @param {any[]} args
+     * @return T
+     *
+     * @method
+     */
+    build(obj: Record<string, any> | T, ...args: any[]): T;
+}

package/lib/esm/utils/serialization.d.ts

@@ -0,0 +1,65 @@
+import { Model } from "../model/Model";
+/**
+ * @summary Helper in serialization
+ *
+ * @interface Serializer
+ * @category Serialization
+ */
+export interface Serializer<T extends Model> {
+    /**
+     * @summary Serializes a model
+     * @param {T} model
+     *
+     * @method
+     *
+     * @throws {Error}
+     */
+    serialize(model: T): string;
+    /**
+     * @summary Rebuilds a model from serialization
+     * @param {string} str
+     *
+     * @method
+     *
+     * @throws {Error}
+     */
+    deserialize(str: string): T;
+}
+/**
+ * @summary Concrete implementation of a {@link Serializer} in JSON format
+ * @description JS's native JSON.stringify (used here) is not deterministic
+ * and therefore should not be used for hashing purposes
+ *
+ * To keep dependencies low, we will not implement this, but we recommend
+ * implementing a similar {@link JSONSerializer} using 'deterministic-json' libraries
+ *
+ * @class JSONSerializer
+ * @implements Serializer
+ *
+ * @category Serialization
+ */
+export declare class JSONSerializer<T extends Model> implements Serializer<T> {
+    /**
+     * @summary prepares the model for serialization
+     * @description returns a shallow copy of the object, containing an enumerable {@link ModelKeys#ANCHOR} property
+     * so the object can be recognized upon deserialization
+     *
+     * @param {T} model
+     * @protected
+     */
+    protected preSerialize(model: T): {} & T;
+    /**
+     * @summary Rebuilds a model from a serialization
+     * @param {string} str
+     *
+     * @throws {Error} If it fails to parse the string, or to build the model
+     */
+    deserialize(str: string): T;
+    /**
+     * @summary Serializes a model
+     * @param {T} model
+     *
+     * @throws {Error} if fails to serialize
+     */
+    serialize(model: T): string;
+}

package/lib/esm/utils/serialization.js

@@ -0,0 +1 @@
+import{Model}from"../model/Model";import{ModelKeys}from"./constants";class JSONSerializer{preSerialize(e){var r=Object.assign({},e);return r[ModelKeys.ANCHOR]=e[ModelKeys.ANCHOR],r}deserialize(e){e=JSON.parse(e);return Model.build(e)}serialize(e){return JSON.stringify(this.preSerialize(e))}}export{JSONSerializer};

package/lib/esm/validation/Validation.d.ts

@@ -0,0 +1,39 @@
+import { IValidatorRegistry, Validator, ValidatorDefinition } from "./Validators";
+/**
+ * @summary Static class acting as a namespace for the Validation
+ *
+ * @class Validation
+ * @static
+ *
+ * @category Validation
+ */
+export declare class Validation {
+    private static actingValidatorRegistry?;
+    private constructor();
+    /**
+     * @summary Defines the acting ValidatorRegistry
+     *
+     * @param {IValidatorRegistry} validatorRegistry the new implementation of the validator Registry
+     * @param {function(Validator): Validator} [migrationHandler] the method to map the validator if required;
+     */
+    static setRegistry(validatorRegistry: IValidatorRegistry<Validator>, migrationHandler?: (validator: Validator) => Validator): void;
+    /**
+     * @summary Returns the current ValidatorRegistry
+     *
+     * @return IValidatorRegistry, defaults to {@link ValidatorRegistry}
+     */
+    private static getRegistry;
+    /**
+     * @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
+     */
+    static get<T extends Validator>(validatorKey: string): T | undefined;
+    /**
+     * @summary Registers the provided validators onto the registry
+     *
+     * @param {T[] | ValidatorDefinition[]} validator
+     */
+    static register<T extends Validator>(...validator: (ValidatorDefinition | T)[]): void;
+}

package/lib/esm/validation/Validation.js

@@ -0,0 +1 @@
+import{TypeValidator,ValidatorRegistry}from"./Validators";import{ModelKeys}from"../utils";class Validation{static{this.actingValidatorRegistry=void 0}constructor(){}static setRegistry(i,a){a&&Validation.actingValidatorRegistry&&Validation.actingValidatorRegistry.getKeys().forEach(t=>{t=i.get(t);t&&i.register(a(t))}),Validation.actingValidatorRegistry=i}static getRegistry(){return Validation.actingValidatorRegistry||(Validation.actingValidatorRegistry=new ValidatorRegistry({validator:TypeValidator,validationKey:ModelKeys.TYPE,save:!1})),Validation.actingValidatorRegistry}static get(t){return Validation.getRegistry().get(t)}static register(...t){return Validation.getRegistry().register(...t)}}export{Validation};

package/lib/esm/validation/Validators/DateValidator.d.ts

@@ -0,0 +1,29 @@
+import { Validator } from "./Validator";
+import { Errors } from "../types";
+/**
+ * @summary Date Validator
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#DATE}
+ *
+ * @class DateValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+export declare class DateValidator extends Validator {
+    constructor(message?: string);
+    /**
+     * @summary Validates a model
+     *
+     * @param {Date | string} value
+     * @param {string} format
+     * @param {string} [message]
+     *
+     * @return Errors
+     *
+     * @override
+     *
+     * @see Validator#hasErrors
+     */
+    hasErrors(value: Date | string, format: string, message?: string): Errors;
+}

package/lib/esm/validation/Validators/DateValidator.js

@@ -0,0 +1 @@
+import{Validator}from"./Validator";import{ValidationKeys,DEFAULT_ERROR_MESSAGES}from"./constants";class DateValidator extends Validator{constructor(a=DEFAULT_ERROR_MESSAGES.DATE){super(ValidationKeys.DATE,a,Number.name,Date.name,String.name)}hasErrors(a,t,e){if(void 0!==a)return"string"==typeof a&&(a=new Date(a)),isNaN(a.getDate())?this.getMessage(e||this.message):void 0}}export{DateValidator};

package/lib/esm/validation/Validators/EmailValidator.d.ts

@@ -0,0 +1,29 @@
+import { Errors } from "../types";
+import { PatternValidator } from "./PatternValidator";
+/**
+ * @summary Email Validator
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#EMAIL}
+ *
+ * @class EmailValidator
+ * @extends PatternValidator
+ *
+ * @category Validators
+ */
+export declare class EmailValidator extends PatternValidator {
+    private static readonly emailPat;
+    constructor(message?: string);
+    /**
+     * @summary Validates a model
+     *
+     * @param {string} value
+     * @param {string} [message]
+     *
+     * @return Errors
+     *
+     * @override
+     *
+     * @see Validator#hasErrors
+     */
+    hasErrors(value: string, message?: string): Errors;
+}

package/lib/esm/validation/Validators/EmailValidator.js

@@ -0,0 +1 @@
+import{ValidationKeys,DEFAULT_ERROR_MESSAGES}from"./constants";import{PatternValidator}from"./PatternValidator";class EmailValidator extends PatternValidator{static{this.emailPat=/[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-zA-Z0-9](?:[a-z0-9-]*[a-zA-Z0-9])?\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?/}constructor(a=DEFAULT_ERROR_MESSAGES.EMAIL){super(ValidationKeys.EMAIL,a)}hasErrors(a,t){return super.hasErrors(a,EmailValidator.emailPat,t)}}export{EmailValidator};

package/lib/esm/validation/Validators/ListValidator.d.ts

@@ -0,0 +1,29 @@
+import { Validator } from "./Validator";
+import { Errors } from "../types";
+/**
+ * @summary List Validator
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#LIST}
+ *
+ * @class ListValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+export declare class ListValidator extends Validator {
+    constructor(message?: string);
+    /**
+     * @summary Validates a model
+     *
+     * @param {any[] | Set<any>} value
+     * @param {string} clazz
+     * @param {string} [message]
+     *
+     * @return Errors
+     *
+     * @override
+     *
+     * @see Validator#hasErrors
+     */
+    hasErrors(value: any[] | Set<any>, clazz: string, message?: string): Errors;
+}

package/lib/esm/validation/Validators/ListValidator.js

@@ -0,0 +1 @@
+import{Validator}from"./Validator";import{DEFAULT_ERROR_MESSAGES,ValidationKeys}from"./constants";class ListValidator extends Validator{constructor(t=DEFAULT_ERROR_MESSAGES.LIST){super(ValidationKeys.LIST,t,Array.name,Set.name)}hasErrors(r,a,e){var s;if(r&&(Array.isArray(r)?r.length:r.size))for(let t=0;t<(Array.isArray(r)?r.length:r.size);t++)switch(typeof(s=r[t])){case"object":case"function":if(s.constructor&&s.constructor.name===a)break;return this.getMessage(e||this.message,a);default:if(typeof s!==a)return this.getMessage(e||this.message,a)}}}export{ListValidator};

package/lib/esm/validation/Validators/MaxLengthValidator.d.ts

@@ -0,0 +1,30 @@
+import { Errors } from "../types";
+import { Validator } from "./Validator";
+/**
+ * @summary Maximum Length Validator
+ * @description Validates strings and Arrays on their maximum length
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#MAX_LENGTH}
+ *
+ * @class MinLengthValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+export declare class MaxLengthValidator extends Validator {
+    constructor(message?: string);
+    /**
+     * @summary Validates a model
+     *
+     * @param {string} value
+     * @param {number} maxlength
+     * @param {string} [message]
+     *
+     * @return Errors
+     *
+     * @override
+     *
+     * @see Validator#hasErrors
+     */
+    hasErrors(value: string | any[], maxlength: number, message?: string): Errors;
+}

package/lib/esm/validation/Validators/MaxLengthValidator.js

@@ -0,0 +1 @@
+import{Validator}from"./Validator";import{ValidationKeys,DEFAULT_ERROR_MESSAGES}from"./constants";class MaxLengthValidator extends Validator{constructor(a=DEFAULT_ERROR_MESSAGES.MAX_LENGTH){super(ValidationKeys.MAX_LENGTH,a,String.name,Array.name)}hasErrors(a,t,r){return void 0!==a&&a.length>t?this.getMessage(r||this.message,t):void 0}}export{MaxLengthValidator};

package/lib/esm/validation/Validators/MaxValidator.d.ts

@@ -0,0 +1,29 @@
+import { Validator } from "./Validator";
+import { Errors } from "../types";
+/**
+ * @summary Max Validator
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#MAX}
+ *
+ * @class MaxValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+export declare class MaxValidator extends Validator {
+    constructor(message?: string);
+    /**
+     * @summary Validates a Model
+     *
+     * @param {string} value
+     * @param {number | Date | string} max
+     * @param {string} [message]
+     *
+     * @return Errors
+     *
+     * @override
+     *
+     * @see Validator#hasErrors
+     */
+    hasErrors(value: number | Date | string, max: number | Date | string, message?: string): Errors;
+}

package/lib/esm/validation/Validators/MaxValidator.js

@@ -0,0 +1 @@
+import{Validator}from"./Validator";import{ValidationKeys,DEFAULT_ERROR_MESSAGES}from"./constants";class MaxValidator extends Validator{constructor(a=DEFAULT_ERROR_MESSAGES.MAX){super(ValidationKeys.MAX,a,"number","Date","string")}hasErrors(a,t,e){if(void 0!==a){if(a instanceof Date&&!(t instanceof Date)&&(t=new Date(t),isNaN(t.getDate())))throw new Error("Invalid Max param defined");return t<a?this.getMessage(e||this.message,t):void 0}}}export{MaxValidator};

package/lib/esm/validation/Validators/MinLengthValidator.d.ts

@@ -0,0 +1,30 @@
+import { Validator } from "./Validator";
+import { Errors } from "../types";
+/**
+ * @summary Minimum Length Validator
+ * @description Validates strings and Arrays on their minimum length
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#MIN_LENGTH}
+ *
+ * @class MinLengthValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+export declare class MinLengthValidator extends Validator {
+    constructor(message?: string);
+    /**
+     *
+     * @param {string | Array} value
+     * @param {number} minlength
+     * @param {string} [message]
+     *
+     * @return Errors
+     *
+     * @memberOf MinLengthValidator
+     * @override
+     *
+     * @see Validator#hasErrors
+     */
+    hasErrors(value: string | any[], minlength: number, message?: string): Errors;
+}

package/lib/esm/validation/Validators/MinLengthValidator.js

@@ -0,0 +1 @@
+import{Validator}from"./Validator";import{ValidationKeys,DEFAULT_ERROR_MESSAGES}from"./constants";class MinLengthValidator extends Validator{constructor(t=DEFAULT_ERROR_MESSAGES.MIN_LENGTH){super(ValidationKeys.MIN_LENGTH,t,String.name,Array.name)}hasErrors(t,a,r){return void 0!==t&&t.length<a?this.getMessage(r||this.message,a):void 0}}export{MinLengthValidator};

package/lib/esm/validation/Validators/MinValidator.d.ts

@@ -0,0 +1,29 @@
+import { Validator } from "./Validator";
+import { Errors } from "../types";
+/**
+ * @summary Min Validator
+ *
+ * @param {string} [message] defaults to {@link DEFAULT_ERROR_MESSAGES#MIN}
+ *
+ * @class MinValidator
+ * @extends Validator
+ *
+ * @category Validators
+ */
+export declare class MinValidator extends Validator {
+    constructor(message?: string);
+    /**
+     * @summary Validates Model
+     *
+     * @param {string} value
+     * @param {number | Date | string} min
+     * @param {string} [message]
+     *
+     * @return Errors
+     *
+     * @override
+     *
+     * @see Validator#hasErrors
+     */
+    hasErrors(value: number | Date | string, min: number | Date | string, message?: string): Errors;
+}

package/lib/esm/validation/Validators/MinValidator.js

@@ -0,0 +1 @@
+import{Validator}from"./Validator";import{ValidationKeys,DEFAULT_ERROR_MESSAGES}from"./constants";class MinValidator extends Validator{constructor(a=DEFAULT_ERROR_MESSAGES.MIN){super(ValidationKeys.MIN,a,"number","Date","string")}hasErrors(a,t,i){if(void 0!==a){if(a instanceof Date&&!(t instanceof Date)&&(t=new Date(t),isNaN(t.getDate())))throw new Error("Invalid Min param defined");return a<t?this.getMessage(i||this.message,t):void 0}}}export{MinValidator};

package/lib/esm/validation/Validators/PasswordValidator.d.ts

@@ -0,0 +1,31 @@
+import { PatternValidator } from "./PatternValidator";
+import { Errors } from "../types";
+/**
+ * @summary Handles Password Validation
+ *
+ * @param {string} [errorMessage] defaults to {@link DEFAULT_ERROR_MESSAGES#PASSWORD}
+ * @param {RegExp} [passwordPattern] defaults to {@link PasswordPatterns.CHAR8_ONE_OF_EACH}
+ *
+ * @class PasswordValidator
+ * @extends PatternValidator
+ *
+ * @category Validators
+ */
+export declare class PasswordValidator extends PatternValidator {
+    readonly pattern: RegExp;
+    constructor(errorMessage?: string, passwordPattern?: RegExp);
+    /**
+     * @summary Validates a model
+     *
+     * @param {string} value
+     * @param {RegExp} [pattern]
+     * @param {string} [message]
+     *
+     * @return Errors
+     *
+     * @override
+     *
+     * @see PatternValidator#hasErrors
+     */
+    hasErrors(value: string, pattern: RegExp, message?: string): Errors;
+}