@lakutata/core 1.0.60 → 3.0.0-beta.1

package/dist/cjs/lib/dto/DTO.js

@@ -0,0 +1,461 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var DTO_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DTO = void 0;
+const DataValidator_js_1 = require("./DataValidator.js");
+const ObjectSchemaValidation_js_1 = require("./ObjectSchemaValidation.js");
+const InvalidValueException_js_1 = require("../../exceptions/dto/InvalidValueException.js");
+const WithCause_js_1 = require("../helpers/internal/WithCause.js");
+const VLD_js_1 = require("../validation/VLD.js");
+const IsSymbol_1 = require("@lakutata/utils/IsSymbol");
+const As_1 = require("@lakutata/utils/As");
+const ObjectConstructor_1 = require("@lakutata/utils/ObjectConstructor");
+const JsonSchema_js_1 = require("../validation/JsonSchema.js");
+const import_js_1 = require("../validation/engine/json-schema/import.js");
+const SchemaConversionException_js_1 = require("../validation/exceptions/SchemaConversionException.js");
+/**
+ * Get DTO's object schema
+ * @param target
+ */
+function getObjectSchema(target) {
+    return (0, ObjectSchemaValidation_js_1.getCachedDTOSchema)(instanceSchemaCache, (0, ObjectConstructor_1.objectConstructor)(target), () => {
+        const indexSignatureSchema = (0, ObjectSchemaValidation_js_1.getObjectIndexSignatureSchemaByPrototype)(target);
+        const objectSchema = (0, ObjectSchemaValidation_js_1.getObjectSchemaByPrototype)(target);
+        return indexSignatureSchema ? objectSchema.pattern(DTO.String(), indexSignatureSchema) : objectSchema;
+    });
+}
+/**
+ * Schemas validating DTO instances (without description), per DTO class
+ */
+const instanceSchemaCache = new WeakMap();
+/**
+ * Schemas returned by DTO.Schema(), per DTO class
+ */
+const classSchemaCache = new WeakMap();
+/**
+ * The schemas validating a single property, per DTO class (null: the whole object is validated)
+ */
+const propertySchemaCache = new WeakMap();
+/**
+ * The flags of an object schema which do not constrain its properties together
+ */
+const PROPERTY_INDEPENDENT_FLAGS = ['presence', 'description', 'label', 'unknown'];
+/**
+ * Whether the properties of an object schema are validated independently: no rule, dependency, rename, condition,
+ * value list or reference constrains them together
+ * @param objectSchema
+ */
+function arePropertiesIndependent(objectSchema) {
+    const terms = objectSchema.$_terms;
+    for (const term of ['dependencies', 'renames', 'externals', 'whens', 'alterations']) {
+        const value = terms[term];
+        if (value && (!Array.isArray(value) || value.length))
+            return false;
+    }
+    if (objectSchema._rules.length || objectSchema._valids || objectSchema._invalids)
+        return false;
+    for (const [flag, value] of Object.entries(objectSchema._flags)) {
+        if (!PROPERTY_INDEPENDENT_FLAGS.includes(flag) || (flag === 'unknown' && typeof value === 'object'))
+            return false;
+    }
+    const keys = (terms.keys || []);
+    //A property referring to other properties (or referred to) is validated with them
+    return keys.every(({ schema }) => !schema.$_rootReferences().length);
+}
+/**
+ * The schema validating a single property of a DTO, with the same label, path and preferences as the object schema
+ * (null: the property is validated with the whole object)
+ * @param instance
+ * @param propertyKey
+ */
+function getPropertySchema(instance, propertyKey) {
+    const schemas = (0, ObjectSchemaValidation_js_1.getCachedDTOSchema)(propertySchemaCache, (0, ObjectConstructor_1.objectConstructor)(instance), () => new Map());
+    let schema = schemas.get(propertyKey);
+    if (schema !== undefined)
+        return schema;
+    schema = null;
+    const objectSchema = (0, As_1.As)(getObjectSchema(instance));
+    if (arePropertiesIndependent(objectSchema)) {
+        const child = (objectSchema.$_terms.keys || []).find(({ key }) => key === propertyKey);
+        if (child) {
+            const propertyObjectSchema = (0, As_1.As)(VLD_js_1.VLD.object({ [propertyKey]: child.schema }));
+            schema = (0, As_1.As)(objectSchema._preferences ? propertyObjectSchema.prefs(objectSchema._preferences) : propertyObjectSchema);
+        }
+    }
+    schemas.set(propertyKey, schema);
+    return schema;
+}
+/**
+ * Validate property value (only the property when the properties are validated independently)
+ * @param instance
+ * @param propertyKey
+ * @param value
+ */
+function validatePropertyValue(instance, propertyKey, value) {
+    if (typeof propertyKey === 'string') {
+        const propertySchema = getPropertySchema(instance, propertyKey);
+        if (propertySchema)
+            return DTO.validate({ [propertyKey]: value }, propertySchema, { noDefaults: true })[propertyKey];
+    }
+    return DTO.validate({ ...instance, [propertyKey]: value }, getObjectSchema(instance), { noDefaults: true })[propertyKey];
+}
+/**
+ * The array methods which change the array
+ */
+const ARRAY_MUTATORS = ['push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'reverse', 'fill', 'copyWithin'];
+/**
+ * Restore the items of an array (its holes included)
+ * @param array
+ * @param snapshot
+ */
+function restoreArray(array, snapshot) {
+    array.length = 0;
+    for (let i = 0; i < snapshot.length; ++i) {
+        if (i in snapshot)
+            array[i] = snapshot[i];
+    }
+    array.length = snapshot.length;
+}
+/**
+ * Restore a property of an object after a rejected change: its previous value, or its absence (and the length of an
+ * array)
+ * @param target
+ * @param prop
+ * @param state
+ */
+function restoreProperty(target, prop, state) {
+    if (state.had) {
+        Reflect.set(target, prop, state.value);
+    }
+    else {
+        Reflect.deleteProperty(target, prop);
+    }
+    if (state.length !== undefined)
+        target.length = state.length;
+}
+/**
+ * The state of a property before a change
+ * @param target
+ * @param prop
+ */
+function propertyState(target, prop) {
+    return {
+        had: Object.prototype.hasOwnProperty.call(target, prop),
+        value: Reflect.get(target, prop),
+        length: Array.isArray(target) ? target.length : undefined
+    };
+}
+/**
+ * Return dynamic property proxy object
+ * @param target
+ * @param prop
+ * @param receiver
+ * @param validateFn
+ */
+function dynamicProxyProperty(target, prop, receiver, validateFn) {
+    const propertyValue = Reflect.get(target, prop, receiver);
+    if (!propertyValue)
+        return propertyValue;
+    if (typeof propertyValue !== 'object') {
+        if (typeof propertyValue !== 'function')
+            return propertyValue;
+        //A change made by an array method is validated once it is done (its steps may be invalid), and undone if invalid
+        if (Array.isArray(target) && typeof prop === 'string' && ARRAY_MUTATORS.includes(prop)) {
+            return (...args) => {
+                const snapshot = target.slice();
+                try {
+                    const result = propertyValue.apply(target, args);
+                    validateFn();
+                    return result;
+                }
+                catch (e) {
+                    restoreArray(target, snapshot);
+                    throw e;
+                }
+            };
+        }
+        return propertyValue.bind(target);
+    }
+    return new Proxy(propertyValue, {
+        set(target, p, value, receiver) {
+            const state = propertyState(target, p);
+            try {
+                const isSuccess = Reflect.set(target, p, value, receiver);
+                validateFn();
+                return isSuccess;
+            }
+            catch (e) {
+                restoreProperty(target, p, state);
+                throw e;
+            }
+        },
+        get(target, p, receiver) {
+            return dynamicProxyProperty(target, p, receiver, validateFn);
+        },
+        deleteProperty: (target, prop) => {
+            const state = propertyState(target, prop);
+            try {
+                const isSuccess = Reflect.deleteProperty(target, prop);
+                validateFn();
+                return isSuccess;
+            }
+            catch (e) {
+                restoreProperty(target, prop, state);
+                throw e;
+            }
+        }
+    });
+}
+const DTODescriptionSymbol = Symbol('DTO.DESCRIPTION');
+/**
+ * The base class of the data transfer objects: a class whose properties are declared with schemas (`@Expect`), and
+ * which validates its data when it is constructed and each time it is changed. Its static methods validate any value
+ * (`DTO.validate()`), build schemas (`DTO.String()`, `DTO.Object()`…), and convert the class schema to or from JSON
+ * Schema. A DTO class is also a schema wherever one is expected: `@Accept`, `@Return`, the input of the controller
+ * actions. The schemas built by `DTO` are strict: a value of the wrong type is rejected, not converted (the string `'5'`
+ * is not the number 5).
+ * @example
+ * ```typescript
+ * import {DTO} from 'lakutata'
+ * import {Expect} from 'lakutata/decorator/dto'
+ *
+ * class AddressDTO extends DTO {
+ *     @Expect(DTO.String().required())
+ *     public city!: string
+ *
+ *     @Expect(DTO.String().pattern(/^[0-9]{5}$/).optional())
+ *     public zip?: string
+ * }
+ *
+ * class CustomerDTO extends DTO {
+ *     @Expect(DTO.String().min(1).required())
+ *     public name!: string
+ *
+ *     @Expect(AddressDTO.required())
+ *     public address!: AddressDTO
+ * }
+ *
+ * //Validated when constructed, the unknown key "note" removed
+ * const customer: CustomerDTO = new CustomerDTO({name: 'Ada', address: {city: 'London'}, note: 'vip'})
+ * //Validated without an instance: the validated value, or an InvalidValueException
+ * const data: CustomerDTO = CustomerDTO.validate({name: 'Ada', address: {city: 'London'}})
+ * //Checked without exception
+ * console.log(customer.name, data.address.city, CustomerDTO.isValid({name: ''}))
+ * ```
+ */
+let DTO = DTO_1 = class DTO extends DataValidator_js_1.DataValidator {
+    /**
+     * Create a DTO from its data, validated against the class schema: the defaults applied, the keys without schema
+     * removed (unless the class has an `@IndexSignature`). The instance then validates each change of a property, or
+     * of a value nested in it (an array, an object): an invalid change throws an `InvalidValueException` and is
+     * undone.
+     * @param props The data of the DTO. Default: no data (`{}`).
+     * @throws {InvalidValueException} When the data does not match the class schema.
+     */
+    constructor(props = {}) {
+        super();
+        //Create DTO proxy object
+        const DTOInstanceProxy = new Proxy(this, {
+            set: (target, prop, value, receiver) => {
+                if (!(0, IsSymbol_1.isSymbol)(prop))
+                    value = validatePropertyValue(this, prop, value);
+                return Reflect.set(target, prop, value, receiver);
+            },
+            get: (target, p, receiver) => dynamicProxyProperty(target, p, receiver, () => {
+                //A nested change is validated with the property holding it
+                if ((0, IsSymbol_1.isSymbol)(p)) {
+                    DTO_1.validate({ ...this }, getObjectSchema(this), { noDefaults: true });
+                }
+                else {
+                    validatePropertyValue(this, p, Reflect.get(target, p));
+                }
+            }),
+            deleteProperty: (target, prop) => {
+                if (!(0, IsSymbol_1.isSymbol)(prop))
+                    validatePropertyValue(this, prop, void (0));
+                return Reflect.deleteProperty(target, prop);
+            }
+        });
+        try {
+            const validProps = DTO_1.validate(props, getObjectSchema(this));
+            Object.keys(validProps).forEach((propertyKey) => Reflect.set(this, propertyKey, validProps[propertyKey]));
+        }
+        catch (e) {
+            throw (0, WithCause_js_1.withCause)(new InvalidValueException_js_1.InvalidValueException(((0, As_1.As)(e).message)), e);
+        }
+        return DTOInstanceProxy;
+    }
+    /**
+     * Resolve the arguments of the validation methods: the schema given, else the class schema (`this.Schema()`), and
+     * the validation options.
+     * @param schemaOrOptions The schema to validate against, or the validation options when no schema is given.
+     * @param options The validation options, when a schema is given. Default: no option (`{}`).
+     * @returns The schema and the options to validate with.
+     * @protected
+     */
+    static prepareValidation(schemaOrOptions, options) {
+        const schema = schemaOrOptions ? VLD_js_1.VLDMethods.isSchema(schemaOrOptions) ? (0, As_1.As)(schemaOrOptions) : this.Schema() : this.Schema();
+        const validateOptions = options ? options : schemaOrOptions ? VLD_js_1.VLDMethods.isSchema(schemaOrOptions) ? {} : (0, As_1.As)(schemaOrOptions) : {};
+        return {
+            schema: schema,
+            options: validateOptions
+        };
+    }
+    /**
+     * Convert the class schema to a JSON Schema, for an API document or another validator. What JSON Schema cannot
+     * express (custom rules, references to other values) is dropped, so the JSON Schema may accept more values, never
+     * less.
+     * @param version The JSON Schema version to write. Default `'draft-2020-12'`.
+     * @param options The validation options the schema is used with, whether `$schema` is written, and the object
+     * receiving the shared schemas. Default: no option (`{}`).
+     * @returns A new JSON Schema.
+     * @throws {SchemaConversionException} When the version is unknown.
+     */
+    static toJsonSchema(version = 'draft-2020-12', options = {}) {
+        return (0, JsonSchema_js_1.toJsonSchema)(this, { ...options, target: version });
+    }
+    /**
+     * Convert the class schema to an OpenAPI schema object, for the `components.schemas` of an OpenAPI document.
+     * @param version The OpenAPI version: `'3.0'` or `'3.1'`. Default `'3.1'`.
+     * @param options The validation options the schema is used with, and the object receiving the shared schemas.
+     * Default: no option (`{}`).
+     * @returns A new OpenAPI schema object.
+     */
+    static toOpenAPIJsonSchema(version = '3.1', options = {}) {
+        return (0, JsonSchema_js_1.toJsonSchema)(this, { ...options, target: version === '3.0' ? 'openapi-3.0' : 'openapi-3.1' });
+    }
+    /**
+     * Create a DTO class (a subclass of the current DTO class) from an object JSON Schema (or an OpenAPI schema object),
+     * validating like JSON Schema: its properties become the properties of the DTO, its other keywords (unknown keys,
+     * pattern properties, key counts, dependencies, subschemas) constrain the whole object.
+     * @param schema The JSON Schema of an object (or an OpenAPI schema object), or a reference (`$ref`) to one.
+     * @param options The version of the JSON Schema, where its references are resolved, whether the values are
+     * converted, and the name of the class. Default `name`: the title of the JSON Schema, else the current class
+     * name followed by `FromJsonSchema`.
+     * @returns The new DTO class.
+     * @throws {SchemaConversionException} When the JSON Schema does not describe objects, a reference cannot be
+     * resolved, or a pattern is not a valid regular expression.
+     */
+    static fromJsonSchema(schema, options = {}) {
+        const imported = (0, import_js_1.importObject)(schema, options);
+        const BaseDTO = this;
+        const name = options.name || imported.title || `${BaseDTO.name}FromJsonSchema`;
+        //A named subclass
+        const GeneratedDTO = (0, As_1.As)({ [name]: class extends BaseDTO {
+            } }[name]);
+        for (const [propertyKey, propertySchema] of Object.entries(imported.keys))
+            (0, ObjectSchemaValidation_js_1.setObjectPropertySchema)(GeneratedDTO.prototype, propertyKey, (0, As_1.As)(propertySchema));
+        (0, ObjectSchemaValidation_js_1.setObjectSchemaRefinement)(GeneratedDTO, (objectSchema) => (0, As_1.As)(imported.refine((0, As_1.As)(objectSchema))));
+        if (imported.description)
+            GeneratedDTO.description(imported.description);
+        return GeneratedDTO;
+    }
+    /**
+     * Create the DTO classes of the object schemas of an OpenAPI document (its components.schemas), by name; the
+     * references between the schemas are resolved in the document. The schemas which do not describe objects are
+     * skipped.
+     * @param document The OpenAPI 3.0 or 3.1 document.
+     * @param options How the JSON Schemas are read. Default `dialect`: the version of the document's `openapi` field.
+     * @returns The DTO classes, by the names of their schemas.
+     * @throws {SchemaConversionException} When the document has no `components.schemas`, or a schema cannot be
+     * converted.
+     */
+    static fromOpenAPI(document, options = {}) {
+        const version = document.openapi;
+        const dialect = options.dialect || (typeof version === 'string' && version.startsWith('3.0') ? 'openapi-3.0' : 'openapi-3.1');
+        const components = document.components?.schemas;
+        if (!components || typeof components !== 'object')
+            throw new SchemaConversionException_js_1.SchemaConversionException('The OpenAPI document has no schemas');
+        const result = {};
+        for (const [name, component] of Object.entries(components)) {
+            //Only the schemas of objects are classes
+            if (!component || typeof component !== 'object')
+                continue;
+            const type = component.type;
+            if (type !== undefined && type !== 'object')
+                continue;
+            const pointer = `#/components/schemas/${name.replace(/~/g, '~0').replace(/\//g, '~1')}`;
+            result[name] = this.fromJsonSchema({ $ref: pointer }, { ...options, dialect, document, name });
+        }
+        return result;
+    }
+    /**
+     * Set the description of the class schema, written into its JSON Schema and its descriptions. The description is
+     * not inherited by the subclasses.
+     * @param desc The description.
+     * @returns The class itself, for chaining.
+     */
+    static description(desc) {
+        Reflect.defineMetadata(DTODescriptionSymbol, desc, this);
+        (0, ObjectSchemaValidation_js_1.invalidateDTOSchemas)();
+        return this;
+    }
+    /**
+     * Get the class schema: an object schema of the properties declared with `@Expect` (the parents' included), with
+     * the `@IndexSignature` and the description of the class. The schema is optional (it accepts `undefined`): use
+     * `required()` for a required one.
+     * @returns The object schema; the same instance until a schema declaration changes.
+     */
+    static Schema() {
+        return (0, ObjectSchemaValidation_js_1.getCachedDTOSchema)(classSchemaCache, this, () => {
+            const objectSchema = (0, ObjectSchemaValidation_js_1.getObjectSchemaByConstructor)(this);
+            const indexSignatureSchema = (0, ObjectSchemaValidation_js_1.getObjectIndexSignatureSchemaByConstructor)(this);
+            const description = Reflect.getOwnMetadata(DTODescriptionSymbol, this);
+            const finalSchema = indexSignatureSchema ? objectSchema.pattern(DTO_1.String(), indexSignatureSchema) : objectSchema;
+            return description === undefined ? finalSchema : finalSchema.description(description);
+        });
+    }
+    /**
+     * Get the class schema marked as required: `undefined` is rejected.
+     * @returns A new object schema.
+     */
+    static required() {
+        return this.Schema().required();
+    }
+    /**
+     * Get the class schema marked as optional: `undefined` is accepted (as by `Schema()`).
+     * @returns A new object schema.
+     */
+    static optional() {
+        return this.Schema().optional();
+    }
+    /**
+     * Get the class schema with its own validation options, which override the options of the validation for the
+     * object and its nested values.
+     * @param options The validation options.
+     * @returns A new object schema.
+     */
+    static options(options) {
+        return this.Schema().options(options);
+    }
+    static isValid(data, schemaOrOptions, validateOptions) {
+        const { schema, options } = this.prepareValidation(schemaOrOptions, validateOptions);
+        return VLD_js_1.VLDMethods.isValid(data, schema, options);
+    }
+    static async isValidAsync(data, schemaOrOptions, validateOptions) {
+        const { schema, options } = this.prepareValidation(schemaOrOptions, validateOptions);
+        return await VLD_js_1.VLDMethods.isValidAsync(data, schema, options);
+    }
+    static validate(data, schemaOrOptions, validateOptions) {
+        const { schema, options } = this.prepareValidation(schemaOrOptions, validateOptions);
+        return VLD_js_1.VLDMethods.validate(data, schema, options);
+    }
+    static async validateAsync(data, schemaOrOptions, validateOptions) {
+        const { schema, options } = this.prepareValidation(schemaOrOptions, validateOptions);
+        return await VLD_js_1.VLDMethods.validateAsync(data, schema, options);
+    }
+};
+exports.DTO = DTO;
+exports.DTO = DTO = DTO_1 = __decorate([
+    ((target) => (0, ObjectSchemaValidation_js_1.defineObjectAsDTO)(target)),
+    __metadata("design:paramtypes", [Object])
+], DTO);

package/dist/cjs/lib/dto/DataValidator.d.ts

@@ -0,0 +1,166 @@
+import 'reflect-metadata';
+import { AnySchema } from '../validation/interfaces/AnySchema.js';
+import type { Description } from '../validation/interfaces/Description.js';
+import { StringSchema } from '../validation/interfaces/StringSchema.js';
+import { NumberSchema } from '../validation/interfaces/NumberSchema.js';
+import { BooleanSchema } from '../validation/interfaces/BooleanSchema.js';
+import { DateSchema } from '../validation/interfaces/DateSchema.js';
+import { SchemaLikeWithoutArray } from '../validation/types/SchemaLikeWithoutArray.js';
+import { ArraySchema } from '../validation/interfaces/ArraySchema.js';
+import { SchemaMap } from '../validation/types/SchemaMap.js';
+import { ObjectSchema } from '../validation/interfaces/ObjectSchema.js';
+import { Schema } from '../validation/types/Schema.js';
+import { ValidationOptions } from '../validation/interfaces/ValidationOptions.js';
+import { SchemaLike } from '../validation/types/SchemaLike.js';
+import { AlternativesSchema } from '../validation/interfaces/AlternativesSchema.js';
+import { SymbolSchema } from '../validation/interfaces/SymbolSchema.js';
+import { FunctionSchema } from '../validation/interfaces/FunctionSchema.js';
+import { BinarySchema } from '../validation/interfaces/BinarySchema.js';
+import { ReferenceOptions } from '../validation/interfaces/ReferenceOptions.js';
+import { Reference } from '../validation/interfaces/Reference.js';
+import { LinkSchema } from '../validation/interfaces/LinkSchema.js';
+import { BigIntSchema } from '../validation/interfaces/BigIntSchema.js';
+import { type CronOptions } from '../../types/CronOptions.js';
+export declare class DataValidator {
+    /**
+     * Rebuild a schema from its description (the output of `schema.describe()`), exactly.
+     * @param description The description of the schema.
+     * @returns The schema.
+     */
+    static Build<TSchema = any>(description: Description): Schema<TSchema>;
+    /**
+     * Build a schema accepting any value (`undefined` included unless marked `required()`).
+     * @returns A new schema.
+     */
+    static Any<TSchema = any>(): AnySchema<TSchema>;
+    /**
+     * Build a schema of strings; strict: a value of another type is rejected, not converted.
+     * @returns A new string schema.
+     */
+    static String<TSchema = string>(): StringSchema<TSchema>;
+    /**
+     * Build a schema of numbers; strict: a value of another type is rejected, not converted (the string `'5'` is not
+     * the number 5).
+     * @returns A new number schema.
+     */
+    static Number<TSchema = number>(): NumberSchema<TSchema>;
+    /**
+     * Build a schema of bigints; strict: a value of another type is rejected, not converted.
+     * @returns A new bigint schema.
+     */
+    static BigInt<TSchema = bigint>(): BigIntSchema<TSchema>;
+    /**
+     * Build a schema of booleans; strict: a value of another type is rejected, not converted (the string `'true'` is
+     * not a boolean).
+     * @returns A new boolean schema.
+     */
+    static Boolean<TSchema = boolean>(): BooleanSchema<TSchema>;
+    /**
+     * Build a schema of `Date` objects; strict: a value of another type is rejected, not converted (a date string or a
+     * timestamp is not a date).
+     * @returns A new date schema.
+     */
+    static Date<TSchema = Date>(): DateSchema<TSchema>;
+    /**
+     * Build a schema of objects, with the schemas of their keys; strict. With the default validation options, the keys
+     * without schema are removed.
+     * @param schema The schemas of the keys, by key. Default: no key declared.
+     * @returns A new object schema.
+     */
+    static Object<TSchema = any, isStrict = false, T = TSchema>(schema?: SchemaMap<T, isStrict>): ObjectSchema<TSchema>;
+    /**
+     * Build a schema of arrays whose items match one of the schemas given; strict.
+     * @param types The schemas an item may match. Default: any item.
+     * @returns A new array schema.
+     */
+    static Array<TSchema = any[]>(...types: SchemaLikeWithoutArray[]): ArraySchema<TSchema>;
+    /**
+     * Build a schema of `Buffer`s; strict: a value of another type is rejected, not converted.
+     * @returns A new binary schema.
+     */
+    static Binary<TSchema = Buffer>(): BinarySchema<TSchema>;
+    /**
+     * Build a schema of functions; strict.
+     * @returns A new function schema.
+     */
+    static Function<TSchema = Function>(): FunctionSchema<TSchema>;
+    /**
+     * Build a schema of async functions (declared `async`); a function which only returns a promise is rejected.
+     * @returns A new function schema.
+     */
+    static AsyncFunction<TSchema = Function>(): FunctionSchema<TSchema>;
+    /**
+     * Build a schema of classes, optionally of the subclasses of a class.
+     * @param inheritsFrom The class the value must be or extend, or a function returning it (for a class declared
+     * later). Default: any class.
+     * @returns A new function schema.
+     */
+    static Class<TSchema = Function>(inheritsFrom?: TSchema | (() => TSchema)): FunctionSchema<TSchema>;
+    /**
+     * Build a schema of the instances of a class (the instances of its subclasses included).
+     * @param constructor The class.
+     * @returns A new schema.
+     */
+    static InstanceOf<TSchema = Function>(constructor: TSchema): AnySchema<TSchema>;
+    /**
+     * Build a schema of glob pattern strings (`*.ts`, `src/**`).
+     * @returns A new string schema.
+     */
+    static Glob<TSchema = string>(): StringSchema<TSchema>;
+    /**
+     * Build a schema of cron expression strings. The options not given default to: seconds allowed (6 fields), `?`
+     * allowed for a day, 7 accepted as Sunday, no aliases (`@daily`).
+     * @param options The cron syntax accepted.
+     * @returns A new string schema.
+     */
+    static Cron<TSchema = string>(options?: CronOptions): StringSchema<TSchema>;
+    /**
+     * Build a schema of HTML or XML document strings.
+     * @returns A new string schema.
+     */
+    static HttpDocument<TSchema = string>(): StringSchema<TSchema>;
+    /**
+     * Build a schema of symbols; strict.
+     * @returns A new symbol schema.
+     */
+    static Symbol<TSchema = Symbol>(): SymbolSchema<TSchema>;
+    /**
+     * Build a schema matching a value against several schemas, in order: the first one matching validates it.
+     * @param types The schemas tried in order.
+     * @returns A new alternatives schema.
+     */
+    static Alternatives<TSchema = any>(...types: SchemaLike[]): AlternativesSchema<TSchema>;
+    /**
+     * Create a reference to another value of the validated object (a sibling key by default), resolved at validation,
+     * for the rules comparing values (`DTO.Number().greater(DTO.Ref('min'))`).
+     * @param key The path of the referenced value: a key, `a.b` for a nested key, `/key` from the root.
+     * @param options How the reference is resolved.
+     * @returns The reference.
+     */
+    static Ref(key: string, options?: ReferenceOptions): Reference;
+    /**
+     * Create a reference to an array of the validated object, whose items are the values allowed, for `valid()` or
+     * `invalid()`.
+     * @param ref The path of the referenced array.
+     * @param options How the reference is resolved.
+     * @returns The reference.
+     */
+    static In(ref: string, options?: ReferenceOptions): Reference;
+    /**
+     * Validate a value against a schema and return the validated value. Unlike `DTO.validate()`, the default options of
+     * lakutata are not applied: an unknown key is rejected, not removed.
+     * @param value The value to validate.
+     * @param schema The schema to validate against.
+     * @param options The validation options.
+     * @returns The validated value.
+     * @throws {SchemaValidationException} When the value does not match the schema.
+     */
+    static Attempt<TSchema extends Schema>(value: any, schema: TSchema, options?: ValidationOptions): TSchema extends Schema<infer Value> ? Value : never;
+    /**
+     * Build a schema linking to another schema of the same tree, for the recursive structures (a tree of nodes): `#id`
+     * for the schema given that id, `/` for the root, `...` for an ancestor.
+     * @param ref The path of the linked schema.
+     * @returns A new link schema.
+     */
+    static Link<TSchema extends Schema>(ref: string): LinkSchema<TSchema>;
+}