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

package/dist/builders/ObjectSchemaBuilder.d.ts

@@ -0,0 +1,83 @@
+import { ISchemaBuilder, SchemaBuilder } from './SchemaBuilder.js';
+import { Schema, Validator, InferType, MakeOptional, MakeRequired, MakeNullable, MakeNotNullable } from '../schema.js';
+export interface IObjectSchemaBuilder<TRequired extends boolean = true, TNullable extends boolean = false, TNoUnknownProperties extends boolean = true, TProperties = {}, TMapToType = undefined> extends ISchemaBuilder<TRequired, TNullable> {
+    optional(): IObjectSchemaBuilder<false, TNullable, TNoUnknownProperties, TProperties, TMapToType>;
+    required(): IObjectSchemaBuilder<true, TNullable, TNoUnknownProperties, TProperties, TMapToType>;
+    nullable(): IObjectSchemaBuilder<TRequired, true, TNoUnknownProperties, TProperties, TMapToType>;
+    notNullable(): IObjectSchemaBuilder<TRequired, false, TNoUnknownProperties, TProperties, TMapToType>;
+    addProps<T extends Record<string, any>>(val?: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties & T, TMapToType>;
+    removeProp<T extends keyof TProperties>(property: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, Omit<TProperties, T>, TMapToType>;
+    canHaveUnknownProps(): IObjectSchemaBuilder<TRequired, TNullable, false, TProperties, TMapToType>;
+    noUnknownProps(): IObjectSchemaBuilder<TRequired, TNullable, true, TProperties, TMapToType>;
+    setPropPreprocessor<T extends keyof TProperties | '*', S = T extends keyof TProperties ? ((value: any) => undefined | InferType<TProperties[T]> | Promise<InferType<TProperties[T]>>) | string : (value: InferType<this>) => void | Promise<void>>(property: T, validator: S): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties, TMapToType>;
+    unsetPropPreprocessor<T extends keyof TProperties | '*'>(property: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties, TMapToType>;
+    clearPropsPreprocessors(): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties, TMapToType>;
+    makeAllPropsOptional<T extends keyof TProperties>(): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, {
+        [k in T]: MakeOptional<TProperties[k]>;
+    }, TMapToType>;
+    makePropOptional<T extends keyof TProperties>(property: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, Omit<TProperties, T> & {
+        [k in T]: MakeOptional<TProperties[k]>;
+    }, TMapToType>;
+    makePropRequired<T extends keyof TProperties>(property: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, Omit<TProperties, T> & {
+        [k in T]: MakeRequired<TProperties[k]>;
+    }, TMapToType>;
+    makePropNullable<T extends keyof TProperties>(property: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, Omit<TProperties, T> & {
+        [k in T]: MakeNullable<TProperties[k]>;
+    }, TMapToType>;
+    makePropNotNullable<T extends keyof TProperties>(property: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, Omit<TProperties, T> & {
+        [k in T]: MakeNotNullable<TProperties[k]>;
+    }, TMapToType>;
+    mapToType<T>(): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties, T>;
+    clearMapToType(): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties, undefined>;
+}
+export declare class ObjectSchemaBuilder<TRequired extends boolean = true, TNullable extends boolean = false, TNoUnknownProperties extends boolean = true, TProperties = {}, TMapToType = undefined> extends SchemaBuilder<TRequired, TNullable> implements IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties, TMapToType> {
+    protected readonly type = "object";
+    protected noUnknownProperties?: TNoUnknownProperties;
+    protected properties?: TProperties;
+    protected preprocessors?: {
+        [S in keyof TProperties | '*']?: S extends keyof TProperties ? ((value: any) => undefined | InferType<TProperties[S]> | Promise<InferType<TProperties[S]>>) | string : (value: InferType<TProperties>) => void | Promise<void>;
+    };
+    clone(): this;
+    get _schema(): Schema;
+    private constructor();
+    static create<TCRequired extends boolean = true, TCNullable extends boolean = false, TCNoUnknownProperties extends boolean = false, TCProperties = {}, TMapToType = undefined>(obj?: {
+        isRequired: TCRequired;
+        isNullable: TCNullable;
+        properties: TCProperties;
+        noUnknownProperties: TCNoUnknownProperties;
+        validators?: Validator[];
+        preprocessor?: ((value: unknown) => unknown | Promise<unknown>) | string;
+        preprocessors?: {
+            [S in keyof TCProperties | '*']?: S extends keyof TCProperties ? ((value: any) => undefined | InferType<TCProperties[S]> | Promise<InferType<TCProperties[S]>>) | string : (value: InferType<TCProperties>) => void | Promise<void>;
+        };
+    }): IObjectSchemaBuilder<TCRequired, TCNullable, TCNoUnknownProperties, TCProperties, TMapToType>;
+    canHaveUnknownProps(): IObjectSchemaBuilder<TRequired, TNullable, false, TProperties, TMapToType>;
+    noUnknownProps(): IObjectSchemaBuilder<TRequired, TNullable, true, TProperties, TMapToType>;
+    optional(): IObjectSchemaBuilder<false, TNullable, TNoUnknownProperties, TProperties, TMapToType>;
+    required(): IObjectSchemaBuilder<true, TNullable, TNoUnknownProperties, TProperties, TMapToType>;
+    nullable(): IObjectSchemaBuilder<TRequired, true, TNoUnknownProperties, TProperties, TMapToType>;
+    notNullable(): IObjectSchemaBuilder<TRequired, false, TNoUnknownProperties, TProperties, TMapToType>;
+    addProps<T extends Record<string, any>>(val?: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties & T, TMapToType>;
+    removeProp<T extends keyof TProperties>(property: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, Omit<TProperties, T>, TMapToType>;
+    setPropPreprocessor<T extends keyof TProperties | '*', S = T extends keyof TProperties ? ((value: any) => undefined | InferType<TProperties[T]> | Promise<InferType<TProperties[T]>>) | string : (value: InferType<T>) => void | Promise<void>>(property: T, validator: S): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties, TMapToType>;
+    unsetPropPreprocessor<T extends keyof TProperties | '*'>(property: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties, TMapToType>;
+    clearPropsPreprocessors(): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties, TMapToType>;
+    mapToType<T>(): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties, T>;
+    clearMapToType(): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties, undefined>;
+    makeAllPropsOptional<T extends keyof TProperties>(): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, {
+        [k in T]: MakeOptional<TProperties[k]>;
+    }, TMapToType>;
+    makePropOptional<T extends keyof TProperties>(property: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, Omit<TProperties, T> & {
+        [k in T]: MakeOptional<TProperties[k]>;
+    }, TMapToType>;
+    makePropRequired<T extends keyof TProperties>(property: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, Omit<TProperties, T> & {
+        [k in T]: MakeRequired<TProperties[k]>;
+    }, TMapToType>;
+    makePropNullable<T extends keyof TProperties>(property: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, Omit<TProperties, T> & {
+        [k in T]: MakeNullable<TProperties[k]>;
+    }, TMapToType>;
+    makePropNotNullable<T extends keyof TProperties>(property: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, Omit<TProperties, T> & {
+        [k in T]: MakeNotNullable<TProperties[k]>;
+    }, TMapToType>;
+}
+export declare const object: <T>(properties?: T) => IObjectSchemaBuilder<true, false, true, T extends undefined ? {} : T, undefined>;

package/dist/builders/ObjectSchemaBuilder.js

@@ -0,0 +1,344 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.object = exports.ObjectSchemaBuilder = void 0;
+const SchemaBuilder_js_1 = require("./SchemaBuilder.js");
+const defaultSchemas_js_1 = require("../defaultSchemas.js");
+class ObjectSchemaBuilder extends SchemaBuilder_js_1.SchemaBuilder {
+    type = 'object';
+    noUnknownProperties;
+    properties;
+    preprocessors;
+    clone() {
+        return ObjectSchemaBuilder.create({
+            isNullable: this._isNullable,
+            isRequired: this._isRequired,
+            noUnknownProperties: this.noUnknownProperties,
+            properties: this.properties,
+            preprocessor: this.preprocessor,
+            preprocessors: this.preprocessors,
+            validators: this.validators
+        });
+    }
+    get _schema() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const that = this;
+        return Object.assign({
+            type: this.type
+        }, this.getCommonSchema(), typeof that.properties !== 'undefined' && that.properties
+            ? {
+                properties: Object.keys(that.properties).reduce((acc, curr) => {
+                    if (!that.properties)
+                        return;
+                    if (that.properties[curr] instanceof SchemaBuilder_js_1.SchemaBuilder) {
+                        acc[curr] = that.properties[curr].clone();
+                    }
+                    else {
+                        acc[curr] = that.properties[curr];
+                    }
+                    return acc;
+                }, {})
+            }
+            : {}, typeof that.noUnknownProperties !== 'undefined'
+            ? { noUnknownProperties: that.noUnknownProperties }
+            : {}, typeof that.preprocessors !== 'undefined' && that.preprocessors
+            ? {
+                preprocessors: {
+                    ...that.preprocessors
+                }
+            }
+            : {});
+    }
+    constructor(obj) {
+        super(obj);
+        if (typeof obj === 'object' && obj) {
+            if (typeof obj.properties !== 'undefined') {
+                this.properties = Object.keys(obj.properties).reduce((acc, curr) => {
+                    if (obj.properties[curr] instanceof SchemaBuilder_js_1.SchemaBuilder) {
+                        acc[curr] = obj.properties[curr].clone();
+                    }
+                    else {
+                        acc[curr] = {
+                            ...obj.properties[curr]
+                        };
+                    }
+                    return acc;
+                }, {});
+            }
+            if (typeof obj.preprocessors !== 'undefined') {
+                this.preprocessors = { ...obj.preprocessors };
+            }
+            if (typeof obj.noUnknownProperties !== 'undefined') {
+                this.noUnknownProperties = obj.noUnknownProperties;
+            }
+        }
+        else {
+            const defaultSchema = defaultSchemas_js_1.defaultSchemas['object'];
+            this.isRequired = defaultSchema.isRequired;
+            this.isNullable = defaultSchema.isNullable;
+        }
+    }
+    static create(obj) {
+        return new ObjectSchemaBuilder(obj);
+    }
+    canHaveUnknownProps() {
+        if (this.noUnknownProperties === false) {
+            return this;
+        }
+        return ObjectSchemaBuilder.create({
+            ...this._schema,
+            noUnknownProperties: false
+        });
+    }
+    noUnknownProps() {
+        if (this.noUnknownProperties === true) {
+            return this;
+        }
+        return ObjectSchemaBuilder.create({
+            ...this._schema,
+            noUnknownProperties: true
+        });
+    }
+    optional() {
+        if (this.isRequired === false) {
+            return this;
+        }
+        return ObjectSchemaBuilder.create({
+            ...this._schema,
+            isRequired: false
+        });
+    }
+    required() {
+        if (this.isRequired === true) {
+            return this;
+        }
+        return ObjectSchemaBuilder.create({
+            ...this._schema,
+            isRequired: true
+        });
+    }
+    nullable() {
+        if (this.isNullable === true) {
+            return this;
+        }
+        return ObjectSchemaBuilder.create({
+            ...this._schema,
+            isNullable: true
+        });
+    }
+    notNullable() {
+        if (this.isNullable === false) {
+            return this;
+        }
+        return ObjectSchemaBuilder.create({
+            ...this._schema,
+            isNullable: false
+        });
+    }
+    addProps(val) {
+        if (typeof val === 'undefined')
+            return this;
+        return ObjectSchemaBuilder.create({
+            ...this._schema,
+            properties: {
+                ...this.properties,
+                ...val
+            }
+        });
+    }
+    removeProp(property) {
+        if (typeof this.properties === 'undefined') {
+            return this;
+        }
+        if (!(property in this.properties)) {
+            return this;
+        }
+        const newProperties = {
+            ...this.properties
+        };
+        delete newProperties[property];
+        let newPreprocessors = this.preprocessors;
+        if (typeof newPreprocessors !== 'undefined' &&
+            property in newPreprocessors) {
+            if (Object.keys(newPreprocessors).length === 1) {
+                newPreprocessors = undefined;
+            }
+            else {
+                newPreprocessors = {
+                    ...this.preprocessors
+                };
+                delete newPreprocessors[property];
+            }
+        }
+        return ObjectSchemaBuilder.create({
+            ...this._schema,
+            preprocessors: newPreprocessors,
+            properties: newProperties
+        });
+    }
+    setPropPreprocessor(property, validator) {
+        if (typeof this.preprocessors === 'undefined') {
+            this.preprocessors = {
+                [property]: validator
+            };
+        }
+        else {
+            this.preprocessors = {
+                ...this.preprocessors,
+                [property]: validator
+            };
+        }
+        return ObjectSchemaBuilder.create({
+            ...this._schema,
+            preprocessors: {
+                ...this.preprocessors
+            }
+        });
+    }
+    unsetPropPreprocessor(property) {
+        if (typeof this.preprocessors === 'undefined' ||
+            !(property in this.preprocessors)) {
+            return this;
+        }
+        let newPreprocessors;
+        if (Object.keys(this.preprocessors).length === 1) {
+            newPreprocessors = undefined;
+        }
+        else {
+            newPreprocessors = {
+                ...this.preprocessors
+            };
+            delete newPreprocessors[property];
+        }
+        return ObjectSchemaBuilder.create({
+            ...this._schema,
+            preprocessors: newPreprocessors
+        });
+    }
+    clearPropsPreprocessors() {
+        if (typeof this.preprocessors === 'undefined') {
+            return this;
+        }
+        return ObjectSchemaBuilder.create({
+            ...this._schema,
+            preprocessors: undefined
+        });
+    }
+    mapToType() {
+        return this;
+    }
+    clearMapToType() {
+        return this;
+    }
+    makeAllPropsOptional() {
+        let res = this;
+        for (const prop in this.properties) {
+            res = res.makePropOptional(prop);
+        }
+        return res;
+    }
+    makePropOptional(property) {
+        if (typeof this.properties[property] === 'undefined')
+            throw new Error(`Property ${property} does not exists`);
+        if (this.properties[property] instanceof SchemaBuilder_js_1.SchemaBuilder) {
+            return ObjectSchemaBuilder.create({
+                ...this._schema,
+                properties: {
+                    ...this.properties,
+                    [property]: this.properties[property].optional()
+                }
+            });
+        }
+        else {
+            return ObjectSchemaBuilder.create({
+                ...this._schema,
+                properties: {
+                    ...this.properties,
+                    [property]: {
+                        ...this.properties[property],
+                        isRequired: false
+                    }
+                }
+            });
+        }
+    }
+    makePropRequired(property) {
+        if (typeof this.properties[property] === 'undefined')
+            throw new Error(`Property ${property} does not exists`);
+        if (this.properties[property] instanceof SchemaBuilder_js_1.SchemaBuilder) {
+            return ObjectSchemaBuilder.create({
+                ...this._schema,
+                properties: {
+                    ...this.properties,
+                    [property]: this.properties[property].required()
+                }
+            });
+        }
+        else {
+            return ObjectSchemaBuilder.create({
+                ...this._schema,
+                properties: {
+                    ...this.properties,
+                    [property]: {
+                        ...this.properties[property],
+                        isRequired: true
+                    }
+                }
+            });
+        }
+    }
+    makePropNullable(property) {
+        if (typeof this.properties[property] === 'undefined')
+            throw new Error(`Property ${property} does not exists`);
+        if (this.properties[property] instanceof SchemaBuilder_js_1.SchemaBuilder) {
+            return ObjectSchemaBuilder.create({
+                ...this._schema,
+                properties: {
+                    ...this.properties,
+                    [property]: this.properties[property].nullable()
+                }
+            });
+        }
+        else {
+            return ObjectSchemaBuilder.create({
+                ...this._schema,
+                properties: {
+                    ...this.properties,
+                    [property]: {
+                        ...this.properties[property],
+                        isNullable: true
+                    }
+                }
+            });
+        }
+    }
+    makePropNotNullable(property) {
+        if (typeof this.properties[property] === 'undefined')
+            throw new Error(`Property ${property} does not exists`);
+        if (this.properties[property] instanceof SchemaBuilder_js_1.SchemaBuilder) {
+            return ObjectSchemaBuilder.create({
+                ...this._schema,
+                properties: {
+                    ...this.properties,
+                    [property]: this.properties[property].notNullable()
+                }
+            });
+        }
+        else {
+            return ObjectSchemaBuilder.create({
+                ...this._schema,
+                properties: {
+                    ...this.properties,
+                    [property]: {
+                        ...this.properties[property],
+                        isNullable: false
+                    }
+                }
+            });
+        }
+    }
+}
+exports.ObjectSchemaBuilder = ObjectSchemaBuilder;
+const object = (properties) => typeof properties === 'undefined'
+    ? ObjectSchemaBuilder.create()
+    : ObjectSchemaBuilder.create().addProps(properties);
+exports.object = object;

package/dist/builders/SchemaBuilder.d.ts

@@ -0,0 +1,36 @@
+import { Schema, Validator } from '../schema.js';
+export interface ISchemaBuilder<TRequired extends boolean = true, TNullable extends boolean = false> {
+    readonly _schema: Schema;
+    isRequired: TRequired;
+    isNullable: TNullable;
+    validators?: Validator[];
+    preprocessor?: ((value: unknown) => unknown | Promise<unknown>) | string;
+    addValidator(validator: Validator): this;
+    clearValidators(): this;
+    addPreprocessor(preprocessor: ((value: unknown) => unknown | Promise<unknown>) | string): this;
+    clearPreprocessor(): this;
+    clone(): this;
+}
+export declare abstract class SchemaBuilder<TRequired extends boolean = true, TNullable extends boolean = false> implements ISchemaBuilder<TRequired, TNullable> {
+    protected _isRequired: TRequired;
+    protected _isNullable: TNullable;
+    validators?: Validator[];
+    preprocessor?: ((value: unknown) => unknown | Promise<unknown>) | string;
+    abstract clone(): this;
+    abstract get _schema(): Schema;
+    protected constructor(obj: {
+        isRequired?: boolean;
+        isNullable?: boolean;
+        preprocessor?: ((value: unknown) => unknown | Promise<unknown>) | string;
+        validators?: Validator[];
+    });
+    protected getCommonSchema(): any;
+    addPreprocessor(preprocessor: ((value: unknown) => unknown | Promise<unknown>) | string): this;
+    clearPreprocessor(): this;
+    addValidator(validator: Validator): this;
+    clearValidators(): this;
+    get isRequired(): TRequired;
+    protected set isRequired(val: boolean);
+    get isNullable(): TNullable;
+    protected set isNullable(val: boolean);
+}

package/dist/builders/SchemaBuilder.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaBuilder = void 0;
+class SchemaBuilder {
+    _isRequired = true;
+    _isNullable = false;
+    validators;
+    preprocessor;
+    constructor(obj) {
+        if (typeof obj === 'object') {
+            if (typeof obj.isRequired !== 'undefined') {
+                this.isRequired = obj.isRequired;
+            }
+            if (typeof obj.isNullable !== 'undefined') {
+                this.isNullable = obj.isNullable;
+            }
+            if (Array.isArray(obj.validators)) {
+                this.validators = [...obj.validators];
+            }
+            if (typeof obj.preprocessor !== 'undefined') {
+                this.preprocessor = obj.preprocessor;
+            }
+        }
+    }
+    getCommonSchema() {
+        const schemas = [];
+        if (typeof this.preprocessor !== 'undefined') {
+            schemas.push({
+                preprocessor: this.preprocessor
+            });
+        }
+        if (typeof this.isRequired !== 'undefined') {
+            schemas.push({ isRequired: this.isRequired });
+        }
+        if (typeof this.isNullable !== 'undefined') {
+            schemas.push({ isNullable: this.isNullable });
+        }
+        if (typeof this.validators !== 'undefined') {
+            schemas.push({ validators: [...this.validators] });
+        }
+        return Object.assign({}, ...schemas);
+    }
+    addPreprocessor(preprocessor) {
+        const result = this.clone();
+        result.preprocessor = preprocessor;
+        return result;
+    }
+    clearPreprocessor() {
+        if (typeof this.preprocessor === 'undefined') {
+            return this;
+        }
+        const result = this.clone();
+        delete result.preprocessor;
+        return result;
+    }
+    addValidator(validator) {
+        const result = this.clone();
+        if (typeof validator !== 'function')
+            throw new Error('validator should be a function');
+        if (Array.isArray(result.validators)) {
+            result.validators.push(validator);
+        }
+        else {
+            result.validators = [validator];
+        }
+        return result;
+    }
+    clearValidators() {
+        if (typeof this.validators === 'undefined')
+            return this;
+        const result = this.clone();
+        delete result.validators;
+        return result;
+    }
+    get isRequired() {
+        return this._isRequired;
+    }
+    set isRequired(val) {
+        this._isRequired = val;
+    }
+    get isNullable() {
+        return this._isNullable;
+    }
+    set isNullable(val) {
+        this._isNullable = val;
+    }
+}
+exports.SchemaBuilder = SchemaBuilder;

package/dist/builders/StringSchemaBuilder.d.ts

@@ -0,0 +1,14 @@
+import { ISchemaBuilder } from './SchemaBuilder.js';
+export interface IStringSchemaBuilder<TRequired extends boolean = true, TNullable extends boolean = false, TMinLength extends number | undefined = undefined, TMaxLength extends number | undefined = undefined, TEqualsTo extends string | undefined = undefined> extends ISchemaBuilder<TRequired, TNullable> {
+    optional(): IStringSchemaBuilder<false, TNullable, TMinLength, TMaxLength, TEqualsTo>;
+    required(): IStringSchemaBuilder<true, TNullable, TMinLength, TMaxLength, TEqualsTo>;
+    nullable(): IStringSchemaBuilder<TRequired, true, TMinLength, TMaxLength, TEqualsTo>;
+    notNullable(): IStringSchemaBuilder<TRequired, false, TMinLength, TMaxLength, TEqualsTo>;
+    minLength<K extends number>(val: K): IStringSchemaBuilder<TRequired, TNullable, K, TMaxLength, TEqualsTo>;
+    clearMinLength(): IStringSchemaBuilder<TRequired, TNullable, undefined, TMaxLength, TEqualsTo>;
+    maxLength<K extends number>(val: K): IStringSchemaBuilder<TRequired, TNullable, TMinLength, K, TEqualsTo>;
+    clearMaxLength(): IStringSchemaBuilder<TRequired, TNullable, TMinLength, undefined, TEqualsTo>;
+    equals<T extends string>(val: T): IStringSchemaBuilder<TRequired, TNullable, TMinLength, TMaxLength, T>;
+    clearEquals(): IStringSchemaBuilder<TRequired, TNullable, TMinLength, TMaxLength, undefined>;
+}
+export declare const string: <T extends string = undefined>(equals?: T) => IStringSchemaBuilder<true, false, undefined, undefined, T extends undefined ? undefined : T>;