@qin-ui/element-plus-pro 1.0.8 → 1.1.0

package/es/index.d.ts

@@ -1,1472 +1,76 @@
-import { AllowedComponentProps } from 'vue';
-import { App } from 'vue';
-import { ColProps } from 'element-plus';
-import { Component } from 'vue';
-import { ComponentCustomProps } from 'vue';
-import { ComponentExposed } from 'vue-component-type-helpers';
-import { ComponentOptionsBase } from 'vue';
-import { ComponentOptionsMixin } from 'vue';
-import { ComponentProps } from 'vue-component-type-helpers';
-import { ComponentProvideOptions } from 'vue';
-import { ComponentPublicInstance } from 'vue';
-import { ComponentSize } from 'element-plus';
-import { ComponentSlots } from 'vue-component-type-helpers';
-import { ComputedRef } from 'vue';
-import { CreateComponentPublicInstanceWithMixins } from 'vue';
-import { CSSProperties } from 'vue';
-import { DefineComponent } from 'vue';
-import { ElAutocomplete } from 'element-plus';
-import { ElCascader } from 'element-plus';
-import { ElCheckboxGroup } from 'element-plus';
-import { ElDatePicker } from 'element-plus';
-import { ElFormItem } from 'element-plus';
-import { ElInput } from 'element-plus';
-import { ElInputNumber } from 'element-plus';
-import { ElRadioGroup } from 'element-plus';
-import { ElSelect } from 'element-plus';
-import { ElSlider } from 'element-plus';
-import { ElSwitch } from 'element-plus';
-import { ElTimePicker } from 'element-plus';
-import { ElTimeSelect } from 'element-plus';
-import { ElTransfer } from 'element-plus';
-import { ElTreeSelect } from 'element-plus';
-import { FormInstance } from 'element-plus';
-import { FormItemInstance } from 'element-plus';
-import { FormItemProps } from 'element-plus';
-import { FormProps } from 'element-plus';
-import { FormRules } from 'element-plus';
-import { GlobalComponents } from 'vue';
-import { GlobalDirectives } from 'vue';
-import { MaybeRef } from 'vue';
-import { PaginationProps } from 'element-plus';
-import { Plugin as Plugin_2 } from 'vue';
-import { PublicProps } from 'vue';
-import { Raw } from 'vue';
-import { Reactive } from 'vue';
-import { Ref } from 'vue';
-import { RowProps } from 'element-plus';
-import { ShallowUnwrapRef } from 'vue';
-import { Slot } from 'vue';
-import { TableColumnCtx } from 'element-plus';
-import { TableProps as TableProps_2 } from 'element-plus';
-import { VNode } from 'vue';
-import { VNodeProps } from 'vue';
-
-declare const __VLS_component: DefineComponent<Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
-
-declare type __VLS_PrettifyLocal<T> = {
-    [K in keyof T]: T[K];
-} & {};
-
-declare type __VLS_PrettifyLocal_2<T> = {
-    [K in keyof T]: T[K];
-} & {};
-
-declare function __VLS_template(): {
-    attrs: Partial<{}>;
-    slots: {
-        default?(_: {}): any;
-        default?(_: {}): any;
-    };
-    refs: {};
-    rootEl: any;
-};
-
-declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-
-declare type __VLS_WithTemplateSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};
-
-/**
- * FormItem 实例提供的额外方法
- * @template FormItemInstance - FormItem 组件实例类型
- */
-declare type AdditionalMethods<FormItemInstance> = {
-    /**
-     * @description 获取 FormItem 实例的方法
-     */
-    getFormItemRef?: () => FormItemInstance;
-    /**
-     * @description 获取传入 FormItem 组件的属性
-     */
-    getFormItemComputedProps?: () => Readonly<{
-        [x: string]: any;
-    }>;
-    /**
-     * @description 获取组件实例的方法
-     */
-    getComponentRef?: () => any;
-    /**
-     * @description 获取传入 Component 组件的属性
-     */
-    getComponentComputedProps?: () => Readonly<{
-        disabled?: boolean;
-        [x: string]: any;
-    }>;
-};
-
-declare type AllowStringKey<T, Prefix extends string = ''> = {
-    [K in keyof T as string extends K ? never : number extends K ? never : K extends string ? K : never]: T[K] extends (infer U)[] ? `${Prefix}${K & string}` | (IsRecord<U> extends true ? AllowStringKey<U, `${Prefix}${K & string}[index].`> : never) : IsRecord<T[K]> extends true ? `${Prefix}${K & string}` | AllowStringKey<T[K], `${Prefix}${K & string}.`> : `${Prefix}${K & string}`;
-} extends infer Obj ? Obj[keyof Obj] : never;
-
-/**
- * @type {Object} Base - 基础公共字段类型
- */
-declare type Base<D extends Data = Data> = BaseWithFields<D> | BaseWithoutFields<D>;
-
-/**
- * 基础表格列配置接口
- * @template D - 表格数据类型，应为一个对象类型
- *
- * @example
- * ```ts
- * interface User { name: string; age: number; address: { city: string } }
- *
- * // 简单列
- * const column: BaseColumn<User> = {
- *   key: 'name',
- *   title: '姓名',
- * }
- *
- * // 带数据索引和嵌套列
- * const column: BaseColumn<User> = {
- *   key: 'address',
- *   title: '地址',
- *   children: [
- *     { key: 'city', title: '城市' },
- *   ],
- * }
- * ```
- */
-declare interface BaseColumn<D extends Data = Data> {
-    /**
-     * @description 列字段路径（数据对象的 key 路径），支持点号分隔的深层路径
-     * @example 'name' | 'address.city'
-     */
-    key?: Path<D>;
-    /**
-     * @description 数据索引，与 key 作用类似，支持数组格式
-     * @example 'name' | ['address', 'city']
-     */
-    dataIndex?: Path<D> | Path<D>[];
-    /**
-     * @description 嵌套子列配置，用于实现表头分组
-     * @example [{ key: 'firstName', title: '名' }, { key: 'lastName', title: '姓' }]
-     */
-    children?: BaseColumn<D>[];
-    /** 其他任意自定义属性（如 title、width、fixed 等 UI 属性） */
-    [key: string]: any;
-}
-
-declare type BaseCommon<D extends Data = Data> = {
-    /**
-     * @description 字段标识namePath, 同prop
-     * @example 'name' | 'age' | 'sex' | ...
-     */
-    path?: Path<D>;
-    /**
-     * @description 字段是否隐藏
-     */
-    hidden?: boolean;
-    /**
-     * @description 字段是否禁用
-     */
-    disabled?: boolean;
-    /**
-     * @description 字段中文名称，支持字符串或组件
-     * @example '姓名' | '年龄' | '性别' | () => h('span', '自定义标签')
-     */
-    label?: SlotComponentType;
-    /**
-     * @description 字段插槽配置，可包含formItem插槽和component插槽
-     * @example
-     * ```js
-     * slots: {
-     *   label: () => h('div', { style: { fontSize: '12px' } }, '年龄'),
-     *   addonAfter: '岁',
-     *   suffix: () => h('span', '元')
-     * }
-     * ```
-     */
-    slots?: Partial<ComponentSlots<typeof ElFormItem>>;
-    /**
-     * @description 字段formItem样式属性
-     * @example { marginBottom: '8px', padding: '12px' }
-     */
-    formItemStyle?: CSSProperties;
-    /**
-     * @description 字段formItem样式类名
-     * @example 'custom-form-item' | 'required-field'
-     */
-    formItemClass?: string;
-    /**
-     * @description 字段formItem容器包裹组件
-     * @example (props, ctx) => h('div', { class: 'custom-container' }, ctx.slots.default?.())
-     */
-    formItemContainer?: ContainerComponent;
-    /**
-     * @description 将属性附加到 FormItem 的 DOM 节点
-     * @example { 'data-form-item-test': 'test-value', 'aria-label': 'name' }
-     */
-    formItemDataAttrs?: Record<string, string>;
-    /**
-     * @description 额外的自定义属性，不会被当作组件参数，仅用做给字段添加标识属性等功能
-     * @example { group: 'group-1' }
-     */
-    extraProps?: Record<string, any>;
-};
-
-/**
- * 内置组件映射表
- * @description Element Plus 内置支持的组件类型映射
- */
-declare type BaseComponentMap = {
-    'input': typeof ElInput;
-    'input-number': typeof ElInputNumber;
-    'autocomplete': typeof ElAutocomplete;
-    'select': typeof ElSelect;
-    'cascader': typeof ElCascader;
-    'date-picker': typeof ElDatePicker;
-    'time-picker': typeof ElTimePicker;
-    'time-select': typeof ElTimeSelect;
-    'checkbox-group': typeof ElCheckboxGroup;
-    'radio-group': typeof ElRadioGroup;
-    'switch': typeof ElSwitch;
-    'slider': typeof ElSlider;
-    'tree-select': typeof ElTreeSelect;
-    'transfer': typeof ElTransfer;
-};
-
-/**
- * 基础字段配置接口
- * @template D - 表单数据类型，应为一个对象类型
- *
- * @example
- * ```ts
- * // 简单的文本输入字段
- * const field: BaseField<{ name: string }> = {
- *   path: 'name',
- *   label: '姓名',
- * }
- *
- * // 带嵌套子字段
- * const field: BaseField<{ address: { city: string; street: string } }> = {
- *   path: 'address',
- *   label: '地址',
- *   fields: [
- *     { path: 'city', label: '城市' },
- *     { path: 'street', label: '街道' },
- *   ],
- * }
- * ```
- */
-declare interface BaseField<D extends Data = Data> {
-    /**
-     * @description 字段路径（数据对象的 key 路径），支持点号分隔的深层路径
-     * @example 'name' | 'user.address.city'
-     */
-    path?: Path<D> | any;
-    /**
-     * @description 字段名称，与 path 作用相同，两者选其一即可
-     * @deprecated 推荐使用 path 替代
-     */
-    name?: any;
-    /**
-     * @description 嵌套子字段配置数组，用于实现分组/嵌套字段
-     * @example [{ path: 'firstName', label: '名' }, { path: 'lastName', label: '姓' }]
-     */
-    fields?: any[];
-    /** 其他任意自定义属性 */
-    [key: string]: any;
-}
-
-declare type BaseWithFields<D extends Data = Data> = BaseCommon<D> & {
-    /**
-     * @description 嵌套子字段配置
-     * @example [{ key: 'firstName', label: '名' }, { key: 'lastName', label: '姓' }]
-     */
-    fields: Fields<D>;
-    /**
-     * @description 网格布局属性，true表示使用默认网格布局，针对具有嵌套字段的字段
-     * @example boolean | { gutter: 24 }
-     */
-    grid?: Grid;
-    component?: never;
-    /**
-     * @description 字段component样式属性
-     * @example { width: '100%', borderColor: '#d9d9d9' }
-     */
-    componentStyle?: never;
-    /**
-     * @description 字段component样式类名
-     * @example 'custom-input' | 'error-input'
-     */
-    componentClass?: never;
-    /**
-     * @description 字段component容器包裹组件
-     * @example (props, ctx) => h('div', { class: 'input-wrapper' }, ctx.slots.default?.())
-     */
-    componentContainer?: never;
-    /**
-     * @description 将属性附加到表单组件的 DOM 节点
-     * @example { 'data-test': 'input-value', 'aria-label': 'name' }
-     */
-    componentDataAttrs?: never;
-    /**
-     * @description 字段值处理函数，在onUpdateValue前执行，函数返回值将作为更新值，也可设置get和set函数，用于处理字段值
-     * @example (val) => val?.trim()
-     */
-    valueFormatter?: never;
-    /**
-     * @description 组件v-model双向绑定更新属性名，默认'modelValue'
-     */
-    modelProp?: never;
-};
-
-declare type BaseWithoutFields<D extends Data = Data> = BaseCommon<D> & {
-    fields?: undefined;
-    grid?: never;
-    /**
-     * @description 字段component样式属性
-     * @example { width: '100%', borderColor: '#d9d9d9' }
-     */
-    componentStyle?: CSSProperties;
-    /**
-     * @description 字段component样式类名
-     * @example 'custom-input' | 'error-input'
-     */
-    componentClass?: string;
-    /**
-     * @description 字段component容器包裹组件
-     * @example (props, ctx) => h('div', { class: 'input-wrapper' }, ctx.slots.default?.())
-     */
-    componentContainer?: ContainerComponent;
-    /**
-     * @description 将属性附加到表单组件的 DOM 节点
-     * @example { 'data-test': 'input-value', 'aria-label': 'name' }
-     */
-    componentDataAttrs?: Record<string, string>;
-    /**
-     * @description 字段值处理函数，在onUpdateValue前执行，函数返回值将作为更新值，也可设置get和set函数，用于处理字段值
-     * @example (val) => val?.trim()
-     */
-    valueFormatter?: ValueFormatter;
-    /**
-     * @description 组件v-model双向绑定更新属性名，默认'modelValue'
-     */
-    modelProp?: string;
-};
-
-declare type BivariantRender<D extends Data = Data> = {
-    bivarianceHack(scope: ColumnScope<D>): any;
-}['bivarianceHack'];
-
-declare type ButtonProps = {
-    onClick: () => void;
-};
-
-/**
- * @qin-ui/element-plus-pro 表格列配置类型
- *
- * @description 基于 Element Plus 的 ColumnType 列类型，并添加：
- * - prop 作为主要字段（Element Plus 使用 prop 而非 dataIndex）
- * - key 作为辅助标识
- * - hidden 属性
- * - render 自定义渲染函数
- *
- * @template D - 表格行数据类型
- *
- * @example
- * ```ts
- * interface User { name: string; age: number }
- *
- * const columns: Columns<User> = [
- *   { prop: 'name', label: '姓名', width: 120 },
- *   { prop: 'age', label: '年龄', width: 80 },
- * ]
- * ```
-
- * @public
- */
-export declare type Column<D extends Data = Data> = Partial<Omit<TableColumnCtx<any>, 'prop' | 'property' | 'children' | 'render'>> & {
-    /** 列字段标识（辅助字段） */
-    key?: Path<D>;
-    /**
-     * @description 列数据路径（主要字段）
-     * Element Plus 使用 prop 而非 dataIndex
-     * @example 'name' | 'address.city'
-     */
-    prop?: KeyExpandString<Extract<keyof D, string>> | Paths<D>;
-    /** 是否隐藏该列 */
-    hidden?: boolean;
-    /** 自定义渲染函数 */
-    render?: BivariantRender<D>;
-};
-
-/**
- * 列查找函数类型，通过自定义函数匹配列
- * @template D - 表格数据类型
- * @template C - 列配置类型
- *
- * @example
- * ```ts
- * // 查找 title 为 '姓名' 的列
- * const findBy: ColumnFindBy<MyData> = (column) => column.title === '姓名'
- *
- * // 查找所有宽度小于 100 的列
- * const findBy: ColumnFindBy<MyData> = (column) => column.width && column.width < 100
- * ```
- */
-declare type ColumnFindBy<D extends Data, C extends BaseColumn<D> = BaseColumn<D>> = (column: Readonly<C>) => boolean;
-
-/**
- * @qin-ui/element-plus-pro 表格列配置数组类型
- * @template D - 表格行数据类型
-
- * @public
- */
-export declare type Columns<D extends Data = Data> = Array<Column<D>>;
-
-/**
- * 列配置数组类型
- * @template D - 表格数据类型
- * @template C - 列配置类型
- */
-declare type Columns_2<D extends Data = Data, C extends BaseColumn<D> = BaseColumn<D>> = Array<C>;
-
-/**
- * Element Plus 表格列作用域
- * @template D - 表格行数据类型
-
- * @public
- */
-declare type ColumnScope<D extends Data = Data> = {
-    /** 当前行数据 */
-    row: ExtendWithAny<D>;
-    /** 当前列配置 */
-    column: Column<D>;
-    /** 行索引 */
-    $index: number;
-    /** 单元格值 */
-    cellValue: any;
-};
-
-/**
- * 组件映射扩展接口
- * @description 暴露给外部扩充自定义组件类型的接口。
- * 用户可通过 TypeScript 的声明合并（module augmentation）添加自定义组件。
- *
- * @example
- * ```ts
- * declare module '@qin-ui/element-plus-pro' {
- *   interface ComponentMap {
- *     'my-custom-input': typeof MyCustomInput;
- *   }
- * }
- * ```
-
- * @public
- */
-export declare interface ComponentMap {
-}
-
-/**
- * 组件名称联合类型
- * @description 所有支持的组件名称
-
- * @public
- */
-export declare type ComponentName = keyof BaseComponentMap | keyof ComponentMap | 'custom';
-
-export declare type ComponentVars = Partial<RequiredComponentVars>;
-
-/**
- * @description 容器组件类型
- */
-declare type ContainerComponent = Component<PathProps>;
-
-export declare const ContainerFragment: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
-
-declare type Control = {
-    sizeControl: boolean;
-    columnControl: boolean;
-};
-
-/**
- * 基础数据类型，表示任意对象
- * @description 所有表单数据对象和表格数据对象的基础类型
- */
-declare type Data = Record<string, any>;
-
-declare type DatePickerType = NonNullable<ComponentProps<typeof ElDatePicker>['type']>;
-
-/**
- * 递归地将对象的所有属性变为可选
- * @template T - 原始类型
- *
- * @example
- * ```ts
- * type T = DeepPartial<{ name: string; address: { city: string } }>
- * // { name?: string; address?: { city?: string } }
- * ```
- */
-declare type DeepPartial<T> = T extends object ? {
-    [P in keyof T]?: DeepPartial<T[P]>;
-} : T;
-
-declare const _default: {
-    /**
-     * @qin-ui/element-plus-pro 安装方法
-     * @description 全局注册所有组件（ProForm、ProTable、ProComponentProvider）
-     *
-     * @param {App} app - Vue 应用实例
-     *
-     * @example
-     * ```ts
-     * import { createApp } from 'vue'
-     * import QinUI from '@qin-ui/element-plus-pro'
-     * const app = createApp(App)
-     * app.use(QinUI)
-     * ```
-     */
-    install(app: App): void;
-};
-export default _default;
-
-declare const _default_2: <T extends Table<any> = Table>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
-        readonly "onUpdate:size"?: ((value: "" | "default" | "large" | "small" | undefined) => any) | undefined;
-        readonly "onUpdate:loading"?: ((value: boolean) => any) | undefined;
-    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onUpdate:size" | "onUpdate:loading"> & ({
-        size?: TableProps["size"];
-        loading?: boolean;
-    } & {
-        table?: T;
-        search?: () => Promise<unknown>;
-        addIndexColumn?: boolean;
-        immediateSearch?: boolean;
-        control?: boolean | Partial<{
-            sizeControl: boolean;
-            columnControl: boolean;
-        }>;
-        searchFormConfig?: Omit<SearchFormProps, "form"> & {
-            hidden?: boolean;
-            container?: ContainerComponent | false;
-        };
-        tableContainer?: ContainerComponent | false;
-        columns?: Columns<T extends Table<any, infer R extends Data> ? R : any>;
-        data?: (T extends Table<any, infer R extends Data> ? R : any)[];
-        pagination?: false | Partial<PaginationProps>;
-    } & Omit<TableProps, "data">) & Partial<{}>> & PublicProps;
-    expose(exposed: ShallowUnwrapRef<    {}>): void;
-    attrs: any;
-    slots: Partial<Record<string, (_: any) => any>> & {
-        'search-form'?(_: {}): any;
-        'button-bar'?(_: {}): any;
-        toolbar?(_: {}): any;
-        table?(_: {}): any;
-    };
-    emit: ((evt: "update:size", value: "" | "default" | "large" | "small" | undefined) => void) & ((evt: "update:loading", value: boolean) => void);
-}>) => VNode & {
-    __ctx?: Awaited<typeof __VLS_setup>;
-};
-
-declare const _default_3: <F extends Form<any> = Form>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal_2<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_PrettifyLocal_2<Pick<Partial<{}> & Omit<{} & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, never> & ({
-        grid?: Grid;
-        form?: F;
-    } & Partial<Omit<FormProps, "model">>) & Partial<{}>> & PublicProps;
-    expose(exposed: ShallowUnwrapRef<    {}>): void;
-    attrs: any;
-    slots: Readonly<Partial<Record<F extends Form<infer D extends Data> ? Path<D> : string, Slot<VModelProps & {
-        path?: string;
-    } & Data & {
-        [x: string]: any;
-        disabled?: boolean;
-    }>> & {
-        default: Slot;
-    }>> & Partial<Record<F extends Form<infer D extends Data> ? Path<D> : string, Slot<VModelProps & {
-        path?: string;
-    } & Data & {
-        [x: string]: any;
-        disabled?: boolean;
-    }>> & {
-        default: Slot;
-    }>;
-    emit: {};
-}>) => VNode & {
-    __ctx?: Awaited<typeof __VLS_setup>;
-};
-
-declare const _default_4: DefineComponent<Props_3, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<Props_3> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
-
-declare type Expand = {
-    minExpandRows?: number;
-    expandStatus?: boolean;
-};
-
-declare type ExpandButtonProps = ButtonProps & {
-    expandStatus: boolean;
-};
-
-/**
- * 用 Record<string, any> 扩展对象类型，保留所有原始属性结构，
- * 同时允许访问任意字符串 key。
- * @template D - 原始对象类型
- *
- * @example
- * ```ts
- * type T = ExtendWithAny<{ name: string; age: number }>
- * // { name: string; age: number } & Record<string, any>
- * // 可访问任意额外属性: obj.anyKey
- * ```
- */
-declare type ExtendWithAny<D> = {
-    [K in keyof D]: IsRecord<D[K]> extends true ? ExtendWithAny<D[K]> : D[K];
-} & Record<string, any>;
-
-/**
- * @description 字段配置类型，包含所有字段属性和响应式支持
- * @template D - 数据对象类型
-
- * @public
- */
-export declare type Field<C extends ComponentName = ComponentName, D extends Data = Data> = (FieldTypeMap<D>[C] & {
-    component?: C extends 'custom' ? FieldTypeMap<D>[C]['component'] : C;
-}) | WithFields<D>;
-
-/**
- * 字段查找函数类型，通过自定义函数匹配字段
- * @template D - 表单数据类型
- * @template F - 字段配置类型
- * @example
- * ```ts
- * // 查找 label 为 '姓名' 的字段
- * const findBy: FieldFindBy<MyData> = (field) => field.label === '姓名'
- * ```
- */
-declare type FieldFindBy<D extends Data, F extends BaseField<D> = BaseField<D>> = (field: Readonly<F>) => boolean;
-
-/**
- * @description 字段数组类型
- * @template D - 数据对象类型
-
- * @public
- */
-export declare type Fields<D extends Data = Data> = Array<Field<ComponentName, D>>;
-
-/**
- * @type {FieldTypeMap} 字段类型集合
- */
-declare type FieldTypeMap<D extends Data = Data> = {
-    [K in ComponentName]: K extends 'custom' ? WithCommon<{
-        slots?: Slots;
-        [x: string]: any;
-    }, D> & {
-        component?: RenderComponentType | Raw<RenderComponentType>;
-    } : WithComponent<GetComponentType<K>, D> & {
-        component?: K;
-    };
-};
-
-/**
- * @qin-ui/element-plus-pro 的表单实例类型
- *
- * @description 在 core Form 类型的基础上：
- * 1. 将字段类型 F 默认绑定为本地 Field<ComponentName, D>，支持 Element Plus 所有内置组件类型
- * 2. 将底层表单实例 I 绑定为 Element Plus 的 FormInstance，使 formRef 获得完整的类型提示
- *
- * @template D - 表单数据类型
- * @template F - 字段配置类型
-
- * @public
- */
-export declare type Form<D extends Data = Data, F extends Field<ComponentName, D> = Field<ComponentName, D>> = Form_2<D, F, FormInstance>;
-
-/**
- * 表单实例类型
- * @template D - 表单数据类型
- * @template F - 字段配置类型
- * @template I - 底层 UI 框架 Form 组件实例类型
- *
- * 组合了表单数据操作、字段操作和表单 ref 操作的能力。
- *
- * @example
- * ```ts
- * // 定义数据类型
- * interface User {
- *   name: string
- *   age: number
- *   address: { city: string; street: string }
- * }
- *
- * // 创建表单实例
- * const form: Form<User> = useForm({
- *   name: '张三',
- *   age: 25,
- * })
- *
- * // 读取数据
- * form.getFormData('name') // '张三'
- * form.getFormData('address.city') // 支持深层路径
- *
- * // 设置数据
- * form.setFormData('name', '李四')
- * form.setFormData({ name: '王五', age: 30 }) // 批量设置
- *
- * // 字段操作
- * form.getField('name') // 获取字段配置
- * form.setField('name', { label: '用户名' }) // 更新字段配置
- * ```
- */
-declare type Form_2<D extends Data = Data, F extends BaseField<D> = BaseField<D>, I = any> = ReturnType<typeof useFormData<D>> & ReturnType<typeof useFields_2<D, F>> & ReturnType<typeof useFormRef_2<I>>;
-
-declare type _FormProps = Pick<Partial<FormProps>, 'disabled' | 'labelPosition' | 'labelWidth' | 'inline' | 'inlineMessage' | 'statusIcon' | 'showMessage' | 'size'>;
-
-declare type FP<T extends Record<string, any>> = Partial<T & Pick<Base, 'valueFormatter' | 'componentContainer' | 'modelProp' | 'componentClass' | 'componentStyle'> & AllowedComponentProps>;
-
-/**
- * 根据组件名获取组件类型
- * @template K - 组件名称
- */
-declare type GetComponentType<K extends ComponentName> = K extends keyof ComponentMap ? ComponentMap[K] : K extends keyof BaseComponentMap ? BaseComponentMap[K] : never;
-
-declare type Grid = boolean | (RowProps & {});
-
-/**
- * 判断类型是否为对象（排除函数、数组和 null）
- * @template T - 要判断的类型
- */
-declare type IsRecord<T> = T extends object ? T extends ((...args: any[]) => any) | any[] | null ? false : true : false;
-
-declare type JoinPath<Prefix extends any[], Key extends PropertyKey> = [
-...Prefix,
-KeyExpandString<Extract<Key, string>>
-];
-
-/**
- * 展开字符串联合类型，保留字符串字面量，同时兼容 string
- * @template T - 字符串字面量类型
- */
-declare type KeyExpandString<T extends string> = T | (string & {});
-
-/**
- * 点号分隔的路径字符串类型
- * @template D - 数据对象类型
- *
- * @description 用于类型安全地表示深层对象属性的路径。
- * 例如给定 `{ user: { name: string; address: { city: string } } }`，
- * 路径值可以是 `'user'`、`'user.name'`、`'user.address.city'`。
- *
- * 同时兼容 string 类型，用于运行时动态路径。
- *
- * @example
- * ```ts
- * interface User {
- *   name: string
- *   age: number
- *   address: { city: string; street: string }
- * }
- *
- * type P = KeyPathString<User>
- * // 'name' | 'age' | 'address' | 'address.city' | 'address.street' | string
- * ```
- */
-declare type KeyPathString<D extends Data> = KeyExpandString<AllowStringKey<D>>;
-
-declare type MaybeRefOrComputedRef<T = any> = MaybeRef<T> | ComputedRef<T>;
-
-/**
- * @description 不支持响应式的属性名
- */
-declare type NotSupportedRefOrGetterProps = 'component' | 'formItemContainer' | 'componentContainer' | 'valueFormatter' | 'fields' | 'slots' | 'modelProp';
-
-/**
- * 分页参数
- *
- * @example
- * ```ts
- * const pageParam: PageParam = {
- *   current: 1,
- *   pageSize: 10,
- *   total: 100,
- * }
- * ```
- */
-declare interface PageParam {
-    /** 当前页码 */
-    current: number;
-    /** 每页条数 */
-    pageSize: number;
-    /** 总记录数 */
-    total: number;
-    /** 其他自定义分页属性 */
-    [key: string]: any;
-}
-
-/**
- * 路径类型，用于类型安全的深层属性访问
- * @template D - 数据对象类型
- *
- * @description 提供对数据对象的深层路径的类型推导。
- * 在 useFormData、useFields 等 API 中作为 path 参数的类型。
- *
- * @example
- * ```ts
- * interface User { name: string; address: { city: string } }
- *
- * // 类型安全的路径
- * const path: Path<User> = 'address.city' // ✅
- * const path: Path<User> = 'invalid.path' // ❌ 类型错误
- * ```
- */
-declare type Path<D extends Data = Data> = KeyPathString<D>;
-
-declare type PathProps = {
-    path?: string;
-} & Data;
-
-/**
- * 路径数组类型（Path 的数组表示）
- * @template T - 数据对象类型
- * @template Prefix - 前缀路径数组（内部递归使用）
- *
- * @description 与 Path 类似，但以元组数组形式表示路径。
- *
- * @example
- * ```ts
- * interface User { name: string; address: { city: string } }
- *
- * type P = Paths<User>
- * // ['name'] | ['address'] | ['address', 'city']
- * ```
- */
-declare type Paths<T, Prefix extends any[] = []> = T extends object ? {
-    [K in keyof T]: IsRecord<T[K]> extends true ? JoinPath<Prefix, K> | Paths<T[K], JoinPath<Prefix, K>> : JoinPath<Prefix, K>;
-}[keyof T] : never;
-
-declare type PP<T extends Record<string, any>> = Partial<T & AllowedComponentProps>;
-
-export declare const ProComponentProvider: SFCWithInstall<{
-    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{
-    componentVars?: ComponentVars;
-    componentMap?: Partial<Record<ComponentName, any>>;
-    }> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
-    P: {};
-    B: {};
-    D: {};
-    C: {};
-    M: {};
-    Defaults: {};
-    }, Readonly<{
-    componentVars?: ComponentVars;
-    componentMap?: Partial<Record<ComponentName, any>>;
-    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
-    __isFragment?: never;
-    __isTeleport?: never;
-    __isSuspense?: never;
-} & ComponentOptionsBase<Readonly<{
-componentVars?: ComponentVars;
-componentMap?: Partial<Record<ComponentName, any>>;
-}> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
-    $slots: {
-        default?(_: {}): any;
-    };
-})>;
-
-export declare const ProForm: SFCWithInstall<(<F extends Form<any> = Form>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
-    slots: Readonly<Partial<Record<F extends Form<infer D extends Data> ? Path<D> : string, Slot<VModelProps & {
-    path?: string;
-    } & Data & {
-    [x: string]: any;
-    disabled?: boolean;
-    }>> & {
-        default: Slot;
-    }>> & Partial<Record<F extends Form<infer D extends Data> ? Path<D> : string, Slot<VModelProps & {
-    path?: string;
-    } & Data & {
-    [x: string]: any;
-    disabled?: boolean;
-    }>> & {
-        default: Slot;
-    }>;
-    attrs: any;
-    emit: {};
-}, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: {
-        grid?: Grid | undefined;
-        form?: F | undefined;
-        size?: ComponentSize | undefined;
-        disabled?: boolean | undefined;
-        labelWidth?: string | number | undefined;
-        labelPosition?: "left" | "right" | "top" | undefined;
-        rules?: FormRules | undefined;
-        inlineMessage?: boolean | undefined;
-        showMessage?: boolean | undefined;
-        requireAsteriskPosition?: "left" | "right" | undefined;
-        labelSuffix?: string | undefined;
-        inline?: boolean | undefined;
-        statusIcon?: boolean | undefined;
-        validateOnRuleChange?: boolean | undefined;
-        hideRequiredAsterisk?: boolean | undefined;
-        scrollToError?: boolean | undefined;
-        scrollIntoViewOptions?: (ScrollIntoViewOptions | boolean) | undefined;
-    } & PublicProps;
-    expose(exposed: ShallowUnwrapRef<    {}>): void;
-    attrs: any;
-    slots: Readonly<Partial<Record<F extends Form<infer D extends Data> ? Path<D> : string, Slot<VModelProps & {
-    path?: string;
-    } & Data & {
-    [x: string]: any;
-    disabled?: boolean;
-    }>> & {
-        default: Slot;
-    }>> & Partial<Record<F extends Form<infer D extends Data> ? Path<D> : string, Slot<VModelProps & {
-    path?: string;
-    } & Data & {
-    [x: string]: any;
-    disabled?: boolean;
-    }>> & {
-        default: Slot;
-    }>;
-    emit: {};
-}>) => VNode & {
-    __ctx?: Awaited<typeof __VLS_setup>;
-})>;
-
-export declare type ProFormInstance = ComponentExposed<typeof _default_3>;
-
-export declare type ProFormItemInstance = ComponentExposed<typeof _default_4>;
-
-export declare type ProFormItemProps = ComponentProps<typeof _default_4>;
-
-export declare type ProFormProps = ComponentProps<typeof _default_3>;
-
-declare type Props = {
-    component?: ContainerComponent;
-};
-
-declare type Props_2 = {
-    component?: SlotComponentType;
-};
-
-declare type Props_3 = {
-    grid?: Grid;
-    fields?: Fields;
-    disabled?: boolean;
-};
-
-export declare const ProTable: typeof _default_2;
-
-export declare type ProTableInstance = ComponentPublicInstance;
-
-export declare type ProTableProps<T extends Table<any> = Table> = {
-    table?: T;
-    search?: () => Promise<unknown>;
-    addIndexColumn?: boolean;
-    immediateSearch?: boolean;
-    control?: boolean | Partial<Control>;
-    searchFormConfig?: SearchFormConfig;
-    tableContainer?: ContainerComponent | false;
-    columns?: Columns<ReturnTableRecord<T>>;
-    data?: ReturnTableRecord<T>[];
-    pagination?: false | Partial<PaginationProps>;
-} & Omit<TableProps, 'data'>;
-
-/**
- * @description 自定义组件
- * @example (p, ctx) => h('div', ctx.attrs)
- */
-declare type RenderComponentType = Component<VModelProps & PathProps>;
-
-declare type RequiredComponentVars = {
-    'pro-table': PP<TableProps & {
-        pagination?: Partial<PaginationProps>;
-        control?: boolean | {
-            sizeControl?: boolean;
-            columnControl?: boolean;
-        };
-        searchFormConfig?: any;
-        immediateSearch?: boolean;
-        addIndexColumn?: boolean;
-        tableContainer?: any;
-    }>;
-    'pro-form': PP<Omit<ProFormProps, 'form' | 'grid'> & {
-        grid: Exclude<Grid, undefined | boolean>;
-    }>;
-    'pro-form-item': PP<FormItemProps & Pick<ColProps, 'span' | 'xs' | 'sm' | 'md' | 'lg' | 'xl'> & Pick<Base, 'formItemContainer'>>;
-    'input.password': FP<ComponentProps<GetComponentType<'input'>>>;
-    'input.textarea': FP<ComponentProps<GetComponentType<'input'>>>;
-} & {
-    [K in DatePickerType as `date-picker.${K}`]: FP<ComponentProps<GetComponentType<'date-picker'>>>;
-} & {
-    [K in Exclude<ComponentName, 'custom'>]: FP<ComponentProps<GetComponentType<K>>>;
-};
-
-declare type ReturnTableRecord<V> = V extends Table<any, infer R> ? R : any;
-
-declare type SearchFormConfig = Omit<SearchFormProps, 'form'> & {
-    hidden?: boolean;
-    container?: ContainerComponent | false;
-};
-
-declare type SearchFormProps = {
-    form: Form;
-    layout?: 'grid' | 'inline';
-    expand?: boolean | Expand;
-    searchButton?: Component<ButtonProps> | DefineComponent<ButtonProps> | false;
-    resetButton?: Component<ButtonProps> | DefineComponent<ButtonProps> | false;
-    expandButton?: Component<ExpandButtonProps> | DefineComponent<ExpandButtonProps> | false;
-    rowGap?: number;
-    columnGap?: number;
-} & /* @vue-ignore */ _FormProps & AllowedComponentProps;
-
-declare type SetColumn<T extends Data = Data, C extends BaseColumn<T> = BaseColumn<T>> = (key: Path<T>, column: C | ((pre: Readonly<C>) => C), options?: {
-    updateType?: 'rewrite' | 'merge';
-} & UpdateColumnOptions) => void;
-
-declare type SetPageParam = (pageParam: Partial<PageParam> | ((pre: Readonly<PageParam>) => Partial<PageParam>)) => void;
-
-declare type SFCWithInstall<T> = T & Plugin_2;
-
-export declare const SlotComponent: DefineComponent<Props_2, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<Props_2> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
-
-/**
- * @description 插槽组件类型
- */
-declare type SlotComponentType = Component<PathProps> | VNode | string | number | boolean | null | undefined | ((...args: any[]) => SlotComponentType);
-
-/**
- * @description 插槽对象类型
- */
-declare type Slots = {
-    [name: string]: SlotComponentType;
-};
-
-/**
- * @qin-ui/element-plus-pro 的表格实例类型
- *
- * @description 在 core Table 类型的基础上：
- * 1. 将列类型 C 绑定为本地 Column<T>
- * 2. 将 dataSource 重命名为 data（Element Plus 使用 data 而非 dataSource）
- *
- * @template D - 搜索表单数据类型
- * @template T - 表格行数据类型
-
- * @public
- */
-export declare type Table<D extends Data = Data, T extends Data = ExtendWithAny<D>> = Omit<Table_2<D, T, Column<T>>, 'dataSource'> & {
-    /**
-     * Element Plus 数据源（与 core 的 dataSource 对应）
-     */
-    data: Ref<T[]>;
-};
-
-/**
- * 表格实例类型
- * @template D - 搜索表单数据类型
- * @template T - 表格数据类型（表格行数据类型），默认为 ExtendWithAny<D>
- * @template C - 列配置类型，继承自 BaseColumn<T>
- *
- * 组合了列操作、数据源管理、分页管理和搜索表单的能力。
- *
- * @example
- * ```ts
- * interface User { name: string; age: number; }
- * interface SearchParams { keyword: string }
- *
- * const table: Table<SearchParams, User> = useTable({
- *   columns: [
- *     { key: 'name', title: '姓名' },
- *     { key: 'age', title: '年龄' },
- *   ],
- *   dataSource: [
- *     { name: '张三', age: 25 },
- *   ],
- *   searchFields: [
- *     { path: 'keyword', label: '关键词', component: 'input' },
- *   ],
- * })
- *
- * // 列操作
- * table.setColumn('name', { title: '用户名' })
- * table.appendColumn('name', { key: 'email', title: '邮箱' })
- * table.deleteColumn('age')
- *
- * // 分页操作
- * table.setPageParam({ current: 2, pageSize: 20 })
- * table.resetQueryParams()
- *
- * // 搜索表单
- * table.searchForm.getFormData('keyword')
- * table.searchForm.setFormData('keyword', '张三')
- * ```
- */
-declare type Table_2<D extends Data = Data, T extends Data = ExtendWithAny<D>, C extends BaseColumn<T> = BaseColumn<T>> = {
-    /** 列配置数组（响应式） */
-    columns: Ref<Columns_2<T, C>>;
-    /** 数据源数组（响应式） */
-    dataSource: Ref<T[]>;
-    /** 分页参数（响应式） */
-    pageParam: Reactive<PageParam>;
-    /** 搜索表单实例 */
-    searchForm: Form_2<D>;
-    /** 设置列配置 */
-    setColumn: SetColumn<T, C>;
-    /** 删除列 */
-    deleteColumn: (path: Path<T> | ColumnFindBy<T, C>, options?: UpdateColumnOptions) => void;
-    /** 在指定列后追加列 */
-    appendColumn: (path: Path<T> | ColumnFindBy<T, C> | undefined, column: C | Columns_2<T, C>, options?: UpdateColumnOptions) => void;
-    /** 在指定列前插入列 */
-    prependColumn: (path: Path<T> | ColumnFindBy<T, C> | undefined, column: C | Columns_2<T, C>, options?: UpdateColumnOptions) => void;
-    /** 设置分页参数 */
-    setPageParam: SetPageParam;
-    /** 重置查询参数（重置分页和搜索条件到初始值） */
-    resetQueryParams: () => void;
-};
-
-declare type TableProps = TableProps_2<any>;
-
-/**
- * 列更新选项
- */
-declare type UpdateColumnOptions = {
-    /**
-     * @description 是否更新所有匹配的列
-     * - true: 更新所有匹配的列
-     * - false/undefined: 只更新第一个匹配的列
-     */
-    all?: boolean;
-};
-
-declare type UpdateFieldOptions = {
-    all?: boolean;
-};
-
-/** useFields 返回值类型，固定为本地 Fields<D>
- * @public
- */
-export declare type UseFields<D extends Data = Data> = ReturnType<typeof useFields<D>>;
-
-/**
- * @qin-ui/element-plus-pro 的字段配置管理 Hook
- *
- * @description 类型安全的 re-export。将 core useFields 的泛型参数绑定为本地类型：
- * - 字段类型 F → Field<ComponentName, D>（支持 Element Plus 组件类型推导）
- * - FormItem 实例 → Element Plus 的 FormItemInstance
- *
- * @template D - 表单数据类型
- *
- * @example
- * ```ts
- * interface User { name: string; age: number }
- *
- * const { fields, getField, setField } = useFields<User>([
- *   { path: 'name', label: '姓名', component: 'input' },
- *   { path: 'age', label: '年龄', component: 'input-number' },
- * ])
- * ```
-
- * @public
- */
-export declare const useFields: {
-    <D extends Data = Data>(initFields?: Fields<D>): ReturnType<typeof useFields_2<D, Field<ComponentName, D>, FormItemInstance>>;
-};
-
-/**
- * 字段配置管理 Hook
- *
- * @description 提供对字段配置数组的增删改查操作，支持：
- * - 通过路径字符串或查找函数定位字段
- * - 深层嵌套字段的遍历和匹配
- * - 字段配置的合并/覆盖更新
- * - 字段的添加、插入、删除
- * - 父级字段查找
- *
- * @template D - 表单数据类型，用于路径类型推导
- * @template F - 字段配置类型，继承自 BaseField<D>
- * @template FormInstance - 底层 FormItem 组件实例类型
- *
- * @param {F[]} [initFields] - 初始字段配置数组
- *
- * @returns {object} 字段操作对象
- * @returns {Ref<F[]>} .fields - 字段配置数组（响应式）
- * @returns {Function} .getField(path) - 获取字段配置
- * @returns {Function} .setField(path, field) - 更新字段配置
- * @returns {Function} .deleteField(path) - 删除字段
- * @returns {Function} .appendField(path, field) - 在指定字段后追加
- * @returns {Function} .prependField(path, field) - 在指定字段前插入
- * @returns {Function} .getParentField(path) - 获取父级字段
- *
- * @example
- * ```ts
- * interface User { name: string; age: number; address: { city: string } }
- *
- * const { fields, getField, setField, deleteField } = useFields<User>([
- *   { path: 'name', label: '姓名', component: 'input' },
- *   { path: 'age', label: '年龄', component: 'input-number' },
- *   {
- *     path: 'address',
- *     label: '地址',
- *     fields: [
- *       { path: 'city', label: '城市' },
- *     ],
- *   },
- * ])
- *
- * // 通过路径获取字段
- * getField('name') // { path: 'name', label: '姓名', ... }
- * getField('address.city') // { path: 'city', label: '城市', ... }
- *
- * // 通过查找函数获取字段
- * getField(f => f.label === '姓名')
- *
- * // 更新字段（合并模式）
- * setField('name', { label: '用户名' })
- *
- * // 删除字段
- * deleteField('age')
- *
- * // 追加/插入字段
- * appendField('name', { path: 'email', label: '邮箱', component: 'input' })
- * prependField('name', { path: 'id', label: 'ID', component: 'input' })
- * ```
- */
-declare const useFields_2: <D extends Data = Data, F extends BaseField<D> = BaseField<D>, FormInstance = any>(initFields?: F[]) => {
-    fields: Ref<F[], F[]>;
-    getField: {
-        (path: Path<D> | FieldFindBy<D, F>): Readonly<F & AdditionalMethods<FormInstance>> | undefined;
-        (path: Path<D> | FieldFindBy<D, F>, options?: {
-            all?: false;
-        }): Readonly<F & AdditionalMethods<FormInstance>> | undefined;
-        (path: Path<D> | FieldFindBy<D, F>, options: {
-            all: true;
-        }): Readonly<F & AdditionalMethods<FormInstance>>[] | undefined;
-    };
-    setField: (path: Path<D> | FieldFindBy<D, F>, field: F | ((preField: Readonly<F>) => F), options?: {
-        updateType?: "rewrite" | "merge";
-    } & UpdateFieldOptions) => void;
-    deleteField: (path: Path<D> | FieldFindBy<D, F>, options?: UpdateFieldOptions) => void;
-    appendField: (path: Path<D> | FieldFindBy<D, F> | undefined, field: F | F[], options?: UpdateFieldOptions) => void;
-    prependField: (path: Path<D> | FieldFindBy<D, F> | undefined, field: F | F[], options?: UpdateFieldOptions) => void;
-    getParentField: {
-        (path: Path<D> | FieldFindBy<D, F>): Readonly<F & AdditionalMethods<FormInstance>> | undefined;
-        (path: Path<D> | FieldFindBy<D, F>, options: {
-            all?: false;
-        }): Readonly<F & AdditionalMethods<FormInstance>> | undefined;
-        (path: Path<D> | FieldFindBy<D, F>, options: {
-            all: true;
-        }): Readonly<F & AdditionalMethods<FormInstance>>[] | undefined;
-    };
-};
-
-/**
- * 创建 @qin-ui/element-plus-pro 表单实例的 Hook
- *
- * @description 类型安全的 re-export。将 core useForm 的泛型参数绑定为本地类型：
- * - 字段类型 F → Field<ComponentName, D>（支持 Element Plus 组件类型推导）
- * - 表单实例 → Element Plus 的 FormInstance
- *
- * @template D - 表单数据类型
- *
- * @example
- * ```ts
- * interface User { name: string; age: number }
- *
- * const form = useForm<User>(
- *   { name: '张三', age: 25 },
- *   [
- *     { path: 'name', label: '姓名', component: 'input' },
- *     { path: 'age', label: '年龄', component: 'input-number' },
- *   ]
- * )
- * ```
-
- * @public
- */
-export declare const useForm: {
-    <D extends Data = Data>(initFormData?: ExtendWithAny<DeepPartial<D>>, initFields?: Field<ComponentName, D>[], root?: boolean): Form<D, Field<ComponentName, D>>;
-    <D extends Data = Data>(root?: boolean): Form<D, Field<ComponentName, D>>;
-};
-
-/**
- * 表单数据处理 Hook
- *
- * @description 提供响应式表单数据的管理能力，支持：
- * - 响应式数据存储（基于 Vue reactive）
- * - 深层路径读写（支持点号分隔，如 'address.city'）
- * - 类型安全的路径提示（传入泛型 D 后，path 参数可获得类型推导）
- * - 父子表单自动注入（非根表单会从注入中获取数据）
- * @public
- *
- * @template D - 表单数据类型，应为一个对象类型
- * @param {ExtendWithAny<DeepPartial<D>>} [initFormData] - 初始表单数据
- *
- * @returns {object} 表单数据操作对象
- * @returns {D & Record<string, any>} .formData - 响应式表单数据
- * @returns {Function} .getFormData(path) - 获取指定路径的数据
- * @returns {Function} .setFormData(path, value) - 设置指定路径的数据
- *
- * @example
- * ```ts
- * interface User { name: string; age: number; address: { city: string } }
- *
- * const { formData, getFormData, setFormData } = useFormData<User>({
- *   name: '张三',
- *   address: { city: '北京' }
- * })
- *
- * // 读取
- * getFormData('name')           // '张三'
- * getFormData('address.city')   // '北京'
- * formData.name                 // '张三'（响应式）
- *
- * // 设置
- * setFormData('name', '李四')
- * setFormData('address.city', '上海')
- * setFormData({ name: '王五', age: 30 }) // 批量覆盖
- * setFormData(prev => ({ ...prev, name: '赵六' })) // 函数式更新
- * ```
- */
-export declare const useFormData: <D extends Data = Data>(initFormData?: ExtendWithAny<DeepPartial<D>>) => {
-    formData: Reactive<ExtendWithAny<D>>;
-    getFormData: {
-        <K extends keyof D>(path: K): D[K];
-        <K extends keyof D & string, K1 extends keyof D[K] & string>(path: `${K}.${K1}`): D[K][K1];
-        <K extends keyof D & string, K1_1 extends keyof D[K] & string, K2 extends keyof D[K][K1_1] & string>(path: `${K}.${K1_1}.${K2}`): D[K][K1_1][K2];
-        (path: Path<D>): any;
-    };
-    setFormData: {
-        (path: Path<D>, value: any): void;
-        (path: Path<D>, value: (v: any) => any): void;
-        (value: ExtendWithAny<DeepPartial<D>>): void;
-        (value: (v: ExtendWithAny<DeepPartial<D>>) => ExtendWithAny<DeepPartial<D>>): void;
-    };
-};
-
-/**
- * @qin-ui/element-plus-pro 的表单组件实例引用 Hook
- *
- * @description 类型安全的 re-export。将 core useFormRef 的泛型参数绑定为 Element Plus 的 FormInstance，
- * 使 formRef 获取到完整的 Element Plus Form 组件 API 类型提示。
- *
- * @returns {object} 表单组件实例引用管理对象
- * @returns {Ref<FormInstance | undefined>} .formRef - Element Plus Form 实例的响应式引用
- * @returns {Function} .setFormRef(inst) - 设置表单组件实例
- *
- * @example
- * ```ts
- * const { formRef, setFormRef } = useFormRef()
- * await formRef.value?.validate()
- * formRef.value?.resetFields()
- * ```
-
- * @public
- */
-export declare const useFormRef: {
-    (): ReturnType<typeof useFormRef_2<FormInstance>>;
-};
-
-/**
- * 表单组件实例引用 Hook
- *
- * @description 用于获取和设置底层 UI 框架（如 ant-design-vue、element-plus）的 Form 组件实例。
- * 在 ProForm 组件内部自动调用 setFormRef 绑定实例，外部可通过 formRef 访问。
- *
- * @template F - 底层 Form 组件实例类型，默认为 any
- *
- * @returns {object} 表单组件实例引用管理对象
- * @returns {Ref<F | undefined>} .formRef - 表单组件实例的响应式引用
- * @returns {Function} .setFormRef(inst) - 设置表单组件实例
- *
- * @example
- * ```ts
- * const { formRef, setFormRef } = useFormRef<InstanceType<typeof AForm>>()
- * setFormRef(formComponentInstance)
- * console.log(formRef.value) // 可通过 formRef 访问底层 Form 实例的方法
- * ```
- */
-declare const useFormRef_2: <F = any>() => {
-    formRef: Ref<F | undefined, F | undefined>;
-    setFormRef: (inst: F) => void;
-};
-
-/**
- * 创建 @qin-ui/element-plus-pro 表格实例的 Hook
- *
- * @description 基于 core useTable 封装，适配 Element Plus 的 API 风格：
- * - 数据源使用 `data` 而非 `dataSource`
- *
- * @template D - 搜索表单数据类型
- * @template T - 表格行数据类型
- *
- * @example
- * ```ts
- * interface User { name: string; age: number }
- *
- * const table = useTable<User>({
- *   columns: [
- *     { prop: 'name', title: '姓名', width: 120 },
- *     { prop: 'age', title: '年龄', width: 80 },
- *   ],
- *   data: [],
- *   pageParam: { current: 1, pageSize: 20, total: 0 },
- * })
- * ```
-
- * @public
- */
-export declare const useTable: <D extends Data = Data, T extends Data = ExtendWithAny<D>>(params?: UseTableParams<D, T>) => Table<D, T>;
-
-declare type UseTableParams<D extends Data = Data, T extends Data = ExtendWithAny<D>> = {
-    /** 列配置数组 */
-    columns?: Columns<T>;
-    /** 数据源数组（Element Plus 使用 data 而非 dataSource） */
-    data?: T[];
-    /** 初始分页参数 */
-    pageParam?: PageParam;
-    /** 初始搜索参数 */
-    searchParam?: ExtendWithAny<DeepPartial<D>>;
-    /** 搜索表单字段配置 */
-    searchFields?: Fields<D>;
-};
-
-declare type ValueFormatter = {
-    (val: any, oldVal: any): any;
-} | {
-    get?: (val: any) => any;
-    set?: (val: any, oldVal: any) => any;
-};
-
-declare type VModelProps<T = any> = {
-    modelValue?: T;
-    'onUpdate:modelValue'?: (val: T) => void;
-};
-
-declare type WithCommon<T, D extends Data = Data> = WithRef<WithCommonBase<T> & BaseWithoutFields<D>>;
-
-declare type WithCommonBase<T = unknown> = T & Omit<FormItemProps, 'label'> & ColProps;
-
-/**
- * @description 自动从 Vue 组件提取 Props 和 Slots，并加上公共表单字段属性
- * @template T - Vue 组件类型
- * @template D - 数据对象类型
- */
-declare type WithComponent<T extends abstract new (...args: any) => any, D extends Data = Data> = WithCommon<{
-    slots?: Partial<ComponentSlots<T>>;
-} & Partial<Omit<ComponentProps<T>, keyof VNodeProps>>, D>;
-
-declare type WithFields<D extends Data = Data> = WithRef<WithCommonBase & BaseWithFields<D>>;
-
-/**
- * @description 为对象属性添加响应式支持的类型
- * @template T - 原始类型
- */
-declare type WithRef<T> = {
-    [P in keyof T]: P extends NotSupportedRefOrGetterProps ? T[P] : T[P] extends (...args: any[]) => any ? T[P] : MaybeRefOrComputedRef<T[P]>;
-};
-
-export { }
+import { App } from 'vue';
+import { default as ProForm } from './components/form';
+import { default as ProTable } from './components/table';
+import { default as ProComponentProvider } from './components/component-provider';
+export * from './components/form';
+export * from './components/table';
+export * from './components/component-provider';
+/**
+ * Schema 驱动的表单组件，基于 element-plus Form 封装
+ *
+ * @description 通过声明式 JSON Schema 配置即可快速生成表单，
+ * 提供极致的 TypeScript 类型推导与组件库插槽扩展能力。
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * import { ProForm, useForm } from '@qin-ui/element-plus-pro'
+ * const form = useForm<User>({ name: '' }, [
+ *   { path: 'name', label: '姓名', component: 'input' }
+ * ])
+ * </script>
+ * <template>
+ *   <ProForm :form="form" />
+ * </template>
+ * ```
+ *
+ * Schema 驱动的表格组件，基于 element-plus Table 封装
+ *
+ * @description 通过声明式列配置即可生成功能完整的表格，
+ * 支持列动态控制、搜索表单集成、分页管理等企业级能力。
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * import { ProTable, useTable } from '@qin-ui/element-plus-pro'
+ * const table = useTable<User>({ columns: [{ key: 'name', title: '姓名' }] })
+ * </script>
+ * <template>
+ *   <ProTable :table="table" />
+ * </template>
+ * ```
+ *
+ * 组件提供者，用于全局配置 ProForm 和 ProTable 的默认行为
+ *
+ * @description 通过 `ProComponentProvider` 包裹应用根组件，
+ * 可以全局覆盖组件的默认属性（如表单布局、表格尺寸等）。
+ *
+ * @example
+ * ```vue
+ * <template>
+ *   <ProComponentProvider :component-props="customProps">
+ *     <App />
+ *   </ProComponentProvider>
+ * </template>
+ * ```
+ */
+export { ProForm, ProTable, ProComponentProvider };
+declare const _default: {
+    /**
+     * @qin-ui/element-plus-pro 安装方法
+     * @description 全局注册所有组件（ProForm、ProTable、ProComponentProvider）
+     *
+     * @param {App} app - Vue 应用实例
+     *
+     * @example
+     * ```ts
+     * import { createApp } from 'vue'
+     * import ProComponents from '@qin-ui/element-plus-pro'
+     * const app = createApp(App)
+     * app.use(ProComponents)
+     * ```
+     */
+    install(app: App): void;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map