cosey 0.5.0 → 0.5.2

package/components/form/form.d.ts

@@ -1,32 +1,26 @@
-import { type FormEmits as ElFormEmits, type ButtonProps, FormItemProp, FormValidateCallback, FormValidationResult, FormItemContext } from 'element-plus';
-import { ExtractPropTypes, type EmitFn, type PropType } from 'vue';
-import { type RowProps } from '../row';
-import { type ColProps } from '../col';
-import { type FormItemWidth } from './form-item';
-import { Arrayable } from '@vueuse/core';
-export declare const formProps: {
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     width: {
-        type: PropType<FormItemWidth>;
+        type: import("vue").PropType<import("./form-item.api").FormItemWidth>;
     };
     grid: {
         type: BooleanConstructor;
         default: boolean;
     };
     rowProps: {
-        type: PropType<RowProps>;
+        type: import("vue").PropType<import("..").RowProps>;
     };
     colProps: {
-        type: PropType<ColProps>;
+        type: import("vue").PropType<import("..").ColProps>;
     };
     readonly: {
         type: BooleanConstructor;
         default: boolean;
     };
     submit: {
-        type: PropType<() => any | Promise<any>>;
+        type: import("vue").PropType<() => any | Promise<any>>;
     };
     reset: {
-        type: PropType<() => any>;
+        type: import("vue").PropType<() => any>;
     };
     submitText: {
         type: StringConstructor;
@@ -37,10 +31,10 @@ export declare const formProps: {
         default: string;
     };
     submitProps: {
-        type: PropType<ButtonProps>;
+        type: import("vue").PropType<import("element-plus").ButtonProps>;
     };
     resetProps: {
-        type: PropType<ButtonProps>;
+        type: import("vue").PropType<import("element-plus").ButtonProps>;
     };
     hideSubmit: {
         type: BooleanConstructor;
@@ -50,13 +44,13 @@ export declare const formProps: {
     };
     model: ObjectConstructor;
     rules: {
-        readonly type: PropType<Partial<Record<string, import("element-plus").FormItemRule | import("element-plus").FormItemRule[]>>>;
+        readonly type: import("vue").PropType<Partial<Record<string, import("element-plus").FormItemRule | import("element-plus").FormItemRule[]>>>;
         readonly required: false;
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     labelPosition: {
-        readonly type: PropType<"left" | "right" | "top">;
+        readonly type: import("vue").PropType<"left" | "right" | "top">;
         readonly required: false;
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
@@ -64,7 +58,7 @@ export declare const formProps: {
         readonly default: "right";
     };
     requireAsteriskPosition: {
-        readonly type: PropType<"left" | "right">;
+        readonly type: import("vue").PropType<"left" | "right">;
         readonly required: false;
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
@@ -72,7 +66,7 @@ export declare const formProps: {
         readonly default: "left";
     };
     labelWidth: {
-        readonly type: PropType<string | number>;
+        readonly type: import("vue").PropType<string | number>;
         readonly required: false;
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
@@ -80,7 +74,7 @@ export declare const formProps: {
         readonly default: "";
     };
     labelSuffix: {
-        readonly type: PropType<string>;
+        readonly type: import("vue").PropType<string>;
         readonly required: false;
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
@@ -91,7 +85,7 @@ export declare const formProps: {
     inlineMessage: BooleanConstructor;
     statusIcon: BooleanConstructor;
     showMessage: {
-        readonly type: PropType<boolean>;
+        readonly type: import("vue").PropType<boolean>;
         readonly required: false;
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
@@ -99,7 +93,7 @@ export declare const formProps: {
         readonly default: true;
     };
     validateOnRuleChange: {
-        readonly type: PropType<boolean>;
+        readonly type: import("vue").PropType<boolean>;
         readonly required: false;
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
@@ -109,7 +103,7 @@ export declare const formProps: {
     hideRequiredAsterisk: BooleanConstructor;
     scrollToError: BooleanConstructor;
     scrollIntoViewOptions: {
-        readonly type: PropType<boolean | Record<string, any>>;
+        readonly type: import("vue").PropType<boolean | Record<string, any>>;
         readonly required: false;
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
@@ -117,54 +111,154 @@ export declare const formProps: {
         readonly default: true;
     };
     size: {
-        readonly type: PropType<"" | "default" | "large" | "small">;
+        readonly type: import("vue").PropType<"" | "default" | "large" | "small">;
         readonly required: false;
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
     };
     disabled: BooleanConstructor;
-};
-export type FormProps = Partial<ExtractPropTypes<typeof formProps>>;
-export declare const formPropsOmit: readonly ["grid", "rowProps", "colProps", "width"];
-export interface FormSlots {
-    default?: (props: Record<string, never>) => any;
-    button?: (props: {
-        submitting: boolean;
-        submit: () => any | Promise<any>;
-        reset: () => any;
-    }) => any;
-}
-export interface FormEmits extends /* @vue-ignore */ EmitFn<ElFormEmits> {
-}
-export interface FormExpose {
-    reset: () => void;
-    submit: () => Promise<any>;
-    validate: (callback?: FormValidateCallback) => FormValidationResult;
-    validateField: (props?: Arrayable<FormItemProp>, callback?: FormValidateCallback) => FormValidationResult;
-    resetFields: (props?: Arrayable<FormItemProp>) => void;
-    clearValidate: (props?: Arrayable<FormItemProp>) => void;
-    scrollToField: (prop: FormItemProp) => void;
-    fields: FormItemContext[];
-}
-export declare const formExposeKeys: string[];
-export interface FormContext {
-    colProps?: ColProps;
-    grid?: boolean;
-    readonly?: boolean;
-    width?: FormItemWidth;
-    addResetField: (reset: () => void) => void;
-    removeResetField: (reset: () => void) => void;
-}
-export declare const formContextSymbol: unique symbol;
-export interface FormBubbleData {
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    validate: (prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => boolean;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    width: {
+        type: import("vue").PropType<import("./form-item.api").FormItemWidth>;
+    };
+    grid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    rowProps: {
+        type: import("vue").PropType<import("..").RowProps>;
+    };
+    colProps: {
+        type: import("vue").PropType<import("..").ColProps>;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    submit: {
+        type: import("vue").PropType<() => any | Promise<any>>;
+    };
+    reset: {
+        type: import("vue").PropType<() => any>;
+    };
+    submitText: {
+        type: StringConstructor;
+        default: string;
+    };
+    resetText: {
+        type: StringConstructor;
+        default: string;
+    };
+    submitProps: {
+        type: import("vue").PropType<import("element-plus").ButtonProps>;
+    };
+    resetProps: {
+        type: import("vue").PropType<import("element-plus").ButtonProps>;
+    };
+    hideSubmit: {
+        type: BooleanConstructor;
+    };
+    hideReset: {
+        type: BooleanConstructor;
+    };
+    model: ObjectConstructor;
+    rules: {
+        readonly type: import("vue").PropType<Partial<Record<string, import("element-plus").FormItemRule | import("element-plus").FormItemRule[]>>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    labelPosition: {
+        readonly type: import("vue").PropType<"left" | "right" | "top">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "right";
+    };
+    requireAsteriskPosition: {
+        readonly type: import("vue").PropType<"left" | "right">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "left";
+    };
+    labelWidth: {
+        readonly type: import("vue").PropType<string | number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "";
+    };
+    labelSuffix: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "";
+    };
+    inline: BooleanConstructor;
+    inlineMessage: BooleanConstructor;
+    statusIcon: BooleanConstructor;
+    showMessage: {
+        readonly type: import("vue").PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    validateOnRuleChange: {
+        readonly type: import("vue").PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    hideRequiredAsterisk: BooleanConstructor;
+    scrollToError: BooleanConstructor;
+    scrollIntoViewOptions: {
+        readonly type: import("vue").PropType<boolean | Record<string, any>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    size: {
+        readonly type: import("vue").PropType<"" | "default" | "large" | "small">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    disabled: BooleanConstructor;
+}>> & Readonly<{
+    onValidate?: ((prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any) | undefined;
+}>, {
+    grid: boolean;
+    inline: boolean;
+    disabled: boolean;
     readonly: boolean;
-    submitting: boolean;
-    submit: (throwError?: boolean, shouldReset?: boolean) => any | Promise<any>;
-    reset: () => any;
-    resetFields: () => any;
-    clearValidate: () => any;
-}
-export interface FormBubbleContext {
-    setFormBubbleData: (data: FormBubbleData) => void;
-}
-export declare const formBubbleContextSymbol: unique symbol;
+    labelWidth: string | number;
+    labelPosition: "left" | "right" | "top";
+    inlineMessage: boolean;
+    showMessage: boolean;
+    submitText: string;
+    resetText: string;
+    hideSubmit: boolean;
+    hideReset: boolean;
+    requireAsteriskPosition: "left" | "right";
+    labelSuffix: string;
+    statusIcon: boolean;
+    validateOnRuleChange: boolean;
+    hideRequiredAsterisk: boolean;
+    scrollToError: boolean;
+    scrollIntoViewOptions: boolean | Record<string, any>;
+}, import("vue").SlotsType<import("./form.api").FormSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/components/form/form.js

@@ -1,62 +1,93 @@
-import { formProps as formProps$1 } from 'element-plus';
+import { defineComponent, inject, reactive, toRef, createVNode, mergeProps, Fragment, isVNode } from 'vue';
+import { formEmits, formSlots, formProps, formBubbleContextSymbol } from './form.api.js';
+import { ElForm, ElButton } from 'element-plus';
+import { useFormTemplate } from './useFormTemplate.js';
+import { Row as _Row } from '../row/index.js';
+import { OptionalWrapper as _OptionalWrapper } from '../optional-wrapper/index.js';
+import stdin_default$2 from './form-item.vue.js';
+import stdin_default$1 from './form.style.js';
+import { useComponentConfig } from '../config-provider/config-provider.api.js';
+import { useLocale } from '../../hooks/useLocale.js';
 
-const formProps = {
-  ...formProps$1,
-  width: {
-    type: [String, Number]
-  },
-  grid: {
-    type: Boolean,
-    default: false
-  },
-  rowProps: {
-    type: Object
-  },
-  colProps: {
-    type: Object
-  },
-  readonly: {
-    type: Boolean,
-    default: false
-  },
-  submit: {
-    type: Function
-  },
-  reset: {
-    type: Function
-  },
-  submitText: {
-    type: String,
-    default: "co.form.submit"
-  },
-  resetText: {
-    type: String,
-    default: "co.form.reset"
-  },
-  submitProps: {
-    type: Object
-  },
-  resetProps: {
-    type: Object
-  },
-  hideSubmit: {
-    type: Boolean
-  },
-  hideReset: {
-    type: Boolean
+function _isSlot(s) {
+  return typeof s === 'function' || Object.prototype.toString.call(s) === '[object Object]' && !isVNode(s);
+}
+var stdin_default = defineComponent({
+  name: "CoForm",
+  props: formProps,
+  slots: formSlots,
+  emits: formEmits,
+  setup(props, {
+    slots,
+    expose: _expose
+  }) {
+    const {
+      prefixCls
+    } = useComponentConfig("form", props);
+    const {
+      hashId
+    } = stdin_default$1(prefixCls);
+    const {
+      t
+    } = useLocale();
+    const {
+      elFormProps,
+      expose,
+      reset,
+      resetFields,
+      submit,
+      clearValidate,
+      submitting
+    } = useFormTemplate(props);
+    const formBubbleContext = inject(formBubbleContextSymbol, null);
+    formBubbleContext?.setFormBubbleData(reactive({
+      readonly: toRef(() => props.readonly),
+      submitting,
+      reset,
+      resetFields,
+      clearValidate,
+      submit
+    }));
+    _expose(expose);
+    return () => {
+      return createVNode(ElForm, mergeProps({
+        "ref": "form"
+      }, elFormProps, {
+        "class": [hashId.value, prefixCls.value]
+      }), {
+        default: () => [createVNode(_OptionalWrapper, {
+          "when": props.grid,
+          "component": _Row,
+          "props": props.rowProps
+        }, {
+          default: () => [slots.default?.({}), !props.readonly && !formBubbleContext && createVNode(stdin_default$2, {
+            "class": `${prefixCls}-form-item-buttons`
+          }, {
+            label: () => {},
+            default: () => {
+              let _slot, _slot2;
+              return createVNode("div", null, [slots.button ? slots.button({
+                reset,
+                submit,
+                submitting: submitting.value
+              }) : createVNode(Fragment, null, [!props.hideSubmit && createVNode(ElButton, mergeProps({
+                "type": "primary"
+              }, props.submitProps, {
+                "loading": submitting.value,
+                "onClick": () => submit()
+              }), _isSlot(_slot = t(props.submitText)) ? _slot : {
+                default: () => [_slot]
+              }), !props.hideReset && createVNode(ElButton, mergeProps(props.resetProps, {
+                "onClick": () => reset()
+              }), _isSlot(_slot2 = t(props.resetText)) ? _slot2 : {
+                default: () => [_slot2]
+              })])]);
+            }
+          })]
+        })]
+      });
+    };
   }
-};
-const formPropsOmit = ["grid", "rowProps", "colProps", "width"];
-const elFormExposeKeys = [
-  "validate",
-  "validateField",
-  "resetFields",
-  "scrollToField",
-  "clearValidate",
-  "fields"
-];
-const formExposeKeys = [...elFormExposeKeys, "submit", "reset"];
-const formContextSymbol = Symbol("form");
-const formBubbleContextSymbol = Symbol("formBubble");
+});
 
-export { formBubbleContextSymbol, formContextSymbol, formExposeKeys, formProps, formPropsOmit };
+export { stdin_default as default };

package/components/form/form.style.d.ts

@@ -0,0 +1,4 @@
+declare const _default: (_prefixCls?: import("vue").ComputedRef<string> | string, themeManager?: import("../theme/theme-context").ThemeManager) => {
+    hashId: import("vue").Ref<string, string>;
+};
+export default _default;

package/components/form/{style/index.js → form.style.js}

@@ -1,4 +1,4 @@
-import { getStyleHook } from '../../theme/getStyleHook.js';
+import { getSimpleStyleHook } from '../theme/getSimpleStyleHook.js';
 
 const getFormStyle = (token) => {
   const { componentCls } = token;
@@ -34,7 +34,7 @@ const getFormItemStyle = (token) => {
     }
   };
 };
-var stdin_default = getStyleHook("Form", (token) => {
+var stdin_default = getSimpleStyleHook("CoForm", (token) => {
   const formToken = {
     ...token,
     formItemCls: `${token.componentCls}-item`

package/components/form/index.d.ts

@@ -1,12 +1,12 @@
 import { useBubbleTemplate } from './useBubbleTemplate';
 import { useFormTemplate } from './useFormTemplate';
 import { getFormItemWidth, useFormItemWidth } from './useFormItemWidth';
-export * from './form';
-export * from './form-item';
+export * from './form.api';
+export * from './form-item.api';
 declare const _Form: {
     new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
         width: {
-            type: import("vue").PropType<import("./form-item").FormItemWidth>;
+            type: import("vue").PropType<import("./form-item.api").FormItemWidth>;
         };
         grid: {
             type: BooleanConstructor;
@@ -125,17 +125,8 @@ declare const _Form: {
         disabled: BooleanConstructor;
     }>> & Readonly<{
         onValidate?: ((prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any) | undefined;
-    }>, {
-        reset: () => void;
-        submit: () => Promise<any>;
-        validate: (callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
-        validateField: (props?: import("@vueuse/core").Arrayable<import("element-plus").FormItemProp>, callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
-        resetFields: (props?: import("@vueuse/core").Arrayable<import("element-plus").FormItemProp>) => void;
-        clearValidate: (props?: import("@vueuse/core").Arrayable<import("element-plus").FormItemProp>) => void;
-        scrollToField: (prop: import("element-plus").FormItemProp) => void;
-        fields: import("element-plus").FormItemContext[];
-    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-        validate: (prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any;
+    }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        validate: (prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => boolean;
     }, import("vue").PublicProps, {
         grid: boolean;
         inline: boolean;
@@ -156,7 +147,7 @@ declare const _Form: {
         hideRequiredAsterisk: boolean;
         scrollToError: boolean;
         scrollIntoViewOptions: boolean | Record<string, any>;
-    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+    }, true, {}, import("vue").SlotsType<import("./form.api").FormSlots>, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
         P: {};
         B: {};
         D: {};
@@ -165,7 +156,7 @@ declare const _Form: {
         Defaults: {};
     }, Readonly<import("vue").ExtractPropTypes<{
         width: {
-            type: import("vue").PropType<import("./form-item").FormItemWidth>;
+            type: import("vue").PropType<import("./form-item.api").FormItemWidth>;
         };
         grid: {
             type: BooleanConstructor;
@@ -284,16 +275,7 @@ declare const _Form: {
         disabled: BooleanConstructor;
     }>> & Readonly<{
         onValidate?: ((prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any) | undefined;
-    }>, {
-        reset: () => void;
-        submit: () => Promise<any>;
-        validate: (callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
-        validateField: (props?: import("@vueuse/core").Arrayable<import("element-plus").FormItemProp>, callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
-        resetFields: (props?: import("@vueuse/core").Arrayable<import("element-plus").FormItemProp>) => void;
-        clearValidate: (props?: import("@vueuse/core").Arrayable<import("element-plus").FormItemProp>) => void;
-        scrollToField: (prop: import("element-plus").FormItemProp) => void;
-        fields: import("element-plus").FormItemContext[];
-    }, {}, {}, {}, {
+    }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
         grid: boolean;
         inline: boolean;
         disabled: boolean;
@@ -319,7 +301,7 @@ declare const _Form: {
     __isSuspense?: never;
 } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
     width: {
-        type: import("vue").PropType<import("./form-item").FormItemWidth>;
+        type: import("vue").PropType<import("./form-item.api").FormItemWidth>;
     };
     grid: {
         type: BooleanConstructor;
@@ -438,17 +420,8 @@ declare const _Form: {
     disabled: BooleanConstructor;
 }>> & Readonly<{
     onValidate?: ((prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any) | undefined;
-}>, {
-    reset: () => void;
-    submit: () => Promise<any>;
-    validate: (callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
-    validateField: (props?: import("@vueuse/core").Arrayable<import("element-plus").FormItemProp>, callback?: import("element-plus").FormValidateCallback) => import("element-plus").FormValidationResult;
-    resetFields: (props?: import("@vueuse/core").Arrayable<import("element-plus").FormItemProp>) => void;
-    clearValidate: (props?: import("@vueuse/core").Arrayable<import("element-plus").FormItemProp>) => void;
-    scrollToField: (prop: import("element-plus").FormItemProp) => void;
-    fields: import("element-plus").FormItemContext[];
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-    validate: (prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => any;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    validate: (prop: import("element-plus").FormItemProp, isValid: boolean, message: string) => boolean;
 }, string, {
     grid: boolean;
     inline: boolean;
@@ -469,26 +442,24 @@ declare const _Form: {
     hideRequiredAsterisk: boolean;
     scrollToError: boolean;
     scrollIntoViewOptions: boolean | Record<string, any>;
-}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
-    $slots: import("./form").FormSlots;
-}) & import("vue").Plugin;
+}, {}, string, import("vue").SlotsType<import("./form.api").FormSlots>, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin;
 declare const _FormItem: (<T extends import("..").FieldType>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
-    slots: import("./form-item").FormItemSlots<T>;
+    slots: import("./form-item.api").FormItemSlots<T>;
     attrs: any;
-    emit: import("./form-item").FormItemEmits;
+    emit: import("./form-item.api").FormItemEmits;
 }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: {
         readonly "onUpdate:modelValue"?: ((value: unknown) => any) | undefined;
         fieldType?: T | undefined;
         fieldProps?: import("..").MapFieldTypeComponentProps[T]["componentProps"] | undefined;
-        fieldSlots?: import("..").MapFieldTypeComponentProps[import("..").FieldType]["componentSlots"];
-        fieldRef?: ((el: any) => void) | undefined;
+        fieldSlots?: import("..").MapFieldTypeComponentProps[T]["componentSlots"] | undefined;
         modelValue?: NonNullable<import("..").MapFieldTypeComponentProps[T]["componentProps"]>["modelValue"] | null | undefined;
-        width?: import("./form-item").FormItemWidth | undefined;
+        fieldRef?: ((el: any) => void) | undefined;
+        width?: import("./form-item.api").FormItemWidth | undefined;
         placeholder?: string | undefined;
         disabled?: boolean | undefined;
         readonly?: boolean | undefined;
-        colProps?: import("..").ColProps | undefined;
+        colProps?: import("..").ColPublicProps | undefined;
         internalIndex?: number | undefined;
         tooltip?: import("vue").VNodeChild;
         extra?: import("vue").VNodeChild;
@@ -498,8 +469,8 @@ declare const _FormItem: (<T extends import("..").FieldType>(__VLS_props: NonNul
         readonly showMessage?: boolean | undefined;
         readonly label?: string | undefined;
         readonly size?: ("" | "default" | "large" | "small") | undefined;
-        readonly error?: string | undefined;
         readonly required?: boolean | undefined;
+        readonly error?: string | undefined;
         readonly prop?: import("element-plus").FormItemProp | undefined;
         readonly rules?: (import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | undefined;
         readonly validateStatus?: ("" | "error" | "success" | "validating") | undefined;
@@ -507,8 +478,8 @@ declare const _FormItem: (<T extends import("..").FieldType>(__VLS_props: NonNul
     } & import("vue").PublicProps;
     expose(exposed: import("vue").ShallowUnwrapRef<import("element-plus").FormItemInstance>): void;
     attrs: any;
-    slots: import("./form-item").FormItemSlots<T>;
-    emit: import("./form-item").FormItemEmits;
+    slots: import("./form-item.api").FormItemSlots<T>;
+    emit: import("./form-item.api").FormItemEmits;
 }>) => import("vue").VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 }) & import("vue").Plugin;