@lakutata/core 1.0.59 → 3.0.0-beta.0

package/dist/types/lib/ioc/Resolvers.d.ts

@@ -0,0 +1,136 @@
+import { FunctionReturning, IDependencyInjectionContainer } from './DependencyInjectionContainer.js';
+import { type LifetimeType } from './Lifetime.js';
+/**
+ * RESOLVER symbol can be used by modules loaded by
+ * `loadModules` to configure their lifetime, injection mode, etc.
+ */
+export declare const RESOLVER: unique symbol;
+/**
+ * Gets passed the container and is expected to return an object
+ * whose properties are accessible at construction time for the
+ * configured resolver.
+ *
+ * @type {Function}
+ */
+export type InjectorFunction = <T extends object>(container: IDependencyInjectionContainer<T>) => object;
+/**
+ * A resolver object returned by asClass(), asFunction() or asValue().
+ */
+export interface Resolver<T> extends ResolverOptions<T> {
+    resolve<U extends object>(container: IDependencyInjectionContainer<U>): T;
+}
+/**
+ * A resolver object created by asClass() or asFunction().
+ */
+export interface BuildResolver<T> extends Resolver<T>, BuildResolverOptions<T> {
+    injector?: InjectorFunction;
+    setLifetime(lifetime: LifetimeType): this;
+    singleton(): this;
+    scoped(): this;
+    transient(): this;
+    inject(injector: InjectorFunction): this;
+}
+/**
+ * Options for disposable resolvers.
+ */
+export interface DisposableResolverOptions<T> extends ResolverOptions<T> {
+    dispose?: Disposer<T>;
+}
+/**
+ * Disposable resolver.
+ */
+export interface DisposableResolver<T> extends Resolver<T>, DisposableResolverOptions<T> {
+    disposer(dispose: Disposer<T>): this;
+}
+/**
+ * Disposer function type.
+ */
+export type Disposer<T> = (value: T) => any | Promise<any>;
+/**
+ * The options when registering a class, function or value.
+ * @type RegistrationOptions
+ */
+export interface ResolverOptions<T> {
+    /**
+     * Only used for inline configuration with `loadModules`.
+     */
+    name?: string;
+    /**
+     * Lifetime setting.
+     */
+    lifetime?: LifetimeType;
+    /**
+     * Registration function to use. Only used for inline configuration with `loadModules`.
+     */
+    register?: (...args: any[]) => Resolver<T>;
+    /**
+     * True if this resolver should be excluded from lifetime leak checking. Used by resolvers that
+     * wish to uphold the anti-leakage contract themselves. Defaults to false.
+     */
+    isLeakSafe?: boolean;
+}
+/**
+ * Builder resolver options.
+ */
+export interface BuildResolverOptions<T> extends ResolverOptions<T>, DisposableResolverOptions<T> {
+    /**
+     * Injector function to provide additional parameters.
+     */
+    injector?: InjectorFunction;
+}
+/**
+ * A class constructor. For example:
+ *
+ *    class MyClass {}
+ *
+ *    container.registerClass('myClass', MyClass)
+ *                                       ^^^^^^^
+ */
+export type Constructor<T> = {
+    new (...args: any[]): T;
+};
+/**
+ * Creates a simple value resolver where the given value will always be resolved. The value is
+ * marked as leak-safe since in strict mode, the value will only be resolved when it is not leaking
+ * upwards from a child scope to a parent singleton.
+ *
+ * @param  {string} name The name to register the value as.
+ *
+ * @param  {*} value The value to resolve.
+ *
+ * @return {object} The resolver.
+ */
+export declare function asValue<T>(value: T): Resolver<T>;
+/**
+ * Creates a factory resolver, where the given factory function
+ * will be invoked with `new` when requested.
+ *
+ * @param  {string} name
+ * The name to register the value as.
+ *
+ * @param  {Function} fn
+ * The function to register.
+ *
+ * @param {object} opts
+ * Additional options for the resolver.
+ *
+ * @return {object}
+ * The resolver.
+ */
+export declare function asFunction<T>(fn: FunctionReturning<T>, opts?: BuildResolverOptions<T>): BuildResolver<T> & DisposableResolver<T>;
+/**
+ * Like a factory resolver, but for classes that require `new`.
+ *
+ * @param  {string} name
+ * The name to register the value as.
+ *
+ * @param  {Class} Type
+ * The function to register.
+ *
+ * @param {object} opts
+ * Additional options for the resolver.
+ *
+ * @return {object}
+ * The resolver.
+ */
+export declare function asClass<T = object>(Type: Constructor<T>, opts?: BuildResolverOptions<T>): BuildResolver<T> & DisposableResolver<T>;

package/dist/types/lib/ioc/Utils.d.ts

@@ -0,0 +1,33 @@
+import { Constructor } from './Resolvers.js';
+/**
+ * Quick flatten utility to flatten a 2-dimensional array.
+ * @param array
+ */
+export declare function flatten<T>(array: Array<Array<T>>): Array<T>;
+/**
+ * Creates a { name: value } object if the input isn't already in that format.
+ * @param name
+ * @param value
+ */
+export declare function nameValueToObject(name: string | symbol | object, value?: any): Record<string | symbol, any>;
+/**
+ * Returns the last item in the array.
+ * @param arr
+ */
+export declare function last<T>(arr: Array<T>): T;
+/**
+ * Determines if the given function is a class.
+ * @param fn
+ */
+export declare function isClass(fn: Function | Constructor<any>): boolean;
+/**
+ * Determines if the given value is a function.
+ * @param val
+ */
+export declare function isFunction(val: unknown): boolean;
+/**
+ * Returns the unique items in the array.
+ * The array to remove dupes from.
+ * @param arr
+ */
+export declare function uniq<T>(arr: Array<T>): Array<T>;

package/dist/types/lib/validation/JsonSchema.d.ts

@@ -0,0 +1,127 @@
+import type { JSONSchema } from '../../types/JSONSchema.js';
+import type { Schema } from './types/Schema.js';
+import type { ValidationOptions } from './interfaces/ValidationOptions.js';
+/**
+ * The JSON Schema versions `toJsonSchema()` writes: the JSON Schema drafts, or the schema objects of OpenAPI 3.0 and
+ * 3.1.
+ */
+export type JsonSchemaTarget = 'draft-2020-12' | 'draft-2019-09' | 'draft-07' | 'draft-04' | 'openapi-3.0' | 'openapi-3.1';
+/**
+ * The options of the conversion of a schema into a JSON Schema
+ */
+export interface ToJsonSchemaOptions {
+    /**
+     * The JSON Schema version to write.
+     * @default 'draft-2020-12'
+     */
+    target?: JsonSchemaTarget;
+    /**
+     * The validation options the schema is used with: they decide which unknown keys are accepted
+     * (`additionalProperties`) and which keys are required.
+     * @default the validation options of lakutata (unknown keys allowed, keys optional)
+     */
+    preferences?: ValidationOptions;
+    /**
+     * Whether the JSON Schema declares its version with `$schema` (JSON Schema versions only, not OpenAPI).
+     * @default false
+     */
+    dialect?: boolean;
+    /**
+     * An object receiving the shared schemas (the schemas given an id with `.id()`), by id. The JSON Schema refers to
+     * them with `$ref` (`#/$defs/<id>`, `#/definitions/<id>` in draft 04, `#/components/schemas/<id>` in OpenAPI);
+     * the JSON Schema versions also embed them in the root `$defs` (`definitions`). An OpenAPI schema object cannot
+     * hold them: the OpenAPI targets return them in the root key `schemas` of the result as well, both to be moved by
+     * the caller into the `components.schemas` of its document.
+     */
+    definitions?: Record<string, JSONSchema>;
+}
+/**
+ * What `toJsonSchema()` converts: a schema, or a DTO class (the schema returned by its static `Schema()`).
+ */
+export type JsonSchemaSource = Schema | {
+    /**
+     * The object schema of the DTO class.
+     * @returns The schema.
+     */
+    Schema(): Schema;
+};
+/**
+ * Converts a schema (or a DTO class) into a JSON Schema, for an API document or another validator. The JSON Schema
+ * describes the values the schema accepts without conversion: what cannot be expressed (custom rules, references to
+ * other values, conversions) is dropped, so the JSON Schema may accept more values, never less. The formats are named
+ * after the rules (their implementations differ on edge cases), and the numbers beyond the safe integers are accepted.
+ * @param source The schema, or the DTO class, to convert.
+ * @param options The JSON Schema version and the validation options the schema is used with.
+ * @returns A new JSON Schema.
+ * @throws {SchemaConversionException} When the source is not a schema nor a DTO class, or the target is unknown.
+ * @example
+ * ```typescript
+ * import {DTO, type JSONSchema} from 'lakutata'
+ * import {toJsonSchema} from 'lakutata/dtos'
+ *
+ * const schema: JSONSchema = toJsonSchema(DTO.Object({
+ *     name: DTO.String().max(64).required(),
+ *     age: DTO.Number().integer().min(0)
+ * }), {target: 'openapi-3.1'})
+ * //{type: 'object', properties: {name: {type: 'string', maxLength: 64, …}, age: {type: 'integer', minimum: 0}}, required: ['name'], …}
+ * console.log(schema)
+ * ```
+ */
+export declare function toJsonSchema(source: JsonSchemaSource, options?: ToJsonSchemaOptions): JSONSchema;
+/**
+ * The JSON Schema versions `fromJsonSchema()` reads: the JSON Schema drafts, or the schema objects of OpenAPI 3.0 and
+ * 3.1.
+ */
+export type JsonSchemaDialect = JsonSchemaTarget | 'draft-06';
+/**
+ * The options of the conversion of a JSON Schema into a schema
+ */
+export interface FromJsonSchemaOptions {
+    /**
+     * The version the JSON Schema is written in.
+     * @default the version its `$schema` declares, else 'draft-2020-12'
+     */
+    dialect?: JsonSchemaDialect;
+    /**
+     * The document the local references (`#/...`) are resolved in, like the OpenAPI document holding the schema
+     * object.
+     * @default the JSON Schema itself
+     */
+    document?: unknown;
+    /**
+     * Other JSON Schemas the references may refer to, by URI (their `$id`, when they have one).
+     */
+    schemas?: Record<string, unknown>;
+    /**
+     * Whether the values are converted like the schemas of lakutata do (the string `'5'` accepted as the number 5);
+     * JSON Schema does not convert.
+     * @default false
+     */
+    convert?: boolean;
+}
+/**
+ * Converts a JSON Schema (drafts 04 to 2020-12, or an OpenAPI 3.0/3.1 schema object) into a schema, which validates
+ * like JSON Schema: without conversion, the unknown keys as `additionalProperties` says, the formats like the full
+ * formats of ajv-formats, and the keywords next to a `$ref` applied (like ajv). The `default` values are applied.
+ * @param schema The JSON Schema, or a boolean schema (true accepts every value, false none).
+ * @param options The version of the JSON Schema, and where its references are resolved.
+ * @returns The schema, to validate with `DTO.validate()` or to use in a DTO.
+ * @throws {SchemaConversionException} When the JSON Schema is not an object nor a boolean, a reference cannot be
+ * resolved, or a pattern is not a valid regular expression.
+ * @example
+ * ```typescript
+ * import {DTO, type Schema} from 'lakutata'
+ * import {fromJsonSchema} from 'lakutata/dtos'
+ *
+ * const schema: Schema = fromJsonSchema({
+ *     type: 'object',
+ *     properties: {
+ *         name: {type: 'string'},
+ *         age: {type: 'integer', minimum: 0, default: 18}
+ *     },
+ *     required: ['name']
+ * })
+ * console.log(DTO.validate({name: 'Ada'}, schema)) //{name: 'Ada', age: 18}
+ * ```
+ */
+export declare function fromJsonSchema(schema: JSONSchema | boolean, options?: FromJsonSchemaOptions): Schema;

package/dist/types/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/types/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;