@reformer/core 1.0.0-beta.1

package/dist/core/behavior/behaviors/compute-from.d.ts

@@ -0,0 +1,70 @@
+import { FieldPathNode } from '../../types';
+import { ComputeFromOptions } from '../types';
+/**
+ * Автоматически вычисляет значение поля на основе других полей
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ *
+ * @param sources - Массив полей-зависимостей
+ * @param target - Поле для записи результата
+ * @param computeFn - Функция вычисления (принимает объект с именами полей)
+ * @param options - Опции (`debounce`, `condition`, `trigger`)
+ *
+ * @example Многополевой расчёт — total = price × quantity
+ * ```typescript
+ * import { computeFrom, type BehaviorSchemaFn } from '@reformer/core/behaviors';
+ *
+ * interface OrderForm {
+ *   price: number;
+ *   quantity: number;
+ *   total: number;
+ * }
+ *
+ * export const orderBehavior: BehaviorSchemaFn<OrderForm> = (path) => {
+ *   computeFrom(
+ *     [path.price, path.quantity],
+ *     path.total,
+ *     (values) =>
+ *       (typeof values.price === 'number' ? values.price : 0) *
+ *       (typeof values.quantity === 'number' ? values.quantity : 0),
+ *   );
+ * };
+ * ```
+ *
+ * @example Edge case — async-like дорогие вычисления с `debounce` и условием
+ * ```typescript
+ * import { computeFrom, type BehaviorSchemaFn } from '@reformer/core/behaviors';
+ *
+ * interface MortgageForm {
+ *   loanType: 'mortgage' | 'consumer';
+ *   loanAmount: number;
+ *   loanTerm: number;
+ *   interestRate: number;
+ *   monthlyPayment: number;
+ * }
+ *
+ * function annuity(values: MortgageForm): number {
+ *   const { loanAmount, loanTerm, interestRate } = values;
+ *   if (!loanAmount || !loanTerm || !interestRate) return 0;
+ *   const r = interestRate / 100 / 12;
+ *   const n = loanTerm;
+ *   return Math.round((loanAmount * r * Math.pow(1 + r, n)) / (Math.pow(1 + r, n) - 1));
+ * }
+ *
+ * export const mortgageBehavior: BehaviorSchemaFn<MortgageForm> = (path) => {
+ *   computeFrom(
+ *     [path.loanAmount, path.loanTerm, path.interestRate],
+ *     path.monthlyPayment,
+ *     annuity,
+ *     {
+ *       debounce: 300,                                  // не пересчитываем на каждый keystroke
+ *       condition: (form) => form.loanType === 'mortgage', // считаем только для ипотеки
+ *     },
+ *   );
+ * };
+ * ```
+ *
+ * @see [docs/llms/20-compute-vs-watch.md](../../../../docs/llms/20-compute-vs-watch.md)
+ */
+export declare function computeFrom<TForm, TTarget>(sources: FieldPathNode<TForm, any>[], target: FieldPathNode<TForm, TTarget>, computeFn: (values: TForm) => TTarget, options?: ComputeFromOptions<TForm>): void;

package/dist/core/behavior/behaviors/copy-from.d.ts

@@ -0,0 +1,56 @@
+import { FieldPathNode } from '../../types';
+import { CopyFromOptions } from '../types';
+/**
+ * Копирует значения из одного поля/группы в другое при выполнении условия
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ *
+ * @param source - Откуда копировать
+ * @param target - Куда копировать
+ * @param options - Опции копирования (`when`, `fields`, `transform`, `debounce`)
+ *
+ * @example Скаляр → скаляр с условием
+ * ```typescript
+ * import { copyFrom, type BehaviorSchemaFn } from '@reformer/core/behaviors';
+ *
+ * interface ContactForm {
+ *   sameEmail: boolean;
+ *   email: string;
+ *   emailAdditional: string;
+ * }
+ *
+ * export const contactBehavior: BehaviorSchemaFn<ContactForm> = (path) => {
+ *   copyFrom(path.email, path.emailAdditional, {
+ *     when: (form) => form.sameEmail === true,
+ *   });
+ * };
+ * ```
+ *
+ * @example Копирование группы с подмножеством полей и `transform`
+ * ```typescript
+ * import { copyFrom, type BehaviorSchemaFn } from '@reformer/core/behaviors';
+ *
+ * interface Address { country: string; region: string; city: string; street: string }
+ * interface ProfileForm {
+ *   sameAsRegistration: boolean;
+ *   registrationAddress: Address;
+ *   residenceAddress: Address;
+ * }
+ *
+ * export const profileBehavior: BehaviorSchemaFn<ProfileForm> = (path) => {
+ *   copyFrom(path.registrationAddress, path.residenceAddress, {
+ *     when: (form) => form.sameAsRegistration === true,
+ *     fields: ['country', 'region', 'city'], // street НЕ копируем
+ *     transform: (addr) => ({
+ *       ...addr,
+ *       country: addr.country.toUpperCase(), // нормализация при копировании
+ *     }),
+ *     debounce: 200,
+ *   });
+ * };
+ * ```
+ *
+ * @see [docs/llms/23-copy-from.md](../../../../docs/llms/23-copy-from.md)
+ */
+export declare function copyFrom<TForm, TSource, TTarget>(source: FieldPathNode<TForm, TSource>, target: FieldPathNode<TForm, TTarget>, options?: CopyFromOptions<TSource, TForm>): void;

package/dist/core/behavior/behaviors/enable-when.d.ts

@@ -0,0 +1,118 @@
+import { FieldPathNode } from '../../types';
+import { EnableWhenOptions } from '../types';
+/**
+ * Условное включение поля на основе значений других полей
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ *
+ * @param field - Поле для включения/выключения
+ * @param condition - Функция условия (true = enable, false = disable)
+ * @param options - Опции (`resetOnDisable`, `debounce`)
+ *
+ * @example Базовый сценарий с `resetOnDisable: true`
+ * ```typescript
+ * import { enableWhen, type BehaviorSchemaFn } from '@reformer/core/behaviors';
+ *
+ * interface LoanForm {
+ *   loanType: 'mortgage' | 'consumer' | 'car';
+ *   propertyValue: number;
+ *   initialPayment: number;
+ * }
+ *
+ * export const loanBehavior: BehaviorSchemaFn<LoanForm> = (path) => {
+ *   // Поля ипотеки активны только для loanType === 'mortgage'.
+ *   // resetOnDisable: true гарантирует чистые initial values при переключении.
+ *   enableWhen(path.propertyValue, (form) => form.loanType === 'mortgage', {
+ *     resetOnDisable: true,
+ *   });
+ *   enableWhen(path.initialPayment, (form) => form.loanType === 'mortgage', {
+ *     resetOnDisable: true,
+ *   });
+ * };
+ * ```
+ *
+ * @example Множественные independent условия + cycle prevention
+ * ```typescript
+ * import { enableWhen, type BehaviorSchemaFn } from '@reformer/core/behaviors';
+ *
+ * interface ProfileForm {
+ *   sameAsRegistration: boolean;
+ *   employmentStatus: 'employed' | 'selfEmployed' | 'unemployed';
+ *   residenceAddress: { city: string; street: string };
+ *   companyName: string;
+ *   companyInn: string;
+ *   businessType: string;
+ * }
+ *
+ * export const profileBehavior: BehaviorSchemaFn<ProfileForm> = (path) => {
+ *   // Адрес проживания: enabled, когда НЕ совпадает с регистрационным
+ *   enableWhen(path.residenceAddress, (form) => form.sameAsRegistration === false, {
+ *     resetOnDisable: true,
+ *   });
+ *
+ *   // Поля работодателя: только для employed
+ *   enableWhen(path.companyName, (form) => form.employmentStatus === 'employed', {
+ *     resetOnDisable: true,
+ *   });
+ *   enableWhen(path.companyInn, (form) => form.employmentStatus === 'employed', {
+ *     resetOnDisable: true,
+ *   });
+ *
+ *   // ИП-поля: только для selfEmployed
+ *   enableWhen(path.businessType, (form) => form.employmentStatus === 'selfEmployed', {
+ *     resetOnDisable: true,
+ *   });
+ *
+ *   // ВАЖНО: condition не должен читать значение САМОГО поля — иначе цикл.
+ *   // condition зависит ТОЛЬКО от независимых триггеров (loanType, employmentStatus, ...).
+ * };
+ * ```
+ *
+ * @see [docs/llms/22-cycle-detection.md](../../../../docs/llms/22-cycle-detection.md)
+ */
+export declare function enableWhen<TForm>(field: FieldPathNode<TForm, any>, condition: (form: TForm) => boolean, options?: EnableWhenOptions): void;
+/**
+ * Условное выключение поля (инверсия enableWhen)
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ *
+ * @param field - Поле для выключения
+ * @param condition - Функция условия (true = disable, false = enable)
+ * @param options - Опции (`resetOnDisable`, `debounce`)
+ *
+ * @example Базовый сценарий — readonly после подтверждения
+ * ```typescript
+ * import { disableWhen, type BehaviorSchemaFn } from '@reformer/core/behaviors';
+ *
+ * interface ConfirmForm {
+ *   isConfirmed: boolean;
+ *   editableField: string;
+ * }
+ *
+ * export const confirmBehavior: BehaviorSchemaFn<ConfirmForm> = (path) => {
+ *   // Поле блокируется после установки чекбокса подтверждения
+ *   disableWhen(path.editableField, (form) => form.isConfirmed === true);
+ *   // resetOnDisable НЕ ставим — сохраняем введённый текст
+ * };
+ * ```
+ *
+ * @example С `resetOnDisable` для очистки заблокированного поля
+ * ```typescript
+ * import { disableWhen, type BehaviorSchemaFn } from '@reformer/core/behaviors';
+ *
+ * interface PromoForm {
+ *   loanType: 'mortgage' | 'consumer';
+ *   promoCode: string;
+ * }
+ *
+ * export const promoBehavior: BehaviorSchemaFn<PromoForm> = (path) => {
+ *   // Промокод недоступен для потребительских кредитов и сбрасывается
+ *   disableWhen(path.promoCode, (form) => form.loanType === 'consumer', {
+ *     resetOnDisable: true,
+ *   });
+ * };
+ * ```
+ */
+export declare function disableWhen<TForm>(field: FieldPathNode<TForm, any>, condition: (form: TForm) => boolean, options?: EnableWhenOptions): void;

package/dist/core/behavior/behaviors/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Behavior rules
+ */
+export { copyFrom } from './copy-from';
+export { enableWhen, disableWhen } from './enable-when';
+export { computeFrom } from './compute-from';
+export { watchField } from './watch-field';
+export { revalidateWhen } from './revalidate-when';
+export { syncFields } from './sync-fields';
+export { resetWhen, type ResetWhenOptions } from './reset-when';
+export { transformValue, createTransformer, transformers, type TransformValueOptions, } from './transform-value';

package/dist/core/behavior/behaviors/reset-when.d.ts

@@ -0,0 +1,64 @@
+import { FieldPathNode, FormFields, FormValue } from '../../types';
+/**
+ * Опции для resetWhen
+ *
+ * @group Behaviors
+ * @category Behavior Types
+ */
+export interface ResetWhenOptions {
+    /** Значение для сброса (по умолчанию null) */
+    resetValue?: FormValue;
+    /** Сбросить только если поле dirty */
+    onlyIfDirty?: boolean;
+}
+/**
+ * Условный сброс поля при выполнении условия
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ *
+ * @param field - Поле для сброса
+ * @param condition - Функция условия (true = reset)
+ * @param options - Опции (`resetValue`, `onlyIfDirty`, `debounce`)
+ *
+ * @example Сброс зависимого поля при смене типа платежа
+ * ```typescript
+ * import { resetWhen, type BehaviorSchemaFn } from '@reformer/core/behaviors';
+ *
+ * interface CheckoutForm {
+ *   paymentType: 'card' | 'cash';
+ *   cardNumber: string;
+ * }
+ *
+ * export const checkoutBehavior: BehaviorSchemaFn<CheckoutForm> = (path) => {
+ *   // Когда выбрано НЕ card — обнуляем номер карты в пустую строку
+ *   resetWhen(path.cardNumber, (form) => form.paymentType !== 'card', {
+ *     resetValue: '',
+ *   });
+ * };
+ * ```
+ *
+ * @example `onlyIfDirty` — не трогаем нетронутые initial значения
+ * ```typescript
+ * import { resetWhen, type BehaviorSchemaFn } from '@reformer/core/behaviors';
+ *
+ * interface CarForm {
+ *   loanType: 'mortgage' | 'car' | 'consumer';
+ *   carPrice: number;
+ * }
+ *
+ * export const carBehavior: BehaviorSchemaFn<CarForm> = (path) => {
+ *   // Если пользователь не вводил carPrice — оставляем default из схемы.
+ *   // Сбрасываем только если поле dirty (была пользовательская правка).
+ *   resetWhen(path.carPrice, (form) => form.loanType !== 'car', {
+ *     resetValue: 0,
+ *     onlyIfDirty: true,
+ *   });
+ * };
+ * ```
+ *
+ * @see [docs/llms/25-reset-when.md](../../../../docs/llms/25-reset-when.md)
+ */
+export declare function resetWhen<TForm extends FormFields>(field: FieldPathNode<TForm, FormValue>, condition: (form: TForm) => boolean, options?: ResetWhenOptions & {
+    debounce?: number;
+}): void;

package/dist/core/behavior/behaviors/revalidate-when.d.ts

@@ -0,0 +1,53 @@
+import { FieldPathNode, FormValue } from '../../types';
+import { RevalidateWhenOptions } from '../types';
+/**
+ * Перевалидирует поле при изменении других полей
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ *
+ * @param target - Поле для перевалидации
+ * @param triggers - Поля-триггеры (НЕ должно содержать `target`)
+ * @param options - Опции (`debounce`)
+ *
+ * @example Парная перевалидация — confirmPassword при смене password
+ * ```typescript
+ * import { revalidateWhen, type BehaviorSchemaFn } from '@reformer/core/behaviors';
+ * import { equalTo } from '@reformer/core/validators';
+ * import type { FieldPath } from '@reformer/core';
+ *
+ * interface RegistrationForm { password: string; confirmPassword: string }
+ *
+ * export const validation = (path: FieldPath<RegistrationForm>) => {
+ *   equalTo(path.confirmPassword, path.password, { message: 'Пароли не совпадают' });
+ * };
+ *
+ * export const behavior: BehaviorSchemaFn<RegistrationForm> = (path) => {
+ *   // Если пользователь сначала ввёл confirm, потом меняет password —
+ *   // без revalidateWhen ошибка confirmPassword останется устаревшей.
+ *   revalidateWhen(path.confirmPassword, [path.password]);
+ * };
+ * ```
+ *
+ * @example Несколько триггеров + `debounce` для async-валидаторов
+ * ```typescript
+ * import { revalidateWhen, type BehaviorSchemaFn } from '@reformer/core/behaviors';
+ *
+ * interface MortgageForm {
+ *   propertyValue: number;
+ *   loanAmount: number;
+ *   initialPayment: number; // правило: initialPayment >= propertyValue * 0.2 - loanAmount
+ * }
+ *
+ * export const mortgageBehavior: BehaviorSchemaFn<MortgageForm> = (path) => {
+ *   revalidateWhen(
+ *     path.initialPayment,
+ *     [path.propertyValue, path.loanAmount],
+ *     { debounce: 300 }, // не дёргаем сервер на каждый keystroke
+ *   );
+ * };
+ * ```
+ *
+ * @see [docs/llms/27-revalidate-when.md](../../../../docs/llms/27-revalidate-when.md)
+ */
+export declare function revalidateWhen<TForm>(target: FieldPathNode<TForm, FormValue>, triggers: FieldPathNode<TForm, FormValue>[], options?: RevalidateWhenOptions): void;

package/dist/core/behavior/behaviors/sync-fields.d.ts

@@ -0,0 +1,48 @@
+import { FieldPathNode, FormFields, FormValue } from '../../types';
+import { SyncFieldsOptions } from '../types';
+/**
+ * Двусторонняя синхронизация двух полей
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ *
+ * @param field1 - Первое поле
+ * @param field2 - Второе поле
+ * @param options - Опции (`transform` асимметричен — применяется только field1 → field2; `debounce`)
+ *
+ * @example Базовый mirror двух текстовых полей
+ * ```typescript
+ * import { syncFields, type BehaviorSchemaFn } from '@reformer/core/behaviors';
+ *
+ * interface MirrorForm {
+ *   syncField1: string;
+ *   syncField2: string;
+ * }
+ *
+ * export const mirrorBehavior: BehaviorSchemaFn<MirrorForm> = (path) => {
+ *   syncFields(path.syncField1, path.syncField2);
+ * };
+ * ```
+ *
+ * @example С `transform` (асимметричный) и `debounce` для защиты от частых перезаписей
+ * ```typescript
+ * import { syncFields, type BehaviorSchemaFn } from '@reformer/core/behaviors';
+ *
+ * interface CodeForm {
+ *   internalCode: string;  // канонический формат
+ *   displayCode: string;   // показываем пользователю
+ * }
+ *
+ * export const codeBehavior: BehaviorSchemaFn<CodeForm> = (path) => {
+ *   // internalCode → displayCode: применяется toUpperCase
+ *   // displayCode → internalCode: пишется как есть
+ *   syncFields(path.internalCode, path.displayCode, {
+ *     transform: (value) => (typeof value === 'string' ? value.toUpperCase() : value),
+ *     debounce: 150, // сглаживает дёргание каретки
+ *   });
+ * };
+ * ```
+ *
+ * @see [docs/llms/24-sync-fields.md](../../../../docs/llms/24-sync-fields.md)
+ */
+export declare function syncFields<TForm extends FormFields, T extends FormValue>(field1: FieldPathNode<TForm, T>, field2: FieldPathNode<TForm, T>, options?: SyncFieldsOptions<T>): void;

package/dist/core/behavior/behaviors/transform-value.d.ts

@@ -0,0 +1,192 @@
+import { FieldPathNode, FormFields, FormValue } from '../../types';
+/**
+ * Опции для transformValue
+ *
+ * @group Behaviors
+ * @category Behavior Types
+ */
+export interface TransformValueOptions {
+    /** Трансформировать только при изменении пользователем (не программно) */
+    onUserChangeOnly?: boolean;
+    /** Триггерить событие изменения после трансформации */
+    emitEvent?: boolean;
+}
+/**
+ * Трансформация значения поля при изменении
+ * Позволяет автоматически форматировать или преобразовывать значения
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ *
+ * @param field - Поле для трансформации
+ * @param transformer - Функция трансформации (ОБЯЗАТЕЛЬНО идемпотентная: f(f(x)) === f(x))
+ * @param options - Опции (`onUserChangeOnly`, `emitEvent`, `debounce`)
+ *
+ * @example Базовая нормализация — uppercase + trim email
+ * ```typescript
+ * import { transformValue, type BehaviorSchemaFn } from '@reformer/core/behaviors';
+ *
+ * interface RegistrationForm {
+ *   promoCode: string;
+ *   email: string;
+ * }
+ *
+ * export const registrationBehavior: BehaviorSchemaFn<RegistrationForm> = (path) => {
+ *   // Идемпотентно: toUpperCase(toUpperCase(x)) === toUpperCase(x) ✓
+ *   transformValue(path.promoCode, (value) => (value ?? '').toUpperCase());
+ *   transformValue(path.email, (value) => (value ?? '').trim().toLowerCase());
+ * };
+ * ```
+ *
+ * @example `onUserChangeOnly` + idempotent guard для не-тривиальных форматов
+ * ```typescript
+ * import { transformValue, type BehaviorSchemaFn } from '@reformer/core/behaviors';
+ *
+ * interface ProfileForm {
+ *   inn: string; // ИНН — только цифры
+ *   prefixedCode: string; // должен иметь префикс "ID-"
+ * }
+ *
+ * export const profileBehavior: BehaviorSchemaFn<ProfileForm> = (path) => {
+ *   // Цифры из ИНН: трансформер идемпотентный естественно
+ *   transformValue(path.inn, (v) => (v ?? '').replace(/\D/g, ''));
+ *
+ *   // Префикс — ВАЖНО guard «уже преобразовано», иначе бесконечный цикл
+ *   // f("ID-123") должно === "ID-123", а не "ID-ID-123"
+ *   transformValue(
+ *     path.prefixedCode,
+ *     (v) => (v?.startsWith('ID-') ? v : `ID-${v ?? ''}`),
+ *     {
+ *       onUserChangeOnly: true, // не трогаем значение из patchValue/preload
+ *       debounce: 200,
+ *     },
+ *   );
+ * };
+ * ```
+ *
+ * @see [docs/llms/26-transform-value.md](../../../../docs/llms/26-transform-value.md)
+ */
+export declare function transformValue<TForm extends FormFields, TValue extends FormValue = FormValue>(field: FieldPathNode<TForm, TValue>, transformer: (value: TValue) => TValue, options?: TransformValueOptions & {
+    debounce?: number;
+}): void;
+/**
+ * Хелпер для создания переиспользуемых трансформаций
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ *
+ * @param transformer - Идемпотентная функция преобразования значения
+ * @param defaultOptions - Опции, применяемые ко всем вызовам созданного трансформера
+ *
+ * @example Доменно-специфичные трансформеры (банковский счёт, СНИЛС)
+ * ```typescript
+ * import { createTransformer, type BehaviorSchemaFn } from '@reformer/core/behaviors';
+ *
+ * // Сохраняем только цифры и форматируем СНИЛС: 000-000-000 00
+ * const formatSnils = createTransformer<string>((v) => {
+ *   const d = (v ?? '').replace(/\D/g, '').slice(0, 11);
+ *   if (d.length < 9) return d;
+ *   return `${d.slice(0, 3)}-${d.slice(3, 6)}-${d.slice(6, 9)}${d.length > 9 ? ' ' + d.slice(9) : ''}`;
+ * });
+ *
+ * interface ProfileForm { snils: string }
+ *
+ * export const profileBehavior: BehaviorSchemaFn<ProfileForm> = (path) => {
+ *   formatSnils(path.snils, { debounce: 100 });
+ * };
+ * ```
+ *
+ * @example С `defaultOptions` — единые настройки на серию полей
+ * ```typescript
+ * import { createTransformer, type BehaviorSchemaFn } from '@reformer/core/behaviors';
+ *
+ * // Все коды должны быть uppercase, но только после правки пользователем
+ * const upperOnUserEdit = createTransformer<string>(
+ *   (v) => (v ?? '').toUpperCase(),
+ *   { onUserChangeOnly: true, debounce: 100 },
+ * );
+ *
+ * interface PromoForm { promoCode: string; partnerCode: string }
+ *
+ * export const promoBehavior: BehaviorSchemaFn<PromoForm> = (path) => {
+ *   upperOnUserEdit(path.promoCode);
+ *   upperOnUserEdit(path.partnerCode);
+ * };
+ * ```
+ */
+export declare function createTransformer<TValue extends FormValue = FormValue>(transformer: (value: TValue) => TValue, defaultOptions?: TransformValueOptions): <TForm extends FormFields>(field: FieldPathNode<TForm, TValue>, options?: TransformValueOptions & {
+    debounce?: number;
+}) => void;
+/**
+ * Готовые трансформеры для частых случаев. Все идемпотентны и безопасны для повторного применения.
+ *
+ * @group Behaviors
+ * @category Behavior Rules
+ *
+ * @example Готовые трансформеры в схеме формы
+ * ```typescript
+ * import { transformers, type BehaviorSchemaFn } from '@reformer/core/behaviors';
+ *
+ * interface RegistrationForm {
+ *   username: string;
+ *   email: string;
+ *   promoCode: string;
+ *   inn: string;
+ *   amount: number;
+ * }
+ *
+ * export const behavior: BehaviorSchemaFn<RegistrationForm> = (path) => {
+ *   transformers.trim(path.username);
+ *   transformers.toLowerCase(path.email);
+ *   transformers.toUpperCase(path.promoCode);
+ *   transformers.digitsOnly(path.inn);
+ *   transformers.roundTo2(path.amount);
+ * };
+ * ```
+ *
+ * @example Композиция готовых трансформеров через createTransformer
+ * ```typescript
+ * import { createTransformer, type BehaviorSchemaFn } from '@reformer/core/behaviors';
+ *
+ * // trim + lowercase в одном трансформере (применяется как одна операция)
+ * const normalizeEmail = createTransformer<string>(
+ *   (v) => (v ?? '').trim().toLowerCase(),
+ * );
+ *
+ * interface ContactForm { email: string }
+ *
+ * export const contactBehavior: BehaviorSchemaFn<ContactForm> = (path) => {
+ *   normalizeEmail(path.email);
+ * };
+ * ```
+ */
+export declare const transformers: {
+    /** Перевести в верхний регистр */
+    toUpperCase: <TForm extends FormFields>(field: FieldPathNode<TForm, string, unknown>, options?: (TransformValueOptions & {
+        debounce?: number;
+    }) | undefined) => void;
+    /** Перевести в нижний регистр */
+    toLowerCase: <TForm extends FormFields>(field: FieldPathNode<TForm, string, unknown>, options?: (TransformValueOptions & {
+        debounce?: number;
+    }) | undefined) => void;
+    /** Удалить пробелы с краев */
+    trim: <TForm extends FormFields>(field: FieldPathNode<TForm, string, unknown>, options?: (TransformValueOptions & {
+        debounce?: number;
+    }) | undefined) => void;
+    /** Удалить все пробелы */
+    removeSpaces: <TForm extends FormFields>(field: FieldPathNode<TForm, string, unknown>, options?: (TransformValueOptions & {
+        debounce?: number;
+    }) | undefined) => void;
+    /** Оставить только цифры */
+    digitsOnly: <TForm extends FormFields>(field: FieldPathNode<TForm, string, unknown>, options?: (TransformValueOptions & {
+        debounce?: number;
+    }) | undefined) => void;
+    /** Округлить число */
+    round: <TForm extends FormFields>(field: FieldPathNode<TForm, number, unknown>, options?: (TransformValueOptions & {
+        debounce?: number;
+    }) | undefined) => void;
+    /** Округлить до 2 знаков после запятой */
+    roundTo2: <TForm extends FormFields>(field: FieldPathNode<TForm, number, unknown>, options?: (TransformValueOptions & {
+        debounce?: number;
+    }) | undefined) => void;
+};