valgen 3.2.1 → 4.0.0-alpha.2

package/typings/rules/is-object.d.ts

@@ -0,0 +1,22 @@
+import { Type, ValidationOptions, Validator } from '../core/index.js';
+export type PropertyOptions = {
+    label?: string;
+    as?: string;
+};
+export type ObjectSchema = Record<string | number, Validator<any, any> | [Validator<any, any>, PropertyOptions]>;
+export interface IsObjectOptions<T> extends ValidationOptions {
+    name?: string;
+    ctor?: Type<T>;
+    additionalFields?: boolean | Validator<any, any>;
+    caseInSensitive?: boolean;
+    detectCircular?: boolean;
+}
+export interface ObjectValidator<T extends object = object, I = object> extends Validator<T, I> {
+    schema: ObjectSchema;
+}
+/**
+ * Validates object according to schema
+ * Converts properties according to schema rules if coerce option is set to 'true'.
+ * @validator isObject
+ */
+export declare function isObject<T extends object = object, I = object>(schema: ObjectSchema, options?: IsObjectOptions<T>): ObjectValidator<T, I>;

package/typings/rules/is-record.d.ts

@@ -0,0 +1,7 @@
+import { ValidationOptions, Validator } from '../core/index.js';
+/**
+ * Validates record object according to given "key" and "value" rules
+ * Converts properties according to rules if coerce option is set to 'true'.
+ * @validator isRecord
+ */
+export declare function isRecord<TKeys extends string | number | symbol, TValues>(keyRule: Validator<TKeys>, valueRule: Validator<TValues>, options?: ValidationOptions): Validator<Record<TKeys, TValues>, Record<TKeys, TValues>, import("../core/types.js").ExecutionOptions>;

package/typings/rules/is-string.d.ts

@@ -0,0 +1,42 @@
+import { ValidationOptions } from '../core/index.js';
+/**
+ * Validates if value is "string".
+ * Converts input value to string if coerce option is set to 'true'.
+ * @validator isString
+ */
+export declare function isString(options?: ValidationOptions): import("../core/validator.js").Validator<string, unknown, import("../core/types.js").ExecutionOptions>;
+/**
+ * Process "String.replace" method
+ * @validator stringReplace
+ */
+export declare function stringReplace(searchValue: string | RegExp, replaceValue: string): any;
+export declare function stringReplace(searchValue: string | RegExp, replacer: (subsring: string, ...args: any[]) => string): any;
+export declare function stringReplace(searchValue: {
+    [Symbol.replace](string: string, replaceValue: string): string;
+}, replaceValue: string): any;
+export declare function stringReplace(searchValue: {
+    [Symbol.replace](string: string, replacer: (substring: string, ...args: any[]) => string): string;
+}, replacer: (substring: string, ...args: any[]) => string): any;
+/**
+ * Process "String.split" method
+ * @validator split
+ */
+export declare function stringSplit(separator: string | RegExp, limit?: number): any;
+export declare function stringSplit(splitter: {
+    [Symbol.split](string: string, limit?: number): string[];
+}, limit?: number): any;
+/**
+ * Removes whitespace from both ends of a string
+ * @validator trim
+ */
+export declare function trim(): import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;
+/**
+ * Removes whitespace from the end of a string
+ * @validator trimEnd
+ */
+export declare const trimEnd: () => import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;
+/**
+ * Removes whitespace from the beginning of a string
+ * @validator trimStart
+ */
+export declare const trimStart: () => import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;

package/typings/rules/is-tuple.d.ts

@@ -0,0 +1,27 @@
+import { ValidationOptions, Validator } from '../core/index.js';
+/**
+ * Validates if value is "tuple" and applies validation for each item.
+ * Converts input value to tuple if coerce option is set to 'true'.
+ * @validator isTuple
+ */
+export declare function isTuple<T1, I1>(items: [Validator<T1, I1>], options?: ValidationOptions): Validator<[T1], [I1]>;
+export declare function isTuple<T1, I1, T2, I2>(items: [Validator<T1, I1>, Validator<T2, I2>], options?: ValidationOptions): Validator<[T1, T2], [I1, I2]>;
+export declare function isTuple<T1, I1, T2, I2, T3, I3>(items: [Validator<T1, I1>, Validator<T2, I2>, Validator<T3, I3>], options?: ValidationOptions): Validator<[T1, T2, T3], [I1, I2, I3]>;
+export declare function isTuple<T1, I1, T2, I2, T3, I3, T4, I4>(items: [Validator<T1, I1>, Validator<T2, I2>, Validator<T3, I3>, Validator<T4, I4>], options?: ValidationOptions): Validator<[T1, T2, T3, T4], [I1, I2, I3, I4]>;
+export declare function isTuple<T1, I1, T2, I2, T3, I3, T4, I4>(items: [Validator<T1, I1>, Validator<T2, I2>, Validator<T3, I3>, Validator<T4, I4>], options?: ValidationOptions): Validator<[T1, T2, T3, T4], [I1, I2, I3, I4]>;
+export declare function isTuple<T1, I1, T2, I2, T3, I3, T4, I4, T5, I5>(items: [
+    Validator<T1, I1>,
+    Validator<T2, I2>,
+    Validator<T3, I3>,
+    Validator<T4, I4>,
+    Validator<T5, I5>
+], options?: ValidationOptions): Validator<[T1, T2, T3, T4, T5], [I1, I2, I3, I4, I5]>;
+export declare function isTuple<T1, I1, T2, I2, T3, I3, T4, I4, T5, I5, T6, I6>(items: [
+    Validator<T1, I1>,
+    Validator<T2, I2>,
+    Validator<T3, I3>,
+    Validator<T4, I4>,
+    Validator<T5, I5>,
+    Validator<T6, I6>,
+    ...Validator<any, any>[]
+], options?: ValidationOptions): Validator<[T1, T2, T3, T4, T5, T6, ...any[]], [I1, I2, I3, I4, I5, I5, ...any[]]>;

package/typings/rules/length.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Returns length of an Array, String, ArrayBuffer, Buffer or any object with the "length" property.
+ * @validator getLength
+ */
+export declare const extractLength: () => import("../core/validator.js").Validator<number, ExtractLengthInput, import("../core/types.js").ExecutionOptions>;
+type ExtractLengthInput = string | any[] | ArrayBuffer | {
+    length: number;
+} | {
+    size: number;
+};
+/**
+ * Checks the length is at least "minValue"
+ * @validator lengthMin
+ */
+export declare const lengthMin: (minValue: number) => import("../core/validator.js").Validator<any, any, import("../core/types.js").ExecutionOptions>;
+/**
+ * Checks if the length is at most "maxValue"
+ * @validator charLengthMax
+ */
+export declare const lengthMax: (maxValue: number) => import("../core/validator.js").Validator<any, any, import("../core/types.js").ExecutionOptions>;
+export {};

package/typings/rules/optional.d.ts

@@ -0,0 +1,17 @@
+import { Nullish } from 'ts-gems';
+import { ValidationOptions, Validator } from '../core/index.js';
+/**
+ * Makes sub-rule optional
+ * @validator optional
+ */
+export declare function optional<T, I>(nested: Validator<T, I>, options?: ValidationOptions): Validator<Nullish<T>, Nullish<I>, import("../core/types.js").ExecutionOptions>;
+/**
+ * Makes sub-rule required
+ * @validator required
+ */
+export declare function required<T, I>(nested: Validator<T, I>, options?: ValidationOptions): Validator<Nullish<T>, I, import("../core/types.js").ExecutionOptions>;
+/**
+ * Validates if property exists
+ * @validator exists
+ */
+export declare function exists(options?: ValidationOptions): Validator<any, unknown, import("../core/types.js").ExecutionOptions>;

package/typings/rules/pipe.d.ts

@@ -0,0 +1,11 @@
+import { Validator } from '../core/index.js';
+/**
+ *
+ * @validator pipe
+ */
+export declare function pipe<T>(...rules: [...Validator<any, any>[], Validator<T, any>]): Validator<T, any, import("../core/types.js").ExecutionOptions>;
+/**
+ * Test given value against to all codecs and returns original input
+ * @validator allOf
+ */
+export declare function allOf(...rules: Validator<any, any>[]): Validator<any, any, import("../core/types.js").ExecutionOptions>;

package/typings/rules/range.d.ts

@@ -0,0 +1,48 @@
+import { ValidationOptions, Validator } from '../core/index.js';
+type RangeInput = number | bigint | Date | string;
+/**
+ * Checks if value is grater than "minValue"
+ * @validator iGt
+ */
+export declare function isGt(minValue: number, options?: ValidationOptions): Validator<number, number>;
+export declare function isGt(minValue: bigint, options?: ValidationOptions): Validator<bigint, bigint | number>;
+export declare function isGt(minValue: Date, options?: ValidationOptions): Validator<Date, Date>;
+export declare function isGt(minValue: string, options?: ValidationOptions & {
+    caseInsensitive?: boolean;
+}): Validator<string, string>;
+/**
+ * Checks if value is grater than or equal to minValue
+ * @validator isGte
+ */
+export declare function isGte(minValue: number, options?: ValidationOptions): Validator<number, number>;
+export declare function isGte(minValue: bigint, options?: ValidationOptions): Validator<bigint, bigint | number>;
+export declare function isGte(minValue: Date, options?: ValidationOptions): Validator<Date, Date>;
+export declare function isGte(minValue: string, options?: ValidationOptions & {
+    caseInsensitive?: boolean;
+}): Validator<string, string>;
+/**
+ * Checks if number value is lover than maxValue
+ * @validator isLt
+ */
+export declare function isLt(maxValue: number, options?: ValidationOptions): Validator<number, number>;
+export declare function isLt(maxValue: bigint, options?: ValidationOptions): Validator<bigint, bigint | number>;
+export declare function isLt(maxValue: Date, options?: ValidationOptions): Validator<Date, Date>;
+export declare function isLt(maxValue: string, options?: ValidationOptions & {
+    caseInsensitive?: boolean;
+}): Validator<string, string>;
+/**
+ * Checks if value is lover than or equal to maxValue
+ * @validator isLte
+ */
+export declare function isLte(maxValue: number, options?: ValidationOptions): Validator<number, number>;
+export declare function isLte(maxValue: bigint, options?: ValidationOptions): Validator<bigint, bigint | number>;
+export declare function isLte(maxValue: Date, options?: ValidationOptions): Validator<Date, Date>;
+export declare function isLte(maxValue: string, options?: ValidationOptions & {
+    caseInsensitive?: boolean;
+}): Validator<string, string>;
+/**
+ * Checks if value is between minValue and maxValue
+ * @validator range
+ */
+export declare function range<T extends RangeInput>(minValue: T, maxValue: T, options?: ValidationOptions): Validator<T, T, import("../core/types.js").ExecutionOptions>;
+export {};

package/typings/rules/string-formats.d.ts

@@ -0,0 +1,140 @@
+import validatorJS from 'validator';
+import { ValidationOptions } from '../core/index.js';
+/**
+ * Validates if value is an "UUID".
+ * @validator isUUID
+ */
+export declare function isUUID(version?: 1 | 2 | 3 | 4 | 5, options?: ValidationOptions): import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;
+export interface IsEmailOptions extends ValidationOptions, validatorJS.IsEmailOptions {
+}
+/**
+ * Validates if value is a valid Email
+ * @validator isEmail
+ */
+export declare function isEmail(options?: IsEmailOptions): import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;
+export interface IsMobilePhoneOptions extends ValidationOptions, validatorJS.IsMobilePhoneOptions {
+    locale?: 'any' | validatorJS.MobilePhoneLocale | validatorJS.MobilePhoneLocale[];
+}
+/**
+ * Validates if value is a valid Email
+ * @validator isMobilePhone
+ */
+export declare function isMobilePhone(options?: IsMobilePhoneOptions): import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;
+/**
+ * Validates if value is an IP
+ * @validator isIP
+ */
+export declare function isIP(version?: 4 | 6, options?: ValidationOptions): import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;
+/**
+ * Validates if value is an IP
+ * @validator isUUID
+ */
+export declare function isIPRange(version?: 4 | 6, options?: ValidationOptions): import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;
+export interface IsMACAddressOptions extends ValidationOptions, validatorJS.IsMACAddressOptions {
+}
+/**
+ * Validates if value is an MACAddress
+ * @validator isMACAddress
+ */
+export declare function isMACAddress(options?: IsMACAddressOptions): import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;
+/**
+ * Validates if value is a port number
+ * @validator isPort
+ */
+export declare function isPort(options?: ValidationOptions): import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;
+export interface IsURLOptions extends ValidationOptions, validatorJS.IsURLOptions {
+}
+/**
+ * Validates if value is an MACAddress
+ * @validator isURL
+ */
+export declare function isURL(options?: IsURLOptions): import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;
+export interface Base64ValidatorOptions extends ValidationOptions, validatorJS.IsBase64Options {
+}
+/**
+ * Validates if value is a "Base64" string.
+ * @validator isBase64
+ */
+export declare function isBase64(options?: Base64ValidatorOptions): import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;
+/**
+ * Validates if value is a BIC (Bank Identification Code) or SWIFT code
+ * @validator isBIC
+ */
+export declare function isBIC(options?: ValidationOptions): import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;
+export interface CreditCardValidatorOptions extends ValidationOptions, validatorJS.IsCreditCardOptions {
+}
+/**
+ * Validates if value is a "Base64" formatted string.
+ * @validator isCreditCard
+ */
+export declare function isCreditCard(options?: CreditCardValidatorOptions): import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;
+/**
+ * Validates if value is an IBAN (International Bank Account Number)
+ * @validator isEAN
+ */
+export declare function isIBAN(options?: ValidationOptions): import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;
+/**
+ * Validates if value is an passport number
+ * @validator isPassportNumber
+ */
+export declare function isPassportNumber(countryCode: string, options?: ValidationOptions): import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;
+/**
+ * Validates if value is an EAN (European Article Number)
+ * @validator isEAN
+ */
+export declare function isEAN(options?: ValidationOptions): import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;
+export interface IsFQDNOptions extends ValidationOptions, validatorJS.IsFQDNOptions {
+}
+/**
+ * Validates if value is an FQDN
+ * @validator isFQDN
+ */
+export declare function isFQDN(options?: IsFQDNOptions): import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;
+export interface IsISSNOptions extends ValidationOptions, validatorJS.IsISSNOptions {
+}
+/**
+ * Validates if value is an ISSN
+ * @validator isISSN
+ */
+export declare function isISSN(options?: IsISSNOptions): import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;
+/**
+ * Validates if value is an VAT number
+ * @validator isVAT
+ */
+export declare function isVAT(countryCode: string, options?: IsISSNOptions): import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;
+/**
+ * Validates if value is a BTC address.
+ * @validator isBtcAddress
+ */
+export declare function isBtcAddress(options?: ValidationOptions): import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;
+/**
+ * Validates if value is a ETH (Ethereum) address.
+ * @validator isBtcAddress
+ */
+export declare function isETHAddress(options?: ValidationOptions): import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;
+export type HashAlgorithm = 'crc32' | 'crc32b' | 'md4' | 'md5' | 'ripemd128' | 'ripemd160' | 'sha1' | 'sha256' | 'sha384' | 'sha512' | 'tiger128' | 'tiger160' | 'tiger192';
+/**
+ * Validates if value a hash of type algorithm
+ * @validator isHash
+ */
+export declare function isHash(algorithm: HashAlgorithm, options?: ValidationOptions): import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;
+/**
+ * Validates if value is a Hex Color
+ * @validator isHexColor
+ */
+export declare function isHexColor(options?: ValidationOptions): import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;
+/**
+ * Validates if value a valid JWT token
+ * @validator isHash
+ */
+export declare function isJWT(options?: ValidationOptions): import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;
+/**
+ * Validates if value a Lowercase string
+ * @validator isLowercase
+ */
+export declare function isLowercase(options?: ValidationOptions): import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;
+/**
+ * Validates if value a Uppercase string
+ * @validator isUppercase
+ */
+export declare function isUppercase(options?: ValidationOptions): import("../core/validator.js").Validator<string, string, import("../core/types.js").ExecutionOptions>;

package/typings/rules/union.d.ts

@@ -0,0 +1,5 @@
+import { Validator } from '../core/index.js';
+/**
+ *
+ */
+export declare function union<T, I>(codecs: Validator<T, I>[]): Validator<T, I, import("../core/types.js").ExecutionOptions>;

package/typings/rules/utilities.d.ts

@@ -0,0 +1,11 @@
+import { Context, Validator } from '../core/index.js';
+/**
+ * Forwards codec process to a sub codec. Useful for circular checks
+ * @validator forwardRef
+ */
+export declare function forwardRef<T, I>(fn: (context: Context) => Validator<T, I>): Validator<T, I, import("../core/types.js").ExecutionOptions>;
+/**
+ * if "check" codec passes returns "then", "else" otherwise
+ * @validator iif
+ */
+export declare function iif<TOutput1, TOutput2, TDefault1, TDefault2>(check: Validator<any>, than_: TDefault1 | Validator<TOutput1, any>, else_?: TDefault2 | Validator<TOutput2, any>): any;

package/lib/ArrayType.d.ts

@@ -1,5 +0,0 @@
-import {DataType} from './DataType';
-
-export class ArrayType extends DataType {
-    items?: DataType;
-}

package/lib/ArrayType.js

@@ -1,43 +0,0 @@
-'use strict';
-
-const {DataType} = require('./DataType');
-
-/**
- *
- * @class ArrayType
- */
-class ArrayType extends DataType {
-
-  create(instance, schema) {
-    instance = super.create(instance, schema);
-    if (schema.items) {
-      const library = this.library;
-      const stack = library._stack;
-      stack.push('items');
-      instance.items = library.getType(schema.items);
-      stack.pop();
-    }
-    return instance;
-  }
-
-  get(attr) {
-    if (attr === 'items' && this.items)
-      return this.items;
-    return super.get(attr);
-  }
-
-  normalizeSchema(schema) {
-    const normalized = super.normalizeSchema(schema);
-    const items = normalized.items;
-    if (items) {
-      const stack = this.library._stack;
-      stack.push('items');
-      normalized.items = this.library.normalizeSchema(items);
-      stack.pop();
-    }
-    return normalized;
-  }
-
-}
-
-module.exports = {ArrayType};

package/lib/DataType.d.ts

@@ -1,25 +0,0 @@
-import {Valgen} from "./Valgen";
-
-export declare const Failed: unique symbol;
-
-export class DataType {
-    readonly library: Valgen;
-    readonly typeName: string;
-    readonly factory: Valgen.ITypeFactory;
-    readonly predecessors?: DataType[];
-    id: number;
-    name?: string;
-    schema: { [index: string]: any };
-
-    constructor(library: Valgen, typeName: string, factory: Valgen.ITypeFactory);
-
-    create(instance: any, schema: any): DataType;
-
-    generate(options?: Valgen.IGenerateOptions): Valgen.ValidateFunction;
-
-    get(attr: string): any;
-
-    set(key: string, value: any);
-
-    [index: string]: any;
-}

package/lib/DataType.js

@@ -1,214 +0,0 @@
-'use strict';
-
-const promisify = require('putil-promisify');
-const objectHash = require('object-hash');
-const {coalesce} = require('putil-varhelpers');
-const ValidationError = require('./ValidationError');
-
-const Failed = Symbol.for('Failed');
-const PROPERTY_PATTERN = /^[a-zA-Z]\w+$/;
-
-/**
- *
- * @class DataType
- */
-class DataType {
-
-  constructor(library, typeName, factory) {
-    if (!typeName)
-      throw new TypeError(`You must provide type name.`);
-    if (!factory || typeof factory !== 'object')
-      throw new TypeError('Factory argument must be an object');
-    if (typeof factory.generate !== 'function')
-      throw new TypeError('Factory must contain a "generate" function');
-    Object.defineProperties(this, {
-      library: {
-        writable: false,
-        configurable: false,
-        value: library
-      },
-      factory: {
-        writable: false,
-        configurable: false,
-        value: factory
-      },
-      typeName: {
-        writable: false,
-        configurable: false,
-        value: typeName
-      }
-    });
-    this.options = {};
-    this._fnCache = {};
-  }
-
-  create(instance, schema) {
-    let proto = this;
-    while (proto.predecessors) {
-      const p = Object.getPrototypeOf(proto);
-      if (!p.predecessors)
-        break;
-      proto = p;
-    }
-    Object.setPrototypeOf(instance, proto);
-    instance.predecessors = [];
-    schema = instance.schema = this.normalizeSchema(schema);
-
-    if (schema.type) {
-      const library = this.library;
-      const stack = library._stack;
-      stack.push('type');
-      const types = Array.isArray(schema.type) ? schema.type : [schema.type];
-      for (const sch of types) {
-        if (sch === this.typeName)
-          continue;
-        const t = library.getType(sch);
-        if (!(t.factory === instance.factory)) { // noinspection ExceptionCaughtLocallyJS
-          throw new Error(`"${instance.typeName}" type can't be mixed with "${t.typeName}" type.`);
-        }
-        instance.predecessors.push(t);
-      }
-      stack.pop();
-    }
-    return instance;
-  }
-
-  normalizeSchema(schema) {
-    const normalized = {};
-    const library = this.library;
-    if (schema.type) {
-      let a = Array.isArray(schema.type) ? schema.type : [schema.type];
-      a = a.map(s => {
-        if (typeof s === 'string')
-          s = library._parseTypeName(s);
-        if (typeof s === 'string')
-          return s;
-        return library.normalizeSchema(s);
-      });
-      if (a.length <= 1) {
-        if (typeof a[0] === 'object')
-          Object.assign(schema, a[0]);
-        else
-          normalized.type = a[0];
-      } else normalized.type = a;
-    }
-    if (this.factory.normalizeAttribute) {
-      const stack = this.library._stack;
-      for (const key of Object.keys(schema)) {
-        let v = schema[key];
-        if (v === undefined || key === 'type')
-          continue;
-        /* istanbul ignore else */
-        stack.push(key);
-        v = this.factory.normalizeAttribute(key, schema[key], schema);
-        if (v !== undefined)
-          normalized[key] = v;
-        /* istanbul ignore else */
-        stack.pop();
-      }
-    }
-    return normalized;
-  }
-
-  generate(options = {}) {
-    options.throwOnError =
-        coalesce(options.throwOnError, this.library.throwOnError);
-
-    /* istanbul ignore else */
-    const preparedOptions = this.factory.normalizeCompileOptions ?
-        this.factory.normalizeCompileOptions(options) : {...options};
-    Object.keys(preparedOptions).forEach(k => {
-      if (preparedOptions[k] === undefined)
-        delete preparedOptions[k];
-    });
-
-    // Lookup for cached validator for same options
-    const cacheId = objectHash({
-      schema: this.schema,
-      defaults: this.options,
-      options: preparedOptions
-    });
-    let validate = this._fnCache[cacheId];
-    if (validate)
-      return validate;
-
-    this._fnCache[cacheId] = function() {
-      return validate.apply(this, arguments);
-    };
-
-    const fn = this.factory.generate(this, options);
-
-    const callValidate = (value, ctx) => {
-      ctx = ctx || {};
-      const _path = ctx.path = ctx.path || [];
-      ctx.errors = ctx.errors || [];
-      ctx.logError = ctx.logError || (
-          (e) => {
-            if (ctx.path.length)
-              e.path = ctx.path.slice();
-            const s = ctx.getPath();
-            if (s)
-              e.message = 'Error at "' + s + '". ' + e.message;
-            ctx.errors.push(e);
-            return Failed;
-          });
-      ctx.getPath = ctx.getPath || (() => {
-        let s = '';
-        const len = _path.length;
-        for (let i = 0; i < len; i++) {
-          const x = _path[i];
-          if (typeof x === 'number')
-            s += '[' + x + ']';
-          else if (x.match(PROPERTY_PATTERN))
-              /* istanbul ignore next */
-            s += (s ? '.' : '') + x;
-          else
-            s += '[' + x.replace(/'/g, '\\\'') + ']';
-        }
-        return s;
-      });
-
-      const v = fn(value, ctx);
-      const valid = v !== Failed;
-      if (options.throwOnError && ctx.errors.length) {
-        const ee = new ValidationError(ctx.errors[0].message);
-        // @ts-ignore
-        ee.errors = ctx.errors;
-        ee.value = value;
-        Object.assign(ee, ctx.errors[0]);
-        throw ee;
-      }
-      return ctx.errors.length ?
-          {valid, errors: ctx.errors} :
-          {valid, value: v};
-    };
-
-    validate = options.resolvePromises ?
-        async (value, ctx) => {
-          value = await promisify.deepResolve(value);
-          return callValidate(value, ctx);
-        } :
-        (value, ctx) => callValidate(value, ctx);
-    this._fnCache[cacheId] = validate;
-    validate.dataType = this;
-    return validate;
-  }
-
-  get(attr) {
-    let v;
-    v = this.schema[attr];
-    if (v !== undefined)
-      return v;
-    if (this.predecessors) {
-      let i = this.predecessors.length;
-      while (i--) {
-        v = this.predecessors[i].get(attr);
-        if (v !== undefined)
-          return v;
-      }
-    }
-  }
-
-}
-
-module.exports = {DataType, Failed};

package/lib/ObjectType.d.ts

@@ -1,5 +0,0 @@
-import {DataType} from './DataType';
-
-export class ObjectType extends DataType {
-    properties?: { [key: string]: DataType }
-}