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

package/dist/core/validation/validators/future-date.d.ts

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

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

@@ -1,5 +1,8 @@
 /**
- * Reusable validators
+ * Reusable validator factories.
+ *
+ * Все примитивы — фабрики, возвращающие чистый Validator<TForm, TField>.
+ * Использование: `validate(path.x, required())`, `validate(path.y, min(18))`.
  */
 export { required } from './required';
 export { min } from './min';
@@ -8,9 +11,13 @@ export { minLength } from './min-length';
 export { maxLength } from './max-length';
 export { email } from './email';
 export { pattern } from './pattern';
-export { url } from './url';
-export { phone, type PhoneFormat } from './phone';
-export { number } from './number';
+export { url, type UrlValidatorOptions } from './url';
+export { phone, type PhoneFormat, type PhoneValidatorOptions } from './phone';
+export { isNumber } from './is-number';
+export { integer } from './integer';
+export { multipleOf } from './multiple-of';
+export { nonNegative } from './non-negative';
+export { nonZero } from './non-zero';
 export { isDate } from './is-date';
 export { minDate } from './min-date';
 export { maxDate } from './max-date';
@@ -18,3 +25,4 @@ export { pastDate } from './past-date';
 export { futureDate } from './future-date';
 export { minAge } from './min-age';
 export { maxAge } from './max-age';
+export { notEmpty } from './array-validators';

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

@@ -0,0 +1,13 @@
+import { Validator, ValidateOptions } from '../../types/validation-schema';
+/**
+ * Фабрика валидатора, проверяющего что число — целое.
+ *
+ * Пустые значения и не-числа пропускаются (используйте `required` и `isNumber`).
+ *
+ * @example
+ * ```typescript
+ * validate(path.age, integer());
+ * validate(path.count, integer({ message: 'Должно быть целым числом' }));
+ * ```
+ */
+export declare function integer<TForm = unknown, TField extends number | undefined = number>(options?: ValidateOptions): Validator<TForm, TField>;

package/dist/core/validation/validators/is-date.d.ts

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

package/dist/core/validation/validators/is-number.d.ts

@@ -0,0 +1,14 @@
+import { Validator, ValidateOptions } from '../../types/validation-schema';
+/**
+ * Фабрика валидатора, проверяющего что значение — конечное число (не NaN, не строка).
+ *
+ * Пустые значения (`null`/`undefined`) пропускаются (используйте `required` для обязательности).
+ * В отличие от других number-валидаторов, **не** пропускает не-числа — это его задача.
+ *
+ * @example
+ * ```typescript
+ * validate(path.amount, isNumber());
+ * validate(path.amount, isNumber({ message: 'Введите число' }));
+ * ```
+ */
+export declare function isNumber<TForm = unknown, TField extends number | undefined = number>(options?: ValidateOptions): Validator<TForm, TField>;

package/dist/core/validation/validators/max-age.d.ts

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

package/dist/core/validation/validators/max-date.d.ts

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

package/dist/core/validation/validators/max-length.d.ts

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

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

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

package/dist/core/validation/validators/min-age.d.ts

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

package/dist/core/validation/validators/min-date.d.ts

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

package/dist/core/validation/validators/min-length.d.ts

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

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

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

package/dist/core/validation/validators/multiple-of.d.ts

@@ -0,0 +1,13 @@
+import { Validator, ValidateOptions } from '../../types/validation-schema';
+/**
+ * Фабрика валидатора, проверяющего что число кратно заданному.
+ *
+ * Пустые значения и не-числа пропускаются (используйте `required` и `isNumber`).
+ *
+ * @example
+ * ```typescript
+ * validate(path.price, multipleOf(0.01));
+ * validate(path.rating, multipleOf(0.5, { message: 'Только шаг 0.5' }));
+ * ```
+ */
+export declare function multipleOf<TForm = unknown, TField extends number | undefined = number>(divisor: number, options?: ValidateOptions): Validator<TForm, TField>;

package/dist/core/validation/validators/non-negative.d.ts

@@ -0,0 +1,13 @@
+import { Validator, ValidateOptions } from '../../types/validation-schema';
+/**
+ * Фабрика валидатора, проверяющего что число неотрицательное (`≥ 0`).
+ *
+ * Пустые значения и не-числа пропускаются (используйте `required` и `isNumber`).
+ *
+ * @example
+ * ```typescript
+ * validate(path.quantity, nonNegative());
+ * validate(path.balance, nonNegative({ message: 'Баланс не может быть отрицательным' }));
+ * ```
+ */
+export declare function nonNegative<TForm = unknown, TField extends number | undefined = number>(options?: ValidateOptions): Validator<TForm, TField>;

package/dist/core/validation/validators/non-zero.d.ts

@@ -0,0 +1,13 @@
+import { Validator, ValidateOptions } from '../../types/validation-schema';
+/**
+ * Фабрика валидатора, проверяющего что число не равно нулю.
+ *
+ * Пустые значения и не-числа пропускаются (используйте `required` и `isNumber`).
+ *
+ * @example
+ * ```typescript
+ * validate(path.quantity, nonZero());
+ * validate(path.divisor, nonZero({ message: 'Не может быть нулём' }));
+ * ```
+ */
+export declare function nonZero<TForm = unknown, TField extends number | undefined = number>(options?: ValidateOptions): Validator<TForm, TField>;

package/dist/core/validation/validators/past-date.d.ts

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

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

@@ -1,40 +1,13 @@
-import { ValidateOptions } from '../../types/validation-schema';
-import { FieldPathNode } from '../../types';
+import { Validator, ValidateOptions } from '../../types/validation-schema';
 /**
- * Валидатор паттерна (регулярного выражения)
+ * Фабрика валидатора регулярного выражения.
  *
- * Проверяет, что значение соответствует указанному регулярному выражению.
  * Пустые значения пропускаются (используйте `required` для обязательности).
  *
- * @group Validation
- * @category Validators
- *
- * @param fieldPath - Путь к полю для валидации
- * @param regex - Регулярное выражение для проверки
- * @param options - Опции валидации (message, params)
- *
- * @example
- * ```typescript
- * // Только буквы
- * pattern(path.name, /^[а-яА-Яa-zA-Z]+$/)
- *
- * // Только цифры
- * pattern(path.code, /^\d+$/)
- *
- * // С кастомным сообщением
- * pattern(path.username, /^[a-z0-9_]+$/i, {
- *   message: 'Только латинские буквы, цифры и подчёркивание'
- * })
- * ```
- *
  * @example
  * ```typescript
- * // Ошибка валидации
- * {
- *   code: 'pattern',
- *   message: 'Значение не соответствует требуемому формату',
- *   params: { pattern: '^[a-z]+$' }
- * }
+ * validate(path.name, pattern(/^[а-яА-Яa-zA-Z]+$/));
+ * validate(path.code, pattern(/^\d+$/, { message: 'Только цифры' }));
  * ```
  */
-export declare function pattern<TForm, TField extends string | null | undefined = string>(fieldPath: FieldPathNode<TForm, TField> | undefined, regex: RegExp, options?: ValidateOptions): void;
+export declare function pattern<TForm = unknown, TField extends string | undefined = string>(regex: RegExp, options?: ValidateOptions): Validator<TForm, TField>;