ele-admin-plus 1.2.2-beta.5 → 1.3.0-beta.2

package/es/ele-pro-form/components/render-util.js

@@ -0,0 +1,442 @@
+import { h, mergeProps, createVNode, defineComponent, isVNode } from "vue";
+import VueDraggable from "vuedraggable";
+import { ElFormItem, ElCol, ElRow } from "element-plus";
+import { omit } from "../../utils/core";
+import { getValue } from "../util";
+import { childrenRenderProps } from "../props";
+import BuilderWrapper from "./builder-wrapper.vue";
+import { defaultItemTypeData } from "./item-type-data";
+function _isSlot(s) {
+  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
+}
+const sortableGroupName = "ProFormBuilderBodySortGroup";
+function getRuleMessage(label, requiredMessage, placeholder) {
+  if (typeof requiredMessage === "string" && requiredMessage) {
+    return requiredMessage;
+  }
+  if (typeof placeholder === "string" && placeholder) {
+    return placeholder;
+  }
+  return `${label ?? ""}必填`;
+}
+function isShowItem(item, form, items, searchExpand) {
+  if (!item.prop) {
+    return false;
+  }
+  if (item.vIf != null) {
+    if (typeof item.vIf === "function") {
+      return item.vIf(form, items, searchExpand);
+    }
+    if (typeof item.vIf === "string" && item.vIf.trim().length) {
+      try {
+        return new Function("form", "items", "searchExpand", "formItems", "formData", `return (${item.vIf})`)(form, items, searchExpand, items, form);
+      } catch (e) {
+        console.error(e);
+        return false;
+      }
+    }
+    if (item.vIf === false) {
+      return false;
+    }
+  }
+  return true;
+}
+function translateJsCode(code, model, items, searchExpand) {
+  if (code != null) {
+    if (typeof code === "string") {
+      if (code.startsWith("/*__PRO_FORM__*/")) {
+        try {
+          return new Function("form", "items", "searchExpand", "formData", "formItems", `return (${code})`)(model, items, searchExpand, model, items);
+        } catch (e) {
+          console.error(e);
+        }
+      }
+      return code;
+    } else if (Array.isArray(code)) {
+      return code.map((c) => translateJsCode(c, model, items, searchExpand));
+    } else if (typeof code === "object") {
+      const result = {};
+      Object.keys(code).forEach((k) => {
+        result[k] = translateJsCode(code[k], model, items, searchExpand);
+      });
+      return result;
+    }
+  }
+  return code;
+}
+function renderProFormItem(props) {
+  var _a, _b, _c;
+  const slots = props.slots || {};
+  const itemType = props.item.type;
+  const formData = props.model || {};
+  const typeSlot = itemType ? slots[itemType] : void 0;
+  const typeData = [...props.itemTypeData || [], ...defaultItemTypeData].find((d) => d.type === itemType);
+  if (!typeSlot && !typeData) {
+    return;
+  }
+  const modelValue = props.item.prop == null ? void 0 : getValue(formData, props.item.prop);
+  const handleUpdateModelValue = (value) => {
+    const propName = props.item.prop;
+    props.updateItemValue(propName, value);
+  };
+  const propsFunctionParams = {
+    item: props.item,
+    modelValue,
+    updateModelValue: handleUpdateModelValue,
+    isShowFormItem: (cItem) => isShowItem(cItem, formData, props.formItems || [], props.searchExpand),
+    renderChildren: (cItem, cSortDisabled, cContainerSelectable) => renderProFormContent({
+      model: formData,
+      items: cItem.children,
+      rules: props.rules,
+      grid: cItem.grid,
+      rowProps: cItem.rowProps,
+      parentItem: cItem,
+      formItems: props.formItems,
+      searchExpand: props.searchExpand,
+      editable: props.editable,
+      sortDisabled: !!cSortDisabled,
+      containerSelectable: !!cContainerSelectable,
+      activeItemKey: props.activeItemKey,
+      updateItemValue: props.updateItemValue,
+      updateItemsData: props.updateItemsData,
+      updateActiveItemKey: props.updateActiveItemKey,
+      slots,
+      itemTypeData: props.itemTypeData
+    })
+  };
+  const slotProFormParams = {
+    item: props.item,
+    model: formData,
+    rules: props.rules,
+    formItems: props.formItems,
+    searchExpand: props.searchExpand,
+    editable: props.editable,
+    activeItemKey: props.activeItemKey,
+    itemTypeData: props.itemTypeData,
+    updateItemValue: props.updateItemValue,
+    updateItemsData: props.updateItemsData,
+    updateActiveItemKey: props.updateActiveItemKey,
+    slots
+  };
+  const itemSlots = {};
+  if (!typeSlot) {
+    const itemSlotMap = props.item.slots || {};
+    Object.keys(itemSlotMap).forEach((name) => {
+      if (itemSlotMap[name]) {
+        const slotFuntion = slots[itemSlotMap[name]];
+        if (slotFuntion) {
+          itemSlots[name] = (slotProps) => slotFuntion({
+            proForm: slotProFormParams,
+            ...slotProps || {}
+          });
+        }
+      }
+    });
+    if (typeData && typeData.reservedSlots) {
+      const itemReservedSlots = typeData.reservedSlots(propsFunctionParams);
+      Object.keys(itemReservedSlots).forEach((name) => {
+        if (itemReservedSlots[name]) {
+          itemSlots[name] = itemReservedSlots[name];
+        }
+      });
+    }
+    if (!itemSlots.default) {
+      const isRenderLabel = (typeData == null ? void 0 : typeData.renderLabelText) && props.item.label != null && props.item.label !== "";
+      const isRenderChildren = (!typeData || typeData.isContainer) && (!(typeData == null ? void 0 : typeData.sortDisabled) && props.editable || props.item.children && props.item.children.length);
+      const isRenderOptions = props.item.options && (typeData == null ? void 0 : typeData.optionsComponent);
+      if (isRenderLabel || isRenderChildren || isRenderOptions) {
+        itemSlots.default = () => {
+          const nodes = [];
+          if (isRenderLabel && props.item.label != null) {
+            nodes.push(props.item.label);
+          }
+          if (isRenderChildren) {
+            const contentNode = renderProFormContent({
+              model: formData,
+              items: props.item.children,
+              rules: props.rules,
+              grid: props.item.grid,
+              rowProps: props.item.rowProps,
+              parentItem: props.item,
+              formItems: props.formItems,
+              searchExpand: props.searchExpand,
+              editable: props.editable,
+              sortDisabled: !!(typeData == null ? void 0 : typeData.sortDisabled),
+              containerSelectable: !!(typeData == null ? void 0 : typeData.containerSelectable),
+              activeItemKey: props.activeItemKey,
+              updateItemValue: props.updateItemValue,
+              updateItemsData: props.updateItemsData,
+              updateActiveItemKey: props.updateActiveItemKey,
+              slots,
+              itemTypeData: props.itemTypeData
+            });
+            if (contentNode) {
+              if (Array.isArray(contentNode)) {
+                contentNode.forEach((node) => {
+                  nodes.push(node);
+                });
+              } else {
+                nodes.push(contentNode);
+              }
+            }
+          } else if (isRenderOptions && (typeData == null ? void 0 : typeData.optionsComponent)) {
+            const optionsComponent = typeData.optionsComponent;
+            (props.item.options || []).forEach((option) => {
+              var _a2;
+              const defaultProps = {
+                key: option.key ?? option.value
+              };
+              const userProps = (_a2 = typeData.optionsComponentProps) == null ? void 0 : _a2.call(typeData, option);
+              nodes.push(h(optionsComponent, userProps ? mergeProps(defaultProps, userProps) : defaultProps));
+            });
+          }
+          return nodes;
+        };
+      }
+    }
+  }
+  const componentTag = (typeData == null ? void 0 : typeData.component) || "div";
+  const isDivTag = componentTag === "div" || componentTag === "td";
+  const componentPropsData = translateJsCode(props.item.props || {}, formData, props.formItems || [], props.searchExpand);
+  const componentNode = typeSlot ? typeSlot({
+    item: props.item,
+    model: formData,
+    modelValue,
+    updateValue: handleUpdateModelValue,
+    updatePropValue: props.updateItemValue,
+    proForm: slotProFormParams
+  }) : h((isDivTag ? (_a = props.item.props) == null ? void 0 : _a.is : void 0) || componentTag, mergeProps({
+    key: props.key
+  }, ((_b = typeData == null ? void 0 : typeData.defaultProps) == null ? void 0 : _b.call(typeData, propsFunctionParams)) || {}, isDivTag ? omit(componentPropsData, ["is"]) : componentPropsData, ((_c = typeData == null ? void 0 : typeData.reservedProps) == null ? void 0 : _c.call(typeData, propsFunctionParams)) || {}), itemSlots);
+  if ((typeData == null ? void 0 : typeData.isContainer) || props.item.itemType === "container" || props.item.itemType === "view") {
+    return componentNode;
+  }
+  const itemPropsData = translateJsCode(props.item.itemProps || {}, formData, props.formItems || [], props.searchExpand);
+  const labelWidth = itemPropsData.labelWidth;
+  const formItemLabelWidth = typeof labelWidth === "number" ? `${labelWidth}px` : labelWidth;
+  const formItemSlots = {};
+  const formItemSlotMap = props.item.itemSlots || {};
+  Object.keys(formItemSlotMap).forEach((name) => {
+    if (formItemSlotMap[name] && slots[formItemSlotMap[name]]) {
+      formItemSlots[name] = slots[formItemSlotMap[name]];
+    }
+  });
+  formItemSlots.default = () => componentNode;
+  const iRule = itemPropsData.rules;
+  const iRules = iRule ? Array.isArray(iRule) ? iRule : [iRule] : void 0;
+  const fRule = props.rules ? props.rules[props.item.prop] : void 0;
+  const fRules = fRule ? Array.isArray(fRule) ? fRule : [fRule] : void 0;
+  const formItemRules = iRules || fRules || [];
+  const trigger = (typeData == null ? void 0 : typeData.requiredTrigger) ?? "change";
+  const message = getRuleMessage(props.item.label, props.item.requiredMessage, componentPropsData.placeholder);
+  if (props.item.required) {
+    formItemRules.unshift({
+      required: true,
+      message,
+      trigger
+    });
+  }
+  return createVNode(ElFormItem, mergeProps({
+    "key": props.key,
+    "label": props.item.label
+  }, itemPropsData, {
+    "labelWidth": formItemLabelWidth,
+    "prop": props.item.prop,
+    "rules": formItemRules
+  }), _isSlot(formItemSlots) ? formItemSlots : {
+    default: () => [formItemSlots]
+  });
+}
+function renderProFormContent(props) {
+  const nodes = [];
+  const slots = props.slots || {};
+  const itemsData = props.items || [];
+  const formData = props.model || {};
+  const ownSlots = ["default", "contentExtra"];
+  const getProFormItemNode = (item, editable, sortDisabled) => {
+    const itemKey = item.key ?? item.prop;
+    const defaultSlot = () => {
+      return renderProFormItem({
+        key: itemKey,
+        item,
+        model: formData,
+        rules: props.rules,
+        formItems: props.formItems,
+        searchExpand: props.searchExpand,
+        editable: props.editable,
+        activeItemKey: props.activeItemKey,
+        updateItemValue: props.updateItemValue,
+        updateItemsData: props.updateItemsData,
+        updateActiveItemKey: props.updateActiveItemKey,
+        slots: omit(slots, ownSlots),
+        itemTypeData: props.itemTypeData
+      });
+    };
+    if (!editable) {
+      return defaultSlot();
+    }
+    return createVNode(BuilderWrapper, {
+      "key": itemKey,
+      "item": item,
+      "handle": !sortDisabled,
+      "activeItemKey": props.activeItemKey,
+      "onUpdate:activeItemKey": props.updateActiveItemKey
+    }, {
+      default: defaultSlot,
+      builderItemHandleContent: slots.builderItemHandleContent,
+      builderItemTools: slots.builderItemTools
+    });
+  };
+  if (props.grid) {
+    itemsData.forEach((item) => {
+      const itemKey = item.key ?? item.prop;
+      const gridColProps = props.grid === true ? {
+        span: 12
+      } : props.grid;
+      const itemColProps = translateJsCode(item.colProps || {}, formData, props.formItems || [], props.searchExpand);
+      if (props.editable && !props.sortDisabled) {
+        let _slot;
+        nodes.push(createVNode(ElCol, mergeProps({
+          "key": itemKey
+        }, gridColProps, itemColProps), _isSlot(_slot = getProFormItemNode(item, true, true)) ? _slot : {
+          default: () => [_slot]
+        }));
+      } else if (isShowItem(item, formData, props.formItems || [], props.searchExpand)) {
+        let _slot2;
+        nodes.push(createVNode(ElCol, mergeProps({
+          "key": itemKey
+        }, gridColProps, itemColProps), _isSlot(_slot2 = getProFormItemNode(item)) ? _slot2 : {
+          default: () => [_slot2]
+        }));
+      }
+    });
+    if (slots.contentExtra) {
+      let _slot3;
+      nodes.push(createVNode(ElCol, translateJsCode(props.contentExtraColProps || {}, formData, props.formItems || [], props.searchExpand), _isSlot(_slot3 = slots.contentExtra()) ? _slot3 : {
+        default: () => [_slot3]
+      }));
+    }
+    return createVNode(ElRow, translateJsCode(props.rowProps || {}, formData, props.formItems || [], props.searchExpand), _isSlot(nodes) ? nodes : {
+      default: () => [nodes]
+    });
+  }
+  if (props.editable && !props.sortDisabled) {
+    const footerSlot = () => {
+      var _a;
+      return createVNode("div", {
+        "class": "ele-pro-form-builder-item-tool-wrapper"
+      }, [createVNode("div", {
+        "class": "ele-pro-form-builder-item-handle is-disabled"
+      }, [slots.builderItemHandleContent ? slots.builderItemHandleContent({
+        item: props.parentItem,
+        activeItemKey: props.activeItemKey
+      }) : createVNode("div", {
+        "class": "ele-pro-form-builder-item-handle-content"
+      }, [(_a = props.parentItem) == null ? void 0 : _a.type])]), createVNode("div", {
+        "class": "ele-pro-form-builder-item-tools"
+      }, [slots.builderItemTools ? slots.builderItemTools({
+        item: props.parentItem,
+        activeItemKey: props.activeItemKey
+      }) : void 0])]);
+    };
+    const handleUpdateModelValue = (data) => {
+      props.updateItemsData(data, props.parentItem);
+    };
+    const handleContainerBuilderWrapperClick = (e) => {
+      var _a;
+      const parentItemKey = (_a = props.parentItem) == null ? void 0 : _a.key;
+      if (props.containerSelectable && parentItemKey != null) {
+        e.stopPropagation();
+        props.updateActiveItemKey(parentItemKey);
+      }
+    };
+    nodes.push(createVNode(VueDraggable, {
+      "itemKey": "key",
+      "animation": 150,
+      "modelValue": itemsData,
+      "setData": () => void 0,
+      "group": sortableGroupName,
+      "handle": ".ele-pro-form-builder-item-handle",
+      "draggable": ".ele-pro-form-builder-item-wrapper",
+      "class": ["ele-pro-form-builder-container-wrapper", {
+        "is-selectable": props.containerSelectable
+      }, {
+        "is-active": props.containerSelectable && props.parentItem && props.parentItem.key != null && props.activeItemKey != null && props.activeItemKey === props.parentItem.key
+      }],
+      "onUpdate:modelValue": handleUpdateModelValue,
+      "onClick": handleContainerBuilderWrapperClick
+    }, {
+      item: ({
+        element
+      }) => getProFormItemNode(element, true),
+      footer: props.containerSelectable && props.parentItem ? footerSlot : void 0
+    }));
+  } else {
+    itemsData.forEach((item) => {
+      if (isShowItem(item, formData, props.formItems || [], props.searchExpand)) {
+        const proFormItemNode = getProFormItemNode(item);
+        if (proFormItemNode) {
+          if (Array.isArray(proFormItemNode)) {
+            proFormItemNode.forEach((node) => {
+              nodes.push(node);
+            });
+          } else {
+            nodes.push(proFormItemNode);
+          }
+        }
+      }
+    });
+  }
+  if (slots.contentExtra) {
+    const contentExtraNodes = slots.contentExtra();
+    if (contentExtraNodes) {
+      if (Array.isArray(contentExtraNodes)) {
+        contentExtraNodes.forEach((node) => {
+          nodes.push(node);
+        });
+      } else {
+        nodes.push(contentExtraNodes);
+      }
+    }
+  }
+  return nodes;
+}
+const ChildrenRender = /* @__PURE__ */ defineComponent({
+  name: "ChildrenRender",
+  props: childrenRenderProps,
+  emits: {
+    updateItemValue: (_prop, _value) => true,
+    updateItemsData: (_items, _parentItem) => true,
+    "update:activeItemKey": (_activeKey) => true
+  },
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const handleUpdateItemValue = (prop, value) => {
+      emit("updateItemValue", prop, value);
+    };
+    const handleUpdateItemsData = (items, parentItem) => {
+      emit("updateItemsData", items, parentItem);
+    };
+    const handleUpdateActiveItemKey = (activeKey) => {
+      emit("update:activeItemKey", activeKey);
+    };
+    return () => renderProFormContent({
+      ...props,
+      updateItemValue: handleUpdateItemValue,
+      updateItemsData: handleUpdateItemsData,
+      updateActiveItemKey: handleUpdateActiveItemKey,
+      slots: props.slots ?? slots
+    });
+  }
+});
+export {
+  ChildrenRender,
+  getRuleMessage,
+  isShowItem,
+  renderProFormContent,
+  renderProFormItem,
+  sortableGroupName,
+  translateJsCode
+};

package/es/ele-pro-form/index.d.ts

@@ -0,0 +1,217 @@
+import { ElFormInstance, ElFormItemProp } from '../ele-app/el';
+import { ProFormItemProps, ProFormItemKey } from './types';
+
+declare const _default: import('vue').DefineComponent<{
+    labelWidth: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    items: import('vue').PropType<ProFormItemProps[]>;
+    grid: import('vue').PropType<boolean | import('../ele-app/el').ElColProps>;
+    rowProps: import('vue').PropType<import('../ele-app/el').ElRowProps>;
+    footer: BooleanConstructor;
+    footerProps: import('vue').PropType<import('../ele-app/el').ElFormItemProps>;
+    footerSlots: ObjectConstructor;
+    footerColProps: {
+        type: import('vue').PropType<import('../ele-app/el').ElColProps>;
+        default: () => {
+            span: number;
+        };
+    };
+    footerStyle: import('vue').PropType<import('vue').CSSProperties>;
+    submitText: {
+        type: StringConstructor;
+        default: string;
+    };
+    resetText: {
+        type: StringConstructor;
+        default: string;
+    };
+    submitButtonProps: import('vue').PropType<import('../ele-app/el').ElButtonProps>;
+    resetButtonProps: import('vue').PropType<import('../ele-app/el').ElButtonProps>;
+    showSearchExpand: BooleanConstructor;
+    searchExpandButtonProps: import('vue').PropType<import('../ele-app/el').ElLinkProps>;
+    searchExpandText: {
+        type: StringConstructor;
+        default: string;
+    };
+    searchShrinkText: {
+        type: StringConstructor;
+        default: string;
+    };
+    searchExpand: BooleanConstructor;
+    preventFormSubmit: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    editable: BooleanConstructor;
+    activeItemKey: import('vue').PropType<ProFormItemKey>;
+    itemTypeData: import('vue').PropType<import('./types').ProFormItemTypeData[]>;
+    model: ObjectConstructor;
+    rules: {
+        readonly type: import('vue').PropType<Partial<Record<string, import('element-plus/es/utils/typescript').Arrayable<import('element-plus').FormItemRule>>>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    labelPosition: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "top" | "left" | "right", unknown, "right", boolean>;
+    requireAsteriskPosition: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "left" | "right", unknown, "left", boolean>;
+    labelSuffix: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    inline: BooleanConstructor;
+    inlineMessage: BooleanConstructor;
+    statusIcon: BooleanConstructor;
+    showMessage: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    validateOnRuleChange: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    hideRequiredAsterisk: BooleanConstructor;
+    scrollToError: BooleanConstructor;
+    scrollIntoViewOptions: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<readonly [ObjectConstructor, BooleanConstructor], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    size: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    disabled: BooleanConstructor;
+}, {
+    slotExcludes: string[];
+    footerSlotExcludes: string[];
+    formItems: import('vue').ModelRef<ProFormItemProps[] | undefined, PropertyKey>;
+    formRef: import('vue').Ref<ElFormInstance>;
+    formSearchExpand: import('vue').Ref<boolean>;
+    currentActiveKey: import('vue').Ref<string | number | symbol | undefined>;
+    footerStyleData: import('vue').ComputedRef<any>;
+    updateValue: (prop: string, value: unknown) => void;
+    handleUpdateItemsData: (items: ProFormItemProps[], parentItem?: ProFormItemProps) => void;
+    handleUpdateActiveItemKey: (key: ProFormItemKey) => void;
+    updateSearchExpand: (expand: boolean) => void;
+    handleSubmit: () => void;
+    handleReset: () => void;
+    handleFormSubmit: (e: MouseEvent) => void;
+    handleFormValidate: (prop: ElFormItemProp, isValid: boolean, message: string) => void;
+    validate: (callback?: import('element-plus').FormValidateCallback | undefined) => import('element-plus').FormValidationResult;
+    validateField: (props?: import('element-plus/es/utils/typescript').Arrayable<import('element-plus').FormItemProp> | undefined, callback?: import('element-plus').FormValidateCallback | undefined) => import('element-plus').FormValidationResult;
+    resetFields: (props?: import('element-plus/es/utils/typescript').Arrayable<import('element-plus').FormItemProp> | undefined) => void;
+    clearValidate: (props?: import('element-plus/es/utils/typescript').Arrayable<import('element-plus').FormItemProp> | undefined) => void;
+    scrollToField: (prop: import('element-plus').FormItemProp) => void;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    'update:searchExpand': (_expand: boolean) => boolean;
+    updateValue: (_prop: string, _value: unknown) => boolean;
+    'update:items': (_items: ProFormItemProps[]) => boolean;
+    'update:activeItemKey': (_activeKey: ProFormItemKey) => boolean;
+    submit: (_model: Record<string, any>) => boolean;
+    reset: () => boolean;
+    validate: (prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => boolean;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    labelWidth: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    items: import('vue').PropType<ProFormItemProps[]>;
+    grid: import('vue').PropType<boolean | import('../ele-app/el').ElColProps>;
+    rowProps: import('vue').PropType<import('../ele-app/el').ElRowProps>;
+    footer: BooleanConstructor;
+    footerProps: import('vue').PropType<import('../ele-app/el').ElFormItemProps>;
+    footerSlots: ObjectConstructor;
+    footerColProps: {
+        type: import('vue').PropType<import('../ele-app/el').ElColProps>;
+        default: () => {
+            span: number;
+        };
+    };
+    footerStyle: import('vue').PropType<import('vue').CSSProperties>;
+    submitText: {
+        type: StringConstructor;
+        default: string;
+    };
+    resetText: {
+        type: StringConstructor;
+        default: string;
+    };
+    submitButtonProps: import('vue').PropType<import('../ele-app/el').ElButtonProps>;
+    resetButtonProps: import('vue').PropType<import('../ele-app/el').ElButtonProps>;
+    showSearchExpand: BooleanConstructor;
+    searchExpandButtonProps: import('vue').PropType<import('../ele-app/el').ElLinkProps>;
+    searchExpandText: {
+        type: StringConstructor;
+        default: string;
+    };
+    searchShrinkText: {
+        type: StringConstructor;
+        default: string;
+    };
+    searchExpand: BooleanConstructor;
+    preventFormSubmit: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    editable: BooleanConstructor;
+    activeItemKey: import('vue').PropType<ProFormItemKey>;
+    itemTypeData: import('vue').PropType<import('./types').ProFormItemTypeData[]>;
+    model: ObjectConstructor;
+    rules: {
+        readonly type: import('vue').PropType<Partial<Record<string, import('element-plus/es/utils/typescript').Arrayable<import('element-plus').FormItemRule>>>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    labelPosition: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "top" | "left" | "right", unknown, "right", boolean>;
+    requireAsteriskPosition: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, "left" | "right", unknown, "left", boolean>;
+    labelSuffix: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    inline: BooleanConstructor;
+    inlineMessage: BooleanConstructor;
+    statusIcon: BooleanConstructor;
+    showMessage: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    validateOnRuleChange: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    hideRequiredAsterisk: BooleanConstructor;
+    scrollToError: BooleanConstructor;
+    scrollIntoViewOptions: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<readonly [ObjectConstructor, BooleanConstructor], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    size: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    disabled: BooleanConstructor;
+}>> & {
+    onValidate?: ((prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => any) | undefined;
+    onReset?: (() => any) | undefined;
+    onSubmit?: ((_model: Record<string, any>) => any) | undefined;
+    "onUpdate:activeItemKey"?: ((_activeKey: string | number | symbol) => any) | undefined;
+    "onUpdate:searchExpand"?: ((_expand: boolean) => any) | undefined;
+    onUpdateValue?: ((_prop: string, _value: unknown) => any) | undefined;
+    "onUpdate:items"?: ((_items: ProFormItemProps[]) => any) | undefined;
+}, {
+    disabled: boolean;
+    footer: boolean;
+    labelPosition: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "top" | "right" | "left", unknown>;
+    requireAsteriskPosition: import('element-plus/es/utils/index').EpPropMergeType<StringConstructor, "right" | "left", unknown>;
+    labelWidth: string | number;
+    labelSuffix: string;
+    inline: boolean;
+    inlineMessage: boolean;
+    statusIcon: boolean;
+    showMessage: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    validateOnRuleChange: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    hideRequiredAsterisk: boolean;
+    scrollToError: boolean;
+    editable: boolean;
+    footerColProps: import('../ele-app/el').ElColProps;
+    submitText: string;
+    resetText: string;
+    showSearchExpand: boolean;
+    searchExpandText: string;
+    searchShrinkText: string;
+    searchExpand: boolean;
+    preventFormSubmit: boolean;
+}, {}>;
+export default _default;