@reformer/core 1.0.0-beta.1 → 1.0.0-beta.2

package/dist/behaviors/compute-from.js

@@ -1,7 +1,7 @@
 import { effect as _ } from "@preact/signals-core";
-import { b as v } from "../registry-helpers-Bv_BJ1s-.js";
+import { g as v } from "../registry-helpers-CLPXad2B.js";
 import { r as V } from "../safe-effect-Dh8uw81c.js";
-function N(n, i, s, f) {
+function b(n, i, s, f) {
   const { debounce: p, condition: u } = f || {}, h = (r, E, m) => {
     const a = r.getFieldByPath(i.__path);
     if (!a) return null;
@@ -27,5 +27,5 @@ function N(n, i, s, f) {
   v().register(h, { debounce: p });
 }
 export {
-  N as computeFrom
+  b as computeFrom
 };

package/dist/behaviors/enable-when.js

@@ -1,20 +1,20 @@
 import { effect as c } from "@preact/signals-core";
-import { b } from "../registry-helpers-Bv_BJ1s-.js";
-import { r as d } from "../safe-effect-Dh8uw81c.js";
+import { g as d } from "../registry-helpers-CLPXad2B.js";
+import { r as b } from "../safe-effect-Dh8uw81c.js";
 function h(t, n, r) {
-  const { debounce: o, resetOnDisable: a = !1 } = r || {}, i = (s, m, l) => {
+  const { debounce: o, resetOnDisable: a = !1 } = r || {}, i = (s, g, l) => {
     const e = s.getFieldByPath(t.__path);
     return e ? c(() => {
       const f = s.value.value;
       l(() => {
         const u = n(f);
-        d(() => {
+        b(() => {
           u ? e.enable() : (e.disable(), a && e.reset());
         });
       });
     }) : null;
   };
-  b().register(i, { debounce: o });
+  d().register(i, { debounce: o });
 }
 function _(t, n, r) {
   h(t, (o) => !n(o), r);

package/dist/behaviors/reset-when.js

@@ -1,5 +1,5 @@
 import { effect as c } from "@preact/signals-core";
-import { b as d } from "../registry-helpers-Bv_BJ1s-.js";
+import { g as d } from "../registry-helpers-CLPXad2B.js";
 import { r as h } from "../safe-effect-Dh8uw81c.js";
 function R(r, n, o) {
   const { debounce: s, resetValue: u = null, onlyIfDirty: a = !1 } = o || {}, i = (t, m, l) => {

package/dist/behaviors/revalidate-when.js

@@ -1,5 +1,5 @@
 import { effect as d } from "@preact/signals-core";
-import { b as h } from "../registry-helpers-Bv_BJ1s-.js";
+import { g as h } from "../registry-helpers-CLPXad2B.js";
 function p(o, a, i) {
   const { debounce: l } = i || {}, u = (t, s, c) => {
     const r = t.getFieldByPath(o.__path);

package/dist/behaviors/sync-fields.js

@@ -1,12 +1,12 @@
 import { effect as o } from "@preact/signals-core";
-import { b as v } from "../registry-helpers-Bv_BJ1s-.js";
+import { g as v } from "../registry-helpers-CLPXad2B.js";
 import { r as i } from "../safe-effect-Dh8uw81c.js";
 function E(u, f, c) {
-  const { debounce: d, transform: a } = c || {}, p = (n, h, l) => {
+  const { debounce: d, transform: a } = c || {}, g = (n, h, l) => {
     const r = n.getFieldByPath(u.__path), s = n.getFieldByPath(f.__path);
     if (!r || !s) return null;
     let e = !1;
-    const g = o(() => {
+    const p = o(() => {
       const t = r.value.value;
       e || l(() => {
         e = !0, i(() => {
@@ -31,10 +31,10 @@ function E(u, f, c) {
       });
     });
     return () => {
-      g(), m();
+      p(), m();
     };
   };
-  v().register(p, { debounce: d });
+  v().register(g, { debounce: d });
 }
 export {
   E as syncFields

package/dist/behaviors/watch-field.js

@@ -1,7 +1,7 @@
 import { effect as c } from "@preact/signals-core";
-import { b as d } from "../registry-helpers-Bv_BJ1s-.js";
+import { g as d } from "../registry-helpers-CLPXad2B.js";
 import { r as i } from "../safe-effect-Dh8uw81c.js";
-function g(n, r, u) {
+function p(n, r, u) {
   const { debounce: a, immediate: f = !1 } = u || {}, s = (l, o, m) => {
     const e = l.getFieldByPath(n.__path);
     return e ? (f && i(() => {
@@ -17,5 +17,5 @@ function g(n, r, u) {
   d().register(s, { debounce: a });
 }
 export {
-  g as watchField
+  p as watchField
 };

package/dist/behaviors.js

@@ -1,5 +1,5 @@
-import { a as o, b as a, i as t, t as m } from "./index-D25LsbRm.js";
-import { a as s, B as f } from "./registry-helpers-Bv_BJ1s-.js";
+import { a as o, b as a, i as t, t as m } from "./index-DLh_Ryb2.js";
+import { a as s, B as f } from "./registry-helpers-CLPXad2B.js";
 import { copyFrom as n } from "./behaviors/copy-from.js";
 import { disableWhen as h, enableWhen as i } from "./behaviors/enable-when.js";
 import { computeFrom as c } from "./behaviors/compute-from.js";

package/dist/core/types/field-path.d.ts

@@ -23,9 +23,9 @@ import { AnyFunction } from './index';
  * };
  * ```
  */
-export type FieldPath<T> = {
+export type FieldPath<T> = NonNullable<T> extends object ? NonNullable<T> extends Array<unknown> | Date | File | Blob | AnyFunction ? FieldPathNode<unknown, T> : {
     [K in keyof T]: NonNullable<T[K]> extends Array<unknown> ? FieldPathNode<T, T[K], K> : NonNullable<T[K]> extends Date | File | Blob | AnyFunction ? FieldPathNode<T, T[K], K> : NonNullable<T[K]> extends object ? FieldPathNode<T, T[K], K> & FieldPath<NonNullable<T[K]>> : FieldPathNode<T, T[K], K>;
-};
+} : FieldPathNode<unknown, T>;
 /**
  * Узел в пути поля
  * Содержит метаинформацию о поле для валидации

package/dist/core/types/index.d.ts

@@ -99,7 +99,7 @@ export interface ErrorFilterOptions {
 export type FieldStatus = 'valid' | 'invalid' | 'pending' | 'disabled';
 export type { FieldConfig } from './deep-schema';
 export type { FieldPath, FieldPathNode } from '../types/field-path';
-export type { ContextualValidatorFn, ContextualAsyncValidatorFn, TreeValidatorFn, ConditionFn, ValidateOptions, ValidateAsyncOptions, ValidateTreeOptions, ValidationSchemaFn, ValidatorRegistration, } from './validation-schema';
+export type { Validator, AsyncValidator, ConditionFn, ValidateOptions, ValidateAsyncOptions, ValidationSchemaFn, ValidatorRegistration, } from './validation-schema';
 export type { FormSchema, ArrayConfig } from './deep-schema';
 export type { FormContext } from './form-context';
 export type { FormControlsProxy, FormProxy, FormArrayProxy } from './form-proxy';

package/dist/core/types/validation-schema.d.ts

@@ -1,57 +1,34 @@
 import { FormFields, ValidationError } from './index';
 import { FieldPath } from './field-path';
-import { FormContext } from './form-context';
+import { FormProxy } from './form-proxy';
 /**
- * Функция валидации поля с контекстом
+ * Чистый синхронный валидатор поля.
  *
- * Новый паттерн: (value, ctx: FormContext) => ValidationError | null
+ * Принимает значение поля, прокси текущего поля (control) и прокси корня формы (root).
+ * Возвращает ValidationError либо null. Не знает про реестр валидации.
  *
  * @example
  * ```typescript
- * validate(path.email, (value, ctx) => {
- *   if (!value) return { code: 'required', message: 'Email required' };
- *   const confirm = ctx.form.confirmEmail.value.value;
- *   if (value !== confirm) return { code: 'mismatch', message: 'Must match' };
+ * const isAdult: Validator<MyForm, number> = (value, control, root) => {
+ *   if (value < 18) return { code: 'tooYoung', message: '18+' };
  *   return null;
- * });
+ * };
+ * validate(path.age, isAdult);
  * ```
  */
-export type ContextualValidatorFn<TForm, TField> = (value: TField, ctx: FormContext<TForm>) => ValidationError | null;
+export type Validator<TForm, TField> = (value: TField, control: FormProxy<TField>, root: FormProxy<TForm>) => ValidationError | null;
 /**
- * Асинхронная функция валидации поля с контекстом
+ * Чистый асинхронный валидатор поля.
  *
- * @example
- * ```typescript
- * validateAsync(path.email, async (value, ctx) => {
- *   const exists = await checkEmailExists(value);
- *   if (exists) return { code: 'exists', message: 'Email already taken' };
- *   return null;
- * });
- * ```
- */
-export type ContextualAsyncValidatorFn<TForm, TField> = (value: TField, ctx: FormContext<TForm>) => Promise<ValidationError | null>;
-/**
- * Функция cross-field валидации
- *
- * @example
- * ```typescript
- * validateTree((ctx) => {
- *   const password = ctx.form.password.value.value;
- *   const confirm = ctx.form.confirmPassword.value.value;
- *   if (password !== confirm) {
- *     return { code: 'mismatch', message: 'Passwords must match' };
- *   }
- *   return null;
- * });
- * ```
+ * Регистрируется через `validateAsync(path, validator, { debounce })`.
  */
-export type TreeValidatorFn<TForm> = (ctx: FormContext<TForm>) => ValidationError | null;
+export type AsyncValidator<TForm, TField> = (value: TField, control: FormProxy<TField>, root: FormProxy<TForm>) => Promise<ValidationError | null>;
 /**
- * Функция условия для applyWhen
+ * Функция условия для applyWhen.
  */
 export type ConditionFn<T> = (value: T) => boolean;
 /**
- * Опции для функции validate
+ * Опции для функции validate.
  */
 export interface ValidateOptions {
     /** Сообщение об ошибке */
@@ -60,23 +37,16 @@ export interface ValidateOptions {
     params?: FormFields;
 }
 /**
- * Опции для функции validateAsync
+ * Опции для функции validateAsync.
  */
 export interface ValidateAsyncOptions extends ValidateOptions {
     /** Задержка перед выполнением валидации (в мс) */
     debounce?: number;
 }
 /**
- * Опции для функции validateTree
- */
-export interface ValidateTreeOptions {
-    /** Поле, к которому привязать ошибку */
-    targetField?: string;
-}
-/**
- * Функция validation schema
+ * Функция validation schema.
  *
- * Принимает FieldPath и определяет все правила валидации для формы
+ * Принимает FieldPath и определяет все правила валидации для формы.
  */
 export type ValidationSchemaFn<T> = (path: FieldPath<T>) => void;
 /**
@@ -85,9 +55,10 @@ export type ValidationSchemaFn<T> = (path: FieldPath<T>) => void;
  */
 export interface ValidatorRegistration {
     fieldPath: string;
-    type: 'sync' | 'async' | 'tree';
-    validator: ContextualValidatorFn<unknown, unknown> | ContextualAsyncValidatorFn<unknown, unknown> | TreeValidatorFn<unknown>;
-    options?: ValidateOptions | ValidateAsyncOptions | ValidateTreeOptions;
+    type: 'sync' | 'async' | 'array-items';
+    validator: Validator<unknown, unknown> | AsyncValidator<unknown, unknown>;
+    options?: ValidateOptions | ValidateAsyncOptions;
+    /** Для условной валидации (applyWhen). */
     condition?: {
         fieldPath: string;
         conditionFn: ConditionFn<unknown>;

package/dist/core/validation/core/index.d.ts

@@ -3,6 +3,5 @@
  */
 export { validate } from './validate';
 export { validateAsync } from './validate-async';
-export { validateTree } from './validate-tree';
 export { applyWhen } from './apply-when';
 export { apply } from './apply';

package/dist/core/validation/core/validate-async.d.ts

@@ -1,7 +1,8 @@
-import { ContextualAsyncValidatorFn, ValidateAsyncOptions } from '../../types/validation-schema';
-import { FieldPathNode } from '../../types';
+import { AsyncValidator, FieldPathNode, ValidateAsyncOptions } from '../../types';
 /**
- * Зарегистрировать асинхронный валидатор для поля
+ * Зарегистрировать асинхронный валидатор для поля.
+ *
+ * Принимает чистую async-функцию `(value, control, root) => Promise<error | null>`.
  *
  * @group Validation
  * @category Core Functions
@@ -10,27 +11,20 @@ import { FieldPathNode } from '../../types';
  * ```typescript
  * validateAsync(
  *   path.inn,
- *   async (ctx: ValidationContext<TForm, TField>) => {
- *     const inn = ctx.value();
- *     if (!inn) return null;
- *
+ *   async (value, _control, _root) => {
+ *     if (!value) return null;
  *     const response = await fetch('/api/validate-inn', {
  *       method: 'POST',
- *       body: JSON.stringify({ inn }),
+ *       body: JSON.stringify({ inn: value }),
  *     });
- *
  *     const data = await response.json();
  *     if (!data.valid) {
- *       return {
- *         code: 'invalidInn',
- *         message: 'ИНН не найден в базе данных ФНС',
- *       };
+ *       return { code: 'invalidInn', message: 'ИНН не найден в базе ФНС' };
  *     }
- *
  *     return null;
  *   },
  *   { debounce: 1000 }
  * );
  * ```
  */
-export declare function validateAsync<TForm, TField>(fieldPath: FieldPathNode<TForm, TField>, validatorFn: ContextualAsyncValidatorFn<TForm, TField>, options?: ValidateAsyncOptions): void;
+export declare function validateAsync<TForm, TField>(fieldPath: FieldPathNode<TForm, TField>, validator: AsyncValidator<TForm, TField>, options?: ValidateAsyncOptions): void;

package/dist/core/validation/core/validate.d.ts

@@ -1,26 +1,26 @@
-import { ContextualValidatorFn, FieldPathNode, ValidateOptions } from '../../types';
+import { Validator, FieldPathNode, ValidateOptions } from '../../types';
 /**
- * Зарегистрировать кастомный синхронный валидатор для поля
- * Поддерживает опциональные поля
+ * Зарегистрировать синхронный валидатор для поля.
+ *
+ * Принимает чистую функцию-валидатор `(value, control, root) => error | null`,
+ * либо фабрику из `@reformer/core/validators` (например, `required()`).
  *
  * @group Validation
  * @category Core Functions
  *
  * @example
  * ```typescript
- * validate(path.birthDate, (ctx: ValidationContext<TForm, TField>) => {
- *   const birthDate = new Date(ctx.value());
- *   const age = calculateAge(birthDate);
- *
- *   if (age < 18) {
- *     return {
- *       code: 'tooYoung',
- *       message: 'Заемщику должно быть не менее 18 лет',
- *     };
- *   }
- *
+ * // Кастомный валидатор
+ * validate(path.birthDate, (value, _control, root) => {
+ *   const age = calculateAge(new Date(value));
+ *   if (age < 18) return { code: 'tooYoung', message: 'Только 18+' };
  *   return null;
  * });
+ *
+ * // Фабрика из @reformer/core/validators
+ * import { required, min } from '@reformer/core/validators';
+ * validate(path.loanAmount, required());
+ * validate(path.loanAmount, min(50000, { message: 'Min 50 000' }));
  * ```
  */
-export declare function validate<TForm, TField>(fieldPath: FieldPathNode<TForm, TField> | undefined, validatorFn: ContextualValidatorFn<TForm, TField>, options?: ValidateOptions): void;
+export declare function validate<TForm, TField>(fieldPath: FieldPathNode<TForm, TField> | undefined, validator: Validator<TForm, TField>, options?: ValidateOptions): void;

package/dist/core/validation/index.d.ts

@@ -1,6 +1,5 @@
 export { validate } from './core/validate';
 export { validateAsync } from './core/validate-async';
-export { validateTree } from './core/validate-tree';
 export { apply } from './core/apply';
 export { applyWhen } from './core/apply-when';
 export { required } from './validators/required';
@@ -12,7 +11,11 @@ export { email } from './validators/email';
 export { pattern } from './validators/pattern';
 export { url } from './validators/url';
 export { phone, type PhoneFormat } from './validators/phone';
-export { number } from './validators/number';
+export { isNumber } from './validators/is-number';
+export { integer } from './validators/integer';
+export { multipleOf } from './validators/multiple-of';
+export { nonNegative } from './validators/non-negative';
+export { nonZero } from './validators/non-zero';
 export { isDate } from './validators/is-date';
 export { minDate } from './validators/min-date';
 export { maxDate } from './validators/max-date';
@@ -24,4 +27,3 @@ export { notEmpty, validateItems } from './validators/array-validators';
 export { createFieldPath, extractPath, extractKey, toFieldPath } from '../utils/field-path';
 export { validateForm } from './validate-form';
 export { ValidationRegistry } from './validation-registry';
-export { ValidationContextImpl, TreeValidationContextImpl } from './validation-context';

package/dist/core/validation/validation-applicator.d.ts

@@ -1,70 +1,16 @@
 import { GroupNode } from '../nodes/group-node';
 import { ValidatorRegistration } from '../types';
-/**
- * Класс для применения валидаторов к форме
- *
- * Выполняет:
- * - Группировку валидаторов по полям
- * - Фильтрацию по условиям (condition)
- * - Применение sync/async валидаторов к FieldNode
- * - Применение tree валидаторов (кросс-полевая валидация)
- *
- * @template T Тип формы (объект)
- */
 export declare class ValidationApplicator<T> {
     private readonly form;
     constructor(form: GroupNode<T>);
     /**
-     * Применить валидаторы к полям формы
-     *
-     * Этапы применения:
-     * 1. Разделение валидаторов на field и tree
-     * 2. Применение field валидаторов (sync/async)
-     * 3. Применение tree валидаторов (кросс-полевая валидация)
-     *
-     * @param validators Зарегистрированные валидаторы
+     * Применить валидаторы к полям формы.
      */
     apply(validators: ValidatorRegistration[]): Promise<void>;
-    /**
-     * Группировка валидаторов по типам
-     *
-     * Разделяет валидаторы на:
-     * - Field validators (sync/async) - группируются по fieldPath
-     * - Tree validators - применяются ко всей форме
-     *
-     * @param validators Все зарегистрированные валидаторы
-     * @returns Сгруппированные валидаторы
-     */
     private groupValidators;
     /**
-     * Применение field валидаторов к полям
-     *
-     * Для каждого поля:
-     * 1. Найти FieldNode по пути
-     * 2. Проверить условия (condition)
-     * 3. Выполнить sync/async валидаторы
-     * 4. Установить ошибки на поле
-     *
-     * @param validatorsByField Валидаторы, сгруппированные по полям
+     * Применение sync/async валидаторов к полям.
      */
     private applyFieldValidators;
-    /**
-     * Применение tree валидаторов (кросс-полевая валидация)
-     *
-     * Tree валидаторы имеют доступ ко всей форме через TreeValidationContext.
-     * Ошибки устанавливаются на targetField (если указано).
-     *
-     * @param treeValidators Список tree валидаторов
-     */
-    private applyTreeValidators;
-    /**
-     * Проверка условия (condition) для валидатора
-     *
-     * Условие определяет, должен ли валидатор выполняться.
-     * Использует getFieldByPath для поддержки вложенных путей.
-     *
-     * @param condition Условие валидатора
-     * @returns true, если условие выполнено
-     */
     private checkCondition;
 }

package/dist/core/validation/validation-registry.d.ts

@@ -1,10 +1,8 @@
 import { GroupNode } from '../nodes/group-node';
 import { FormFields } from '../types';
-import { AbstractRegistry } from '../utils/abstract-registry';
-import { ValidatorRegistration, ContextualValidatorFn, ContextualAsyncValidatorFn, TreeValidatorFn, ConditionFn, ValidateOptions, ValidateAsyncOptions, ValidateTreeOptions } from '../types/validation-schema';
+import { ValidatorRegistration, Validator, AsyncValidator, ConditionFn, ValidateOptions, ValidateAsyncOptions } from '../types/validation-schema';
 /**
  * Контекст регистрации валидаторов
- * Управляет condition stack для условных валидаторов
  */
 declare class RegistrationContext {
     private validators;
@@ -32,9 +30,10 @@ declare class RegistrationContext {
  * Каждый экземпляр GroupNode создает собственный реестр (композиция).
  * Устраняет race conditions и изолирует формы друг от друга.
  *
- * Наследует AbstractRegistry для унификации:
- * - Управления global stack
- * - Template methods begin/end registration
+ * Context stack используется для tracking текущего активного реестра:
+ * - beginRegistration() помещает this в global stack
+ * - endRegistration() извлекает из global stack
+ * - getCurrent() возвращает текущий активный реестр
  *
  * @example
  * ```typescript
@@ -49,10 +48,13 @@ declare class RegistrationContext {
  * }
  * ```
  */
-export declare class ValidationRegistry extends AbstractRegistry<ValidatorRegistration> {
-    /** Внутренний стек контекстов для управления condition blocks */
+export declare class ValidationRegistry {
+    /**
+     * Global stack активных реестров
+     * Используется для изоляции форм друг от друга
+     */
+    private static registryStack;
     private contextStack;
-    /** Финальные валидаторы после завершения регистрации */
     private validators;
     /**
      * Получить текущий активный реестр из global stack
@@ -75,7 +77,6 @@ export declare class ValidationRegistry extends AbstractRegistry<ValidatorRegist
      * Начать регистрацию валидаторов для формы
      *
      * Помещает this в global stack для изоляции форм
-     * Создает новый RegistrationContext для condition management
      */
     beginRegistration(): RegistrationContext;
     /**
@@ -100,15 +101,11 @@ export declare class ValidationRegistry extends AbstractRegistry<ValidatorRegist
     /**
      * Зарегистрировать синхронный валидатор
      */
-    registerSync<TForm = unknown, TField = unknown>(fieldPath: string, validator: ContextualValidatorFn<TForm, TField>, options?: ValidateOptions): void;
+    registerSync<TForm = unknown, TField = unknown>(fieldPath: string, validator: Validator<TForm, TField>, options?: ValidateOptions): void;
     /**
      * Зарегистрировать асинхронный валидатор
      */
-    registerAsync<TForm = unknown, TField = unknown>(fieldPath: string, validator: ContextualAsyncValidatorFn<TForm, TField>, options?: ValidateAsyncOptions): void;
-    /**
-     * Зарегистрировать tree валидатор
-     */
-    registerTree<TForm = unknown>(validator: TreeValidatorFn<TForm>, options?: ValidateTreeOptions): void;
+    registerAsync<TForm = unknown, TField = unknown>(fieldPath: string, validator: AsyncValidator<TForm, TField>, options?: ValidateAsyncOptions): void;
     /**
      * Войти в условный блок
      */
@@ -133,6 +130,11 @@ export declare class ValidationRegistry extends AbstractRegistry<ValidatorRegist
      * Возвращает локальный массив валидаторов (без аргумента form).
      */
     getValidators(): ValidatorRegistration[];
+    /**
+     * Применить зарегистрированные валидаторы к GroupNode
+     * @private
+     */
+    private applyValidators;
     /**
      * Применить array-items validators к ArrayNode элементам
      * @private

package/dist/core/validation/validators/array-validators.d.ts

@@ -1,51 +1,26 @@
-import { ValidateOptions, ValidationSchemaFn } from '../../types/validation-schema';
+import { Validator, ValidateOptions, ValidationSchemaFn } from '../../types/validation-schema';
 import { FieldPathNode } from '../../types';
 /**
- * Проверить что массив содержит хотя бы один элемент
- *
- * Это удобный алиас для `minLength(field, 1)`, оптимизированный для массивов.
- *
- * @group Validation
- * @category Validators
- *
- * @param fieldPath - Поле-массив для валидации
- * @param options - Опции валидации (message, params и т.д.)
+ * Фабрика валидатора, проверяющего что массив (или строка) не пустой.
  *
  * @example
  * ```typescript
- * // Простая проверка
- * notEmpty(path.properties, { message: 'Добавьте хотя бы один объект имущества' });
- *
- * // С дополнительными параметрами
- * notEmpty(path.coBorrowers, {
- *   message: 'Требуется хотя бы один созаемщик',
- *   params: { minItems: 1 }
- * });
+ * validate(path.properties, notEmpty({ message: 'Добавьте хотя бы один элемент' }));
  * ```
  */
-export declare function notEmpty<TForm, TItem>(fieldPath: FieldPathNode<TForm, TItem[] | undefined> | undefined, options?: ValidateOptions): void;
+export declare function notEmpty<TForm = unknown, TField = unknown>(options?: ValidateOptions): Validator<TForm, TField>;
 /**
- * Применить validation schema к каждому элементу массива
+ * Применить validation schema к каждому элементу массива.
  *
  * Регистрирует схему валидации, которая будет автоматически применяться
  * к каждому элементу ArrayNode (как существующим, так и новым).
  *
- * @group Validation
- * @category Validators
- *
- * @param fieldPath - Поле-массив для валидации элементов
- * @param itemSchemaFn - Validation schema для одного элемента
- *
  * @example
  * ```typescript
  * import { propertyValidation } from './property-validation';
  *
- * // В additionalValidation
  * applyWhen(path.hasProperty, (value) => value === true, (path) => {
- *   // Проверка что массив не пустой
- *   notEmpty(path.properties, { message: 'Добавьте хотя бы один объект имущества' });
- *
- *   // Валидация каждого элемента
+ *   validate(path.properties, notEmpty({ message: 'Добавьте хотя бы один объект' }));
  *   validateItems(path.properties, propertyValidation);
  * });
  * ```

package/dist/core/validation/validators/email.d.ts

@@ -1,37 +1,13 @@
-import { ValidateOptions } from '../../types/validation-schema';
-import { FieldPathNode } from '../../types';
+import { Validator, ValidateOptions } from '../../types/validation-schema';
 /**
- * Валидатор формата email
+ * Фабрика валидатора формата email.
  *
- * Проверяет, что значение соответствует формату email адреса.
  * Пустые значения пропускаются (используйте `required` для обязательности).
  *
- * @group Validation
- * @category Validators
- *
- * @param fieldPath - Путь к полю для валидации
- * @param options - Опции валидации (message, params)
- *
- * @example
- * ```typescript
- * // Базовое использование
- * validationSchema: (path) => [
- *   required(path.email),
- *   email(path.email),
- * ]
- *
- * // С кастомным сообщением
- * email(path.email, { message: 'Введите корректный email адрес' })
- * ```
- *
  * @example
  * ```typescript
- * // Ошибка валидации
- * {
- *   code: 'email',
- *   message: 'Неверный формат email',
- *   params: {}
- * }
+ * validate(path.email, email());
+ * validate(path.email, email({ message: 'Введите корректный email' }));
  * ```
  */
-export declare function email<TForm, TField extends string | null | undefined = string>(fieldPath: FieldPathNode<TForm, TField> | undefined, options?: ValidateOptions): void;
+export declare function email<TForm = unknown, TField extends string | undefined = string>(options?: ValidateOptions): Validator<TForm, TField>;