@lakutata/core 1.0.60 → 3.0.0-beta.1

package/dist/cjs/lib/validation/VLD.d.ts

@@ -0,0 +1,275 @@
+import { AnySchema } from './interfaces/AnySchema.js';
+import { ArraySchema } from './interfaces/ArraySchema.js';
+import { BooleanSchema } from './interfaces/BooleanSchema.js';
+import { BinarySchema } from './interfaces/BinarySchema.js';
+import { DateSchema } from './interfaces/DateSchema.js';
+import { FunctionSchema } from './interfaces/FunctionSchema.js';
+import { NumberSchema } from './interfaces/NumberSchema.js';
+import { ObjectSchema } from './interfaces/ObjectSchema.js';
+import { StringSchema } from './interfaces/StringSchema.js';
+import { SymbolSchema } from './interfaces/SymbolSchema.js';
+import { AlternativesSchema } from './interfaces/AlternativesSchema.js';
+import { LinkSchema } from './interfaces/LinkSchema.js';
+import { Schema } from './types/Schema.js';
+import { SchemaFunction } from './types/SchemaFunction.js';
+import { ValidationOptions } from './interfaces/ValidationOptions.js';
+import { SchemaMap } from './types/SchemaMap.js';
+import { SchemaLike } from './types/SchemaLike.js';
+import { CustomValidator } from './types/CustomValidator.js';
+import { ReferenceOptions } from './interfaces/ReferenceOptions.js';
+import { Reference } from './interfaces/Reference.js';
+import { BigIntSchema } from './interfaces/BigIntSchema.js';
+import { SchemaValidationException } from './exceptions/SchemaValidationException.js';
+import { CacheConfiguration } from './interfaces/CacheConfiguration.js';
+import { CompileOptions } from './interfaces/CompileOptions.js';
+import { Extension } from './interfaces/Extension.js';
+/**
+ * An extension created from the validation API
+ */
+export type ExtensionFactory = (vld: ValidateAPI) => Extension;
+export declare const DefaultValidationOptions: ValidationOptions;
+export interface ValidateAPI {
+    ValidationError: typeof SchemaValidationException;
+    /**
+     * Generates a schema object that matches any data type.
+     */
+    any<TSchema = any>(): AnySchema<TSchema>;
+    /**
+     * Generates a schema object that matches an array data type.
+     */
+    array<TSchema = any[]>(): ArraySchema<TSchema>;
+    /**
+     * Generates a schema object that matches a boolean data type (as well as the strings 'true', 'false', 'yes', and 'no'). Can also be called via boolean().
+     */
+    bool<TSchema = boolean>(): BooleanSchema<TSchema>;
+    /**
+     * Generates a schema object that matches a boolean data type (as well as the strings 'true', 'false', 'yes', and 'no'). Can also be called via bool().
+     */
+    boolean<TSchema = boolean>(): BooleanSchema<TSchema>;
+    /**
+     * Generates a schema object that matches a Buffer data type (as well as the strings which will be converted to Buffers).
+     */
+    binary<TSchema = Buffer>(): BinarySchema<TSchema>;
+    /**
+     * Generates a schema object that matches a date type (as well as a JavaScript date string or number of milliseconds).
+     */
+    date<TSchema = Date>(): DateSchema<TSchema>;
+    /**
+     * Generates a schema object that matches a function type.
+     */
+    func<TSchema = Function>(): FunctionSchema<TSchema>;
+    /**
+     * Generates a schema object that matches a function type.
+     */
+    function<TSchema = Function>(): FunctionSchema<TSchema>;
+    /**
+     * Generates a schema object that matches a number data type (as well as strings that can be converted to numbers).
+     */
+    number<TSchema = number>(): NumberSchema<TSchema>;
+    /**
+     * Generates a schema object that matches a bigint data type (as well as strings that can be converted to bigint).
+     */
+    bigint<TSchema = bigint>(): BigIntSchema<TSchema>;
+    /**
+     * Generates a schema object that matches an object data type (as well as JSON strings that have been parsed into objects).
+     */
+    object<TSchema = any, isStrict = false, T = TSchema>(schema?: SchemaMap<T, isStrict>): ObjectSchema<TSchema>;
+    /**
+     * Generates a schema object that matches a string data type. Note that empty strings are not allowed by default and must be enabled with allow('').
+     */
+    string<TSchema = string>(): StringSchema<TSchema>;
+    /**
+     * Generates a schema object that matches any symbol.
+     */
+    symbol<TSchema = Symbol>(): SymbolSchema<TSchema>;
+    /**
+     * Generates a type that will match one of the provided alternative schemas
+     */
+    alternatives<TSchema = any>(types: SchemaLike[]): AlternativesSchema<TSchema>;
+    alternatives<TSchema = any>(...types: SchemaLike[]): AlternativesSchema<TSchema>;
+    /**
+     * Alias for `alternatives`
+     */
+    alt<TSchema = any>(types: SchemaLike[]): AlternativesSchema<TSchema>;
+    alt<TSchema = any>(...types: SchemaLike[]): AlternativesSchema<TSchema>;
+    /**
+     * Links to another schema node and reuses it for validation, typically for creative recursive schemas.
+     *
+     * @param ref - the reference to the linked schema node.
+     * Cannot reference itself or its children as well as other links.
+     * Links can be expressed in relative terms like value references (`VLD.link('...')`),
+     * in absolute terms from the schema run-time root (`VLD.link('/a')`),
+     * or using schema ids implicitly using object keys or explicitly using `any.id()` (`VLD.link('#a.b.c')`).
+     */
+    link<TSchema = any>(ref?: string): LinkSchema<TSchema>;
+    /**
+     * Validates a value against a schema and throws if validation fails.
+     *
+     * @param value - the value to validate.
+     * @param schema - the schema object.
+     * @param options
+     */
+    assert(value: any, schema: Schema, options?: ValidationOptions): void;
+    /**
+     * Validates a value against a schema and throws if validation fails.
+     *
+     * @param value - the value to validate.
+     * @param schema - the schema object.
+     * @param message - optional message string prefix added in front of the error message. may also be an Error object.
+     * @param options
+     */
+    assert(value: any, schema: Schema, message: string | Error, options?: ValidationOptions): void;
+    /**
+     * Validates a value against a schema, returns valid object, and throws if validation fails.
+     *
+     * @param value - the value to validate.
+     * @param schema - the schema object.
+     * @param options
+     */
+    attempt<TSchema extends Schema>(value: any, schema: TSchema, options?: ValidationOptions): TSchema extends Schema<infer Value> ? Value : never;
+    /**
+     * Validates a value against a schema, returns valid object, and throws if validation fails.
+     *
+     * @param value - the value to validate.
+     * @param schema - the schema object.
+     * @param message - optional message string prefix added in front of the error message. may also be an Error object.
+     * @param options
+     */
+    attempt<TSchema extends Schema>(value: any, schema: TSchema, message: string | Error, options?: ValidationOptions): TSchema extends Schema<infer Value> ? Value : never;
+    cache: CacheConfiguration;
+    /**
+     * Converts literal schema definition to schema object (or returns the same back if already a schema object).
+     */
+    compile(schema: SchemaLike, options?: CompileOptions): Schema;
+    /**
+     * Checks if the provided preferences are valid.
+     *
+     * Throws an exception if the prefs object is invalid.
+     *
+     * The method is provided to perform inputs validation for the `any.validate()` and `any.validateAsync()` methods.
+     * Validation is not performed automatically for performance reasons. Instead, manually validate the preferences passed once and reuse.
+     */
+    checkPreferences(prefs: ValidationOptions): void;
+    /**
+     * Creates a custom validation schema.
+     */
+    custom(fn: CustomValidator, description?: string): Schema;
+    /**
+     * Creates a new instance that will apply defaults onto newly created schemas
+     * through the use of the fn function that takes exactly one argument, the schema being created.
+     *
+     * @param fn - The function must always return a schema, even if untransformed.
+     */
+    defaults(fn: SchemaFunction): ValidateAPI;
+    /**
+     * Generates a dynamic expression using a template string.
+     */
+    expression(template: string, options?: ReferenceOptions): any;
+    /**
+     * Creates a new instance customized with the extension(s) you provide included.
+     */
+    extend(...extensions: Array<Extension | ExtensionFactory>): any;
+    /**
+     * Creates a reference that when resolved, is used as an array of values to match against the rule.
+     */
+    in(ref: string, options?: ReferenceOptions): Reference;
+    /**
+     * Checks whether or not the provided argument is a SchemaValidationException
+     */
+    isError(error: any): error is SchemaValidationException;
+    /**
+     * Checks whether or not the provided argument is an expression.
+     */
+    isExpression(expression: any): boolean;
+    /**
+     * Checks whether or not the provided argument is a reference. It's especially useful if you want to post-process error messages.
+     */
+    isRef(ref: any): ref is Reference;
+    /**
+     * Checks whether or not the provided argument is a schema.
+     */
+    isSchema(schema: any, options?: CompileOptions): schema is AnySchema;
+    /**
+     * A special value used with `any.allow()`, `any.invalid()`, and `any.valid()` as the first value to reset any previously set values.
+     */
+    override: symbol;
+    /**
+     * Generates a reference to the value of the named key.
+     */
+    ref(key: string, options?: ReferenceOptions): Reference;
+    /**
+     * Returns an object where each key is a plain schema type.
+     * Useful for creating type shortcuts using deconstruction.
+     * Note that the types are already formed and do not need to be called as functions (e.g. `string`, not `string()`).
+     */
+    types(): {
+        alternatives: AlternativesSchema;
+        any: AnySchema;
+        array: ArraySchema;
+        binary: BinarySchema;
+        boolean: BooleanSchema;
+        date: DateSchema;
+        function: FunctionSchema;
+        link: LinkSchema;
+        number: NumberSchema;
+        object: ObjectSchema;
+        string: StringSchema;
+        symbol: SymbolSchema;
+    };
+    /**
+     * Generates a dynamic expression using a template string.
+     */
+    x(template: string, options?: ReferenceOptions): any;
+}
+declare class ValidateMethods {
+    /**
+     * Whether input is schema or not
+     * @param schema
+     */
+    isSchema(schema: any): boolean;
+    /**
+     * Is data matched with given schema
+     * @param data
+     * @param schema
+     * @param options
+     */
+    isValid<T = any>(data: T, schema: Schema, options?: ValidationOptions): boolean;
+    /**
+     * Is data matched with given schema
+     * @param data
+     * @param schema
+     * @param options
+     */
+    isValidAsync<T = any>(data: T, schema: Schema, options?: ValidationOptions): Promise<boolean>;
+    /**
+     * Validates a value using the schema and options.
+     * @param data
+     * @param schema
+     * @param options
+     */
+    validate<T = any>(data: T, schema: Schema, options?: ValidationOptions): T;
+    /**
+     * Validates a value using the schema and options (in the language of the options)
+     * @param data
+     * @param schema
+     * @param options
+     */
+    protected validateIn<T = any>(data: T, schema: Schema, options: ValidationOptions): T;
+    /**
+     * Validates a value using the schema and options.
+     * @param data
+     * @param schema
+     * @param options
+     */
+    validateAsync<T = any>(data: T, schema: Schema, options?: ValidationOptions): Promise<T>;
+    /**
+     * Validates a value using the schema and options (in the language of the options)
+     * @param data
+     * @param schema
+     * @param options
+     */
+    protected validateAsyncIn<T = any>(data: T, schema: Schema, options: ValidationOptions): Promise<T>;
+}
+export declare const VLD: ValidateAPI;
+export declare const VLDMethods: ValidateMethods;
+export {};

package/dist/cjs/lib/validation/VLD.js

@@ -0,0 +1,216 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VLDMethods = exports.VLD = exports.DefaultValidationOptions = void 0;
+const index_js_1 = __importDefault(require("./engine/schema/index.js"));
+const bigint_js_1 = require("./engine/schema/extensions/bigint.js");
+const ValidationLanguage_js_1 = require("./ValidationLanguage.js");
+const InvalidValueException_js_1 = require("../../exceptions/dto/InvalidValueException.js");
+const As_1 = require("@lakutata/utils/As");
+const WithCause_js_1 = require("../helpers/internal/WithCause.js");
+exports.DefaultValidationOptions = Object.freeze({
+    abortEarly: true,
+    cache: false,
+    allowUnknown: true,
+    stripUnknown: true,
+    convert: true
+});
+let mergedOptionsRoot = { next: new Map() };
+let mergedOptionsCount = 0;
+const maxMergedOptions = 1000;
+/**
+ * The default options merged with the options. For options of primitive values, the merged options are frozen and
+ * reused (the validation engine then reuses its settings and the schema preferences merged with them).
+ * @param options
+ */
+function mergeOptions(options) {
+    if (Object.getOwnPropertySymbols(options).length)
+        return { ...exports.DefaultValidationOptions, ...options };
+    let node = mergedOptionsRoot;
+    for (const name of Object.keys(options)) {
+        const value = options[name];
+        //-0 is not kept apart from 0 by the maps
+        if ((value !== null && typeof value === 'object') || typeof value === 'function' || Object.is(value, -0))
+            return { ...exports.DefaultValidationOptions, ...options };
+        let byValue = node.next.get(name);
+        if (!byValue) {
+            byValue = new Map();
+            node.next.set(name, byValue);
+        }
+        let child = byValue.get(value);
+        if (!child) {
+            child = { next: new Map() };
+            byValue.set(value, child);
+        }
+        node = child;
+    }
+    if (!node.merged) {
+        if (mergedOptionsCount >= maxMergedOptions) {
+            mergedOptionsRoot = { next: new Map() };
+            mergedOptionsCount = 0;
+        }
+        node.merged = Object.freeze({ ...exports.DefaultValidationOptions, ...options });
+        mergedOptionsCount++;
+    }
+    return node.merged;
+}
+/**
+ * The object schemas wrapping a schema under a target name, by schema then by name (schemas are immutable)
+ */
+const targetSchemas = new WeakMap();
+/**
+ * An object schema with the schema under the target name, reused for schema objects
+ * @param schema
+ * @param targetName
+ */
+function targetSchema(schema, targetName) {
+    if (!index_js_1.default.isSchema(schema))
+        return index_js_1.default.object({ [targetName]: schema });
+    let byName = targetSchemas.get(schema);
+    if (!byName) {
+        byName = new Map();
+        targetSchemas.set(schema, byName);
+    }
+    let wrapper = byName.get(targetName);
+    if (!wrapper) {
+        wrapper = index_js_1.default.object({ [targetName]: schema });
+        byName.set(targetName, wrapper);
+    }
+    return wrapper;
+}
+class ValidateMethods {
+    /**
+     * Whether input is schema or not
+     * @param schema
+     */
+    isSchema(schema) {
+        return index_js_1.default.isSchema(schema);
+    }
+    /**
+     * Is data matched with given schema
+     * @param data
+     * @param schema
+     * @param options
+     */
+    isValid(data, schema, options = {}) {
+        try {
+            this.validate(data, schema, options);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    /**
+     * Is data matched with given schema
+     * @param data
+     * @param schema
+     * @param options
+     */
+    async isValidAsync(data, schema, options = {}) {
+        try {
+            await this.validateAsync(data, schema, options);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    /**
+     * Validates a value using the schema and options.
+     * @param data
+     * @param schema
+     * @param options
+     */
+    validate(data, schema, options = {}) {
+        try {
+            return this.validateIn(data, schema, options);
+        }
+        catch (error) {
+            //An invalid value of the code running in a language: validated again in it, for its errors
+            const language = inLanguage(options);
+            if (!language)
+                throw error;
+            return this.validateIn(data, schema, { ...options, errors: { ...(0, As_1.As)(options).errors, language: language } });
+        }
+    }
+    /**
+     * Validates a value using the schema and options (in the language of the options)
+     * @param data
+     * @param schema
+     * @param options
+     */
+    validateIn(data, schema, options) {
+        options = mergeOptions(options);
+        let error;
+        let value;
+        if (options.targetName) {
+            const result = targetSchema(schema, options.targetName).validate({ [options.targetName]: data }, (0, As_1.As)(options));
+            error = result.error;
+            value = (0, As_1.As)(result.value)[options.targetName];
+        }
+        else {
+            const result = (0, As_1.As)(schema).validate(data, (0, As_1.As)(options));
+            error = result.error;
+            value = (0, As_1.As)(result.value);
+        }
+        if (error)
+            throw (0, WithCause_js_1.withCause)(new InvalidValueException_js_1.InvalidValueException(error.message), error);
+        return value;
+    }
+    /**
+     * Validates a value using the schema and options.
+     * @param data
+     * @param schema
+     * @param options
+     */
+    async validateAsync(data, schema, options = {}) {
+        try {
+            return await this.validateAsyncIn(data, schema, options);
+        }
+        catch (error) {
+            //An invalid value of the code running in a language: validated again in it, for its errors
+            const language = inLanguage(options);
+            if (!language)
+                throw error;
+            return await this.validateAsyncIn(data, schema, { ...options, errors: { ...(0, As_1.As)(options).errors, language: language } });
+        }
+    }
+    /**
+     * Validates a value using the schema and options (in the language of the options)
+     * @param data
+     * @param schema
+     * @param options
+     */
+    async validateAsyncIn(data, schema, options) {
+        options = mergeOptions(options);
+        try {
+            if (options.targetName) {
+                const result = (0, As_1.As)(await targetSchema(schema, options.targetName).validateAsync({ [options.targetName]: data }, (0, As_1.As)(mergeOptions({
+                    ...options,
+                    artifacts: false
+                }))));
+                return result[options.targetName];
+            }
+            else {
+                return (0, As_1.As)(await (0, As_1.As)(schema).validateAsync(data, (0, As_1.As)(options)));
+            }
+        }
+        catch (e) {
+            throw (0, WithCause_js_1.withCause)(new InvalidValueException_js_1.InvalidValueException(e.message), e);
+        }
+    }
+}
+/**
+ * The language a validation is validated again in when its value is invalid: the one of the code running, unless the
+ * validation gives its own
+ * @param options
+ */
+function inLanguage(options) {
+    const language = (0, ValidationLanguage_js_1.currentValidationLanguage)();
+    return language && !((0, As_1.As)(options).errors?.language) ? language : undefined;
+}
+exports.VLD = (0, As_1.As)((0, bigint_js_1.extendBigInt)(index_js_1.default));
+exports.VLDMethods = new ValidateMethods();

package/dist/cjs/lib/validation/ValidationLanguage.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Run a function with a validation language: the validation errors raised in it, its asynchronous continuations
+ * included, have their messages in that language (the messages registered by `registerValidationMessages()`), except
+ * for the validations giving their own `errors.language` option. The codes without a message in the language keep the
+ * default (English) one, and so does every code of a language with no registered messages.
+ * @param language The language tag the messages are registered under, like `fr` or `zh-CN`.
+ * @param fn The function to run; it may be asynchronous.
+ * @returns What the function returns (its promise, for an asynchronous function).
+ * @remarks A valid value is validated as without a language: only an invalid value is validated a second time, in the
+ * language, for its messages.
+ * @example
+ * ```typescript
+ * import {DTO, loadValidationMessages, registerValidationMessages, runInValidationLanguage} from 'lakutata'
+ *
+ * const messages: Record<string, string> | undefined = await loadValidationMessages('fr')
+ * if (messages) registerValidationMessages('fr', messages)
+ *
+ * await runInValidationLanguage('fr', async (): Promise<void> => {
+ *     try {
+ *         DTO.validate('', DTO.String().required())
+ *     } catch (error) {
+ *         //The message is in French
+ *         console.log((error as Error).message)
+ *     }
+ * })
+ * ```
+ */
+export declare function runInValidationLanguage<T>(language: string, fn: () => T): T;
+/**
+ * The validation language of the code running, set by `runInValidationLanguage()`.
+ * @returns The language tag, or undefined outside of `runInValidationLanguage()`.
+ * @example
+ * ```typescript
+ * import {currentValidationLanguage, runInValidationLanguage} from 'lakutata'
+ *
+ * console.log(currentValidationLanguage()) //undefined
+ * runInValidationLanguage('ja', (): void => {
+ *     console.log(currentValidationLanguage()) //ja
+ * })
+ * ```
+ */
+export declare function currentValidationLanguage(): string | undefined;

package/dist/cjs/lib/validation/ValidationLanguage.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInValidationLanguage = runInValidationLanguage;
+exports.currentValidationLanguage = currentValidationLanguage;
+const node_async_hooks_1 = require("node:async_hooks");
+/**
+ * The language of the validations of the code running (the language of a request)
+ */
+const LANGUAGE = new node_async_hooks_1.AsyncLocalStorage();
+/**
+ * Run a function with a validation language: the validation errors raised in it, its asynchronous continuations
+ * included, have their messages in that language (the messages registered by `registerValidationMessages()`), except
+ * for the validations giving their own `errors.language` option. The codes without a message in the language keep the
+ * default (English) one, and so does every code of a language with no registered messages.
+ * @param language The language tag the messages are registered under, like `fr` or `zh-CN`.
+ * @param fn The function to run; it may be asynchronous.
+ * @returns What the function returns (its promise, for an asynchronous function).
+ * @remarks A valid value is validated as without a language: only an invalid value is validated a second time, in the
+ * language, for its messages.
+ * @example
+ * ```typescript
+ * import {DTO, loadValidationMessages, registerValidationMessages, runInValidationLanguage} from 'lakutata'
+ *
+ * const messages: Record<string, string> | undefined = await loadValidationMessages('fr')
+ * if (messages) registerValidationMessages('fr', messages)
+ *
+ * await runInValidationLanguage('fr', async (): Promise<void> => {
+ *     try {
+ *         DTO.validate('', DTO.String().required())
+ *     } catch (error) {
+ *         //The message is in French
+ *         console.log((error as Error).message)
+ *     }
+ * })
+ * ```
+ */
+function runInValidationLanguage(language, fn) {
+    return LANGUAGE.run(language, fn);
+}
+/**
+ * The validation language of the code running, set by `runInValidationLanguage()`.
+ * @returns The language tag, or undefined outside of `runInValidationLanguage()`.
+ * @example
+ * ```typescript
+ * import {currentValidationLanguage, runInValidationLanguage} from 'lakutata'
+ *
+ * console.log(currentValidationLanguage()) //undefined
+ * runInValidationLanguage('ja', (): void => {
+ *     console.log(currentValidationLanguage()) //ja
+ * })
+ * ```
+ */
+function currentValidationLanguage() {
+    return LANGUAGE.getStore();
+}

package/dist/cjs/lib/validation/ValidationMessages.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Register the validation error messages of a language, by error code (`any.required`, `string.min`). The messages are
+ * merged into the ones already registered for the language, replacing those with the same code. A validation in the
+ * language (run in `runInValidationLanguage()`, or given the `errors.language` option) uses them; the codes without a
+ * message in the language keep the default (English) one.
+ * @param language The language tag, like `fr` or `zh-CN`, matched exactly (case-sensitive) by the validations.
+ * @param messages The message templates by error code, like `{'any.required': '{{#label}} est requis'}`: `{{#label}}`,
+ * `{{#limit}}`… are replaced by the context of the error (see `defaultValidationMessages()` for the codes and their
+ * variables).
+ * @throws {SchemaDefinitionException} When a message is not a string, or its template is invalid.
+ * @remarks The templates are compiled once, when registered: register the languages when the application starts.
+ * @example
+ * ```typescript
+ * import {DTO, registerValidationMessages, runInValidationLanguage} from 'lakutata'
+ *
+ * registerValidationMessages('fr', {
+ *     'any.required': '{{#label}} est requis',
+ *     'string.min': '{{#label}} doit contenir au moins {{#limit}} caractères'
+ * })
+ *
+ * runInValidationLanguage('fr', (): void => {
+ *     //Throws: "name" est requis
+ *     DTO.validate({}, DTO.Object({name: DTO.String().min(2).required()}))
+ * })
+ * ```
+ */
+export declare function registerValidationMessages(language: string, messages: Record<string, string>): void;
+/**
+ * The languages with validation error messages registered by `registerValidationMessages()`.
+ * @returns The language tags, in registration order; empty until a language is registered (the default English
+ * messages are not listed).
+ * @example
+ * ```typescript
+ * import {registerValidationMessages, validationLanguages} from 'lakutata'
+ *
+ * registerValidationMessages('de', {'any.required': '{{#label}} ist erforderlich'})
+ * console.log(validationLanguages()) //['de']
+ * ```
+ */
+export declare function validationLanguages(): string[];
+/**
+ * The language tags with built-in validation error messages, which `loadValidationMessages()` loads (`en`: the
+ * default messages).
+ */
+export declare const BUILT_IN_VALIDATION_LANGUAGES: readonly string[];
+/**
+ * The built-in messages language closest to a language tag: the same tag (compared case-insensitively, `_` read as
+ * `-`); for Chinese, the one of its script or region (`zh-Hant`, `zh-HK`, `zh-MO`: `zh-TW`; `zh`, `zh-Hans`, `zh-SG`:
+ * `zh-CN`); otherwise the built-in one of the same primary language (`pt-PT`: `pt-BR`, `en-GB`: `en`).
+ * @param language A language tag, like `pt_PT` or the `Accept-Language` value of a request.
+ * @returns One of `BUILT_IN_VALIDATION_LANGUAGES`, or undefined for a language without built-in messages.
+ * @example
+ * ```typescript
+ * import {builtInValidationLanguage} from 'lakutata'
+ *
+ * console.log(builtInValidationLanguage('zh-HK')) //zh-TW
+ * console.log(builtInValidationLanguage('pt_PT')) //pt-BR
+ * console.log(builtInValidationLanguage('sv')) //undefined
+ * ```
+ */
+export declare function builtInValidationLanguage(language: string): string | undefined;
+/**
+ * Load the built-in validation error messages of a language, the ones of its closest built-in language
+ * (`builtInValidationLanguage()`). They are loaded on demand, so an application only loads the languages it uses; they
+ * are not registered: pass them to `registerValidationMessages()`.
+ * @param language A language tag, like `fr` or `zh-Hant`.
+ * @returns A copy of the message templates by error code (for `en`, the default messages), or undefined for a language
+ * without built-in messages.
+ * @example
+ * ```typescript
+ * import {loadValidationMessages, registerValidationMessages} from 'lakutata'
+ *
+ * for (const language of ['fr', 'zh-CN']) {
+ *     const messages: Record<string, string> | undefined = await loadValidationMessages(language)
+ *     if (messages) registerValidationMessages(language, messages)
+ * }
+ * ```
+ */
+export declare function loadValidationMessages(language: string): Promise<Record<string, string> | undefined>;
+/**
+ * The default (English) validation error messages: the starting point of the messages of a new language.
+ * @returns A new object of the message templates by error code, the bigint ones included, like
+ * `{'any.required': '{{#label}} is required', …}`.
+ * @example
+ * ```typescript
+ * import {defaultValidationMessages} from 'lakutata'
+ *
+ * const messages: Record<string, string> = defaultValidationMessages()
+ * console.log(messages['string.min']) //{{#label}} length must be at least {{#limit}} characters long
+ * ```
+ */
+export declare function defaultValidationMessages(): Record<string, string>;