@cleverbrush/schema 1.0.0-beta.0 → 1.0.0-beta.2

package/src/schemaRegistry.ts

@@ -18,7 +18,6 @@ import {
     StringSchema,
     ValidationResult,
     ValidationResultRaw,
-    InferType,
     ExpandSchemaBuilder,
     FunctionSchema
 } from './schema.js';
@@ -29,11 +28,6 @@ import { object } from './builders/ObjectSchemaBuilder.js';
 import { string } from './builders/StringSchemaBuilder.js';
 import { boolean } from './builders/BooleanSchemaBuilder.js';
 import { array } from './builders/ArraySchemaBuilder.js';
-import {
-    alias,
-    externalAlias,
-    IAliasSchemaBuilder
-} from './builders/AliasSchemaBuilder.js';
 import { func } from './builders/FunctionSchemaBuilder.js';
 import { defaultSchemas } from './defaultSchemas.js';
 import { ISchemaBuilder, SchemaBuilder } from './builders/SchemaBuilder.js';
@@ -86,13 +80,41 @@ export default class SchemaRegistry<T extends Record<string, Schema> = {}>
         return this;
     }
 
+    private _aliasBuilder = <TSchemaName extends keyof T>(
+        schemaName: TSchemaName
+    ): ExpandSchemaBuilder<T[TSchemaName]> => {
+        if (typeof schemaName !== 'string' || !schemaName)
+            throw new Error('schemaName must be non-empty string');
+        const aliasSchema = this._schemasMap.get(schemaName.toString());
+        if (!aliasSchema)
+            throw new Error(`Schema name ${schemaName} is not defined.`);
+        return aliasSchema;
+    };
+
+    private _externalAlias = <
+        TExternalSchemaName extends keyof TExternalAliases,
+        TExternalAliases extends Record<string, any>,
+        TExternalSchemaRegistry extends ISchemaRegistry<TExternalAliases>
+    >(
+        registry: TExternalSchemaRegistry,
+        schemaName: TExternalSchemaName
+    ): ExpandSchemaBuilder<TExternalAliases[TExternalSchemaName]> => {
+        if (typeof schemaName !== 'string' || !schemaName)
+            throw new Error('schemaName must be non-empty string');
+        // TODO: accessing private property here...
+        const externalSchema = (registry as any)._schemasMap.get(schemaName);
+        if (!externalSchema)
+            throw new Error(`Schema name ${schemaName} is not defined.`);
+        return externalSchema;
+    };
+
     public addSchemaFrom<
         TOldName extends keyof T,
         TName extends string,
         TParam extends
             | Record<string, any>
             | ((params: {
-                  schema: ExpandSchemaBuilder<T[TOldName]>;
+                  base: ExpandSchemaBuilder<T[TOldName]>;
                   boolean: typeof boolean;
                   func: typeof func;
                   array: typeof array;
@@ -100,35 +122,22 @@ export default class SchemaRegistry<T extends Record<string, Schema> = {}>
                   number: typeof number;
                   union: typeof union;
                   object: typeof object;
-                  alias: <
-                      TSchemaName extends keyof T,
-                      TCompiledType = InferType<
-                          ExpandSchemaBuilder<T[TSchemaName]>
-                      >
-                  >(
+                  alias: <TSchemaName extends keyof T>(
                       schemaName: TSchemaName
-                  ) => IAliasSchemaBuilder<
-                      TSchemaName,
-                      true,
-                      false,
-                      {
-                          [k in keyof T]: TSchemaName extends k ? T[k] : never;
-                      },
-                      TCompiledType
-                  >;
+                  ) => ExpandSchemaBuilder<T[TSchemaName]>;
               }) => TSchema),
         TSchema extends Schema | ISchemaBuilder
     >(
         oldName: TOldName,
         name: TName,
         param: TParam
-    ): SchemaRegistry<
-        T & {
-            [key in TName]: TParam extends (...args: any[]) => any
-                ? ReduceSchemaBuilder<ReturnType<TParam>>
-                : TParam;
-        }
-    > {
+    ): SchemaRegistry<{
+        [key in keyof T | TName]: key extends keyof T
+            ? T[key]
+            : TParam extends (...args: any[]) => any
+            ? ReduceSchemaBuilder<ReturnType<TParam>>
+            : TParam;
+    }> {
         if (!this._schemasMap.has(oldName.toString())) {
             throw new Error(`unknown schema name ${oldName.toString()}`);
         }
@@ -138,8 +147,8 @@ export default class SchemaRegistry<T extends Record<string, Schema> = {}>
         const schema =
             typeof param === 'function'
                 ? param({
-                      schema: oldSchema,
-                      alias,
+                      base: oldSchema,
+                      alias: this._aliasBuilder,
                       array,
                       boolean,
                       func,
@@ -180,54 +189,28 @@ export default class SchemaRegistry<T extends Record<string, Schema> = {}>
                   union: typeof union;
                   object: typeof object;
                   func: typeof func;
-                  alias: <
-                      TSchemaName extends keyof T,
-                      TCompiledType = InferType<
-                          ExpandSchemaBuilder<T[TSchemaName]>
-                      >
-                  >(
+                  alias: <TSchemaName extends keyof T>(
                       schemaName: TSchemaName
-                  ) => IAliasSchemaBuilder<
-                      TSchemaName,
-                      true,
-                      false,
-                      {
-                          [k in keyof T]: TSchemaName extends k ? T[k] : never;
-                      },
-                      TCompiledType
-                  >;
+                  ) => ExpandSchemaBuilder<T[TSchemaName]>;
                   external: <
-                      TRegistryKeys extends Record<string, any>,
-                      TSchemaName extends keyof TRegistryKeys,
-                      TCompiledType = InferType<
-                          ExpandSchemaBuilder<TRegistryKeys[TSchemaName]>
-                      >
+                      TRegistryKeys,
+                      TSchemaName extends keyof TRegistryKeys
                   >(
-                      registry: ISchemaRegistry<TRegistryKeys>,
+                      registry: SchemaRegistry<TRegistryKeys>,
                       schemaName: TSchemaName
-                  ) => IAliasSchemaBuilder<
-                      TSchemaName,
-                      true,
-                      false,
-                      {
-                          [k in keyof TRegistryKeys]: TSchemaName extends k
-                              ? TRegistryKeys[k]
-                              : never;
-                      },
-                      TCompiledType
-                  >;
+                  ) => ExpandSchemaBuilder<TRegistryKeys[TSchemaName]>;
               }) => TSchema),
         TSchema extends Schema | ISchemaBuilder
     >(
         name: TName,
         param: TParam
-    ): SchemaRegistry<
-        T & {
-            [key in TName]: TParam extends (...args: any[]) => any
-                ? ReduceSchemaBuilder<ReturnType<TParam>>
-                : TParam;
-        }
-    > {
+    ): SchemaRegistry<{
+        [key in keyof T | TName]: key extends keyof T
+            ? T[key]
+            : TParam extends (...args: any[]) => any
+            ? ReduceSchemaBuilder<ReturnType<TParam>>
+            : TParam;
+    }> {
         if (typeof name !== 'string' || !name)
             throw new Error('Name is required');
 
@@ -242,8 +225,8 @@ export default class SchemaRegistry<T extends Record<string, Schema> = {}>
         const schema =
             typeof param === 'function'
                 ? param({
-                      alias,
-                      external: externalAlias,
+                      alias: this._aliasBuilder,
+                      external: this._externalAlias,
                       array,
                       boolean,
                       number,
@@ -454,60 +437,6 @@ export default class SchemaRegistry<T extends Record<string, Schema> = {}>
                     obj,
                     schema
                 );
-            } else if (spec.type === 'alias') {
-                if (spec.isRequired === false && typeof obj === 'undefined') {
-                    return {
-                        valid: true
-                    };
-                }
-                if (spec.isNullable === true && obj === null) {
-                    return {
-                        valid: true
-                    };
-                }
-
-                const registry = (spec.externalRegistry ||
-                    this) as ISchemaRegistry<any>;
-                const alias = (registry as any)._schemasMap.get(
-                    spec.schemaName
-                );
-                if (typeof alias === 'undefined') {
-                    throw new Error(
-                        `Unknown schema alias - ${spec.schemaName}`
-                    );
-                }
-                if (Array.isArray(alias)) {
-                    if (
-                        (!spec.isRequired && typeof obj === 'undefined') ||
-                        (spec.isNullable && obj === null)
-                    ) {
-                        return {
-                            valid: true
-                        };
-                    }
-                    return await (registry as any).validate(alias as any, obj);
-                }
-                if (typeof alias !== 'object')
-                    throw new Error(
-                        'it is only possible to use a full schema schema definition as alias'
-                    );
-
-                let schemaToValidate = alias;
-
-                if (alias instanceof SchemaBuilder) {
-                    if (typeof schema.isRequired === 'boolean') {
-                        schemaToValidate = (schemaToValidate as any)[
-                            schema.isRequired ? 'required' : 'optional'
-                        ]();
-                    }
-                    if (typeof schema.isNullable === 'boolean') {
-                        schemaToValidate = (schemaToValidate as any)[
-                            schema.isNullable ? 'nullable' : 'notNullable'
-                        ]();
-                    }
-                }
-
-                return await (registry as any).validate(schemaToValidate, obj);
             } else if (spec.type === 'union') {
                 return await validateUnion(obj, spec, this as any);
             } else if (spec.type === 'object') {

package/dist/builders/AliasSchemaBuilder.d.ts

@@ -1,14 +0,0 @@
-import { ISchemaBuilder } from './SchemaBuilder.js';
-import { InferType } from '../schema.js';
-import { ISchemaRegistry } from '../index.js';
-export interface IAliasSchemaBuilder<TSchemaName extends keyof TAliases, TRequired extends boolean = true, TNullable extends boolean = false, TAliases extends Record<string, any> = never, TAliasesCompiledType = any, TExternalRegistryKeys extends Record<string, any> = {}> extends ISchemaBuilder<TRequired, TNullable> {
-    readonly type: 'alias';
-    schemaName: TSchemaName;
-    externalRegistry: ISchemaRegistry<TExternalRegistryKeys>;
-    optional(): IAliasSchemaBuilder<TSchemaName, false, TNullable, TAliases, TAliasesCompiledType, TExternalRegistryKeys>;
-    required(): IAliasSchemaBuilder<TSchemaName, true, TNullable, TAliases, TAliasesCompiledType, TExternalRegistryKeys>;
-    nullable(): IAliasSchemaBuilder<TSchemaName, TRequired, true, TAliases, TAliasesCompiledType, TExternalRegistryKeys>;
-    notNullable(): IAliasSchemaBuilder<TSchemaName, TRequired, false, TAliases, TAliasesCompiledType, TExternalRegistryKeys>;
-}
-export declare const alias: <TSchemaName extends keyof TAliases, TAliases extends Record<string, any>, TAliasesCompiledType = InferType<TAliases[TSchemaName]>>(schemaName: TSchemaName) => IAliasSchemaBuilder<TSchemaName, true, false, TAliases, TAliasesCompiledType, {}>;
-export declare const externalAlias: <TSchemaName extends keyof TAliases, TAliases extends Record<string, any>, TExternalSchemaRegistry extends ISchemaRegistry<TAliases>, TAliasesCompiledType = InferType<TAliases[TSchemaName]>>(registry: TExternalSchemaRegistry, schemaName: TSchemaName) => IAliasSchemaBuilder<TSchemaName, true, false, TAliases, TAliasesCompiledType, {}>;

package/dist/builders/AliasSchemaBuilder.js

@@ -1,91 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.externalAlias = exports.alias = void 0;
-const SchemaBuilder_js_1 = require("./SchemaBuilder.js");
-const defaultSchemas_js_1 = require("../defaultSchemas.js");
-class AliasSchemaBuilder extends SchemaBuilder_js_1.SchemaBuilder {
-    clone() {
-        return AliasSchemaBuilder.create(this._schema);
-    }
-    get _schema() {
-        return Object.assign({
-            type: this.type,
-            schemaName: this.schemaName,
-            externalRegistry: this.externalRegistry
-        }, this.getCommonSchema());
-    }
-    static create(obj) {
-        return new AliasSchemaBuilder(obj);
-    }
-    schemaName;
-    externalRegistry;
-    constructor(obj) {
-        super(obj);
-        if (typeof obj === 'object' && obj) {
-            if (typeof obj.schemaName === 'string') {
-                this.schemaName = obj.schemaName;
-            }
-            if (typeof obj.externalRegistry === 'object' &&
-                obj.externalRegistry) {
-                this.externalRegistry = obj.externalRegistry;
-            }
-        }
-        else {
-            const defaultSchema = defaultSchemas_js_1.defaultSchemas['alias'];
-            this.isRequired = defaultSchema.isRequired;
-            this.isNullable = defaultSchema.isNullable;
-        }
-    }
-    get type() {
-        return 'alias';
-    }
-    optional() {
-        if (this.isRequired === false) {
-            return this;
-        }
-        return AliasSchemaBuilder.create({
-            ...this._schema,
-            isRequired: false
-        });
-    }
-    required() {
-        if (this.isRequired === true) {
-            return this;
-        }
-        return AliasSchemaBuilder.create({
-            ...this._schema,
-            isRequired: true
-        });
-    }
-    nullable() {
-        if (this._isNullable === true) {
-            return this;
-        }
-        return AliasSchemaBuilder.create({
-            ...this._schema,
-            isNullable: true
-        });
-    }
-    notNullable() {
-        if (this.isNullable === false) {
-            return this;
-        }
-        return AliasSchemaBuilder.create({
-            ...this._schema,
-            isNullable: false
-        });
-    }
-}
-const alias = (schemaName) => AliasSchemaBuilder.create({
-    schemaName,
-    isRequired: true,
-    isNullable: false
-});
-exports.alias = alias;
-const externalAlias = (registry, schemaName) => AliasSchemaBuilder.create({
-    schemaName,
-    isRequired: true,
-    isNullable: false,
-    externalRegistry: registry
-});
-exports.externalAlias = externalAlias;

package/dist/builders/ArraySchemaBuilder.d.ts

@@ -1,15 +0,0 @@
-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

@@ -1,141 +0,0 @@
-"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

@@ -1,31 +0,0 @@
-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

@@ -1,90 +0,0 @@
-"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

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