@reformer/core 11.0.0-beta.1 → 11.0.0-beta.10

package/dist/form/nodes/group-node.d.ts

@@ -1,284 +0,0 @@
-import { Signal, ReadonlySignal } from '@preact/signals-core';
-import { FormNode, SetValueOptions } from './form-node';
-import { ValidationError, FieldStatus, FormSchema, GroupNodeConfig, FormValue } from '../types/index';
-import { FormProxy } from '../types/form-proxy';
-import { SubmitOptions, SubmitResult } from '../form-submitter';
-/**
- * GroupNode - узел для группы полей
- *
- * Создаётся из {@link FormSchema} (дерево field-конфигов). Обычно строится через `createForm`
- * (M1: `createForm({ model, schema })`); schema-валидация/behavior живут на слое модели
- * (`validateModel` из `@reformer/core/validation`, `computeFrom`/`enableWhen`/…), а не на ноде.
- *
- * @group Nodes
- *
- * @example
- * ```typescript
- * const form = new GroupNode({
- *   email: { valueSignal: model.$.email, component: Input },
- *   password: { valueSignal: model.$.password, component: Input },
- * });
- *
- * // Прямой доступ к полям через Proxy
- * const proxy = form.getProxy();
- * proxy.email.setValue('test@mail.com');
- * await proxy.validate();
- * console.log(proxy.valid.value);
- * ```
- */
-export declare class GroupNode<T> extends FormNode<T> {
-    id: `${string}-${string}-${string}-${string}-${string}`;
-    /**
-     * Коллекция полей формы (упрощённый Map вместо FieldRegistry)
-     */
-    private readonly _fields;
-    /**
-     * Менеджер подписок для централизованного cleanup
-     */
-    private disposers;
-    /**
-     * Ссылка на Proxy-инстанс
-     */
-    private _proxyInstance?;
-    /**
-     * Cleanup декларативной схемы поведения (createForm({ behavior })). Вызывается в dispose().
-     */
-    private _behaviorCleanup?;
-    /**
-     * Фабрика для создания узлов формы
-     */
-    private readonly nodeFactory;
-    /** Управление отправкой формы */
-    private readonly formSubmitter;
-    /** Флаг disabled состояния */
-    private readonly _disabled;
-    /** Form-level validation errors */
-    private readonly _formErrors;
-    /**
-     * M1: связь листовой ноды-ребёнка → её сигнал модели (тот, что помечает `markDerived`).
-     * Нужна bulk-сеттерам (`setValue`/`patchValue`), чтобы корректно определять derived-поля:
-     * `field.value` — computed-обёртка, отличная от записываемого сигнала модели. @internal
-     */
-    private readonly _fieldSignals;
-    readonly value: ReadonlySignal<T>;
-    readonly valid: ReadonlySignal<boolean>;
-    readonly invalid: ReadonlySignal<boolean>;
-    readonly touched: ReadonlySignal<boolean>;
-    readonly dirty: ReadonlySignal<boolean>;
-    readonly pending: ReadonlySignal<boolean>;
-    readonly errors: ReadonlySignal<ValidationError[]>;
-    readonly status: ReadonlySignal<FieldStatus>;
-    readonly submitting: ReadonlySignal<boolean>;
-    /**
-     * Создать GroupNode только со схемой формы (обратная совместимость)
-     */
-    constructor(schema: FormSchema<T>);
-    /**
-     * Создать GroupNode с полной конфигурацией (form, behavior, validation)
-     */
-    constructor(config: GroupNodeConfig<T>);
-    /**
-     * Создать Proxy для типобезопасного доступа к полям
-     * @see buildFormProxy
-     */
-    private buildProxy;
-    getValue(): T;
-    setValue(value: T, options?: SetValueOptions): void;
-    patchValue(value: Partial<T>): void;
-    /**
-     * Сбросить форму к указанным значениям (или к initialValues)
-     *
-     * @param value - опциональный объект со значениями для сброса
-     *
-     * @remarks
-     * Рекурсивно вызывает reset() для всех полей формы
-     *
-     * @example
-     * ```typescript
-     * // Сброс к initialValues
-     * form.reset();
-     *
-     * // Сброс к новым значениям
-     * form.reset({ email: 'new@mail.com', password: '' });
-     * ```
-     */
-    reset(value?: T): void;
-    /**
-     * Сбросить форму к исходным значениям (initialValues)
-     */
-    resetToInitial(): void;
-    validate(): Promise<boolean>;
-    /**
-     * Установить form-level validation errors
-     */
-    setErrors(errors: ValidationError[]): void;
-    /**
-     * Очистить все errors (form-level + field-level)
-     */
-    clearErrors(): void;
-    /**
-     * Получить поле по ключу
-     */
-    getField<K extends keyof T>(key: K): FormNode<T[K]> | undefined;
-    /**
-     * Получить Map всех полей формы (для совместимости)
-     */
-    get fields(): Map<keyof T, FormNode<FormValue>>;
-    /**
-     * Получить Proxy-инстанс для прямого доступа к полям
-     *
-     * Proxy позволяет обращаться к полям формы напрямую через точечную нотацию:
-     * - form.email вместо form.fields.get('email')
-     * - form.address.city вместо form.fields.get('address').fields.get('city')
-     *
-     * @returns Proxy-инстанс с типобезопасным доступом к полям или сама форма, если proxy не доступен
-     *
-     * @example
-     * ```typescript
-     * const form = new GroupNode({
-     *   email: { value: '', component: Input },
-     *   name: { value: '', component: Input },
-     * });
-     *
-     * const proxy = form.getProxy();
-     * console.log(proxy.email.value.value); // Прямой доступ к полю
-     * ```
-     */
-    getProxy(): FormProxy<T>;
-    /**
-     * Получить все поля формы как итератор
-     */
-    getAllFields(): IterableIterator<FormNode<FormValue>>;
-    protected onMarkAsTouched(): void;
-    protected onMarkAsUntouched(): void;
-    protected onMarkAsDirty(): void;
-    protected onMarkAsPristine(): void;
-    /**
-     * Отправить форму
-     *
-     * @param onSubmit - Callback для отправки данных
-     * @param options - Опции submit (skipValidation, skipTouch)
-     * @returns Результат от onSubmit или `null` если валидация не пройдена
-     *
-     * @remarks
-     * `null` перегружен: он означает и «валидация не пройдена», и легитимный `null`-результат
-     * `onSubmit` (или void-обработчик). Если вызывающей стороне нужно различать эти случаи —
-     * используйте {@link submitWithResult}, который возвращает явный флаг `success`.
-     */
-    submit<R>(onSubmit: (values: T) => Promise<R> | R, options?: SubmitOptions): Promise<R | null>;
-    /**
-     * Отправить форму с расширенным результатом
-     *
-     * @param onSubmit - Callback для отправки данных
-     * @param options - Опции submit
-     * @returns Объект SubmitResult с данными, статусом и возможной ошибкой
-     */
-    submitWithResult<R>(onSubmit: (values: T) => Promise<R> | R, options?: SubmitOptions): Promise<SubmitResult<R>>;
-    /**
-     * Получить вложенное поле по пути
-     *
-     * Поддерживаемые форматы путей:
-     * - Simple: "email" - получить поле верхнего уровня
-     * - Nested: "address.city" - получить вложенное поле
-     * - Array index: "items[0]" - получить элемент массива по индексу
-     * - Combined: "items[0].name" - получить поле элемента массива
-     *
-     * @param path - Путь к полю
-     * @returns FormNode если найдено, undefined если путь не существует
-     *
-     * @example
-     * ```typescript
-     * const form = new GroupNode({
-     *   email: { value: '', component: Input },
-     *   address: {
-     *     city: { value: '', component: Input }
-     *   },
-     *   items: [{ name: { value: '', component: Input } }]
-     * });
-     *
-     * form.getFieldByPath('email');           // FieldNode
-     * form.getFieldByPath('address.city');    // FieldNode
-     * form.getFieldByPath('items[0]');        // GroupNode
-     * form.getFieldByPath('items[0].name');   // FieldNode
-     * form.getFieldByPath('invalid.path');    // undefined
-     * ```
-     */
-    getFieldByPath(path: string): FormNode<FormValue> | undefined;
-    /**
-     * Создать узел на основе конфигурации
-     *
-     * ✅ РЕФАКТОРИНГ: Полное делегирование NodeFactory
-     *
-     * NodeFactory теперь обрабатывает:
-     * - Массивы [schema, ...items]
-     * - FieldConfig
-     * - GroupConfig
-     * - ArrayConfig
-     *
-     * @param config Конфигурация узла
-     * @returns Созданный узел формы
-     * @private
-     */
-    private createNode;
-    /**
-     * Связывает два поля: при изменении source автоматически обновляется target
-     */
-    linkFields<K1 extends keyof T, K2 extends keyof T>(sourceKey: K1, targetKey: K2, transform?: (value: T[K1]) => T[K2]): () => void;
-    /**
-     * Подписка на изменения вложенного поля по строковому пути
-     * Поддерживает вложенные пути типа "address.city"
-     *
-     * @param fieldPath - Строковый путь к полю (например, "address.city")
-     * @param callback - Функция, вызываемая при изменении поля
-     * @returns Функция отписки для cleanup
-     *
-     * @example
-     * ```typescript
-     * // Подписка на изменение страны для загрузки городов
-     * const dispose = form.watchField(
-     *   'registrationAddress.country',
-     *   async (countryCode) => {
-     *     if (countryCode) {
-     *       const cities = await fetchCitiesByCountry(countryCode);
-     *       form.registrationAddress.city.updateComponentProps({
-     *         options: cities
-     *       });
-     *     }
-     *   }
-     * );
-     *
-     * // Cleanup
-     * useEffect(() => dispose, []);
-     * ```
-     */
-    /** Подписка на top-level поле — value типизирован как `T[K]`. */
-    watchField<K extends keyof T & string>(fieldPath: K, callback: (value: T[K]) => void | Promise<void>): () => void;
-    /**
-     * Подписка на вложенное поле по строковому пути ("address.city").
-     * Путь нельзя выразить в типах узла → value честно `unknown`, потребитель сужает.
-     */
-    watchFieldByPath(path: string, callback: (value: unknown) => void | Promise<void>): () => void;
-    /**
-     * Hook: вызывается после disable()
-     */
-    protected onDisable(): void;
-    /**
-     * Hook: вызывается после enable()
-     */
-    protected onEnable(): void;
-    /**
-     * Прикрепить cleanup декларативной схемы поведения (вызывается createForm).
-     * @internal
-     */
-    attachBehaviorCleanup(cleanup: () => void): void;
-    /**
-     * Связать листовую ноду-ребёнка с её сигналом модели (M1). Вызывается `createForm` для каждого
-     * листового поля на его владеющей группе — используется bulk-сеттерами для derived-guard (F9).
-     * @internal
-     */
-    registerFieldSignal(node: FormNode<any>, signal: Signal<unknown>): void;
-    /**
-     * Очистить все ресурсы узла
-     */
-    dispose(): void;
-}

package/dist/form/nodes/model-array-node.d.ts

@@ -1,121 +0,0 @@
-import { Signal, ReadonlySignal } from '@preact/signals-core';
-import { FormNode } from './form-node';
-import { FieldStatus, ValidationError } from '../types/index';
-import { FormModel } from '../../state/types';
-import { FormProxy } from '../types/form-proxy';
-/** Минимальный контракт реактивного массива модели, используемый узлом. */
-export interface ModelArrayControl<TItem extends object> {
-    readonly length: number;
-    at(index: number): FormModel<TItem> | undefined;
-    push(item: TItem): void;
-    insertAt(index: number, item: TItem): void;
-    removeAt(index: number): void;
-    move(from: number, to: number): void;
-    swap(a: number, b: number): void;
-    clear(): void;
-    toArray(): TItem[];
-}
-/**
- * Узел массива, делегирующий данные массиву {@link FormModel} (архитектура M1).
- *
- * В отличие от {@link ArrayNode} (владеет элементами сам), `ModelArrayNode` НЕ владеет данными:
- * массив принадлежит модели, а узел держит per-item формы элементов (привязанные к сигналам
- * под-моделей) и синхронизирует их с длиной массива модели. Мутации (`push`/`removeAt`/`move`/…)
- * делегируются массиву модели; per-item формы кэшируются по идентичности под-модели, поэтому при
- * reorder/повторном рендере не пересоздаются (состояние и валидация сохраняются). Реализует тот же
- * контракт, что ждут секции массива и `useFormControl` (`length`/`value`/`valid`/`errors`/`at`/`push`/…).
- *
- * Обычно создаётся не напрямую, а `createForm({ model, schema })`: когда в схеме встречается узел
- * массива `{ array: model.<field>, item: (item) => itemSchema }`, форма материализует его как
- * `ModelArrayNode` и кладёт под `form.<field>` (совместим с `FormArraySection`).
- *
- * @group Nodes
- *
- * @example Массив как часть формы (через createForm)
- * ```typescript
- * const model = createModel<{ rows: { name: string; qty: number }[] }>({ rows: [] });
- *
- * const rowItem = (item: FormModel<{ name: string; qty: number }>) => ({
- *   name: { value: item.$.name, component: Input },
- *   qty: { value: item.$.qty, component: Input },
- * });
- *
- * const form = createForm({
- *   model,
- *   schema: {
- *     children: [{ array: model.rows, item: rowItem }],
- *   },
- * });
- *
- * const rows = form.rows as unknown as ModelArrayNode<{ name: string; qty: number }>;
- * rows.push({ name: 'A', qty: 1 });   // мутация уезжает в model.rows
- * rows.at(0)?.name.setValue('B');     // правка поля элемента доезжает в под-модель
- * rows.length.value;                  // 1 (реактивная длина)
- * ```
- */
-export declare class ModelArrayNode<T extends object> extends FormNode<T[]> {
-    private readonly control;
-    private readonly buildItem;
-    private readonly itemNodes;
-    private readonly cache;
-    private mountedModels;
-    private readonly initial;
-    private readonly _arrayErrors;
-    private readonly disposeSync;
-    /**
-     * Сигнал per-item форм. Публичен в т.ч. чтобы `isArrayNode` распознавал узел как массив
-     * (duck-typing проверяет наличие `items`).
-     */
-    get items(): Signal<FormProxy<T>[]>;
-    readonly value: ReadonlySignal<T[]>;
-    readonly valid: ReadonlySignal<boolean>;
-    readonly invalid: ReadonlySignal<boolean>;
-    readonly pending: ReadonlySignal<boolean>;
-    readonly touched: ReadonlySignal<boolean>;
-    readonly dirty: ReadonlySignal<boolean>;
-    readonly errors: ReadonlySignal<ValidationError[]>;
-    readonly status: ReadonlySignal<FieldStatus>;
-    readonly length: ReadonlySignal<number>;
-    /**
-     * @param control Реактивный массив модели (`model.<path>`).
-     * @param buildItem Строитель формы элемента по его под-модели (инъекция, чтобы избежать цикла
-     *   импорта с `create-form`). Обычно `(item) => createForm({ model: item, schema: itemSchema(item) })`.
-     */
-    constructor(control: ModelArrayControl<T>, buildItem: (item: FormModel<T>) => FormProxy<T>);
-    at(index: number): FormProxy<T> | undefined;
-    map<R>(fn: (item: FormProxy<T>, index: number) => R): R[];
-    forEach(fn: (item: FormProxy<T>, index: number) => void): void;
-    push(item?: Partial<T>): void;
-    insert(index: number, item?: Partial<T>): void;
-    removeAt(index: number): void;
-    /**
-     * Переместить элемент модель-массива. Делегирует мутацию массиву модели; внутренний `effect`
-     * пересоберёт `itemNodes` в новом порядке (per-item формы сохраняются по кешу идентичности).
-     */
-    move(from: number, to: number): void;
-    /** Поменять местами два элемента модель-массива (см. {@link move}). */
-    swap(a: number, b: number): void;
-    clear(): void;
-    getValue(): T[];
-    setValue(values: T[]): void;
-    patchValue(values: Partial<T[]>): void;
-    reset(values?: T[]): void;
-    resetToInitial(): void;
-    validate(): Promise<boolean>;
-    setErrors(errors: ValidationError[]): void;
-    clearErrors(): void;
-    protected onMarkAsTouched(): void;
-    protected onMarkAsUntouched(): void;
-    protected onMarkAsDirty(): void;
-    protected onMarkAsPristine(): void;
-    protected onDisable(): void;
-    protected onEnable(): void;
-    /** Диспозит форму элемента (эффекты/поведения/вложенные подписки); терпима к не-GroupNode. */
-    private disposeItemNode;
-    /**
-     * Очистка подписки синхронизации И детерминированный teardown всех форм элементов.
-     * Без пробрасывания dispose в itemNodes эффекты/поведения каждой формы элемента (в т.ч. disposeSync
-     * вложенных ModelArrayNode) остались бы жить после teardown формы — утечка подписок.
-     */
-    dispose(): void;
-}

package/dist/form/status-machine.d.ts

@@ -1,115 +0,0 @@
-import { ReadonlySignal } from '@preact/signals-core';
-import { FieldStatus } from './types/index';
-/**
- * FormStatusMachine - управляет состоянием поля формы
- *
- * Предоставляет:
- * - Единый источник истины для статуса
- * - Computed signals для derived состояний (valid, invalid, pending, disabled)
- * - Валидацию переходов между состояниями
- *
- * @example
- * ```typescript
- * const statusMachine = new FormStatusMachine('valid');
- *
- * // Начало валидации
- * statusMachine.startValidation();
- * console.log(statusMachine.pending.value); // true
- *
- * // Завершение валидации с ошибками
- * statusMachine.completeValidation(true);
- * console.log(statusMachine.invalid.value); // true
- *
- * // Отключение поля
- * statusMachine.disable();
- * console.log(statusMachine.disabled.value); // true
- * ```
- */
-export declare class FormStatusMachine {
-    /** Внутренний сигнал статуса */
-    private readonly _status;
-    /** Публичный read-only сигнал статуса */
-    readonly status: ReadonlySignal<FieldStatus>;
-    /** Поле валидно */
-    readonly valid: ReadonlySignal<boolean>;
-    /** Поле невалидно */
-    readonly invalid: ReadonlySignal<boolean>;
-    /** Идет валидация */
-    readonly pending: ReadonlySignal<boolean>;
-    /** Поле отключено */
-    readonly disabled: ReadonlySignal<boolean>;
-    /**
-     * @param initial - Начальный статус (по умолчанию 'valid')
-     */
-    constructor(initial?: FieldStatus);
-    /**
-     * Начать валидацию
-     *
-     * Переводит статус в 'pending' если поле не отключено
-     *
-     * @example
-     * ```typescript
-     * statusMachine.startValidation();
-     * // status: 'pending'
-     * ```
-     */
-    startValidation(): void;
-    /**
-     * Завершить валидацию
-     *
-     * @param hasErrors - Есть ли ошибки валидации
-     *
-     * @example
-     * ```typescript
-     * // Валидация успешна
-     * statusMachine.completeValidation(false);
-     * // status: 'valid'
-     *
-     * // Есть ошибки
-     * statusMachine.completeValidation(true);
-     * // status: 'invalid'
-     * ```
-     */
-    completeValidation(hasErrors: boolean): void;
-    /**
-     * Установить ошибки напрямую (без перехода через pending)
-     *
-     * Используется для синхронной валидации или установки ошибок извне
-     *
-     * @param hasErrors - Есть ли ошибки
-     *
-     * @example
-     * ```typescript
-     * statusMachine.setErrors(true);
-     * // status: 'invalid'
-     * ```
-     */
-    setErrors(hasErrors: boolean): void;
-    /**
-     * Отключить поле
-     *
-     * Переводит статус в 'disabled'
-     *
-     * @example
-     * ```typescript
-     * statusMachine.disable();
-     * // status: 'disabled'
-     * ```
-     */
-    disable(): void;
-    /**
-     * Включить поле
-     *
-     * @param hasErrors - Есть ли ошибки (определяет valid/invalid)
-     *
-     * @example
-     * ```typescript
-     * statusMachine.enable(false);
-     * // status: 'valid'
-     *
-     * statusMachine.enable(true);
-     * // status: 'invalid'
-     * ```
-     */
-    enable(hasErrors?: boolean): void;
-}

package/dist/form/types/deep-schema.d.ts

@@ -1,107 +0,0 @@
-import { ComponentType } from 'react';
-import { Signal } from '@preact/signals-core';
-import { ValidatorFn, AsyncValidatorFn, AnyFunction } from './index';
-/**
- * Конфигурация поля
- * @group Types
- * @category Configuration Types
- * @remarks
- * В схеме `createForm({ model, schema })` лист связывают через **`value: model.$.field`**: harvest
- * ловит узел по идентичности `Signal` (`node.value instanceof Signal` — см. `create-form.ts`) и
- * нормализует его в `valueSignal`. Писать `valueSignal:` **в самой схеме `createForm` нельзя** —
- * harvest его не подхватит (проверка идёт по `node.value`), и `component`/`componentProps` этого
- * узла молча отбросятся. `value`/`valueSignal` на прямом FieldNode-конфиге — это
- * post-normalization / legacy-слой, а не форма записи в схеме `createForm`.
- */
-export interface FieldConfig<T> {
-    /**
-     * Начальное значение-литерал (legacy-путь). Под архитектурой M1 значение приходит из
-     * {@link FieldConfig.valueSignal} (сигнал {@link FormModel}); тогда `value` не требуется.
-     */
-    value?: T | null;
-    /**
-     * Сигнал значения из {@link FormModel} (M1). Если задан — служит источником истины значения
-     * поля (нода не владеет значением, а ссылается на этот сигнал). Имеет приоритет над `value`.
-     */
-    valueSignal?: Signal<T>;
-    /**
-     * UI-компонент поля. Опционален: core-часть можно использовать без ссылки на компонент
-     * (значение/валидация работают без UI; компонент нужен только для рендеринга).
-     */
-    component?: ComponentType<any>;
-    componentProps?: any;
-    validators?: ValidatorFn<T>[];
-    asyncValidators?: AsyncValidatorFn<T>[];
-    disabled?: boolean;
-    updateOn?: 'change' | 'blur' | 'submit';
-    /** Задержка (в мс) перед запуском асинхронной валидации */
-    debounce?: number;
-}
-/**
- * «Хотя бы одно поле обязано присутствовать»: превращает объект со всеми опциональными
- * свойствами в объединение вариантов, где ровно один ключ обязателен, а остальные опциональны.
- * Пустой объект `{}` не assignable ни к одному варианту и потому отклоняется.
- *
- * @internal
- */
-type RequireAtLeastOne<T> = {
-    [K in keyof T]-?: Required<Pick<T, K>> & Partial<Omit<T, K>>;
-}[keyof T];
-/**
- * {@link FieldConfig}, из которого нельзя сделать пустой `{}`.
- *
- * Все свойства {@link FieldConfig} опциональны, поэтому в {@link FormSchema} опечатка вида
- * `{ email: {} }` молча проходит проверку типов и в рантайме становится пустой подгруппой
- * вместо поля. `NonEmptyFieldConfig` требует наличия хотя бы одного свойства (value/valueSignal/
- * component/validators/…), оставляя каждое из них опциональным по отдельности.
- *
- * @internal
- */
-type NonEmptyFieldConfig<T> = RequireAtLeastOne<FieldConfig<T>>;
-/**
- * **Data-shaped** конфиг формы: ключи повторяют структуру данных `T`, значения — {@link FieldConfig}
- * (или вложенный `FormSchema`). Форма конфига, из которой строится {@link GroupNode}.
- * - `T[] -> [FormSchema<T>]` (массив с одним элементом)
- * - `object -> FormSchema<T>` (группа)
- * - `primitive -> FieldConfig<T>` (поле)
- *
- * Использует NonNullable для корректной обработки опциональных полей.
- *
- * ⚠️ Не путать с {@link FormSchemaNode} — тот описывает **узел дерева** M1-схемы (лист/массив/
- * контейнер), передаваемой в `createForm({ model, schema })`. `FormSchema` — это data-shaped конфиг
- * (ключи = поля данных), а не узел дерева.
- *
- * @group Types
- * @category Configuration Types
- *
- * @example
- * ```typescript
- * interface Form {
- *   name: string;                    // → FieldConfig<string>
- *   address: {                       // → FormSchema<Address>
- *     city: string;
- *     street: string;
- *   };
- *   items?: Array<{                  // → [FormSchema<Item>] (опциональный)
- *     title: string;
- *     price: number;
- *   }>;
- * }
- *
- * const schema: FormSchema<Form> = {
- *   name: { value: '', component: Input },
- *   address: {
- *     city: { value: '', component: Input },
- *     street: { value: '', component: Input },
- *   },
- *   items: [{
- *     title: { value: '', component: Input },
- *     price: { value: 0, component: Input },
- *   }],
- * };
- * ```
- */
-export type FormSchema<T> = {
-    [K in keyof T]: NonNullable<T[K]> extends string | number | boolean ? NonEmptyFieldConfig<T[K]> : NonNullable<T[K]> extends Array<infer U> ? U extends string | number | boolean ? NonEmptyFieldConfig<T[K]> : U extends Date | File | Blob | AnyFunction ? NonEmptyFieldConfig<T[K]> : [FormSchema<U>] : NonNullable<T[K]> extends Date | File | Blob | AnyFunction ? NonEmptyFieldConfig<T[K]> : FormSchema<NonNullable<T[K]>>;
-};
-export {};