@cleverbrush/schema 1.0.0-beta.3 → 1.0.0-beta.5

package/dist/builders/ArraySchemaBuilder.d.ts

@@ -0,0 +1,15 @@
+import { ISchemaBuilder } from './SchemaBuilder.js';
+import { Schema } from '../schema.js';
+export interface IArraySchemaBuilder<TRequired extends boolean = true, TNullable extends boolean = false, TOfType extends Schema | undefined = undefined, TMaxLength extends number | undefined = undefined, TMinLength extends number | undefined = undefined> extends ISchemaBuilder<TRequired, TNullable> {
+    optional(): IArraySchemaBuilder<false, TNullable, TOfType, TMaxLength, TMinLength>;
+    required(): IArraySchemaBuilder<true, TNullable, TOfType, TMaxLength, TMinLength>;
+    ofType<T extends Schema>(schema: T): IArraySchemaBuilder<TRequired, TNullable, T, TMaxLength, TMinLength>;
+    nullable(): IArraySchemaBuilder<TRequired, true, TOfType, TMaxLength, TMinLength>;
+    notNullable(): IArraySchemaBuilder<TRequired, false, TOfType, TMaxLength, TMinLength>;
+    clearOfType(): IArraySchemaBuilder<TRequired, TNullable, undefined, TMaxLength, TMinLength>;
+    maxLength<T extends number>(length: T): IArraySchemaBuilder<TRequired, TNullable, TOfType, T, TMinLength>;
+    clearMaxLength(): IArraySchemaBuilder<TRequired, TNullable, TOfType, undefined, TMinLength>;
+    minLength<T extends number>(length: T): IArraySchemaBuilder<TRequired, TNullable, TOfType, TMaxLength, T>;
+    clearMinLength(): IArraySchemaBuilder<TRequired, TNullable, TOfType, TMaxLength, TMinLength>;
+}
+export declare const array: () => IArraySchemaBuilder<true, false, undefined, undefined, undefined>;

package/dist/builders/ArraySchemaBuilder.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.array = void 0;
+const SchemaBuilder_js_1 = require("./SchemaBuilder.js");
+const defaultSchemas_js_1 = require("../defaultSchemas.js");
+class ArraySchemaBuilder extends SchemaBuilder_js_1.SchemaBuilder {
+    clone() {
+        return ArraySchemaBuilder.create(this._schema);
+    }
+    get _schema() {
+        return Object.assign({
+            type: this.type
+        }, this.getCommonSchema(), typeof this._ofType !== 'undefined'
+            ? {
+                ofType: this._ofType
+            }
+            : {}, typeof this._minLength !== 'undefined'
+            ? { minLength: this._minLength }
+            : {}, typeof this._maxLength !== 'undefined'
+            ? { maxLength: this._maxLength }
+            : {});
+    }
+    static create(obj) {
+        return new ArraySchemaBuilder(obj);
+    }
+    constructor(obj) {
+        super(obj);
+        if (typeof obj === 'object' && obj) {
+            if (typeof obj.ofType !== 'undefined') {
+                this._ofType =
+                    obj.ofType instanceof SchemaBuilder_js_1.SchemaBuilder
+                        ? obj.ofType.clone()
+                        : { ...obj.ofType };
+            }
+            if (typeof obj.maxLength !== 'undefined') {
+                this._maxLength = obj.maxLength;
+            }
+            if (typeof obj.minLength !== 'undefined') {
+                this._minLength = obj.minLength;
+            }
+        }
+        else {
+            const defaultSchema = defaultSchemas_js_1.defaultSchemas['array'];
+            this.isRequired = defaultSchema.isRequired;
+            this.isNullable = defaultSchema.isNullable;
+        }
+    }
+    type = 'array';
+    _ofType;
+    _maxLength;
+    _minLength;
+    optional() {
+        if (this.isRequired === false) {
+            return this;
+        }
+        return ArraySchemaBuilder.create({
+            ...this._schema,
+            isRequired: false
+        });
+    }
+    required() {
+        if (this.isRequired === true) {
+            return this;
+        }
+        return ArraySchemaBuilder.create({
+            ...this._schema,
+            isRequired: true
+        });
+    }
+    nullable() {
+        if (this._isNullable === true) {
+            return this;
+        }
+        return ArraySchemaBuilder.create({
+            ...this._schema,
+            isNullable: true
+        });
+    }
+    notNullable() {
+        if (this.isNullable === false) {
+            return this;
+        }
+        return ArraySchemaBuilder.create({
+            ...this._schema,
+            isNullable: false
+        });
+    }
+    ofType(schema) {
+        return ArraySchemaBuilder.create({
+            ...this._schema,
+            ofType: schema
+        });
+    }
+    clearOfType() {
+        if (typeof this._ofType === 'undefined') {
+            return this;
+        }
+        return ArraySchemaBuilder.create({
+            ...this._schema,
+            ofType: undefined
+        });
+    }
+    maxLength(length) {
+        if (this._maxLength === length) {
+            return this;
+        }
+        return ArraySchemaBuilder.create({
+            ...this._schema,
+            maxLength: length
+        });
+    }
+    clearMaxLength() {
+        if (typeof this._maxLength === 'undefined') {
+            return this;
+        }
+        return ArraySchemaBuilder.create({
+            ...this._schema,
+            maxLength: undefined
+        });
+    }
+    minLength(length) {
+        if (this._minLength === length) {
+            return this;
+        }
+        return ArraySchemaBuilder.create({
+            ...this._schema,
+            minLength: length
+        });
+    }
+    clearMinLength() {
+        if (typeof this._minLength === 'undefined') {
+            return this;
+        }
+        return ArraySchemaBuilder.create({
+            ...this._schema,
+            minLength: undefined
+        });
+    }
+}
+const array = () => ArraySchemaBuilder.create();
+exports.array = array;

package/dist/builders/BooleanSchemaBuilder.d.ts

@@ -0,0 +1,31 @@
+import { Schema, Validator } from '../schema.js';
+import { ISchemaBuilder, SchemaBuilder } from './SchemaBuilder.js';
+export interface IBooleanSchemaBuilder<TRequired extends boolean = true, TNullable extends boolean = false, TEqualsTo extends boolean | undefined = undefined> extends ISchemaBuilder<TRequired, TNullable> {
+    equals<T extends boolean>(val: T): IBooleanSchemaBuilder<TRequired, TNullable, T>;
+    clearEqualsTo(): IBooleanSchemaBuilder<TRequired, TNullable, undefined>;
+    optional(): IBooleanSchemaBuilder<false, TNullable, TEqualsTo>;
+    required(): IBooleanSchemaBuilder<true, TNullable, TEqualsTo>;
+    nullable(): IBooleanSchemaBuilder<TRequired, true, TEqualsTo>;
+    notNullable(): IBooleanSchemaBuilder<TRequired, false, TEqualsTo>;
+}
+export declare class BooleanSchemaBuilder<TRequired extends boolean = true, TNullable extends boolean = false, TEqualsTo extends boolean | undefined = undefined> extends SchemaBuilder<TRequired, TNullable> implements IBooleanSchemaBuilder<TRequired, TNullable, TEqualsTo> {
+    protected readonly type = "boolean";
+    get _schema(): Schema;
+    clone(): this;
+    static create<TRequired extends boolean = true, TNullable extends boolean = false, TEqualsTo extends boolean | undefined = undefined>(obj?: {
+        isRequired: TRequired;
+        isNullable: TNullable;
+        equals?: TEqualsTo;
+        validators?: Validator[];
+        preprocessor?: ((value: unknown) => unknown | Promise<unknown>) | string;
+    }): IBooleanSchemaBuilder<TRequired, TNullable, TEqualsTo>;
+    private constructor();
+    protected _equals?: TEqualsTo;
+    equals<T extends boolean>(val: T): IBooleanSchemaBuilder<TRequired, TNullable, T>;
+    clearEqualsTo(): IBooleanSchemaBuilder<TRequired, TNullable, undefined>;
+    optional(): IBooleanSchemaBuilder<false, TNullable, TEqualsTo>;
+    required(): IBooleanSchemaBuilder<true, TNullable, TEqualsTo>;
+    nullable(): IBooleanSchemaBuilder<TRequired, true, TEqualsTo>;
+    notNullable(): IBooleanSchemaBuilder<TRequired, false, TEqualsTo>;
+}
+export declare const boolean: () => IBooleanSchemaBuilder;

package/dist/builders/BooleanSchemaBuilder.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boolean = exports.BooleanSchemaBuilder = void 0;
+const SchemaBuilder_js_1 = require("./SchemaBuilder.js");
+const defaultSchemas_js_1 = require("../defaultSchemas.js");
+class BooleanSchemaBuilder extends SchemaBuilder_js_1.SchemaBuilder {
+    type = 'boolean';
+    get _schema() {
+        return Object.assign({
+            type: this.type
+        }, this.getCommonSchema(), typeof this._equals !== 'undefined' ? { equals: this._equals } : {});
+    }
+    clone() {
+        return BooleanSchemaBuilder.create(this._schema);
+    }
+    static create(obj) {
+        return new BooleanSchemaBuilder(obj);
+    }
+    constructor(obj) {
+        super(obj);
+        if (typeof obj === 'object' && obj) {
+            if (typeof obj.equals !== 'undefined') {
+                this._equals = obj.equals;
+            }
+        }
+        else {
+            const defaultSchema = defaultSchemas_js_1.defaultSchemas['boolean'];
+            this.isRequired = defaultSchema.isRequired;
+            this.isNullable = defaultSchema.isNullable;
+        }
+    }
+    _equals;
+    equals(val) {
+        if (this._equals === val) {
+            return this;
+        }
+        return BooleanSchemaBuilder.create({
+            ...this._schema,
+            equals: val
+        });
+    }
+    clearEqualsTo() {
+        if (typeof this._equals === 'undefined') {
+            return this;
+        }
+        return BooleanSchemaBuilder.create({
+            ...this._schema,
+            equals: undefined
+        });
+    }
+    optional() {
+        if (this.isRequired === false) {
+            return this;
+        }
+        return BooleanSchemaBuilder.create({
+            ...this._schema,
+            isRequired: false
+        });
+    }
+    required() {
+        if (this.isRequired === true) {
+            return this;
+        }
+        return BooleanSchemaBuilder.create({
+            ...this._schema,
+            isRequired: true
+        });
+    }
+    nullable() {
+        if (this.isNullable === true) {
+            return this;
+        }
+        return BooleanSchemaBuilder.create({
+            ...this._schema,
+            isNullable: true
+        });
+    }
+    notNullable() {
+        if (this.isNullable === false) {
+            return this;
+        }
+        return BooleanSchemaBuilder.create({
+            ...this._schema,
+            isNullable: false
+        });
+    }
+}
+exports.BooleanSchemaBuilder = BooleanSchemaBuilder;
+const boolean = () => BooleanSchemaBuilder.create();
+exports.boolean = boolean;

package/dist/builders/FunctionSchemaBuilder.d.ts

@@ -0,0 +1,27 @@
+import { Schema, Validator } from '../schema.js';
+import { ISchemaBuilder, SchemaBuilder } from './SchemaBuilder.js';
+export interface IFunctionSchemaBuilder<TRequired extends boolean = true, TNullable extends boolean = false, TMapToType = undefined> extends ISchemaBuilder<TRequired, TNullable> {
+    optional(): IFunctionSchemaBuilder<false, TNullable, TMapToType>;
+    required(): IFunctionSchemaBuilder<true, TNullable, TMapToType>;
+    nullable(): IFunctionSchemaBuilder<TRequired, true, TMapToType>;
+    notNullable(): IFunctionSchemaBuilder<TRequired, false, TMapToType>;
+    mapToType<T>(): IFunctionSchemaBuilder<TRequired, TNullable, T>;
+}
+export declare class FunctionSchemaBuilder<TRequired extends boolean = true, TNullable extends boolean = false, TMapToType = undefined> extends SchemaBuilder<TRequired, TNullable> implements IFunctionSchemaBuilder<TRequired, TNullable> {
+    protected readonly type = "function";
+    get _schema(): Schema;
+    clone(): this;
+    mapToType<T>(): IFunctionSchemaBuilder<TRequired, TNullable, T>;
+    static create<TRequired extends boolean = true, TNullable extends boolean = false, TMapToType = undefined>(obj?: {
+        isRequired: TRequired;
+        isNullable: TNullable;
+        validators?: Validator[];
+        preprocessor?: ((value: unknown) => unknown | Promise<unknown>) | string;
+    }): IFunctionSchemaBuilder<TRequired, TNullable, TMapToType>;
+    private constructor();
+    optional(): IFunctionSchemaBuilder<false, TNullable, TMapToType>;
+    required(): IFunctionSchemaBuilder<true, TNullable, TMapToType>;
+    nullable(): IFunctionSchemaBuilder<TRequired, true, TMapToType>;
+    notNullable(): IFunctionSchemaBuilder<TRequired, false, TMapToType>;
+}
+export declare const func: () => IFunctionSchemaBuilder;

package/dist/builders/FunctionSchemaBuilder.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.func = exports.FunctionSchemaBuilder = void 0;
+const SchemaBuilder_js_1 = require("./SchemaBuilder.js");
+const defaultSchemas_js_1 = require("../defaultSchemas.js");
+class FunctionSchemaBuilder extends SchemaBuilder_js_1.SchemaBuilder {
+    type = 'function';
+    get _schema() {
+        return Object.assign({
+            type: this.type
+        }, this.getCommonSchema());
+    }
+    clone() {
+        return FunctionSchemaBuilder.create(this._schema);
+    }
+    mapToType() {
+        return this;
+    }
+    static create(obj) {
+        return new FunctionSchemaBuilder(obj);
+    }
+    constructor(obj) {
+        super(obj);
+        if (typeof obj !== 'object' || !obj) {
+            const defaultSchema = defaultSchemas_js_1.defaultSchemas['function'];
+            this.isRequired = defaultSchema.isRequired;
+            this.isNullable = defaultSchema.isNullable;
+        }
+    }
+    optional() {
+        if (this.isRequired === false) {
+            return this;
+        }
+        return FunctionSchemaBuilder.create({
+            ...this._schema,
+            isRequired: false
+        });
+    }
+    required() {
+        if (this.isRequired === true) {
+            return this;
+        }
+        return FunctionSchemaBuilder.create({
+            ...this._schema,
+            isRequired: true
+        });
+    }
+    nullable() {
+        if (this.isNullable === true) {
+            return this;
+        }
+        return FunctionSchemaBuilder.create({
+            ...this._schema,
+            isNullable: true
+        });
+    }
+    notNullable() {
+        if (this.isNullable === false) {
+            return this;
+        }
+        return FunctionSchemaBuilder.create({
+            ...this._schema,
+            isNullable: false
+        });
+    }
+}
+exports.FunctionSchemaBuilder = FunctionSchemaBuilder;
+const func = () => FunctionSchemaBuilder.create();
+exports.func = func;

package/dist/builders/NumberSchemaBuilder.d.ts

@@ -0,0 +1,61 @@
+import { ISchemaBuilder, SchemaBuilder } from './SchemaBuilder.js';
+import { Schema, Validator } from '../schema.js';
+export interface INumberSchemaBuilder<TRequired extends boolean = true, TNullable extends boolean = false, TMin extends number | undefined = undefined, TMax extends number | undefined = undefined, TIsInteger extends boolean | undefined = undefined, TEnsureNotNaN extends boolean = true, TEnsureIsFinite extends boolean = true, TEqualsTo extends number | undefined = undefined> extends ISchemaBuilder<TRequired, TNullable> {
+    min<K extends number>(val: K): INumberSchemaBuilder<TRequired, TNullable, K, TMax, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo>;
+    clearMin(): INumberSchemaBuilder<TRequired, TNullable, undefined, TMax, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo>;
+    max<K extends number>(val: K): INumberSchemaBuilder<TRequired, TNullable, TMin, K, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo>;
+    clearMax(): INumberSchemaBuilder<TRequired, TNullable, TMin, undefined, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo>;
+    optional(): INumberSchemaBuilder<false, TNullable, TMin, TMax, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo>;
+    required(): INumberSchemaBuilder<true, TNullable, TMin, TMax, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo>;
+    nullable(): INumberSchemaBuilder<TRequired, true, TMin, TMax, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo>;
+    notNullable(): INumberSchemaBuilder<TRequired, false, TMin, TMax, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo>;
+    equals<T extends number>(val: T): INumberSchemaBuilder<TRequired, TNullable, TMin, TMax, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, T>;
+    clearEquals(): INumberSchemaBuilder<TRequired, TNullable, TMin, TMax, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, undefined>;
+    isInteger(): INumberSchemaBuilder<TRequired, TNullable, TMin, TMax, true, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo>;
+    canBeNotInteger(): INumberSchemaBuilder<TRequired, TNullable, TMin, TMax, undefined, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo>;
+    notNaN(): INumberSchemaBuilder<TRequired, TNullable, TMin, TMax, TIsInteger, true, TEnsureIsFinite, TEqualsTo>;
+    canBeNaN(): INumberSchemaBuilder<TRequired, TNullable, TMin, TMax, TIsInteger, false, TEnsureIsFinite, TEqualsTo>;
+    isFinite(): INumberSchemaBuilder<TRequired, TNullable, TMin, TMax, TIsInteger, TEnsureNotNaN, true, TEqualsTo>;
+    canBeInfinite(): INumberSchemaBuilder<TRequired, TNullable, TMin, TMax, TIsInteger, TEnsureNotNaN, false, TEqualsTo>;
+}
+export declare class NumberSchemaBuilder<TRequired extends boolean = true, TNullable extends boolean = false, TMin extends number | undefined = undefined, TMax extends number | undefined = undefined, TIsInteger extends boolean | undefined = undefined, TEnsureNotNaN extends boolean = true, TEnsureIsFinite extends boolean = true, TEqualsTo extends number | undefined = undefined> extends SchemaBuilder<TRequired, TNullable> implements INumberSchemaBuilder<TRequired, TNullable, TMin, TMax, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo> {
+    clone(): this;
+    get _schema(): Schema;
+    static create<TRequired extends boolean = true, TNullable extends boolean = false, TMin extends number | undefined = undefined, TMax extends number | undefined = undefined, TIsInteger extends boolean | undefined = undefined, TEnsureNotNaN extends boolean = true, TEnsureIsFinite extends boolean = true, TEqualsTo extends number | undefined = undefined>(obj?: {
+        isRequired: TRequired;
+        isNullable: TNullable;
+        min: TMin;
+        max: TMax;
+        isInteger: TIsInteger;
+        ensureNotNaN: TEnsureNotNaN;
+        ensureIsFinite: TEnsureIsFinite;
+        equals: TEqualsTo;
+        validators?: Validator[];
+        preprocessor?: ((value: unknown) => unknown | Promise<unknown>) | string;
+    }): INumberSchemaBuilder<TRequired, TNullable, TMin, TMax, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo>;
+    private constructor();
+    protected readonly type = "number";
+    _min?: TMin;
+    _max?: TMax;
+    _isInteger?: TIsInteger;
+    _ensureNotNaN: TEnsureNotNaN;
+    _ensureIsFinite: TEnsureIsFinite;
+    _equals?: TEqualsTo;
+    min<K extends number>(val: K): INumberSchemaBuilder<TRequired, TNullable, K, TMax, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo>;
+    clearMin(): INumberSchemaBuilder<TRequired, TNullable, undefined, TMax, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo>;
+    max<K extends number>(val: K): INumberSchemaBuilder<TRequired, TNullable, TMin, K, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo>;
+    clearMax(): INumberSchemaBuilder<TRequired, TNullable, TMin, undefined, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo>;
+    optional(): INumberSchemaBuilder<false, TNullable, TMin, TMax, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo>;
+    required(): INumberSchemaBuilder<true, TNullable, TMin, TMax, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo>;
+    nullable(): INumberSchemaBuilder<TRequired, true, TMin, TMax, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo>;
+    notNullable(): INumberSchemaBuilder<TRequired, false, TMin, TMax, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo>;
+    equals<T extends number>(val: T): INumberSchemaBuilder<TRequired, TNullable, TMin, TMax, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, T>;
+    clearEquals(): INumberSchemaBuilder<TRequired, TNullable, TMin, TMax, TIsInteger, TEnsureNotNaN, TEnsureIsFinite, undefined>;
+    isInteger(): INumberSchemaBuilder<TRequired, TNullable, TMin, TMax, true, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo>;
+    canBeNotInteger(): INumberSchemaBuilder<TRequired, TNullable, TMin, TMax, undefined, TEnsureNotNaN, TEnsureIsFinite, TEqualsTo>;
+    notNaN(): INumberSchemaBuilder<TRequired, TNullable, TMin, TMax, TIsInteger, true, TEnsureIsFinite, TEqualsTo>;
+    canBeNaN(): INumberSchemaBuilder<TRequired, TNullable, TMin, TMax, TIsInteger, false, TEnsureIsFinite, TEqualsTo>;
+    isFinite(): INumberSchemaBuilder<TRequired, TNullable, TMin, TMax, TIsInteger, TEnsureNotNaN, true, TEqualsTo>;
+    canBeInfinite(): INumberSchemaBuilder<TRequired, TNullable, TMin, TMax, TIsInteger, TEnsureNotNaN, false, TEqualsTo>;
+}
+export declare const number: () => INumberSchemaBuilder<true, false, undefined, undefined, undefined, true, true, undefined>;

package/dist/builders/NumberSchemaBuilder.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.number = exports.NumberSchemaBuilder = void 0;
+const SchemaBuilder_js_1 = require("./SchemaBuilder.js");
+const defaultSchemas_js_1 = require("../defaultSchemas.js");
+class NumberSchemaBuilder extends SchemaBuilder_js_1.SchemaBuilder {
+    clone() {
+        return NumberSchemaBuilder.create(this._schema);
+    }
+    get _schema() {
+        return Object.assign({
+            type: this.type,
+            ensureNotNaN: this._ensureNotNaN,
+            ensureIsFinite: this._ensureIsFinite
+        }, this.getCommonSchema(), typeof this._min !== 'undefined' ? { min: this._min } : {}, typeof this._max !== 'undefined' ? { max: this._max } : {}, typeof this._isInteger !== 'undefined'
+            ? { isInteger: this._isInteger }
+            : {}, typeof this._equals !== 'undefined' ? { equals: this._equals } : {});
+    }
+    static create(obj) {
+        return new NumberSchemaBuilder(obj);
+    }
+    constructor(obj) {
+        super(obj);
+        if (typeof obj === 'object' && obj) {
+            if (typeof obj.min !== 'undefined') {
+                this._min = obj.min;
+            }
+            if (typeof obj.max !== 'undefined') {
+                this._max = obj.max;
+            }
+            if (typeof obj.isInteger !== 'undefined') {
+                this._isInteger = obj.isInteger;
+            }
+            if (typeof obj.ensureNotNaN !== 'undefined') {
+                this._ensureNotNaN = obj.ensureNotNaN;
+            }
+            if (typeof obj.ensureIsFinite !== 'undefined') {
+                this._ensureIsFinite = obj.ensureIsFinite;
+            }
+            if (typeof obj.equals !== 'undefined') {
+                this._equals = obj.equals;
+            }
+        }
+        else {
+            const defaultSchema = defaultSchemas_js_1.defaultSchemas['number'];
+            this.isRequired = defaultSchema.isRequired;
+            this.isNullable = defaultSchema.isNullable;
+            this._ensureNotNaN = defaultSchema.ensureNotNaN;
+            this._ensureIsFinite = defaultSchema.ensureIsFinite;
+        }
+    }
+    type = 'number';
+    _min;
+    _max;
+    _isInteger;
+    _ensureNotNaN = true;
+    _ensureIsFinite = true;
+    _equals;
+    min(val) {
+        if (this._min === val) {
+            return this;
+        }
+        return NumberSchemaBuilder.create({
+            ...this._schema,
+            min: val
+        });
+    }
+    clearMin() {
+        if (typeof this._min === 'undefined') {
+            return this;
+        }
+        return NumberSchemaBuilder.create({
+            ...this._schema,
+            min: undefined
+        });
+    }
+    max(val) {
+        if (this._max === val) {
+            return this;
+        }
+        return NumberSchemaBuilder.create({
+            ...this._schema,
+            max: val
+        });
+    }
+    clearMax() {
+        if (typeof this._max === 'undefined') {
+            return this;
+        }
+        return NumberSchemaBuilder.create({
+            ...this._schema,
+            max: undefined
+        });
+    }
+    optional() {
+        if (this.isRequired === false) {
+            return this;
+        }
+        return NumberSchemaBuilder.create({
+            ...this._schema,
+            isRequired: false
+        });
+    }
+    required() {
+        if (this.isRequired === true) {
+            return this;
+        }
+        return NumberSchemaBuilder.create({
+            ...this._schema,
+            isRequired: true
+        });
+    }
+    nullable() {
+        if (this.isNullable === true) {
+            return this;
+        }
+        return NumberSchemaBuilder.create({
+            ...this._schema,
+            isNullable: true
+        });
+    }
+    notNullable() {
+        if (this.isNullable === false) {
+            return this;
+        }
+        return NumberSchemaBuilder.create({
+            ...this._schema,
+            isNullable: false
+        });
+    }
+    equals(val) {
+        if (this._equals === val) {
+            return this;
+        }
+        return NumberSchemaBuilder.create({
+            ...this._schema,
+            equals: val
+        });
+    }
+    clearEquals() {
+        if (typeof this._equals === 'undefined') {
+            return this;
+        }
+        return NumberSchemaBuilder.create({
+            ...this._schema,
+            equals: undefined
+        });
+    }
+    isInteger() {
+        if (this._isInteger === true) {
+            return this;
+        }
+        return NumberSchemaBuilder.create({
+            ...this._schema,
+            isInteger: true
+        });
+    }
+    canBeNotInteger() {
+        if (typeof this._isInteger === 'undefined') {
+            return this;
+        }
+        return NumberSchemaBuilder.create({
+            ...this._schema,
+            isInteger: undefined
+        });
+    }
+    notNaN() {
+        if (this._ensureNotNaN === true) {
+            return this;
+        }
+        return NumberSchemaBuilder.create({
+            ...this._schema,
+            ensureNotNaN: true
+        });
+    }
+    canBeNaN() {
+        if (this._ensureNotNaN === false) {
+            return this;
+        }
+        return NumberSchemaBuilder.create({
+            ...this._schema,
+            ensureNotNaN: false
+        });
+    }
+    isFinite() {
+        if (this._ensureIsFinite === true) {
+            return this;
+        }
+        return NumberSchemaBuilder.create({
+            ...this._schema,
+            ensureIsFinite: true
+        });
+    }
+    canBeInfinite() {
+        if (this._ensureIsFinite === false) {
+            return this;
+        }
+        return NumberSchemaBuilder.create({
+            ...this._schema,
+            ensureIsFinite: false
+        });
+    }
+}
+exports.NumberSchemaBuilder = NumberSchemaBuilder;
+const number = () => NumberSchemaBuilder.create();
+exports.number = number;