@movk/nuxt 1.1.2 → 1.3.0

package/dist/runtime/types/api/response.d.ts

@@ -0,0 +1,62 @@
+import type { Toast } from '@nuxt/ui/composables';
+declare module 'ofetch' {
+    interface FetchOptions {
+        context?: ApiFetchContext;
+    }
+}
+/**
+ * API 请求扩展上下文
+ * @description 通过 fetch options 的 context 字段传递的额外配置
+ */
+export interface ApiFetchContext {
+    /** Toast 提示配置，设置为 false 禁用提示 */
+    toast?: RequestToastOptions | false;
+    /**
+     * 是否跳过业务状态码检查
+     * @description 仅跳过 code 校验，**仍按 dataKey 解包**业务数据。与 skipUnwrap 正交。
+     */
+    skipBusinessCheck?: boolean;
+    /**
+     * 是否跳过数据解包
+     * @description 为 true 时拦截器不重写 response._data，调用方拿到原始响应。与 skipBusinessCheck 正交。
+     */
+    skipUnwrap?: boolean;
+}
+/**
+ * 请求级别的 Toast 提示选项
+ * @description 用于单个请求的 Toast 配置，可覆盖全局配置
+ */
+export interface RequestToastOptions {
+    /** 成功提示配置，设置为 false 禁用成功提示 */
+    success?: Partial<Toast> | false;
+    /** 错误提示配置，设置为 false 禁用错误提示 */
+    error?: Partial<Toast> | false;
+    /** 自定义成功消息 */
+    successMessage?: string;
+    /** 自定义错误消息 */
+    errorMessage?: string;
+}
+/**
+ * API 响应数据结构
+ * @description 字段名通过 ApiResponseConfig 的 codeKey/messageKey/dataKey 配置化读取
+ */
+export interface ApiResponse {
+    code?: number | string;
+    message?: string;
+    msg?: string;
+    data?: unknown;
+    status?: number;
+    [key: string]: unknown;
+}
+/**
+ * API 错误对象
+ * @description 扩展标准 Error，包含业务响应和状态码信息
+ */
+export interface ApiError extends Error {
+    /** HTTP 或业务状态码 */
+    statusCode?: number;
+    /** 原始 API 响应数据 */
+    response?: ApiResponse;
+    /** 是否为业务逻辑错误（非 HTTP 错误） */
+    isBusinessError: boolean;
+}

package/dist/runtime/types/api/transfer.d.ts

@@ -0,0 +1,32 @@
+import type { MovkApiEndpointName } from './fetch';
+import type { ApiError, RequestToastOptions } from './response';
+/**
+ * 传输状态
+ * @description idle 初始；pending 进行中；success 成功；error 失败；aborted 已中止
+ */
+export type TransferStatus = 'idle' | 'pending' | 'success' | 'error' | 'aborted';
+/**
+ * 传输结果（命令式调用返回值）
+ * @description data/error 二选一；aborted 标记是否被 abort 取消
+ */
+export interface TransferResult<T = unknown> {
+    /** 业务数据（已按 dataKey 解包）；失败或中止时为 null */
+    data: T | null;
+    /** 错误对象；成功或中止时为 null */
+    error: ApiError | Error | null;
+    /** 是否因调用方主动 abort 而结束 */
+    aborted: boolean;
+}
+/**
+ * 传输请求公共选项
+ */
+export interface TransferRequestOptions {
+    /** 端点名称，未指定时使用 defaultEndpoint */
+    endpoint?: MovkApiEndpointName;
+    /** 额外的请求头（覆盖同名 auth 头） */
+    headers?: Record<string, string>;
+    /** Toast 配置，设置为 false 整体禁用 */
+    toast?: RequestToastOptions | false;
+    /** 跳过业务码校验（仍按 dataKey 解包），与 useApiFetch.skipBusinessCheck 同义 */
+    skipBusinessCheck?: boolean;
+}

package/dist/runtime/types/app.config.d.ts

@@ -0,0 +1,6 @@
+declare module '#build/app.config' {
+  import type { AppConfig } from '@nuxt/schema'
+
+  const _default: AppConfig
+  export default _default
+}

package/dist/runtime/types/auto-form/base.d.ts

@@ -0,0 +1,26 @@
+import type { FormProps } from '@nuxt/ui';
+import type { z } from 'zod';
+import type { OmitByKey } from '@movk/core';
+import type { AutoFormControls } from './controls';
+import type { ZodAutoFormFieldMeta } from '../zod';
+import type { ClassNameValue } from '../shared';
+export interface BaseAutoFormProps<S extends z.ZodObject, T extends boolean = true, N extends boolean = false> extends /** @vue-ignore */ OmitByKey<FormProps<S, T, N>, 'schema' | 'state' | 'loadingAuto' | 'validateOn' | 'ui'> {
+    /** Zod 对象 schema，定义表单字段 */
+    schema: S;
+    /** 自定义控件映射 */
+    controls?: AutoFormControls;
+    /** 全局字段元数据配置 */
+    globalMeta?: ZodAutoFormFieldMeta;
+    /**
+     * 是否启用自动 loading 功能。
+     * @defaultValue true
+     */
+    loadingAuto?: FormProps<S, T, N>['loadingAuto'];
+    /**
+     * 表单验证时机，详见 UForm 的 validateOn 属性
+     * @defaultValue []
+     */
+    validateOn?: FormProps<S, T, N>['validateOn'];
+    class?: ClassNameValue;
+    ui?: Record<string, ClassNameValue>;
+}

package/dist/runtime/types/auto-form/component.d.ts

@@ -0,0 +1,28 @@
+import type { ButtonProps, FormProps, FormSubmitEvent, FormData, FormErrorEvent } from '@nuxt/ui';
+import type { z } from 'zod';
+import type { BaseAutoFormProps } from './base';
+import type { AutoFormSlotProps, DynamicFormSlots } from './slots';
+import type { VNode } from 'vue';
+export interface AutoFormProps<S extends z.ZodObject = z.ZodObject, T extends boolean = true, N extends boolean = false> extends BaseAutoFormProps<S, T, N> {
+    /** 表单的状态对象。 */
+    state?: FormProps<S, T, N>['state'];
+    /**
+     * 是否显示默认提交按钮
+     * @defaultValue true
+     */
+    submit?: boolean;
+    /** 提交按钮属性 */
+    submitButtonProps?: ButtonProps;
+    /** 数组字段添加按钮属性 */
+    addButtonProps?: ButtonProps;
+}
+export type AutoFormSubmitHandler<S extends z.ZodObject, T extends boolean = true> = (event: FormSubmitEvent<FormData<S, T>>) => void;
+export type AutoFormErrorHandler = (event: FormErrorEvent) => void;
+export interface AutoFormEmits {
+    error: [FormErrorEvent];
+}
+export type AutoFormSlots<T extends object> = {
+    header(props: AutoFormSlotProps<T>): VNode[];
+    footer(props: AutoFormSlotProps<T>): VNode[];
+    submit(props: AutoFormSlotProps<T>): VNode[];
+} & DynamicFormSlots<T>;

package/dist/runtime/types/auto-form/controls.d.ts

@@ -0,0 +1,45 @@
+import type { z } from 'zod';
+import type { ComponentProps, ComponentSlots, IsComponent, ReactiveValue } from '@movk/core';
+import type { ClassNameValue } from '../shared';
+import type { ZodAutoFormFieldMeta } from '../zod';
+import type { AutoFormFieldContext } from './fields';
+/** 幻影类型哨兵：标记 P/S 未被覆写 */
+export type _Unset = {
+    readonly __brand: 'AutoFormControlUnset';
+};
+export interface AutoFormControl<C extends IsComponent = IsComponent, _P = _Unset, _S = _Unset> {
+    component: C;
+    controlProps?: ComponentProps<C>;
+    controlSlots?: Partial<ComponentSlots<C>>;
+}
+export type AutoFormControlProps = Partial<Record<string, unknown>>;
+export type AutoFormControlSlots = Partial<Record<string, unknown>>;
+export type AutoFormControls = Record<string, AutoFormControl<IsComponent, AutoFormControlProps, AutoFormControlSlots>>;
+export interface AutoFormControlsMeta<C extends IsComponent = IsComponent> {
+    type?: string;
+    component?: C;
+    controlProps?: ReactiveValue<ComponentProps<C>, AutoFormFieldContext>;
+    controlSlots?: ReactiveValue<Partial<ComponentSlots<C>>, AutoFormFieldContext> | Record<string, unknown>;
+    error?: string;
+}
+export interface AutoFormRuntimeControlsMeta {
+    type?: string;
+    component?: IsComponent;
+    controlProps?: ReactiveValue<AutoFormControlProps, AutoFormFieldContext>;
+    controlSlots?: ReactiveValue<AutoFormControlSlots, AutoFormFieldContext> | Record<string, unknown>;
+    error?: string;
+}
+export interface AutoFormLayoutConfig<C extends IsComponent = IsComponent> {
+    component?: C;
+    props?: ReactiveValue<ComponentProps<C>, AutoFormFieldContext>;
+    class?: ReactiveValue<ClassNameValue, AutoFormFieldContext>;
+    slots?: ReactiveValue<Partial<ComponentSlots<C>>, AutoFormFieldContext>;
+    fields: Record<string, z.ZodType>;
+    fieldSlot?: ReactiveValue<keyof ComponentSlots<C> & string, AutoFormFieldContext>;
+    fieldSlots?: ReactiveValue<Partial<Record<string, keyof ComponentSlots<C> & string>>, AutoFormFieldContext>;
+}
+export type AutoFormMergeMeta = ZodAutoFormFieldMeta & AutoFormRuntimeControlsMeta & {
+    mapped?: AutoFormControl;
+    layout?: AutoFormLayoutConfig;
+    overwrite?: AutoFormRuntimeControlsMeta;
+};

package/dist/runtime/types/auto-form/fields.d.ts

@@ -0,0 +1,68 @@
+import type { CollapsibleRootProps } from 'reka-ui';
+import type { ClassNameValue } from '../shared';
+import type { GetFieldValue } from '@movk/core';
+type FieldValueType<S, P extends string> = P extends string ? (string extends P ? S[keyof S] : GetFieldValue<S, P>) : S[keyof S];
+type NonUndefinedFieldValue<S, P extends string> = Exclude<FieldValueType<S, P>, undefined>;
+type RelativePath<T> = T extends readonly any[] ? string : T extends Record<string, any> ? Extract<keyof T, string> : string;
+type _SetValueRelKey<S, P extends string> = RelativePath<NonUndefinedFieldValue<S, P>>;
+export interface AutoFormFieldContext<S = any, P extends string = string> {
+    readonly state: S;
+    readonly path: P;
+    readonly value: FieldValueType<S, P>;
+    /**
+     * @example
+     * setValue({ name: '张三', email: 'test@example.com' })  // 设置整个对象
+     * setValue('name', '张三')  // key 自动推断
+     * setValue('[0].title', '新标题')  // 数组索引路径
+     */
+    setValue: {
+        (value: FieldValueType<S, P>): void;
+        <K extends _SetValueRelKey<S, P>>(relativePath: K extends never ? string : K, value: any): void;
+        (relativePath: string, value: any): void;
+    };
+    readonly errors: unknown[];
+    readonly loading: boolean;
+    readonly open?: boolean;
+    readonly count?: number;
+}
+export interface ResolvedAutoFormFieldContext {
+    readonly state: Record<string, any>;
+    readonly path: string;
+    readonly value: any;
+    setValue: (valueOrPathOrUpdater: any, value?: any) => void;
+    readonly errors: unknown[];
+    readonly loading: boolean;
+    readonly open?: boolean;
+    readonly count?: number;
+    readonly extraProps?: Record<string, unknown>;
+}
+export interface AutoFormFieldSlots {
+    label: (props: {
+        label?: string;
+    } & AutoFormFieldContext) => unknown;
+    hint: (props: {
+        hint?: string;
+    } & AutoFormFieldContext) => unknown;
+    description: (props: {
+        description?: string;
+    } & AutoFormFieldContext) => unknown;
+    help: (props: {
+        help?: string;
+    } & AutoFormFieldContext) => unknown;
+    error: (props: {
+        error?: boolean | string;
+    } & AutoFormFieldContext) => unknown;
+    default: (props: {
+        error?: boolean | string;
+    } & AutoFormFieldContext) => unknown;
+}
+export interface AutoFormNestedCollapsible extends Pick<CollapsibleRootProps, 'defaultOpen' | 'open' | 'disabled' | 'unmountOnHide'> {
+    enabled?: boolean;
+    as?: unknown;
+    class?: unknown;
+    ui?: {
+        root?: ClassNameValue;
+        content?: ClassNameValue;
+    };
+}
+export {};

package/dist/runtime/types/auto-form/index.d.ts

@@ -0,0 +1,7 @@
+export type { AutoFormFieldContext, AutoFormFieldSlots, AutoFormNestedCollapsible, ResolvedAutoFormFieldContext } from './fields';
+export type { AutoFormControl, AutoFormControlProps, AutoFormControlSlots, AutoFormControls, AutoFormLayoutConfig, AutoFormMergeMeta } from './controls';
+export type { AutoFormField, AutoFormSlotProps, DynamicFormSlots } from './slots';
+export type { TypedZodFactory } from './zod-factory';
+export type { BaseAutoFormProps } from './base';
+export type { AutoFormEmits, AutoFormProps, AutoFormSlots, AutoFormErrorHandler, AutoFormSubmitHandler } from './component';
+export type { SearchFormEmits, SearchFormProps, SearchFormSlots, SearchFormAction, SearchFormSlotProps } from './search-form';

package/dist/runtime/types/auto-form/search-form.d.ts

@@ -0,0 +1,84 @@
+import type { ButtonProps, FormError, FormErrorEvent, IconProps, InferInput } from '@nuxt/ui';
+import type { z } from 'zod';
+import type { Suggest } from '@movk/core';
+import type { BaseAutoFormProps } from './base';
+import type { DynamicFormSlots } from './slots';
+import type { VNode } from 'vue';
+export interface SearchFormSlotProps<S extends z.ZodObject> {
+    expanded: boolean;
+    loading: boolean;
+    state: Partial<InferInput<S>>;
+    errors: FormError[];
+    toggle: () => void;
+    search: () => void;
+    reset: () => void;
+    clear: () => void;
+}
+export interface SearchFormAction extends /** @vue-ignore */ Omit<ButtonProps, 'onClick'> {
+    key: Suggest<'search' | 'reset'>;
+    label?: string;
+    visible?: boolean | ((ctx: SearchFormSlotProps<z.ZodObject>) => boolean);
+    onClick?: (ctx: SearchFormSlotProps<z.ZodObject>) => void;
+}
+export interface SearchFormProps<S extends z.ZodObject> extends BaseAutoFormProps<S> {
+    /**
+     * 网格列数
+     * @defaultValue 3
+     */
+    cols?: number | {
+        sm?: number;
+        md?: number;
+        lg?: number;
+        xl?: number;
+    };
+    /**
+     * 可见行数（折叠时显示的行数）
+     * @defaultValue 1
+     */
+    visibleRows?: number;
+    /**
+     * 动作按钮配置；不传时使用默认 [search, reset]；传 [] 则关闭所有内置按钮
+     * @defaultValue [{ key: 'search', ... }, { key: 'reset', ... }]
+     */
+    actions?: SearchFormAction[];
+    /** 搜索按钮加载状态（作用于 type==='submit' 或 key==='search' 的按钮） */
+    loading?: boolean;
+    /** 收起按钮属性 */
+    collapseButtonProps?: ButtonProps;
+    /**
+     * 展开/收起按钮图标
+     * @IconifyIcon
+     * @defaultValue 'i-lucide-chevron-down'
+     */
+    icon?: IconProps['name'];
+    /**
+     * 展开按钮文本
+     * @defaultValue '展开'
+     */
+    expandText?: string;
+    /**
+     * 收起按钮文本
+     * @defaultValue '收起'
+     */
+    collapseText?: string;
+    /** 受控展开状态；优先级高于 defaultExpanded */
+    expanded?: boolean;
+    /**
+     * 默认展开状态
+     * @defaultValue false
+     */
+    defaultExpanded?: boolean;
+}
+export interface SearchFormEmits {
+    'reset': [];
+    'clear': [];
+    'expand': [expanded: boolean];
+    'update:expanded': [expanded: boolean];
+    'error': [event: FormErrorEvent];
+}
+export type SearchFormSlots<S extends z.ZodObject> = {
+    header(props: SearchFormSlotProps<S>): VNode[];
+    footer(props: SearchFormSlotProps<S>): VNode[];
+    actions(props: SearchFormSlotProps<S>): VNode[];
+    extraActions(props: SearchFormSlotProps<S>): VNode[];
+} & DynamicFormSlots<Partial<InferInput<S>>>;

package/dist/runtime/types/auto-form/slots.d.ts

@@ -0,0 +1,85 @@
+import type { z } from 'zod';
+import type { FormError } from '@nuxt/ui';
+import type { ArrayFieldKeys, NonObjectFieldKeys, ObjectFieldKeys } from '@movk/core';
+import type { AutoFormFieldContext, AutoFormFieldSlots } from './fields';
+import type { AutoFormMergeMeta } from './controls';
+import type { VNode } from 'vue';
+export interface AutoFormField {
+    path: string;
+    schema: z.ZodType;
+    meta: AutoFormMergeMeta;
+    decorators: {
+        isOptional?: boolean;
+        isReadonly?: boolean;
+        defaultValue?: unknown;
+        description?: string;
+    };
+    children?: AutoFormField[];
+    arrayElement?: AutoFormField;
+}
+export interface AutoFormSlotProps<T extends object> {
+    errors: FormError[];
+    loading: boolean;
+    fields: AutoFormField[];
+    state: T;
+}
+/** 插槽附加 props 查找表 */
+type SlotExtraPropsMap = {
+    label: {
+        label?: string;
+    };
+    hint: {
+        hint?: string;
+    };
+    description: {
+        description?: string;
+    };
+    help: {
+        help?: string;
+    };
+    error: {
+        error?: boolean | string;
+    };
+    default: {
+        error?: boolean | string;
+    };
+};
+type _FormGenericSlots<T> = {
+    [K in keyof AutoFormFieldSlots as `field-${K}`]: (props: SlotExtraPropsMap[K] & AutoFormFieldContext<T>) => VNode[];
+};
+type _FieldPath<T> = string & (NonObjectFieldKeys<T> | ObjectFieldKeys<T>);
+type _NestedPath<T> = string & (ObjectFieldKeys<T> | ArrayFieldKeys<T>);
+type _SlotEntry = {
+    key: PropertyKey;
+    props: unknown;
+};
+type _EntryToSlots<E extends _SlotEntry> = {
+    [Entry in E as Entry['key']]: (props: Entry['props']) => VNode[];
+};
+type _FormKeyedSlotEntry<T> = {
+    [K in keyof AutoFormFieldSlots]: {
+        [P in _FieldPath<T>]: {
+            key: `field-${K}:${P}`;
+            props: SlotExtraPropsMap[K] & AutoFormFieldContext<T, P>;
+        };
+    }[_FieldPath<T>];
+}[keyof AutoFormFieldSlots];
+type _NestedSlotName = 'content' | 'before' | 'after';
+type _FormNestedSlotEntry<T> = {
+    [P in _NestedPath<T>]: {
+        key: `field-${_NestedSlotName}:${P}`;
+        props: AutoFormFieldContext<T, P>;
+    };
+}[_NestedPath<T>];
+type _FormKeyedSlots<T> = _EntryToSlots<_FormKeyedSlotEntry<T>>;
+type _FormNestedSlots<T> = _EntryToSlots<_FormNestedSlotEntry<T>>;
+/**
+ * 动态表单插槽类型
+ *
+ * 插槽命名：
+ * - 通用：`field-{slotType}`
+ * - 字段：`field-{slotType}:{fieldKey}` — 精确推导字段类型
+ * - 嵌套：`field-{content|before|after}:{objectKey|arrayKey}`
+ */
+export type DynamicFormSlots<T> = _FormGenericSlots<T> & _FormKeyedSlots<T> & _FormNestedSlots<T>;
+export {};

package/dist/runtime/types/auto-form/zod-factory.d.ts

@@ -0,0 +1,127 @@
+import type { z } from 'zod';
+import type { DateRange } from 'reka-ui';
+import type { CalendarDate, DateValue, Time } from '@internationalized/date';
+import type { ComponentProps, ComponentSlots, IsAny, IsComponent, KnownKeys, OmitByKey, Prettify, ReactiveValue, UnionToIntersection, WidenLiteral } from '@movk/core';
+import type { AutoFormFieldContext } from './fields';
+import type { AutoFormControl, AutoFormControls, AutoFormControlsMeta, _Unset, AutoFormLayoutConfig } from './controls';
+import type { AUTOFORM_META } from '../../domains/auto-form/constants';
+interface LayoutFieldMarker<Fields extends Record<string, z.ZodType>> extends z.ZodType<AutoFormLayoutConfig, any, any> {
+    __brand: typeof AUTOFORM_META.LAYOUT_KEY;
+    fields: Fields;
+}
+type LayoutRestShape<S extends Record<string, any>> = {
+    [P in keyof S as S[P] extends LayoutFieldMarker<any> ? never : P]: S[P];
+};
+type LayoutFieldShape<S extends Record<string, any>> = UnionToIntersection<{
+    [P in keyof S]: S[P] extends LayoutFieldMarker<infer Fields> ? ExtractLayoutShape<Fields> : {};
+}[keyof S]>;
+type _HasLayoutMarker<S> = {
+    [P in keyof S]: S[P] extends LayoutFieldMarker<any> ? true : never;
+}[keyof S] extends never ? false : true;
+type ExtractLayoutShape<S extends Record<string, any>> = _HasLayoutMarker<S> extends true ? LayoutRestShape<S> & LayoutFieldShape<S> : S;
+type StrictComponentProps<C extends IsComponent> = {
+    [K in keyof ComponentProps<C> as {} extends Record<K, unknown> ? never : K]: ComponentProps<C>[K];
+};
+type StrictComponentSlots<C extends IsComponent> = IsAny<ComponentSlots<C>> extends true ? {} : ComponentSlots<C>;
+type ControlKey<TControls extends AutoFormControls> = Extract<KnownKeys<TControls>, string>;
+type ControlEntryByKey<TControls extends AutoFormControls, K extends string> = K extends keyof TControls ? TControls[K] : never;
+type _WidenForFactory<T> = {
+    [K in keyof T]+?: WidenLiteral<T[K]>;
+};
+type _IsUnsetLike<P> = [P] extends [_Unset] ? true : IsAny<P> extends true ? true : [unknown] extends [P] ? true : [keyof P] extends [never] ? true : false;
+type ResolveControlProps<C extends IsComponent, P> = _IsUnsetLike<P> extends true ? StrictComponentProps<C> : Prettify<_WidenForFactory<P> & {}>;
+type ExtractControlProps<T> = T extends AutoFormControl<infer C, infer P, any> ? ResolveControlProps<C, P> : T extends {
+    component: infer C extends IsComponent;
+} ? StrictComponentProps<C> : {};
+type ResolveControlSlots<C extends IsComponent, S> = _IsUnsetLike<S> extends true ? StrictComponentSlots<C> : S;
+type ExtractControlSlots<T> = T extends AutoFormControl<infer C, any, infer S> ? ResolveControlSlots<C, S> : T extends {
+    component: infer C extends IsComponent;
+} ? StrictComponentSlots<C> : {};
+type FallbackToRecordIfEmpty<T> = [keyof T] extends [never] ? Record<string, unknown> : Prettify<T & {}>;
+type ControlPropsByKey<TControls extends AutoFormControls, K extends ControlKey<TControls>> = FallbackToRecordIfEmpty<ExtractControlProps<ControlEntryByKey<TControls, K>>>;
+type ControlSlotsByKey<TControls extends AutoFormControls, K extends ControlKey<TControls>> = Partial<ExtractControlSlots<ControlEntryByKey<TControls, K>>>;
+type MetaPropsFor<TControls extends AutoFormControls, K extends ControlKey<TControls>> = {
+    controlProps?: ReactiveValue<ControlPropsByKey<TControls, K>, AutoFormFieldContext>;
+    controlSlots?: ReactiveValue<ControlSlotsByKey<TControls, K>, AutoFormFieldContext> | Record<string, unknown>;
+    error?: string;
+};
+type MetaByControlKey<TControls extends AutoFormControls, K extends ControlKey<TControls>> = {
+    type: K;
+    component?: never;
+} & MetaPropsFor<TControls, K>;
+type MetaByComponent<C extends IsComponent> = {
+    component: C;
+    type?: never;
+} & OmitByKey<AutoFormControlsMeta<C>, 'component' | 'type'>;
+type MetaByDefaultIfExists<TControls extends AutoFormControls, TDefaultKey extends string> = TDefaultKey extends ControlKey<TControls> ? {
+    component?: never;
+    type?: never;
+} & MetaPropsFor<TControls, TDefaultKey> : never;
+type AutoFormFactoryMethod<TControls extends AutoFormControls, TResult, TDefaultKey extends string, TExtraArgs extends unknown[] = []> = _FactoryMetaOverloads<TControls, TResult, TDefaultKey, TExtraArgs> & {
+    (...args: [...TExtraArgs, string?]): TResult;
+};
+type _FactoryMetaOverloads<TControls extends AutoFormControls, TResult, TDefaultKey extends string, TExtraArgs extends unknown[] = []> = {
+    <K extends ControlKey<TControls>>(...args: [...TExtraArgs, MetaByControlKey<TControls, K>]): TResult;
+    (...args: [...TExtraArgs, MetaByDefaultIfExists<TControls, TDefaultKey>]): TResult;
+    <C extends IsComponent>(...args: [...TExtraArgs, MetaByComponent<C>]): TResult;
+};
+type EnumValues = readonly string[] | z.core.util.EnumLike;
+type EnumFactoryResult<T extends EnumValues> = T extends readonly [] ? z.ZodString : T extends readonly [string, ...string[]] ? z.ZodEnum<z.core.util.ToEnum<T[number]>> : T extends readonly string[] ? z.ZodEnum<z.core.util.ToEnum<T[number]>> : T extends z.core.util.EnumLike ? z.ZodEnum<T> : z.ZodString;
+type EnumFactory<TControls extends AutoFormControls> = {
+    <const T extends EnumValues, K extends ControlKey<TControls>>(values: T, overwrite?: MetaByControlKey<TControls, K>): EnumFactoryResult<T>;
+    <const T extends EnumValues>(values: T, overwrite: MetaByDefaultIfExists<TControls, 'enum'>): EnumFactoryResult<T>;
+    <const T extends EnumValues, C extends IsComponent>(values: T, overwrite: MetaByComponent<C>): EnumFactoryResult<T>;
+};
+type CalendarDateFactory<TControls extends AutoFormControls> = {
+    <T extends DateValue | DateRange | DateValue[] = CalendarDate, K extends ControlKey<TControls> = ControlKey<TControls>>(meta?: MetaByControlKey<TControls, K>): z.ZodType<T>;
+    <T extends DateValue | DateRange | DateValue[] = CalendarDate>(meta: MetaByDefaultIfExists<TControls, 'calendarDate'>): z.ZodType<T>;
+    <C extends IsComponent, T extends DateValue | DateRange | DateValue[] = CalendarDate>(meta: MetaByComponent<C>): z.ZodType<T>;
+};
+type ArrayFactory<TControls extends AutoFormControls> = {
+    <T extends z.ZodType, K extends ControlKey<TControls>>(schema: T, overwrite?: MetaByControlKey<TControls, K>): z.ZodArray<T>;
+    <T extends z.ZodType>(schema: T, overwrite: MetaByDefaultIfExists<TControls, 'array'>): z.ZodArray<T>;
+    <T extends z.ZodType, C extends IsComponent>(schema: T, overwrite: MetaByComponent<C>): z.ZodArray<T>;
+};
+type TupleFactory<TControls extends AutoFormControls> = {
+    <T extends readonly [z.ZodType, ...z.ZodType[]], K extends ControlKey<TControls>>(schemas: T, overwrite?: MetaByControlKey<TControls, K>): z.ZodTuple<T>;
+    <T extends readonly [z.ZodType, ...z.ZodType[]]>(schemas: T, overwrite: MetaByDefaultIfExists<TControls, 'tuple'>): z.ZodTuple<T>;
+    <T extends readonly [z.ZodType, ...z.ZodType[]], C extends IsComponent>(schemas: T, overwrite: MetaByComponent<C>): z.ZodTuple<T>;
+};
+type ObjectFactoryResult<S extends Record<string, z.ZodType>, Mode extends z.core.$strip | z.core.$loose | z.core.$strict> = z.ZodObject<ExtractLayoutShape<S>, Mode>;
+/** 对象工厂重载 */
+type ObjectFactoryOverloads<TControls extends AutoFormControls, Mode extends z.core.$strip | z.core.$loose | z.core.$strict, TDefaultKey extends string, ShapeConstraint = {}> = {
+    <S extends Record<string, z.ZodType>, K extends ControlKey<TControls>>(shape: S & ShapeConstraint, meta?: MetaByControlKey<TControls, K>): ObjectFactoryResult<S, Mode>;
+    <S extends Record<string, z.ZodType>>(shape: S & ShapeConstraint, meta: MetaByDefaultIfExists<TControls, TDefaultKey>): ObjectFactoryResult<S, Mode>;
+    <S extends Record<string, z.ZodType>, C extends IsComponent>(shape: S & ShapeConstraint, meta: MetaByComponent<C>): ObjectFactoryResult<S, Mode>;
+};
+export interface TypedZodFactory<TControls extends AutoFormControls> {
+    string: AutoFormFactoryMethod<TControls, z.ZodString, 'string'>;
+    number: AutoFormFactoryMethod<TControls, z.ZodNumber, 'number'>;
+    boolean: AutoFormFactoryMethod<TControls, z.ZodBoolean, 'boolean'>;
+    file: AutoFormFactoryMethod<TControls, z.ZodType<File>, 'file'>;
+    email: AutoFormFactoryMethod<TControls, z.ZodString, 'string'>;
+    url: AutoFormFactoryMethod<TControls, z.ZodString, 'string'>;
+    uuid: AutoFormFactoryMethod<TControls, z.ZodString, 'string'>;
+    enum: EnumFactory<TControls>;
+    calendarDate: CalendarDateFactory<TControls>;
+    inputDate: AutoFormFactoryMethod<TControls, z.ZodType<CalendarDate>, 'inputDate'>;
+    inputTime: AutoFormFactoryMethod<TControls, z.ZodType<Time>, 'inputTime'>;
+    isoDatetime: AutoFormFactoryMethod<TControls, z.ZodType<string>, 'string'>;
+    isoDate: AutoFormFactoryMethod<TControls, z.ZodType<string>, 'string'>;
+    isoTime: AutoFormFactoryMethod<TControls, z.ZodType<string>, 'string'>;
+    array: ArrayFactory<TControls>;
+    tuple: TupleFactory<TControls>;
+    layout: <C extends IsComponent = IsComponent, Fields extends Record<string, z.ZodType> = Record<string, z.ZodType>>(config: Omit<AutoFormLayoutConfig<C>, 'fields'> & {
+        fields: Fields;
+    }) => LayoutFieldMarker<Fields>;
+    object: {
+        <T extends object>(): ObjectFactoryOverloads<TControls, z.core.$strip, 'object', Partial<Record<Extract<keyof T, string>, z.ZodType>>>;
+    } & ObjectFactoryOverloads<TControls, z.core.$strip, 'object'>;
+    looseObject: {
+        <T extends object>(): ObjectFactoryOverloads<TControls, z.core.$loose, 'looseObject', Partial<Record<Extract<keyof T, string>, z.ZodType>>>;
+    } & ObjectFactoryOverloads<TControls, z.core.$loose, 'looseObject'>;
+    strictObject: {
+        <T extends object>(): ObjectFactoryOverloads<TControls, z.core.$strict, 'strictObject', Partial<Record<Extract<keyof T, string>, z.ZodType>>>;
+    } & ObjectFactoryOverloads<TControls, z.core.$strict, 'strictObject'>;
+}
+export {};