@reformer/core 5.0.2 → 6.0.0

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

@@ -1,6 +1,4 @@
-import { BehaviorSchemaFn } from '../behavior/types';
 import { FormSchema } from './deep-schema';
-import { ValidationSchemaFn } from './validation-schema';
 import { FormNode } from '../nodes/form-node';
 /**
  * Represents any valid form value type
@@ -98,14 +96,14 @@ 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, } from './validation-schema';
 export type { FormSchema, ArrayConfig } from './deep-schema';
-export type { FormContext } from './form-context';
 export type { FormControlsProxy, FormProxy, FormArrayProxy } from './form-proxy';
 /**
- * Конфигурация GroupNode с поддержкой схем
- * Используется для создания форм с автоматическим применением behavior и validation схем
+ * Конфигурация GroupNode.
+ *
+ * Под M1 группа создаётся из плоской {@link FormSchema} (дерево field-конфигов). Обёртка
+ * `{ form }` сохранена для совместимости вызова, legacy behavior/validation-схемы удалены (Ф7).
  *
  * @group Types
  * @category Configuration Types
@@ -113,22 +111,6 @@ export type { FormControlsProxy, FormProxy, FormArrayProxy } from './form-proxy'
 export interface GroupNodeConfig<T> {
     /** Схема структуры формы (поля и их конфигурация) */
     form: FormSchema<T>;
-    /** Схема реактивного поведения (copyFrom, enableWhen, computeFrom и т.д.) */
-    behavior?: BehaviorSchemaFn<T>;
-    /** Схема валидации (required, email, minLength и т.д.) */
-    validation?: ValidationSchemaFn<T>;
-    /**
-     * Опциональный ValidationRegistry для dependency injection
-     * Используется для тестирования с mock-реестрами
-     * @internal
-     */
-    _validationRegistry?: unknown;
-    /**
-     * Опциональный BehaviorRegistry для dependency injection
-     * Используется для тестирования с mock-реестрами
-     * @internal
-     */
-    _behaviorRegistry?: unknown;
 }
 /**
  * Тип для Record с unknown значениями

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

@@ -1,57 +1,33 @@
 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,36 +36,9 @@ export interface ValidateOptions {
     params?: FormFields;
 }
 /**
- * Опции для функции validateAsync
+ * Опции для функции validateAsync.
  */
 export interface ValidateAsyncOptions extends ValidateOptions {
     /** Задержка перед выполнением валидации (в мс) */
     debounce?: number;
 }
-/**
- * Опции для функции validateTree
- */
-export interface ValidateTreeOptions {
-    /** Поле, к которому привязать ошибку */
-    targetField?: string;
-}
-/**
- * Функция validation schema
- *
- * Принимает FieldPath и определяет все правила валидации для формы
- */
-export type ValidationSchemaFn<T> = (path: FieldPath<T>) => void;
-/**
- * Регистрация валидатора в системе
- * @internal
- */
-export interface ValidatorRegistration {
-    fieldPath: string;
-    type: 'sync' | 'async' | 'tree';
-    validator: ContextualValidatorFn<unknown, unknown> | ContextualAsyncValidatorFn<unknown, unknown> | TreeValidatorFn<unknown>;
-    options?: ValidateOptions | ValidateAsyncOptions | ValidateTreeOptions;
-    condition?: {
-        fieldPath: string;
-        conditionFn: ConditionFn<unknown>;
-    };
-}

package/dist/core/utils/create-form.d.ts

@@ -1,4 +1,27 @@
 import { FormProxy, GroupNodeConfig, FormSchema } from '../types';
+import { FormModel } from '../model/types';
+import { FormBehavior } from '../../behaviors';
+/**
+ * Аргументы createForm под архитектуру M1: данные приходят из {@link FormModel},
+ * конфиг полей (component/componentProps/validators) — из единой схемы.
+ *
+ * @group Utilities
+ */
+export interface CreateFormFromModelArgs<T> {
+    /** Реактивная модель данных (источник истины значений). */
+    model: FormModel<T>;
+    /**
+     * Единая Schema (дерево узлов). createForm обходит её и привязывает конфиг поля к ноде
+     * по идентичности сигнала (`node.value === model.$.path`). Опциональна.
+     */
+    schema?: unknown;
+    /**
+     * Декларативная схема поведения ({@link defineFormBehavior}). Запускается ПОСЛЕ построения нод и
+     * заполнения реестра сигнал→нода; cleanup живёт на форме и вызывается в `form.dispose()`.
+     */
+    behavior?: FormBehavior<T>;
+}
+export declare function createFormFromModel<T>(args: CreateFormFromModelArgs<T>): FormProxy<T>;
 /**
  * Создать форму с полной конфигурацией (form, behavior, validation)
  *
@@ -26,6 +49,7 @@ import { FormProxy, GroupNodeConfig, FormSchema } from '../types';
  * form.email.setValue('test@mail.com');
  * ```
  */
+export declare function createForm<T>(args: CreateFormFromModelArgs<T>): FormProxy<T>;
 export declare function createForm<T>(config: GroupNodeConfig<T>): FormProxy<T>;
 /**
  * Создать форму только со схемой полей (обратная совместимость)

package/dist/core/utils/derived-registry.d.ts

@@ -0,0 +1,5 @@
+import { Signal } from '@preact/signals-core';
+/** Пометить сигнал производным (вызывают compute/computeFrom). */
+export declare function markDerived(signal: Signal<any>): void;
+/** Производный ли сигнал (читают bulk-сеттеры, чтобы не затирать вычисляемые поля). */
+export declare function isDerived(signal: Signal<any>): boolean;

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

@@ -3,14 +3,14 @@
  *
  * Централизованные вспомогательные классы и функции.
  */
-export { FieldPathNavigator, type PathSegment } from './field-path-navigator';
-export { createFieldPath, extractPath, extractKey, toFieldPath } from './field-path';
 export { SubscriptionManager } from './subscription-manager';
-export { getCurrentValidationRegistry, getCurrentBehaviorRegistry } from './registry-helpers';
 export { RegistryStack } from './registry-stack';
 export { isFormNode, isFieldNode, isGroupNode, isArrayNode, getNodeType } from './type-guards';
 export { FormErrorHandler, ErrorStrategy } from './error-handler';
-export { createForm } from './create-form';
+export { createForm, createFormFromModel } from './create-form';
+export type { CreateFormFromModelArgs } from './create-form';
+export { registerSignalNode, getNodeForSignal } from './signal-node-registry';
+export { markDerived, isDerived } from './derived-registry';
 export { uniqueId } from './unique-id';
 export { safeCallback, runOutsideEffect, safeDebouncedCallback } from './safe-effect';
 export { AbstractRegistry } from './abstract-registry';

package/dist/core/utils/signal-node-registry.d.ts

@@ -0,0 +1,12 @@
+import { Signal } from '@preact/signals-core';
+import { FormNode } from '../nodes/form-node';
+/**
+ * Связать сигнал модели с его FieldNode.
+ * @internal
+ */
+export declare function registerSignalNode(signal: Signal<any>, node: FormNode<any>): void;
+/**
+ * Получить FieldNode по сигналу модели (или undefined, если форма не построена/поле не материализовано,
+ * например элемент массива в родительской форме).
+ */
+export declare function getNodeForSignal(signal: Signal<any>): FormNode<any> | undefined;

package/dist/core/utils/type-guards.d.ts

@@ -48,8 +48,8 @@ export declare function isFieldNode(value: unknown): value is FieldNode<FormValu
 /**
  * Проверить, является ли значение GroupNode (объект с вложенными полями)
  *
- * GroupNode представляет объект с вложенными полями формы
- * и имеет методы для применения validation/behavior схем
+ * GroupNode представляет объект с вложенными полями формы: имеет навигацию по полям
+ * (`getFieldByPath`/`fields`) и НЕ имеет array-методов (`items`/`push`/`removeAt`).
  *
  * @param value - Значение для проверки
  * @returns true если value является GroupNode
@@ -57,7 +57,6 @@ export declare function isFieldNode(value: unknown): value is FieldNode<FormValu
  * @example
  * ```typescript
  * if (isGroupNode(node)) {
- *   node.applyValidationSchema(schema); //  OK
  *   node.getFieldByPath('user.email'); //  OK
  * }
  * ```

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

@@ -1,8 +1,3 @@
-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';
 export { min } from './validators/min';
 export { max } from './validators/max';
@@ -12,7 +7,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';
@@ -20,8 +19,3 @@ export { pastDate } from './validators/past-date';
 export { futureDate } from './validators/future-date';
 export { minAge } from './validators/min-age';
 export { maxAge } from './validators/max-age';
-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/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>;

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';

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>;