@decaf-ts/decorator-validation 1.0.7

package/lib/esm/index.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @module decorator-validation
+ */
+/**
+ * @summary Defines the Model object
+ * @namespace Model
+ * @memberOf module:decorator-validation
+ */
+/**
+ * @summary Holds all the supported decorators
+ * @namespace Decorators
+ * @memberOf module:decorator-validation
+ */
+/**
+ * @namespace Validation
+ * @memberOf module:decorator-validation.Decorators
+ */
+/**
+ * @namespace Model
+ * @memberOf module:decorator-validation.Decorators
+ */
+/**
+ * @namespace Construction
+ * @memberOf module:decorator-validation
+ */
+/**
+ * @namespace Validation
+ * @memberOf module:decorator-validation
+ */
+/**
+ * @namespace Validators
+ * @memberOf module:decorator-validation.Validation
+ */
+/**
+ * @namespace Utils
+ * @memberOf module:decorator-validation
+ */
+/**
+ * @namespace Dates
+ * @memberOf module:decorator-validation.Utils
+ */
+/**
+ * @namespace Equality
+ * @memberOf module:decorator-validation.Utils
+ */
+/**
+ * @namespace Hashing
+ * @memberOf module:decorator-validation.Utils
+ */
+/**
+ * @namespace Serialization
+ * @memberOf module:decorator-validation.Utils
+ */
+/**
+ * @namespace Format
+ * @memberOf module:decorator-validation.Utils
+ */
+export * from "./utils";
+export * from "./validation";
+export * from "./model";
+export declare const VERSION = "1.0.7";

package/lib/esm/index.js

@@ -0,0 +1 @@
+export*from"./utils";export*from"./validation";export*from"./model";const VERSION="1.0.7";export{VERSION};

package/lib/esm/model/Model.d.ts

@@ -0,0 +1,160 @@
+import { BuilderRegistry, HashingFunction, Serializer } from "../utils";
+import { ModelErrorDefinition } from "./ModelErrorDefinition";
+import { ModelArg, ModelConstructor, Serializable, Validatable } from "./types";
+import { ModelBuilderFunction } from "./construction";
+/**
+ * @summary Analyses the decorations of the properties and validates the obj according to them
+ *
+ * @typedef T extends Model
+ * @prop {T} obj Model object to validate
+ * @prop {string[]} [propsToIgnore] object properties to ignore in the validation
+ *
+ * @function validate
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+export declare function validate<T extends Model>(obj: T, ...propsToIgnore: string[]): ModelErrorDefinition | undefined;
+/**
+ * @summary Abstract class representing a Validatable Model object
+ * @description Meant to be used as a base class for all Model classes
+ *
+ * Model objects must:
+ *  - Have all their properties defined as optional;
+ *  - Have all their properties initialized eg:
+ *
+ *  <pre>
+ *      class ClassName {
+ *          propertyName?: PropertyType = undefined;
+ *      }
+ *  </pre>
+ *
+ * @param {Model | {}} model base object from which to populate properties from
+ *
+ * @class Model
+ * @abstract
+ * @implements Validatable
+ * @implements Serializable
+ *
+ * @category Model
+ */
+export declare abstract class Model implements Validatable, Serializable {
+    [indexer: string]: any;
+    protected constructor(model?: ModelArg<Model>);
+    /**
+     * @summary Validates the object according to its decorated properties
+     *
+     * @param {any[]} [exceptions] properties in the object to be ignored for he validation. Marked as 'any' to allow for extension but expects strings
+     */
+    hasErrors(...exceptions: any[]): ModelErrorDefinition | undefined;
+    /**
+     * @summary Compare object equality recursively
+     * @param {any} obj object to compare to
+     * @param {string} [exceptions] property names to be excluded from the comparison
+     */
+    equals(obj: any, ...exceptions: string[]): boolean;
+    /**
+     * @summary Returns the serialized model according to the currently defined {@link Serializer}
+     */
+    serialize(): string;
+    /**
+     * @summary Override the implementation for js's 'toString()' which sucks...
+     * @override
+     */
+    toString(): string;
+    /**
+     * @summary Defines a default implementation for object hash. Relies on a very basic implementation based on Java's string hash;
+     */
+    toHash(): string;
+    /**
+     * @summary Deserializes a Model
+     * @param {string} str
+     *
+     * @throws {Error} If it fails to parse the string, or if it fails to build the model
+     */
+    static deserialize(str: string): any;
+    /**
+     * @summary Serializes a Model
+     * @param {Model} model
+     */
+    static serialize(model: any): string;
+    static hash(obj: any): string;
+    /**
+     * @summary Wrapper around {@link constructFromObject}
+     * @param {T} self
+     * @param {T | Record<string, any>} obj
+     */
+    static fromObject<T extends Model>(self: T, obj?: T | Record<string, any>): T;
+    /**
+     * @summary Wrapper around {@link constructFromModel}
+     * @param {T} self
+     * @param {T | Record<string, any>} obj
+     */
+    static fromModel<T extends Model>(self: T, obj?: T | Record<string, any>): T;
+    /**
+     * @summary Sets the Global {@link ModelBuilderFunction}
+     * @param {ModelBuilderFunction} [builder]
+     */
+    static setBuilder(builder?: ModelBuilderFunction): void;
+    /**
+     * @summary Retrieves the current global {@link ModelBuilderFunction}
+     */
+    static getBuilder(): ModelBuilderFunction | undefined;
+    /**
+     * Returns the current {@link ModelRegistryManager}
+     *
+     * @return ModelRegistry, defaults to {@link ModelRegistryManager}
+     */
+    private static getRegistry;
+    /**
+     * Returns the current actingModelRegistry
+     *
+     * @param {BuilderRegistry} modelRegistry the new implementation of Registry
+     */
+    static setRegistry(modelRegistry: BuilderRegistry<any>): void;
+    /**
+     * @summary register new Models
+     * @param {any} constructor
+     * @param {string} [name] when not defined, the name of the constructor will be used
+     *
+     * @see ModelRegistry
+     */
+    static register<T extends Model>(constructor: ModelConstructor<T>, name?: string): void;
+    /**
+     * @summary Gets a registered Model {@link ModelConstructor}
+     * @param {string} name
+     *
+     * @see ModelRegistry
+     */
+    static get<T extends Model>(name: string): ModelConstructor<T> | undefined;
+    /**
+     * @param {Record<string, any>} obj
+     * @param {string} [clazz] when provided, it will attempt to find the matching constructor
+     *
+     * @throws Error If clazz is not found, or obj is not a {@link Model} meaning it has no {@link ModelKeys.ANCHOR} property
+     *
+     * @see ModelRegistry
+     */
+    static build<T extends Model>(obj?: Record<string, any>, clazz?: string): T;
+    /**
+     * @summary Sets the {@link Serializer}
+     *
+     * @param {Serializer} ser
+     */
+    static setSerializer(ser: Serializer<any>): void;
+    /**
+     * @summary Retrieves the current defined {@link Serializer}
+     *
+     */
+    private static getSerializer;
+    /**
+     * @summary Sets the {@link HashingFunction}
+     *
+     * @param {HashingFunction} hasher
+     */
+    static setHashingFunction(hasher: HashingFunction): void;
+    /**
+     * @summary Retrieves the current defined {@link HashingFunction}
+     *
+     */
+    private static getHashingFunction;
+}

package/lib/esm/model/Model.js

@@ -0,0 +1 @@
+import{DEFAULT_ERROR_MESSAGES,ValidationKeys}from"../validation";import{getPropertyDecorators,hashObj,isEqual,JSONSerializer,stringFormat}from"../utils";import{ModelErrorDefinition}from"./ModelErrorDefinition";import{ReservedModels}from"./constants";import{ModelKeys}from"../utils/constants";import{constructFromModel,constructFromObject}from"./construction";import{ModelRegistryManager}from"./Registry";import{Validation}from"../validation/Validation";function validate(a,...e){var t=[];for(const i in a)a.hasOwnProperty(i)&&-1===e.indexOf(i)&&t.push(getPropertyDecorators(ValidationKeys.REFLECT,a,i));var r=t.reduce((e,r)=>{const{prop:i,decorators:o}=r;if(o&&o.length){const s=o[0];o.find(e=>e.key===ValidationKeys.TYPE||!!e.props.types?.find(e=>e===s.props.name))&&o.shift();let t=o.reduce((e,t)=>{var r=Validation.get(t.key);return r&&(r=r.hasErrors(a[i.toString()],...t.key===ModelKeys.TYPE?[t.props]:Object.values(t.props)))&&((e=e||{})[t.key]=r),e},void 0);(t=t||Object.keys(a).filter(e=>!t||!t[e]).reduce((e,r)=>{let i;const o=getPropertyDecorators(ValidationKeys.REFLECT,a,r).decorators;var t=o.filter(e=>-1!==[ModelKeys.TYPE,ValidationKeys.TYPE].indexOf(e.key));if(t&&t.length){t=t.pop(),t=t.props.name?[t.props.name]:Array.isArray(t.props.customTypes)?t.props.customTypes:[t.props.customTypes];const s=Object.values(ReservedModels).map(e=>e.toLowerCase());t.forEach(e=>{if(-1===s.indexOf(e.toLowerCase()))switch(e){case"Array":case"Set":var t;o.length&&o.find(e=>e.key===ValidationKeys.LIST)&&(t="Array"===e?a[r].find(e=>e.hasErrors()):a[r].values().find(e=>e.hasErrors()))&&(i=stringFormat(DEFAULT_ERROR_MESSAGES.LIST_INSIDE,t.toString()));break;default:try{a[r]&&(i=a[r].hasErrors())}catch(e){console.warn(stringFormat("Model should be validatable but its not"))}}}),i&&((e=e||{})[r]=i)}return e},void 0))&&((e=e||{})[r.prop.toString()]=t)}return e},void 0);return r?new ModelErrorDefinition(r):void 0}let modelBuilderFunction,actingModelRegistry,serializer,hashingFunction;class Model{constructor(e){}hasErrors(...e){return validate(this,...e)}equals(e,...t){return isEqual(this,e,...t)}serialize(){return Model.serialize(this)}toString(){return this.constructor.name+": "+JSON.stringify(this,void 0,2)}toHash(){return Model.getHashingFunction()(this).toString()}static deserialize(e){return Model.getSerializer().deserialize(e)}static serialize(e){return Model.getSerializer().serialize(e)}static hash(e){return Model.getHashingFunction()(e)}static fromObject(e,t){return constructFromObject(e,t)}static fromModel(e,t){return constructFromModel(e,t)}static setBuilder(e){modelBuilderFunction=e}static getBuilder(){return modelBuilderFunction}static getRegistry(){return actingModelRegistry=actingModelRegistry||new ModelRegistryManager}static setRegistry(e){actingModelRegistry=e}static register(e,t){return Model.getRegistry().register(e,t)}static get(e){return Model.getRegistry().get(e)}static build(e={},t){return Model.getRegistry().build(e,t)}static setSerializer(e){serializer=e}static getSerializer(){return serializer=serializer||new JSONSerializer}static setHashingFunction(e){hashingFunction=e}static getHashingFunction(){return hashingFunction=hashingFunction||hashObj}}export{validate,Model};

package/lib/esm/model/ModelErrorDefinition.d.ts

@@ -0,0 +1,22 @@
+import { Errors, ModelErrors } from "../validation";
+/**
+ * @summary Helper Class to hold the error results
+ * @description holds error results in an 'indexable' manner
+ * while still providing the same result on toString
+ *
+ * @param {ModelErrors} errors
+ *
+ * @class ModelErrorDefinition
+ *
+ * @category Model
+ */
+export declare class ModelErrorDefinition {
+    [indexer: string]: Record<string, Errors> | (() => Errors);
+    constructor(errors: ModelErrors);
+    /**
+     * @summary Outputs the class to a nice readable string
+     *
+     * @override
+     */
+    toString(): string;
+}

package/lib/esm/model/ModelErrorDefinition.js

@@ -0,0 +1,3 @@
+class ModelErrorDefinition{constructor(e){for(const r in e)e.hasOwnProperty(r)&&e[r]&&Object.defineProperty(this,r,{enumerable:!0,configurable:!1,value:e[r],writable:!1})}toString(){const o=this;return Object.keys(o).filter(e=>o.hasOwnProperty(e)&&"function"!=typeof o[e]).reduce((e,t)=>{var r=Object.keys(o[t]).reduce((e,r)=>(e?e+=`
+`+o[t][r]:e=o[t][r],e),void 0);return r&&(r=t+" - "+r,e?e+=`
+`+r:e=r),e},"")}}export{ModelErrorDefinition};

package/lib/esm/model/Registry.d.ts

@@ -0,0 +1,61 @@
+import { Model } from "./Model";
+import { BuilderRegistry } from "../utils";
+import { Constructor, ModelConstructor } from "./types";
+/**
+ * @summary ModelRegistry Interface
+ *
+ * @interface ModelRegistry
+ * @extends BuilderRegistry<Model>
+ *
+ * @category Model
+ */
+export interface ModelRegistry<T extends Model> extends BuilderRegistry<T> {
+}
+/**
+ * @summary Util class to enable serialization and correct rebuilding
+ *
+ * @param {string} anchorKey defaults to {@link ModelKeys.ANCHOR}. The property name where the registered class name is stored;
+ * @param {function(Record<string, any>): boolean} [testFunction] method to test if the provided object is a Model Object. defaults to {@link isModel}
+ *
+ * @class ModelRegistryManager
+ * @implements ModelRegistry
+ *
+ * @category Model
+ */
+export declare class ModelRegistryManager<T extends Model> implements ModelRegistry<T> {
+    private cache;
+    private readonly testFunction;
+    private readonly anchorKey;
+    constructor(anchorKey?: string, testFunction?: (obj: Record<string, any>) => boolean);
+    /**
+     * @summary register new Models
+     * @param {any} constructor
+     * @param {string} [name] when not defined, the name of the constructor will be used
+     */
+    register(constructor: ModelConstructor<T>, name?: string): void;
+    /**
+     * @summary Gets a registered Model {@link ModelConstructor}
+     * @param {string} name
+     */
+    get(name: string): ModelConstructor<T> | undefined;
+    /**
+     * @param {Record<string, any>} obj
+     * @param {string} [clazz] when provided, it will attempt to find the matching constructor
+     *
+     * @throws Error If clazz is not found, or obj is not a {@link Model} meaning it has no {@link ModelKeys.ANCHOR} property
+     */
+    build(obj?: Record<string, any>, clazz?: string): T;
+}
+/**
+ * @summary Bulk Registers Models
+ * @description Useful when using bundlers that might not evaluate all of the code at once
+ *
+ * @param {Array<Constructor<T>> | Array<{name: string, constructor: Constructor<T>}>} [models]
+ *
+ * @memberOf module:decorator-validation.Model
+ * @category Model
+ */
+export declare function bulkModelRegister<T extends Model>(...models: (Constructor<T> | {
+    name: string;
+    constructor: Constructor<T>;
+})[]): void;

package/lib/esm/model/Registry.js

@@ -0,0 +1 @@
+import{Model}from"./Model";import{isModel,stringFormat}from"../utils";import{ModelKeys}from"../utils/constants";class ModelRegistryManager{constructor(e=ModelKeys.ANCHOR,t=isModel){this.cache={},this.testFunction=t,this.anchorKey=e}register(e,t){if("function"!=typeof e)throw new Error("Model registering failed. Missing Class name or constructor");t=t||e.name,this.cache[t]=e}get(e){try{return this.cache[e]}catch(e){}}build(e={},t){if(!t&&!this.testFunction(e))throw new Error("Provided obj is not a Model object");t=t||e[this.anchorKey].class;if(t in this.cache)return new this.cache[t](e);throw new Error(stringFormat("Provided class {0} is not a registered Model object",t))}}function bulkModelRegister(...e){e.forEach(e=>{var t=e.constructor||e;Model.register(t,e.name)})}export{ModelRegistryManager,bulkModelRegister};

package/lib/esm/model/constants.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @summary References the relevant JS primitives
+ *
+ * @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
+ *
+ * @constant Primitives
+ * @memberOf module:decorator-validation.Construction
+ * @category Model
+ */
+export declare enum Primitives {
+    STRING = "string",
+    NUMBER = "number",
+    BOOLEAN = "boolean",
+    BIGINT = "bigint"
+}
+/**
+ * @summary References the Reserved model names to ignore during Model rebuilding
+ *
+ * @property {string} STRING
+ * @property {string} OBJECT
+ * @property {string} NUMBER
+ * @property {string} BOOLEAN
+ * @property {string} BIGINT
+ * @property {string} DATE
+ *
+ * @constant ReservedModels
+ * @memberOf module:decorator-validation.Construction
+ * @category Construction
+ */
+export declare enum ReservedModels {
+    STRING = "string",
+    OBJECT = "object",
+    NUMBER = "number",
+    BOOLEAN = "boolean",
+    BIGINT = "bigint",
+    DATE = "date"
+}

package/lib/esm/model/constants.js

@@ -0,0 +1 @@
+var Primitives,ReservedModels;!function(e){e.STRING="string",e.NUMBER="number",e.BOOLEAN="boolean",e.BIGINT="bigint"}(Primitives=Primitives||{}),function(e){e.STRING="string",e.OBJECT="object",e.NUMBER="number",e.BOOLEAN="boolean",e.BIGINT="bigint",e.DATE="date"}(ReservedModels=ReservedModels||{});export{Primitives,ReservedModels};

package/lib/esm/model/construction.d.ts

@@ -0,0 +1,45 @@
+import { Model } from "./Model";
+/**
+ * @summary Repopulates the Object properties with the ones from the new object
+ * @description Iterates all common properties of obj (if existing) and self, and copies them onto self
+ *
+ * @param {T} self
+ * @param {T | Record<string, any>} [obj]
+ *
+ * @function constructFromObject
+ * @memberOf module:decorator-validation.Construction
+ * @category Construction
+ */
+export declare function constructFromObject<T extends Model>(self: T, obj?: T | Record<string, any>): T;
+/**
+ * @summary Repopulates the instance with the ones from the new Model Object
+ * @description Iterates all common properties of obj (if existing) and self, and copies them onto self.
+ * Is aware of nested Model Objects and rebuilds them also.
+ * When List properties are decorated with {@link list}, they list items will also be rebuilt
+ *
+ * @param {T} self
+ * @param {T | Record<string, any>} [obj]
+ *
+ * @function constructFromModel
+ * @memberOf module:decorator-validation.Construction
+ * @category Construction
+ */
+export declare function constructFromModel<T extends Model>(self: T, obj?: T | Record<string, any>): T;
+/**
+ * @summary Helper Function to override constructors
+ *
+ * @param {Function} constructor
+ * @param {any[]} [args]
+ * @return {T} the new instance
+ *
+ * @function construct
+ * @memberOf module:decorator-validation.Construction
+ * @category Construction
+ */
+export declare function construct<T extends Model>(constructor: any, ...args: any[]): T;
+/**
+ * @summary Typo of a Model builder function
+ * @memberOf module:decorator-validation.Construction
+ * @category Construction
+ */
+export type ModelBuilderFunction = <T extends Model>(self: T, obj?: T | Record<string, any>) => T;

package/lib/esm/model/construction.js

@@ -0,0 +1 @@
+import{Model}from"./Model";import{getPropertyDecorators,isModel,stringFormat}from"../utils";import{ValidationKeys}from"../validation";import{ReservedModels}from"./constants";import{ModelKeys}from"../utils/constants";function constructFromObject(o,r){if(r)for(const t in r)r.hasOwnProperty(t)&&(o.hasOwnProperty(t)||o.prototype&&o.prototype.hasOwnProperty(t))&&(o[t]=r[t]);return o}function constructFromModel(s,o){if(o)for(const n in o)if(o.hasOwnProperty(n)&&(s.hasOwnProperty(n)||s.prototype&&s.prototype.hasOwnProperty(n))){if(s[n]=o[n],"object"!=typeof s[n])continue;if(isModel(s[n])){try{s[n]=Model.build(s[n])}catch(o){console.log(o)}continue}const p=getPropertyDecorators(ValidationKeys.REFLECT,s,n).decorators;if(!(r=p.filter(o=>-1!==[ModelKeys.TYPE,ValidationKeys.TYPE].indexOf(o.key)))||!r.length)throw new Error(stringFormat("failed to find decorators for property {0}",n));var r=(r=r.pop()).props.name?[r.props.name]:Array.isArray(r.props.customTypes)?r.props.customTypes:[r.props.customTypes];const a=Object.values(ReservedModels).map(o=>o.toLowerCase());r.forEach(o=>{if(-1===a.indexOf(o.toLowerCase()))try{switch(o){case"Array":case"Set":if(p.length){const t=p.find(o=>o.key===ValidationKeys.LIST);if(t&&("Array"===o&&(s[n]=s[n].map(o=>Model.build(o,t.props.class))),"Set"===o)){var r=new Set;for(const e of s[n])r.add(Model.build(e,t.props.class));s[n]=r}}break;default:s[n]&&(s[n]=Model.build(s[n],o))}}catch(o){console.log(o)}})}return s}function construct(r,...o){var t=(...o)=>new r(...o);return t.prototype=r.prototype,t(...o)}export{constructFromObject,constructFromModel,construct};

package/lib/esm/model/decorators.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @summary Builds the key to store as Metadata under Reflections
+ * @description concatenates {@link ModelKeys#REFLECT} with the provided key
+ * @param {string} str
+ *
+ * @function getModelKey
+ * @memberOf module:decorator-validation.Model
+ * @category Utilities
+ */
+export declare const getModelKey: (str: string) => string;
+/**
+ * @summary defines the tpe os an InstanceCallback function
+ * @memberOf module:decorator-validation.Construction
+ * @category Construction
+ */
+export type InstanceCallback = (instance: any, ...args: any[]) => void;
+/**
+ * @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;
+ * - Runs the optional {@link InstanceCallback} if provided;
+ * - Defines an {@link ModelKeys#ANCHOR} property for serialization and model rebuilding purposes;
+ *
+ * @prop {Record<string, any>} [props] additional properties to store as metadata
+ * @prop {InstanceCallback} [instanceCallback] optional callback that will be call with the instance upon instantiation. defaults to undefined
+ *
+ * @function model
+ * @memberOf module:decorator-validation.Decorators.Model
+ * @category Decorators
+ */
+export declare function model(props?: Record<string, any>, instanceCallback?: InstanceCallback): (original: any) => any;

package/lib/esm/model/decorators.js

@@ -0,0 +1 @@
+import{construct}from"./construction";import{ModelKeys}from"../utils/constants";import{Model}from"./Model";const getModelKey=e=>ModelKeys.REFLECT+e;function model(n,l){return r=>{function e(...e){var t=construct(r,...e),o=((o=Model.getBuilder())&&o(t,e.length?e[0]:void 0),Object.assign({},{class:r.name}));return Object.defineProperty(t,ModelKeys.ANCHOR,{writable:!1,enumerable:!1,configurable:!1,value:o}),Reflect.defineMetadata(getModelKey(ModelKeys.MODEL),Object.assign(o,n||{}),t.constructor),l&&l(t,...e),t}return e.prototype=r.prototype,Object.defineProperty(e,"name",{writable:!1,enumerable:!0,configurable:!1,value:r.prototype.constructor.name}),Model.register(e),e}}export{getModelKey,model};

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

@@ -0,0 +1,7 @@
+export * from "./construction";
+export * from "./Registry";
+export * from "./decorators";
+export * from "./ModelErrorDefinition";
+export * from "./types";
+export * from "./Model";
+export * from "./constants";

package/lib/esm/model/index.js

@@ -0,0 +1 @@
+export*from"./construction";export*from"./Registry";export*from"./decorators";export*from"./ModelErrorDefinition";export*from"./types";export*from"./Model";export*from"./constants";

package/lib/esm/model/types.d.ts

@@ -0,0 +1,67 @@
+import { ModelErrorDefinition } from "./ModelErrorDefinition";
+import { Model } from "./Model";
+/**
+ * @summary Definition of a Model Constructor Argument
+ *
+ * @memberOf module:decorator-validation.Model
+ * @category Model
+ *
+ * @see ModelConstructor
+ */
+export type ModelArg<T> = T | Record<string, any>;
+/**
+ * @summary Definition of a Class Constructor
+ * @description Generic type for Constructor functions
+ *
+ * @typedef Constructor
+ *
+ * @param {any[]} [args]
+ * @memberOf module:decorator-validation.Model
+ * @category Model
+ */
+export type Constructor<T> = {
+    new (...args: any[]): T;
+};
+/**
+ * @summary Definition of a Model Constructor
+ * @description Generic type for all Model Constructor functions
+ *
+ * @typedef ModelConstructor
+ *
+ * @param {ModelArg<T>} [model]
+ * @param {any[]} [args]
+ * @memberOf module:decorator-validation.Model
+ * @category Construction
+ */
+export type ModelConstructor<T extends Model> = {
+    new (model?: ModelArg<T>, ...args: any[]): T;
+};
+/**
+ * @summary Defines the Validation API for validatable models
+ * @interface Validatable
+ *
+ * @category Validation
+ */
+export interface Validatable {
+    /**
+     * @summary Validates the model and returns the {@link ModelErrorDefinition} if any
+     * @param {any} [args]
+     *
+     * @method
+     */
+    hasErrors(...args: any[]): ModelErrorDefinition | undefined;
+}
+/**
+ * @summary Serializable interface
+ *
+ * @interface Serializable
+ *
+ * @category Serialization
+ */
+export interface Serializable {
+    /**
+     * @summary serializes the model
+     * @method
+     */
+    serialize(): string;
+}

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

@@ -0,0 +1,22 @@
+/**
+ * @summary Defines the various Model keys used for reflection
+ *
+ * @property {string} REFLECT prefix to all other keys
+ * @property {string} TYPE type key
+ * @property {string} PARAMS method params key
+ * @property {string} RETURN method return key
+ * @property {string} MODEL model key
+ * @property {string} ANCHOR anchor key. will serve as a ghost property in the model
+ *
+ * @constant ModelKeys
+ * @memberOf module:decorator-validation.Model
+ * @category Model
+ */
+export declare enum ModelKeys {
+    REFLECT = "model.definition.",
+    TYPE = "design:type",
+    PARAMS = "design:paramtypes",
+    RETURN = "design:returntype",
+    MODEL = "model",
+    ANCHOR = "__modelDefinition"
+}

package/lib/esm/utils/constants.js

@@ -0,0 +1 @@
+var ModelKeys;!function(e){e.REFLECT="model.definition.",e.TYPE="design:type",e.PARAMS="design:paramtypes",e.RETURN="design:returntype",e.MODEL="model",e.ANCHOR="__modelDefinition"}(ModelKeys=ModelKeys||{});export{ModelKeys};