typebad 1.0.0-alpha.2 → 1.0.0

package/dist/cjs/Type.d.ts

@@ -0,0 +1,54 @@
+export type InputType<T> = T extends Type<infer U> ? U : never;
+type InputSchema<T extends TypeSchema> = Simplify<{
+    [K in keyof T as undefined extends InputType<T[K]> ? never : unknown extends InputType<T[K]> ? never : K]: InputType<T[K]>;
+} & {
+    [K in keyof T as undefined extends InputType<T[K]> ? unknown extends InputType<T[K]> ? never : K : never]?: InputType<T[K]>;
+}>;
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type TypeSchema = Record<string, Type<any>>;
+type IsTuple<T> = T extends readonly any[] ? number extends T["length"] ? false : true : false;
+type OutputValue<T> = T extends undefined ? OutputValue<Exclude<T, undefined>> : T extends Date ? Date : IsTuple<T> extends true ? {
+    [K in keyof T]: OutputValue<T[K]>;
+} : T extends (infer U)[] ? OutputValue<U>[] : T extends Record<string, any> ? {
+    [K in keyof T]-?: OutputValue<T[K]>;
+} : T;
+type ExtendedValue<T> = T extends Date ? Date : T extends any[] ? any[] : T extends Record<string, any> ? Record<string, any> : T;
+export type OutputType<T extends Type<any>> = OutputValue<InputType<T>>;
+export interface ParseOptions {
+    allowUnknownProperties: boolean;
+}
+export declare class Type<T> {
+    private matcher;
+    private parser;
+    private onParseCallback;
+    private allowMissingProperty;
+    onParse(callback: (value: OutputValue<T>) => void): Type<T>;
+    private parse;
+    private isFinalType;
+    extend(matcher: (value: ExtendedValue<T>) => boolean): Type<T>;
+    nullable(): Type<T | null>;
+    optional(): Type<T | null | undefined>;
+    default(defaultValue: T | (() => T)): Type<T | undefined>;
+    static match<T>(matcher: (value: any) => boolean): Type<T>;
+    static enum<const V extends readonly (string | number)[]>(values: V): Type<V[number]>;
+    static array<T extends Type<any>>(elementType: T): Type<InputType<T>[]>;
+    static object<S extends TypeSchema>(schema: S): Type<InputSchema<S>>;
+    static union<U extends Type<any>[]>(types: U): Type<InputType<U[number]>>;
+    static tuple<const U extends Type<any>[]>(types: U): Type<{
+        [K in keyof U]: InputType<U[K]>;
+    }>;
+    static lazy<T extends Type<any>>(callback: () => T): T;
+    static parse<T extends Type<any>>(type: T, value: InputType<T>, options?: Partial<ParseOptions>): OutputType<T>;
+    private static getValueError;
+    private static getUnknownPropertyError;
+    private static getMissingPropertyError;
+    static readonly String: Type<string>;
+    static readonly Boolean: Type<boolean>;
+    static readonly Number: Type<number>;
+    static readonly Integer: Type<number>;
+    static readonly Float: Type<number>;
+    static readonly Date: Type<Date>;
+}
+export {};

package/dist/cjs/Type.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Type = void 0;
+class Type {
+    matcher = () => true;
+    parser = (value) => value;
+    onParseCallback = null;
+    allowMissingProperty = false;
+    onParse(callback) {
+        this.onParseCallback = callback;
+        return this;
+    }
+    parse(value, propertyName, options) {
+        const isMatching = this.matcher(value);
+        if (!isMatching) {
+            throw new Error(Type.getValueError(propertyName));
+        }
+        const parsedValue = this.parser(value, propertyName, options) ?? null;
+        this.onParseCallback?.(parsedValue);
+        return parsedValue;
+    }
+    isFinalType() {
+        return this.onParseCallback !== null;
+    }
+    extend(matcher) {
+        if (this.isFinalType()) {
+            throw new Error("Cannot extend a Type that has onParse callback.");
+        }
+        const type = new Type();
+        type.matcher = (value) => {
+            return this.matcher(value) && matcher(value);
+        };
+        type.parser = this.parser;
+        type.allowMissingProperty = this.allowMissingProperty;
+        return type;
+    }
+    nullable() {
+        if (this.isFinalType()) {
+            throw new Error("Cannot extend a Type that has onParse callback.");
+        }
+        const type = new Type();
+        type.matcher = (value) => {
+            if (value === null) {
+                return true;
+            }
+            return this.matcher(value);
+        };
+        type.parser = (value, propertyName, options) => {
+            if (value === null) {
+                return null;
+            }
+            return this.parser(value, propertyName, options);
+        };
+        type.allowMissingProperty = this.allowMissingProperty;
+        return type;
+    }
+    optional() {
+        if (this.isFinalType()) {
+            throw new Error("Cannot extend a Type that has onParse callback.");
+        }
+        const type = new Type();
+        type.matcher = (value) => {
+            if (value === null || value === undefined) {
+                return true;
+            }
+            return this.matcher(value);
+        };
+        type.parser = (value, propertyName, options) => {
+            if (value === null || value === undefined) {
+                return null;
+            }
+            return this.parser(value, propertyName, options);
+        };
+        type.allowMissingProperty = true;
+        type.onParseCallback = this.onParseCallback;
+        return type;
+    }
+    default(defaultValue) {
+        if (this.isFinalType()) {
+            throw new Error("Cannot extend a Type that has onParse callback.");
+        }
+        const type = new Type();
+        type.matcher = (value) => {
+            if (value === undefined) {
+                return true;
+            }
+            return this.matcher(value);
+        };
+        type.parser = (value, propertyName, options) => {
+            if (value === undefined) {
+                const tmpValue = typeof defaultValue === "function"
+                    ? defaultValue()
+                    : defaultValue;
+                return this.parser(tmpValue, propertyName, options);
+            }
+            return this.parser(value, propertyName, options);
+        };
+        type.allowMissingProperty = true;
+        return type;
+    }
+    static match(matcher) {
+        const type = new Type();
+        type.matcher = matcher;
+        return type;
+    }
+    static enum(values) {
+        const type = new Type();
+        type.matcher = (value) => {
+            return values.includes(value);
+        };
+        return type;
+    }
+    static array(elementType) {
+        const type = new Type();
+        type.matcher = (value) => {
+            return Array.isArray(value);
+        };
+        type.parser = (value, propertyName, options) => {
+            return value.map((tmpValue, i) => {
+                const tmpPropertyName = `${propertyName ?? ""}[${i}]`;
+                return elementType.parse(tmpValue, tmpPropertyName, options);
+            });
+        };
+        return type;
+    }
+    static object(schema) {
+        const type = new Type();
+        type.matcher = (value) => {
+            return (value !== null && !Array.isArray(value) && typeof value === "object");
+        };
+        type.parser = (value, propertyName, options) => {
+            const objectValue = {};
+            if (!options.allowUnknownProperties) {
+                for (const key in value) {
+                    const tmpPropertyName = propertyName !== null ? `${propertyName}.${key}` : key;
+                    if (!(key in schema)) {
+                        throw new Error(this.getUnknownPropertyError(tmpPropertyName));
+                    }
+                }
+            }
+            for (const key in schema) {
+                const tmpPropertyName = propertyName !== null ? `${propertyName}.${key}` : key;
+                const tmpType = schema[key];
+                const tmpValue = value[key];
+                if (!(key in value) && !tmpType.allowMissingProperty) {
+                    throw new Error(this.getMissingPropertyError(tmpPropertyName));
+                }
+                objectValue[key] = tmpType.parse(tmpValue, tmpPropertyName, options);
+            }
+            return objectValue;
+        };
+        return type;
+    }
+    static union(types) {
+        const type = new Type();
+        type.matcher = (value) => {
+            for (const tmpType of types) {
+                if (tmpType.matcher(value)) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        type.parser = (value, propertyName, options) => {
+            for (const tmpType of types) {
+                try {
+                    return tmpType.parse(value, propertyName, options);
+                }
+                catch { }
+            }
+            throw new Error(Type.getValueError(propertyName));
+        };
+        return type;
+    }
+    static tuple(types) {
+        const type = new Type();
+        type.matcher = (value) => {
+            return Array.isArray(value) && value.length === types.length;
+        };
+        type.parser = (value, propertyName, options) => {
+            return types.map((tmpType, i) => {
+                const tmpValue = value[i];
+                const tmpPropertyName = `${propertyName ?? ""}[${i}]`;
+                return tmpType.parse(tmpValue, tmpPropertyName, options);
+            });
+        };
+        return type;
+    }
+    static lazy(callback) {
+        const type = new Type();
+        type.matcher = (value) => {
+            const tmpType = callback();
+            return tmpType.matcher(value);
+        };
+        type.parser = (value, propertyName, options) => {
+            const tmpType = callback();
+            return tmpType.parser(value, propertyName, options);
+        };
+        return type;
+    }
+    static parse(type, value, options = {}) {
+        const tmpOptions = {
+            allowUnknownProperties: options.allowUnknownProperties ?? false,
+        };
+        return type.parse(value, null, tmpOptions);
+    }
+    static getValueError(propertyName) {
+        return ("Invalid value" +
+            (propertyName !== null ? ` for "${propertyName}".` : "."));
+    }
+    static getUnknownPropertyError(propertyName) {
+        return `Unknown property "${propertyName}".`;
+    }
+    static getMissingPropertyError(propertyName) {
+        return `Missing property "${propertyName}".`;
+    }
+    static String = Type.match((value) => typeof value === "string");
+    static Boolean = Type.match((value) => typeof value === "boolean");
+    static Number = Type.match((value) => typeof value === "number");
+    static Integer = Type.match((value) => typeof value === "number" && Number.isInteger(value));
+    static Float = Type.match((value) => typeof value === "number" && !Number.isInteger(value));
+    static Date = Type.match((value) => value instanceof Date);
+}
+exports.Type = Type;

package/dist/esm/Type.d.ts

@@ -0,0 +1,54 @@
+export type InputType<T> = T extends Type<infer U> ? U : never;
+type InputSchema<T extends TypeSchema> = Simplify<{
+    [K in keyof T as undefined extends InputType<T[K]> ? never : unknown extends InputType<T[K]> ? never : K]: InputType<T[K]>;
+} & {
+    [K in keyof T as undefined extends InputType<T[K]> ? unknown extends InputType<T[K]> ? never : K : never]?: InputType<T[K]>;
+}>;
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type TypeSchema = Record<string, Type<any>>;
+type IsTuple<T> = T extends readonly any[] ? number extends T["length"] ? false : true : false;
+type OutputValue<T> = T extends undefined ? OutputValue<Exclude<T, undefined>> : T extends Date ? Date : IsTuple<T> extends true ? {
+    [K in keyof T]: OutputValue<T[K]>;
+} : T extends (infer U)[] ? OutputValue<U>[] : T extends Record<string, any> ? {
+    [K in keyof T]-?: OutputValue<T[K]>;
+} : T;
+type ExtendedValue<T> = T extends Date ? Date : T extends any[] ? any[] : T extends Record<string, any> ? Record<string, any> : T;
+export type OutputType<T extends Type<any>> = OutputValue<InputType<T>>;
+export interface ParseOptions {
+    allowUnknownProperties: boolean;
+}
+export declare class Type<T> {
+    private matcher;
+    private parser;
+    private onParseCallback;
+    private allowMissingProperty;
+    onParse(callback: (value: OutputValue<T>) => void): Type<T>;
+    private parse;
+    private isFinalType;
+    extend(matcher: (value: ExtendedValue<T>) => boolean): Type<T>;
+    nullable(): Type<T | null>;
+    optional(): Type<T | null | undefined>;
+    default(defaultValue: T | (() => T)): Type<T | undefined>;
+    static match<T>(matcher: (value: any) => boolean): Type<T>;
+    static enum<const V extends readonly (string | number)[]>(values: V): Type<V[number]>;
+    static array<T extends Type<any>>(elementType: T): Type<InputType<T>[]>;
+    static object<S extends TypeSchema>(schema: S): Type<InputSchema<S>>;
+    static union<U extends Type<any>[]>(types: U): Type<InputType<U[number]>>;
+    static tuple<const U extends Type<any>[]>(types: U): Type<{
+        [K in keyof U]: InputType<U[K]>;
+    }>;
+    static lazy<T extends Type<any>>(callback: () => T): T;
+    static parse<T extends Type<any>>(type: T, value: InputType<T>, options?: Partial<ParseOptions>): OutputType<T>;
+    private static getValueError;
+    private static getUnknownPropertyError;
+    private static getMissingPropertyError;
+    static readonly String: Type<string>;
+    static readonly Boolean: Type<boolean>;
+    static readonly Number: Type<number>;
+    static readonly Integer: Type<number>;
+    static readonly Float: Type<number>;
+    static readonly Date: Type<Date>;
+}
+export {};

package/dist/esm/Type.js

@@ -0,0 +1,220 @@
+export class Type {
+    matcher = () => true;
+    parser = (value) => value;
+    onParseCallback = null;
+    allowMissingProperty = false;
+    onParse(callback) {
+        this.onParseCallback = callback;
+        return this;
+    }
+    parse(value, propertyName, options) {
+        const isMatching = this.matcher(value);
+        if (!isMatching) {
+            throw new Error(Type.getValueError(propertyName));
+        }
+        const parsedValue = this.parser(value, propertyName, options) ?? null;
+        this.onParseCallback?.(parsedValue);
+        return parsedValue;
+    }
+    isFinalType() {
+        return this.onParseCallback !== null;
+    }
+    extend(matcher) {
+        if (this.isFinalType()) {
+            throw new Error("Cannot extend a Type that has onParse callback.");
+        }
+        const type = new Type();
+        type.matcher = (value) => {
+            return this.matcher(value) && matcher(value);
+        };
+        type.parser = this.parser;
+        type.allowMissingProperty = this.allowMissingProperty;
+        return type;
+    }
+    nullable() {
+        if (this.isFinalType()) {
+            throw new Error("Cannot extend a Type that has onParse callback.");
+        }
+        const type = new Type();
+        type.matcher = (value) => {
+            if (value === null) {
+                return true;
+            }
+            return this.matcher(value);
+        };
+        type.parser = (value, propertyName, options) => {
+            if (value === null) {
+                return null;
+            }
+            return this.parser(value, propertyName, options);
+        };
+        type.allowMissingProperty = this.allowMissingProperty;
+        return type;
+    }
+    optional() {
+        if (this.isFinalType()) {
+            throw new Error("Cannot extend a Type that has onParse callback.");
+        }
+        const type = new Type();
+        type.matcher = (value) => {
+            if (value === null || value === undefined) {
+                return true;
+            }
+            return this.matcher(value);
+        };
+        type.parser = (value, propertyName, options) => {
+            if (value === null || value === undefined) {
+                return null;
+            }
+            return this.parser(value, propertyName, options);
+        };
+        type.allowMissingProperty = true;
+        type.onParseCallback = this.onParseCallback;
+        return type;
+    }
+    default(defaultValue) {
+        if (this.isFinalType()) {
+            throw new Error("Cannot extend a Type that has onParse callback.");
+        }
+        const type = new Type();
+        type.matcher = (value) => {
+            if (value === undefined) {
+                return true;
+            }
+            return this.matcher(value);
+        };
+        type.parser = (value, propertyName, options) => {
+            if (value === undefined) {
+                const tmpValue = typeof defaultValue === "function"
+                    ? defaultValue()
+                    : defaultValue;
+                return this.parser(tmpValue, propertyName, options);
+            }
+            return this.parser(value, propertyName, options);
+        };
+        type.allowMissingProperty = true;
+        return type;
+    }
+    static match(matcher) {
+        const type = new Type();
+        type.matcher = matcher;
+        return type;
+    }
+    static enum(values) {
+        const type = new Type();
+        type.matcher = (value) => {
+            return values.includes(value);
+        };
+        return type;
+    }
+    static array(elementType) {
+        const type = new Type();
+        type.matcher = (value) => {
+            return Array.isArray(value);
+        };
+        type.parser = (value, propertyName, options) => {
+            return value.map((tmpValue, i) => {
+                const tmpPropertyName = `${propertyName ?? ""}[${i}]`;
+                return elementType.parse(tmpValue, tmpPropertyName, options);
+            });
+        };
+        return type;
+    }
+    static object(schema) {
+        const type = new Type();
+        type.matcher = (value) => {
+            return (value !== null && !Array.isArray(value) && typeof value === "object");
+        };
+        type.parser = (value, propertyName, options) => {
+            const objectValue = {};
+            if (!options.allowUnknownProperties) {
+                for (const key in value) {
+                    const tmpPropertyName = propertyName !== null ? `${propertyName}.${key}` : key;
+                    if (!(key in schema)) {
+                        throw new Error(this.getUnknownPropertyError(tmpPropertyName));
+                    }
+                }
+            }
+            for (const key in schema) {
+                const tmpPropertyName = propertyName !== null ? `${propertyName}.${key}` : key;
+                const tmpType = schema[key];
+                const tmpValue = value[key];
+                if (!(key in value) && !tmpType.allowMissingProperty) {
+                    throw new Error(this.getMissingPropertyError(tmpPropertyName));
+                }
+                objectValue[key] = tmpType.parse(tmpValue, tmpPropertyName, options);
+            }
+            return objectValue;
+        };
+        return type;
+    }
+    static union(types) {
+        const type = new Type();
+        type.matcher = (value) => {
+            for (const tmpType of types) {
+                if (tmpType.matcher(value)) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        type.parser = (value, propertyName, options) => {
+            for (const tmpType of types) {
+                try {
+                    return tmpType.parse(value, propertyName, options);
+                }
+                catch { }
+            }
+            throw new Error(Type.getValueError(propertyName));
+        };
+        return type;
+    }
+    static tuple(types) {
+        const type = new Type();
+        type.matcher = (value) => {
+            return Array.isArray(value) && value.length === types.length;
+        };
+        type.parser = (value, propertyName, options) => {
+            return types.map((tmpType, i) => {
+                const tmpValue = value[i];
+                const tmpPropertyName = `${propertyName ?? ""}[${i}]`;
+                return tmpType.parse(tmpValue, tmpPropertyName, options);
+            });
+        };
+        return type;
+    }
+    static lazy(callback) {
+        const type = new Type();
+        type.matcher = (value) => {
+            const tmpType = callback();
+            return tmpType.matcher(value);
+        };
+        type.parser = (value, propertyName, options) => {
+            const tmpType = callback();
+            return tmpType.parser(value, propertyName, options);
+        };
+        return type;
+    }
+    static parse(type, value, options = {}) {
+        const tmpOptions = {
+            allowUnknownProperties: options.allowUnknownProperties ?? false,
+        };
+        return type.parse(value, null, tmpOptions);
+    }
+    static getValueError(propertyName) {
+        return ("Invalid value" +
+            (propertyName !== null ? ` for "${propertyName}".` : "."));
+    }
+    static getUnknownPropertyError(propertyName) {
+        return `Unknown property "${propertyName}".`;
+    }
+    static getMissingPropertyError(propertyName) {
+        return `Missing property "${propertyName}".`;
+    }
+    static String = Type.match((value) => typeof value === "string");
+    static Boolean = Type.match((value) => typeof value === "boolean");
+    static Number = Type.match((value) => typeof value === "number");
+    static Integer = Type.match((value) => typeof value === "number" && Number.isInteger(value));
+    static Float = Type.match((value) => typeof value === "number" && !Number.isInteger(value));
+    static Date = Type.match((value) => value instanceof Date);
+}

package/dist/esm/index.d.ts

@@ -0,0 +1 @@
+export * from "./Type";

package/dist/esm/index.js

@@ -0,0 +1 @@
+export * from "./Type";

package/package.json

@@ -1,16 +1,31 @@
 {
   "name": "typebad",
-  "version": "1.0.0-alpha.2",
+  "version": "1.0.0",
   "description": "Efficient type validator for complex structures.",
-  "main": "dist/index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/iconshot/typebad.git"
+  },
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/cjs/index.js",
+      "import": "./dist/esm/index.js"
+    }
+  },
   "scripts": {
     "clean": "rm -rf dist",
-    "build": "npm run clean && tsc",
+    "build-cjs": "tsc --project tsconfig.cjs.json",
+    "build-esm": "tsc --project tsconfig.esm.json",
+    "build": "npm run clean && npm run build-cjs && npm run build-esm",
     "prepare": "npm run build"
   },
   "keywords": [
     "type",
     "validation",
+    "normalization",
     "json"
   ],
   "license": "MIT",

package/dist/Type.d.ts

@@ -1,53 +0,0 @@
-export type InferType<T> = T extends Type<infer U> ? U : never;
-export type InferSchema<T extends TypeSchema> = Simplify<{
-    [K in keyof T as undefined extends InferType<T[K]> ? never : unknown extends InferType<T[K]> ? never : K]: InferType<T[K]>;
-} & {
-    [K in keyof T as undefined extends InferType<T[K]> ? unknown extends InferType<T[K]> ? never : K : never]?: InferType<T[K]>;
-}>;
-type Simplify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-export type TypeSchema = Record<string, Type<any>>;
-export type NormalizedValue<T> = T extends undefined ? Exclude<T, undefined> : T extends (infer U)[] ? NormalizedValue<U>[] : T extends Record<string, any> ? {
-    [K in keyof T]-?: NormalizedValue<T[K]>;
-} : T;
-export type NormalizedType<T extends Type<any>> = NormalizedValue<InferType<T>>;
-export interface ValidateOptions {
-    allowUnknownProperties: boolean;
-}
-export interface NormalizeOptions {
-    allowUnknownProperties: boolean;
-}
-export declare class Type<T> {
-    private matcher;
-    private validator;
-    private normalizer;
-    private onValidateCallback;
-    private onNormalizeCallback;
-    private allowMissingProperty;
-    onValidate(callback: (value: T) => void): Type<T>;
-    onNormalize(callback: (value: NormalizedValue<T>) => void): Type<T>;
-    private validate;
-    private normalize;
-    extend(matcher: (value: T) => boolean): Type<T>;
-    default(defaultValue: T | (() => T)): Type<T | undefined>;
-    optional(): Type<T | null | undefined>;
-    static match<T>(matcher: (value: T) => boolean): Type<T>;
-    static enum<const V extends readonly (string | number)[]>(values: V): Type<V[number]>;
-    static array<T extends Type<any>>(type: T): Type<InferType<T>[]>;
-    static schema<S extends TypeSchema>(schema: S): Type<InferSchema<S>>;
-    static lazy<T extends Type<any>>(callback: () => T): T;
-    static validate(type: Type<any>, value: any, options?: Partial<ValidateOptions>): void;
-    static normalize<T extends Type<any>>(type: T, value: any, options?: Partial<NormalizeOptions>): NormalizedType<T>;
-    private static getValueError;
-    private static getUnknownPropertyError;
-    private static getMissingPropertyError;
-    static readonly Null: Type<null>;
-    static readonly String: Type<string>;
-    static readonly Boolean: Type<boolean>;
-    static readonly Number: Type<number>;
-    static readonly Integer: Type<number>;
-    static readonly Float: Type<number>;
-    static readonly Date: Type<Date>;
-}
-export {};

package/dist/Type.js

@@ -1,214 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Type = void 0;
-class Type {
-    constructor() {
-        this.matcher = () => true;
-        this.validator = () => true;
-        this.normalizer = (value) => value;
-        this.onValidateCallback = null;
-        this.onNormalizeCallback = null;
-        this.allowMissingProperty = false;
-    }
-    onValidate(callback) {
-        this.onValidateCallback = callback;
-        return this;
-    }
-    onNormalize(callback) {
-        this.onNormalizeCallback = callback;
-        return this;
-    }
-    validate(value, propertyName, options) {
-        if (!this.matcher(value) || !this.validator(value, propertyName, options)) {
-            throw new Error(Type.getValueError(propertyName));
-        }
-        this.onValidateCallback?.(value);
-    }
-    normalize(value, propertyName, options) {
-        if (!this.matcher(value)) {
-            throw new Error(Type.getValueError(propertyName));
-        }
-        const normalizedValue = this.normalizer(value, propertyName, options) ?? null;
-        this.onNormalizeCallback?.(normalizedValue);
-        return normalizedValue;
-    }
-    extend(matcher) {
-        const type = new Type();
-        type.matcher = (value) => {
-            return this.matcher(value) && matcher(value);
-        };
-        type.validator = this.validator;
-        type.normalizer = this.normalizer;
-        type.allowMissingProperty = this.allowMissingProperty;
-        return type;
-    }
-    default(defaultValue) {
-        const type = new Type();
-        type.matcher = (value) => {
-            return value === undefined || this.matcher(value);
-        };
-        type.validator = (value, propertyName, options) => {
-            if (value === undefined) {
-                return true;
-            }
-            return this.validator(value, propertyName, options);
-        };
-        type.normalizer = (value, propertyName, options) => {
-            if (value === undefined) {
-                const tmpValue = typeof defaultValue === "function"
-                    ? defaultValue()
-                    : defaultValue;
-                return this.normalizer(tmpValue, propertyName, options);
-            }
-            return this.normalizer(value, propertyName, options);
-        };
-        type.allowMissingProperty = true;
-        return type;
-    }
-    optional() {
-        const type = new Type();
-        type.matcher = (value) => {
-            return value === null || value === undefined || this.matcher(value);
-        };
-        type.validator = (value, propertyName, options) => {
-            if (value === null || value === undefined) {
-                return true;
-            }
-            return this.validator(value, propertyName, options);
-        };
-        type.normalizer = (value, propertyName, options) => {
-            if (value === null || value === undefined) {
-                return null;
-            }
-            return this.normalizer(value, propertyName, options);
-        };
-        type.allowMissingProperty = true;
-        return type;
-    }
-    static match(matcher) {
-        const type = new Type();
-        type.matcher = matcher;
-        return type;
-    }
-    static enum(values) {
-        const type = new Type();
-        type.matcher = (value) => {
-            return values.includes(value);
-        };
-        return type;
-    }
-    static array(type) {
-        const arrayType = new Type();
-        arrayType.matcher = (value) => {
-            return Array.isArray(value);
-        };
-        arrayType.validator = (value, propertyName, options) => {
-            value.forEach((tmpValue, i) => {
-                const tmpPropertyName = `${propertyName ?? ""}[${i}]`;
-                type.validate(tmpValue, tmpPropertyName, options);
-            });
-            return true;
-        };
-        arrayType.normalizer = (value, propertyName, options) => {
-            return value.map((tmpValue, i) => {
-                const tmpPropertyName = `${propertyName ?? ""}[${i}]`;
-                return type.normalize(tmpValue, tmpPropertyName, options);
-            });
-        };
-        return arrayType;
-    }
-    static schema(schema) {
-        const type = new Type();
-        type.matcher = (value) => {
-            return (value !== null && !Array.isArray(value) && typeof value === "object");
-        };
-        type.validator = (value, propertyName, options) => {
-            if (!options.allowUnknownProperties) {
-                for (const key in value) {
-                    const tmpPropertyName = propertyName !== null ? `${propertyName}.${key}` : key;
-                    if (!(key in schema)) {
-                        throw new Error(this.getUnknownPropertyError(tmpPropertyName));
-                    }
-                }
-            }
-            for (const key in schema) {
-                const tmpPropertyName = propertyName !== null ? `${propertyName}.${key}` : key;
-                const tmpType = schema[key];
-                const tmpValue = value[key];
-                if (!(key in value) && !tmpType.allowMissingProperty) {
-                    throw new Error(this.getMissingPropertyError(tmpPropertyName));
-                }
-                tmpType.validate(tmpValue, tmpPropertyName, options);
-            }
-            return true;
-        };
-        type.normalizer = (value, propertyName, options) => {
-            const objectValue = {};
-            if (!options.allowUnknownProperties) {
-                for (const key in value) {
-                    const tmpPropertyName = propertyName !== null ? `${propertyName}.${key}` : key;
-                    if (!(key in schema)) {
-                        throw new Error(this.getUnknownPropertyError(tmpPropertyName));
-                    }
-                }
-            }
-            for (const key in schema) {
-                const tmpPropertyName = propertyName !== null ? `${propertyName}.${key}` : key;
-                const tmpType = schema[key];
-                const tmpValue = value[key];
-                if (!(key in value) && !tmpType.allowMissingProperty) {
-                    throw new Error(this.getMissingPropertyError(tmpPropertyName));
-                }
-                objectValue[key] = tmpType.normalize(tmpValue, tmpPropertyName, options);
-            }
-            return objectValue;
-        };
-        return type;
-    }
-    static lazy(callback) {
-        const type = new Type();
-        type.matcher = (value) => {
-            const tmpType = callback();
-            return tmpType.matcher(value);
-        };
-        type.validator = (value, propertyName, options) => {
-            const tmpType = callback();
-            return tmpType.validator(value, propertyName, options);
-        };
-        type.normalizer = (value, propertyName, options) => {
-            const tmpType = callback();
-            return tmpType.normalizer(value, propertyName, options);
-        };
-        return type;
-    }
-    static validate(type, value, options = {}) {
-        const tmpOptions = {
-            allowUnknownProperties: options.allowUnknownProperties ?? false,
-        };
-        type.validate(value, null, tmpOptions);
-    }
-    static normalize(type, value, options = {}) {
-        const tmpOptions = {
-            allowUnknownProperties: options.allowUnknownProperties ?? false,
-        };
-        return type.normalize(value, null, tmpOptions);
-    }
-    static getValueError(propertyName) {
-        return ("Invalid value" +
-            (propertyName !== null ? ` for "${propertyName}".` : "."));
-    }
-    static getUnknownPropertyError(propertyName) {
-        return `Unknown property "${propertyName}".`;
-    }
-    static getMissingPropertyError(propertyName) {
-        return `Missing property "${propertyName}".`;
-    }
-}
-exports.Type = Type;
-Type.Null = Type.match((value) => value === null);
-Type.String = Type.match((value) => typeof value === "string");
-Type.Boolean = Type.match((value) => typeof value === "boolean");
-Type.Number = Type.match((value) => typeof value === "number");
-Type.Integer = Type.match((value) => typeof value === "number" && Number.isInteger(value));
-Type.Float = Type.match((value) => typeof value === "number" && !Number.isInteger(value));
-Type.Date = Type.match((value) => value instanceof Date && !isNaN(value.getTime()));