knight-validation 2.0.0 → 2.0.3

package/README.md

@@ -6,7 +6,7 @@
 
 ## Overview
 
-### Constraints for single fields
+### Constraints for single properties
 
 ```typescript
 import { Required, TypeOf, Unique, Validator } from 'knight-validation'
@@ -25,7 +25,7 @@ class UserValidator extends Validator {
 }
 ```
 
-### Constraints for multiple fields
+### Constraints for multiple properties
 
 ```typescript
 import { Validator } from 'knight-validation'
@@ -41,12 +41,12 @@ class UserValidator extends Validator {
 ### Available constraints
 
 ```typescript
-// Check if a field is absent
+// Check if a property is absent
 new Absent
 
-// Check a field's value equals one of the three given strings
+// Check a property's value equals one of the three given strings
 new Enum('Moni', 'Lisa', 'Anna')
-// Check if a field's value equals one of the three given numbers
+// Check if a property's value equals one of the three given numbers
 new Enum(1, 3, 7)
 
 new Exists(async (user: User) => {
@@ -54,12 +54,12 @@ new Exists(async (user: User) => {
   // Return true if your exists condition is met
 })
 
-// Check if a field is there
+// Check if a property is there
 new Required
 
-// Check if a field's value is of the given JavaScript type
+// Check if a property's value is of the given JavaScript type
 new TypeOf('number')
-// Check if a field's value is an instance if the given class
+// Check if a property's value is an instance if the given class
 new TypeOf(Date)
 
 new Unique(async (user: User) => {
@@ -70,7 +70,7 @@ new Unique(async (user: User) => {
 
 ### Validation
 
-Validating an object returns an array of misfits which is empty if there are not any. The validator goes through all constraints for one field and stops the validation on the first misfit. Afterwards it goes on to the next field.
+Validating an object returns an array of misfits which is empty if there are not any. The validator goes through all constraints for one property and stops the validation on the first misfit. Afterwards it goes on to the next property.
 
 ```typescript
 let user = new User
@@ -86,19 +86,19 @@ A misfit contains the following informations by default.
 
 ```typescript
 // The name of the misfit which defaults to the name of the constraint which was not met
-misfit.name == 'Required'
+misfit.constraint == 'Required'
 
-// The field where the misfit occured
-misfit.field == 'email'
+// The property where the misfit occured
+misfit.property == 'email'
 
-// The fields where the misfit
-misfit.fields == ['firstName', 'lastName']
+// The properties where the misfit occured
+misfit.properties == ['firstName', 'lastName']
 
 // It contains any information that is useful about why checking the constraint resulted in a misfit (Optional)
-misfit.constraints
+misfit.value
 
 // A message (Optional)
-misift.message == 'The field email is required.'
+misift.message == 'The property email is required.'
 ```
 
 #### Check only what is there
@@ -111,7 +111,7 @@ user.email = undefined
 
 let misfits = validator.validate(user, { checkOnlyWhatIsThere: true })
 
-misfits.length == 0 // There are no misfits even though the email field is required
+misfits.length == 0 // There are no misfits even though the email property is required
 ```
 
 ### Constraints that are only checked if a condition is met
@@ -132,11 +132,11 @@ class UserValidator extends Validator {
 #### Exclude rules
 
 ```typescript
-// Exclude all constraints regarding the email field
+// Exclude all constraints regarding the email property
 let misfits = validator.validate(user, { exclude: ['email'] })
 
-// Exclude only the required constraint of the email field
-let misfits = validator.validate(user, { exclude: [{ field: 'email', constraint: 'Required' }] })
+// Exclude only the required constraint of the email property
+let misfits = validator.validate(user, { exclude: [{ properties: 'email', constraint: 'Required' }] })
 ```
 
 ### Anonymous custom constraints
@@ -150,7 +150,7 @@ validator.add(['firstName', 'lastName'], 'Different', async (user: User) => {
   if (user.firstName == user.lastName) {
     let misfit = new Misfit
 
-    // You can skip setting a name and the field(s) for the misfit. These will be set automatically.
+    // You can skip setting a name and the property(s) for the misfit. These will be set automatically.
     
     // We give it some information here on what went wrong. What you put in here depends on your needs.
     misfit.constraints = {
@@ -173,32 +173,32 @@ import { Constraint } from 'knight-validation'
 class YourConstraint extends Constraint {
 
   // Override the abstract method validate
-  async validate(obj: any, field: string|string[]): Promise<Misfit|undefined> {
+  async validate(obj: any, properties: string|string[]): Promise<Misfit|undefined> {
 
-    // At first you want to check if the field is absent because in case of absense you do not want to validate because a field may be optional.
-    if (this.isFieldAbsent(obj, field)) {
+    // At first you want to check if the properties are absent because in case of absense you do not want to validate because a property may be optional.
+    if (this.arePropertyAbsent(obj, properties)) {
       return
     }
 
-    // Next you need to check if the field was a single or a combined one. Maybe you just implement on of the two possibilities.
-    if (typeof field == 'string') {
-      // In case of a single field
+    // Next you need to check if the properties were single or a nultiple ones. Maybe you just implement on of the two possibilities.
+    if (typeof properties == 'string') {
+      // In case of a single property
     }
     else {
-      // In case of multiple fields
+      // In case of multiple properties
     }
   }
 }
 ```
 
-Another possibility is to use the `defaultValidation` method. It will do the check for absence and will implement the validation of combined fields.
+Another possibility is to use the `defaultValidation` method. It will do the check for absence and will implement the validation of combined properties.
 
 ```typescript
 import { Constraint } from 'knight-validation'
 
 class YourConstraint extends Constraint {
-  async validate(obj: any, field: string|string[]): Promise<Misfit|undefined> {
-    return this.defaultValidation(obj, field, async (value: any) => {
+  async validate(obj: any, properties: string|string[]): Promise<Misfit|undefined> {
+    return this.defaultValidation(obj, properties, async (value: any) => {
       if (value == 1) {  // Validate the value here
         return new Misfit
       }

package/lib/index.d.ts

@@ -1,13 +1,12 @@
-export { default as Constraint } from './lib/Constraint';
-export { default as Absent } from './lib/constraints/Absent';
-export { default as Enum } from './lib/constraints/Enum';
-export { default as Exists } from './lib/constraints/Exists';
-export { default as Max } from './lib/constraints/Max';
-export { default as QuickConstraint } from './lib/constraints/QuickConstraint';
-export { default as Required } from './lib/constraints/Required';
-export { default as TypeOf, TypeOfValues } from './lib/constraints/TypeOf';
-export { default as Unique } from './lib/constraints/Unique';
-export { default as fieldsEqual } from './lib/fieldsEqual';
-export { default as Misfit } from './lib/Misfit';
-export { default as MisfitsError } from './lib/MisfitsError';
-export { default as Validator, ValidatorOptions } from './lib/Validator';
+export * from './lib/constraints/Absent';
+export * from './lib/constraints/Bounds';
+export * from './lib/constraints/Enum';
+export * from './lib/constraints/Exists';
+export * from './lib/constraints/Length';
+export * from './lib/constraints/Required';
+export * from './lib/constraints/TypeOf';
+export * from './lib/constraints/Unique';
+export * from './lib/Misfit';
+export * from './lib/MisfitsError';
+export * from './lib/QuickConstraint';
+export * from './lib/Validator';

package/lib/index.js

@@ -1,28 +1,28 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-var Constraint_1 = require("./lib/Constraint");
-Object.defineProperty(exports, "Constraint", { enumerable: true, get: function () { return Constraint_1.default; } });
-var Absent_1 = require("./lib/constraints/Absent");
-Object.defineProperty(exports, "Absent", { enumerable: true, get: function () { return Absent_1.default; } });
-var Enum_1 = require("./lib/constraints/Enum");
-Object.defineProperty(exports, "Enum", { enumerable: true, get: function () { return Enum_1.default; } });
-var Exists_1 = require("./lib/constraints/Exists");
-Object.defineProperty(exports, "Exists", { enumerable: true, get: function () { return Exists_1.default; } });
-var Max_1 = require("./lib/constraints/Max");
-Object.defineProperty(exports, "Max", { enumerable: true, get: function () { return Max_1.default; } });
-var QuickConstraint_1 = require("./lib/constraints/QuickConstraint");
-Object.defineProperty(exports, "QuickConstraint", { enumerable: true, get: function () { return QuickConstraint_1.default; } });
-var Required_1 = require("./lib/constraints/Required");
-Object.defineProperty(exports, "Required", { enumerable: true, get: function () { return Required_1.default; } });
-var TypeOf_1 = require("./lib/constraints/TypeOf");
-Object.defineProperty(exports, "TypeOf", { enumerable: true, get: function () { return TypeOf_1.default; } });
-var Unique_1 = require("./lib/constraints/Unique");
-Object.defineProperty(exports, "Unique", { enumerable: true, get: function () { return Unique_1.default; } });
-var fieldsEqual_1 = require("./lib/fieldsEqual");
-Object.defineProperty(exports, "fieldsEqual", { enumerable: true, get: function () { return fieldsEqual_1.default; } });
-var Misfit_1 = require("./lib/Misfit");
-Object.defineProperty(exports, "Misfit", { enumerable: true, get: function () { return Misfit_1.default; } });
-var MisfitsError_1 = require("./lib/MisfitsError");
-Object.defineProperty(exports, "MisfitsError", { enumerable: true, get: function () { return MisfitsError_1.default; } });
-var Validator_1 = require("./lib/Validator");
-Object.defineProperty(exports, "Validator", { enumerable: true, get: function () { return Validator_1.default; } });
+__exportStar(require("./lib/constraints/Absent"), exports);
+__exportStar(require("./lib/constraints/Bounds"), exports);
+__exportStar(require("./lib/constraints/Enum"), exports);
+__exportStar(require("./lib/constraints/Exists"), exports);
+__exportStar(require("./lib/constraints/Length"), exports);
+__exportStar(require("./lib/constraints/Required"), exports);
+__exportStar(require("./lib/constraints/TypeOf"), exports);
+__exportStar(require("./lib/constraints/Unique"), exports);
+__exportStar(require("./lib/Misfit"), exports);
+__exportStar(require("./lib/MisfitsError"), exports);
+__exportStar(require("./lib/QuickConstraint"), exports);
+__exportStar(require("./lib/Validator"), exports);

package/lib/lib/Constraint.d.ts

@@ -1,9 +1,5 @@
-import Misfit from './Misfit';
-export default abstract class Constraint {
+import { Misfit } from './Misfit';
+export declare abstract class Constraint<T = any, MisfitValuesType = any> {
     name: string;
-    abstract validate(obj: any, field: string | string[]): Promise<Misfit | undefined>;
-    protected defaultValidation(obj: any, field: string | string[], validateValue: (value: any) => Promise<Misfit | undefined>): Promise<Misfit | undefined>;
-    validateValue(value: any): Promise<Misfit | undefined>;
-    isFieldAbsent(obj: any, field: string | string[]): boolean;
-    static absent(value: any): boolean;
+    abstract validate(value: T): Promise<Misfit<MisfitValuesType> | null>;
 }

package/lib/lib/Constraint.js

@@ -1,125 +1,9 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var Constraint = /** @class */ (function () {
-    function Constraint() {
+exports.Constraint = void 0;
+class Constraint {
+    constructor() {
         this.name = this.constructor.name;
     }
-    Constraint.prototype.defaultValidation = function (obj, field, validateValue) {
-        return __awaiter(this, void 0, void 0, function () {
-            var value, _i, field_1, fld, value, misfit;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (this.isFieldAbsent(obj, field)) {
-                            return [2 /*return*/];
-                        }
-                        if (!(typeof field == 'string')) return [3 /*break*/, 1];
-                        value = obj[field];
-                        return [2 /*return*/, validateValue(value)];
-                    case 1:
-                        if (!(field instanceof Array)) return [3 /*break*/, 6];
-                        _i = 0, field_1 = field;
-                        _a.label = 2;
-                    case 2:
-                        if (!(_i < field_1.length)) return [3 /*break*/, 5];
-                        fld = field_1[_i];
-                        value = obj[fld];
-                        return [4 /*yield*/, validateValue(value)];
-                    case 3:
-                        misfit = _a.sent();
-                        if (misfit) {
-                            return [2 /*return*/, misfit];
-                        }
-                        _a.label = 4;
-                    case 4:
-                        _i++;
-                        return [3 /*break*/, 2];
-                    case 5: return [3 /*break*/, 7];
-                    case 6: throw new Error('Parameter field was neither of type string nor instance of Array');
-                    case 7: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    Constraint.prototype.validateValue = function (value) {
-        return __awaiter(this, void 0, void 0, function () {
-            var misfit;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.validate({ value: value }, 'value')];
-                    case 1:
-                        misfit = _a.sent();
-                        if (misfit) {
-                            return [2 /*return*/, misfit];
-                        }
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    Constraint.prototype.isFieldAbsent = function (obj, field) {
-        if (typeof field == 'string') {
-            var value = obj[field];
-            if (Constraint.absent(value)) {
-                return true;
-            }
-        }
-        else if (field instanceof Array) {
-            for (var _i = 0, field_2 = field; _i < field_2.length; _i++) {
-                var fld = field_2[_i];
-                var value = obj[fld];
-                if (Constraint.absent(value)) {
-                    return true;
-                }
-            }
-        }
-        else {
-            throw new Error('Parameter field was neither of type string nor instance of Array');
-        }
-        return false;
-    };
-    Constraint.absent = function (value) {
-        return value === undefined ||
-            value === null ||
-            value === '' ||
-            typeof value === 'number' && isNaN(value);
-    };
-    return Constraint;
-}());
-exports.default = Constraint;
+}
+exports.Constraint = Constraint;

package/lib/lib/Misfit.d.ts

@@ -1,17 +1,11 @@
-export default class Misfit {
+export declare class Misfit<ValuesType = any> {
     constraint: string;
-    field: string;
-    fields: string[];
-    values?: any;
+    properties: string[];
+    values?: ValuesType;
     message?: string;
-    constructor(constraint?: string, field?: string | string[], values?: any);
-    setMessage(message: string | undefined): this;
-    isSingleField(): boolean;
-    isMultipleField(): boolean;
-    fieldsEqual(fields: string[]): boolean;
-    static required(field: string, message?: string): Misfit;
-    static absent(field: string, message?: string): Misfit;
-    static unique(field: string, message?: string): Misfit;
-    static exists(field: string, message?: string): Misfit;
-    static typeOf(field: string, message?: string): Misfit;
+    constructor(constraint?: string, values?: ValuesType);
+    setProperties(property: string | string[]): void;
+    addPrefix(prefix: string): void;
+    isSinglePropery(): boolean;
+    isMultipleProperties(): boolean;
 }

package/lib/lib/Misfit.js

@@ -1,50 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var Absent_1 = require("./constraints/Absent");
-var Exists_1 = require("./constraints/Exists");
-var Required_1 = require("./constraints/Required");
-var TypeOf_1 = require("./constraints/TypeOf");
-var Unique_1 = require("./constraints/Unique");
-var fieldsEqual_1 = require("./fieldsEqual");
-var Misfit = /** @class */ (function () {
-    function Misfit(constraint, field, values) {
+exports.Misfit = void 0;
+class Misfit {
+    constructor(constraint, values) {
+        this.properties = [];
         this.constraint = constraint;
-        if (typeof field == 'string') {
-            this.field = field;
+        this.values = values;
+    }
+    setProperties(property) {
+        if (typeof property == 'string') {
+            this.properties = [property];
         }
-        else if (field instanceof Array) {
-            this.fields = field;
+        else if (property instanceof Array) {
+            this.properties = property;
         }
-        this.values = values;
     }
-    Misfit.prototype.setMessage = function (message) {
-        this.message = message;
-        return this;
-    };
-    Misfit.prototype.isSingleField = function () {
-        return this.field != undefined;
-    };
-    Misfit.prototype.isMultipleField = function () {
-        return this.fields != undefined;
-    };
-    Misfit.prototype.fieldsEqual = function (fields) {
-        return fieldsEqual_1.default(this.fields, fields);
-    };
-    Misfit.required = function (field, message) {
-        return new Misfit(Required_1.default.name, field).setMessage(message);
-    };
-    Misfit.absent = function (field, message) {
-        return new Misfit(Absent_1.default.name, field).setMessage(message);
-    };
-    Misfit.unique = function (field, message) {
-        return new Misfit(Unique_1.default.name, field).setMessage(message);
-    };
-    Misfit.exists = function (field, message) {
-        return new Misfit(Exists_1.default.name, field).setMessage(message);
-    };
-    Misfit.typeOf = function (field, message) {
-        return new Misfit(TypeOf_1.default.name, field).setMessage(message);
-    };
-    return Misfit;
-}());
-exports.default = Misfit;
+    addPrefix(prefix) {
+        for (let i = 0; i < this.properties.length; i++) {
+            this.properties[i] = prefix + this.properties[i];
+        }
+    }
+    isSinglePropery() {
+        return this.properties && this.properties.length == 1;
+    }
+    isMultipleProperties() {
+        return this.properties && this.properties.length > 1;
+    }
+}
+exports.Misfit = Misfit;

package/lib/lib/MisfitsError.d.ts

@@ -1,5 +1,5 @@
-import Misfit from './Misfit';
-export default class MisfitsError extends Error {
+import { Misfit } from './Misfit';
+export declare class MisfitsError extends Error {
     misfits: Misfit[];
     constructor(misfits: Misfit | Misfit[]);
 }

package/lib/lib/MisfitsError.js

@@ -1,25 +1,10 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-var MisfitsError = /** @class */ (function (_super) {
-    __extends(MisfitsError, _super);
-    function MisfitsError(misfits) {
-        var _this = _super.call(this, 'Misfits occured ' + JSON.stringify(misfits)) || this;
-        _this.misfits = misfits instanceof Array ? misfits : [misfits];
-        return _this;
+exports.MisfitsError = void 0;
+class MisfitsError extends Error {
+    constructor(misfits) {
+        super('Misfits occured ' + JSON.stringify(misfits));
+        this.misfits = misfits instanceof Array ? misfits : [misfits];
     }
-    return MisfitsError;
-}(Error));
-exports.default = MisfitsError;
+}
+exports.MisfitsError = MisfitsError;

package/lib/lib/QuickConstraint.d.ts

@@ -0,0 +1,8 @@
+import { Constraint } from './Constraint';
+import { Misfit } from './Misfit';
+export declare class QuickConstraint<T> extends Constraint<T, any> {
+    name: string;
+    validateFn: (obj: T) => Promise<Misfit | null>;
+    constructor(name: string, validateFn: (obj: T) => Promise<Misfit | null>);
+    validate(obj: T): Promise<Misfit | null>;
+}

package/lib/lib/QuickConstraint.js

@@ -0,0 +1,26 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuickConstraint = void 0;
+const Constraint_1 = require("./Constraint");
+class QuickConstraint extends Constraint_1.Constraint {
+    constructor(name, validateFn) {
+        super();
+        this.name = name;
+        this.validateFn = validateFn;
+    }
+    validate(obj) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.validateFn(obj);
+        });
+    }
+}
+exports.QuickConstraint = QuickConstraint;

package/lib/lib/Validator.d.ts

@@ -1,38 +1,23 @@
-import Constraint from './Constraint';
-import Misfit from './Misfit';
+import { Constraint } from './Constraint';
+import { Misfit } from './Misfit';
 export interface ValidatorOptions {
     checkOnlyWhatIsThere?: boolean;
-    include?: (string | string[] | {
-        field: string | string[];
-        constraint?: string | string[];
-    })[];
-    exclude?: (string | string[] | {
-        field: string | string[];
-        constraint?: string | string[];
-    })[];
 }
-export default class Validator {
-    options?: ValidatorOptions;
-    fieldConstraints: FieldConstraint[];
-    constructor(options?: ValidatorOptions);
-    add(field: string | string[], constraint: Constraint, condition?: (object: any) => Promise<boolean>): void;
-    add(field: string | string[], constraintName: string, validate: (object: any, field: string | string[]) => Promise<Misfit | undefined>, condition?: (object: any) => Promise<boolean>): void;
-    add(field: string | string[], validator: Validator, condition?: (object: any) => Promise<boolean>): void;
-    add(validator: Validator): void;
-    get fields(): (string | string[])[];
-    get singleFields(): string[];
-    get combinedFields(): string[][];
-    constraints(field: string | string[]): FieldConstraint[];
-    validate(object: any, options?: ValidatorOptions): Promise<Misfit[]>;
-}
-declare class FieldConstraint {
-    field?: string;
-    fields?: string[];
+interface ValidatorEntry {
+    properties: string[];
     constraint?: Constraint;
-    validator?: Validator;
+    validator?: Validator<any>;
     condition?: (object: any) => Promise<boolean>;
-    constructor(field: string | string[], constraintOrValidator: Constraint | Validator, condition?: (object: any) => Promise<boolean>);
-    validateConstraint(value: any, object: any): Promise<Misfit | undefined>;
-    validateValidator(value: any): Promise<Misfit[]>;
+}
+export declare class Validator<T> {
+    options?: ValidatorOptions;
+    entries: ValidatorEntry[];
+    constructor(options?: ValidatorOptions);
+    add(properties: string, constraint: Constraint, condition?: (object: T) => Promise<boolean>): void;
+    add(properties: string, constraintName: string, validate: (value: any) => Promise<Misfit | null>, condition?: (object: T) => Promise<boolean>): void;
+    add(properties: string[], constraintName: string, validate: (object: T) => Promise<Misfit | null>, condition?: (object: T) => Promise<boolean>): void;
+    add(property: string, validator: Validator<any>, condition?: (object: T) => Promise<boolean>): void;
+    add(validator: Validator<any>): void;
+    validate(object: T, options?: ValidatorOptions): Promise<Misfit[]>;
 }
 export {};