yuang-framework-ui-pc 1.0.19 → 1.1.0

package/es/ele-tree-select/types.d.ts

@@ -0,0 +1,21 @@
+import type { ElTreeV2Props } from '../ele-app/el';
+
+/**
+ * 多选标签显示策略
+ */
+export type ShowCheckedStrategy = 'all' | 'parent' | 'child';
+
+/**
+ * 树配置选项
+ */
+export type TreeOption = Required<Exclude<ElTreeV2Props['props'], undefined>>;
+
+/**
+ * 树数据
+ */
+export type TreeData = Exclude<ElTreeV2Props['data'], undefined>;
+
+/**
+ * 树数据项
+ */
+export type DataItem = TreeData[number];

package/es/ele-tree-select/util.d.ts

@@ -0,0 +1,56 @@
+import { MultipleValue, SelectedItem } from '../ele-basic-select/types';
+import { TreeData } from './types';
+
+/**
+ * 获取平铺后的数据值和数据
+ * @param data 数据
+ * @param valueKey 数据值字段名
+ * @param childrenKey 子级字段名
+ */
+export declare function getKeysAndList(data: TreeData | undefined, valueKey: string, childrenKey: string): [MultipleValue, TreeData];
+/**
+ * 获取普通结构的多选选中标签
+ * @param data 树数据
+ * @param checkedKeys 多选选中值
+ * @param valueKey 值键名
+ * @param labelKey 名称键名
+ * @param childrenKey 子级数据键名
+ * @param cacheData 缓存的数据
+ * @param checkedData 树选中的数据
+ */
+export declare function getNormalSelectedItems(data: TreeData | undefined, checkedKeys: MultipleValue | null | undefined, valueKey: string, labelKey: string, childrenKey: string, cacheData?: TreeData, checkedData?: TreeData): SelectedItem[];
+/**
+ * 获取树结构的多选选中标签
+ * @param data 树数据
+ * @param checkedKeys 多选选中值
+ * @param valueKey 值键名
+ * @param labelKey 名称键名
+ * @param childrenKey 子级数据键名
+ * @param showParent 只显示父级(否则只显示子级)
+ */
+export declare function getTreeSelectedItems(data: TreeData | undefined, checkedKeys: MultipleValue | null | undefined, valueKey: string, labelKey: string, childrenKey: string, showParent: boolean, hide?: boolean): SelectedItem[];
+/**
+ * 检查并补充多选选中标签
+ * @param selected 标签数据
+ * @param checkedKeys 多选选中值
+ * @param valueKey 值键名
+ * @param labelKey 名称键名
+ * @param cacheData 缓存的数据
+ */
+export declare function checkSelectedItems(selected: SelectedItem[], checkedKeys: MultipleValue | null | undefined, valueKey: string, labelKey: string, cacheData?: TreeData): SelectedItem[];
+/**
+ * 判断是否全选
+ * @param data 数据
+ * @param checkedKeys 选中值
+ * @param valueKey 值键名
+ * @param childrenKey 子级数据键名
+ * @param disabledKey 禁用键名
+ */
+export declare function isCheckAll(data: TreeData | null | undefined, checkedKeys: MultipleValue | null | undefined, valueKey: string, childrenKey: string, disabledKey: string): any;
+/**
+ * 获取选中值
+ * @param keys 全部选中节点值
+ * @param selected 选中的标签数据
+ * @param checkedValueStrategy 多选值绑定策略
+ */
+export declare function getModelValue(keys: MultipleValue, selected: SelectedItem[], checkedValueStrategy?: boolean): MultipleValue;

package/es/ele-tree-select/util.js

@@ -0,0 +1,141 @@
+import { eachTree } from "../utils/core";
+import { isEmptyValue } from "../ele-basic-select/util";
+function getKeysAndList(data, valueKey, childrenKey) {
+  const keys = [];
+  const list = [];
+  eachTree(
+    data,
+    (d) => {
+      keys.push(d[valueKey]);
+      list.push(d);
+    },
+    childrenKey
+  );
+  return [keys, list];
+}
+function getNormalSelectedItems(data, checkedKeys, valueKey, labelKey, childrenKey, cacheData, checkedData) {
+  const selected = [];
+  if (isEmptyValue(checkedKeys) || !checkedKeys.length) {
+    return selected;
+  }
+  const cacheKeys = cacheData ? cacheData.map((d) => d[valueKey]) : [];
+  const ckKeys = checkedData ? checkedData.map((d) => d[valueKey]) : [];
+  const [dataKeys, list] = getKeysAndList(data, valueKey, childrenKey);
+  checkedKeys.forEach((key) => {
+    const index = cacheKeys.indexOf(key);
+    let item = cacheData && index !== -1 ? cacheData[index] : void 0;
+    if (index === -1 && checkedData) {
+      const tIndex = ckKeys.indexOf(key);
+      if (tIndex !== -1) {
+        item = checkedData[tIndex];
+      }
+    }
+    if (!item && data) {
+      const i = dataKeys.indexOf(key);
+      if (i !== -1) {
+        item = list[i];
+      }
+    }
+    selected.push({ value: key, label: item ? item[labelKey] : String(key) });
+  });
+  return selected;
+}
+function getTreeSelectedItems(data, checkedKeys, valueKey, labelKey, childrenKey, showParent, hide) {
+  const selected = [];
+  if (isEmptyValue(checkedKeys) || !checkedKeys.length) {
+    return selected;
+  }
+  if (data) {
+    data.forEach((d) => {
+      const value = d[valueKey];
+      const children = d[childrenKey];
+      const checked = checkedKeys.includes(value);
+      if (showParent) {
+        if (checked) {
+          selected.push({ value, label: d[labelKey], hide });
+        }
+        getTreeSelectedItems(
+          children,
+          checkedKeys,
+          valueKey,
+          labelKey,
+          childrenKey,
+          showParent,
+          checked ? true : hide
+        ).forEach((item) => {
+          selected.push(item);
+        });
+      } else {
+        const hasChildren = !!(children && children.length);
+        if (checked) {
+          selected.push({ value, label: d[labelKey], hide: hasChildren });
+        }
+        if (hasChildren) {
+          getTreeSelectedItems(
+            children,
+            checkedKeys,
+            valueKey,
+            labelKey,
+            childrenKey,
+            showParent
+          ).forEach((item) => {
+            selected.push(item);
+          });
+        }
+      }
+    });
+  }
+  return selected;
+}
+function checkSelectedItems(selected, checkedKeys, valueKey, labelKey, cacheData) {
+  const selectedValues = selected.map((s) => s.value);
+  const cacheKeys = cacheData ? cacheData.map((d) => d[valueKey]) : [];
+  checkedKeys.forEach((key) => {
+    if (!selectedValues.includes(key)) {
+      const index = cacheKeys.indexOf(key);
+      const item = cacheData && index !== -1 ? cacheData[index] : void 0;
+      selected.push({ value: key, label: item ? item[labelKey] : String(key) });
+    }
+  });
+  return selected;
+}
+function isCheckAll(data, checkedKeys, valueKey, childrenKey, disabledKey) {
+  if (!data || !data.length || !checkedKeys || !checkedKeys.length) {
+    return false;
+  }
+  return data.every((d) => {
+    if (d[disabledKey] || checkedKeys.includes(d[valueKey])) {
+      return true;
+    }
+    if (d[childrenKey] && d[childrenKey].length) {
+      return isCheckAll(
+        d[childrenKey],
+        checkedKeys,
+        valueKey,
+        childrenKey,
+        disabledKey
+      );
+    }
+    return false;
+  });
+}
+function getModelValue(keys, selected, checkedValueStrategy) {
+  if (!checkedValueStrategy) {
+    return keys;
+  }
+  const ids = [];
+  selected.forEach((d) => {
+    if (!d.hide) {
+      ids.push(d.value);
+    }
+  });
+  return ids;
+}
+export {
+  checkSelectedItems,
+  getKeysAndList,
+  getModelValue,
+  getNormalSelectedItems,
+  getTreeSelectedItems,
+  isCheckAll
+};

package/es/ele-upload-list/components/list-item.d.ts

@@ -0,0 +1,85 @@
+import { PropType } from 'vue';
+import { ElProgressProps, ElImageProps } from '../../ele-app/el';
+import { UploadItem, UploadLocale, ImageObjectUrl, ListType } from '../types';
+
+declare const _default: import('vue').DefineComponent<{
+    /** 数据 */
+    item: {
+        type: PropType<UploadItem>;
+        required: true;
+    };
+    /** 是否只读 */
+    readonly: BooleanConstructor;
+    /** 是否禁用 */
+    disabled: BooleanConstructor;
+    /** 是否可拖拽排序 */
+    sortable: BooleanConstructor;
+    /** 图片属性 */
+    imageProps: PropType<ElImageProps>;
+    /** 进度条属性 */
+    progressProps: PropType<ElProgressProps>;
+    /** 预读图片文件 */
+    imageObjectUrls: PropType<ImageObjectUrl[]>;
+    /** 是否开启底部预览和修改的操作按钮 */
+    tools: BooleanConstructor;
+    /** 列表样式 */
+    listType: PropType<ListType>;
+    /** 国际化 */
+    locale: {
+        type: PropType<Partial<UploadLocale>>;
+        required: true;
+    };
+}, {
+    imageUrl: import('vue').ComputedRef<string | undefined>;
+    uploadProgress: import('vue').ComputedRef<number>;
+    handleItemClick: () => void;
+    handleRemove: () => void;
+    handleEdit: () => void;
+    handlePreview: () => void;
+    handleRetry: () => void;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    itemClick: (_item: UploadItem) => true;
+    remove: (_item: UploadItem) => true;
+    edit: (_item: UploadItem) => true;
+    preview: (_item: UploadItem) => true;
+    retry: (_item: UploadItem) => true;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /** 数据 */
+    item: {
+        type: PropType<UploadItem>;
+        required: true;
+    };
+    /** 是否只读 */
+    readonly: BooleanConstructor;
+    /** 是否禁用 */
+    disabled: BooleanConstructor;
+    /** 是否可拖拽排序 */
+    sortable: BooleanConstructor;
+    /** 图片属性 */
+    imageProps: PropType<ElImageProps>;
+    /** 进度条属性 */
+    progressProps: PropType<ElProgressProps>;
+    /** 预读图片文件 */
+    imageObjectUrls: PropType<ImageObjectUrl[]>;
+    /** 是否开启底部预览和修改的操作按钮 */
+    tools: BooleanConstructor;
+    /** 列表样式 */
+    listType: PropType<ListType>;
+    /** 国际化 */
+    locale: {
+        type: PropType<Partial<UploadLocale>>;
+        required: true;
+    };
+}>> & {
+    onEdit?: ((_item: UploadItem) => any) | undefined;
+    onRetry?: ((_item: UploadItem) => any) | undefined;
+    onRemove?: ((_item: UploadItem) => any) | undefined;
+    onPreview?: ((_item: UploadItem) => any) | undefined;
+    onItemClick?: ((_item: UploadItem) => any) | undefined;
+}, {
+    disabled: boolean;
+    readonly: boolean;
+    sortable: boolean;
+    tools: boolean;
+}, {}>;
+export default _default;

package/es/ele-upload-list/components/list-item.js

@@ -0,0 +1,233 @@
+import { defineComponent, computed, resolveComponent, openBlock, createElementBlock, renderSlot, createVNode, withCtx, createElementVNode, toDisplayString, createBlock, mergeProps, withModifiers, createCommentVNode } from "vue";
+import { ElImage, ElProgress, ElIcon } from "element-plus";
+import { CloseOutlined, EyeOutlined, EditOutlined, SyncOutlined, FileOutlined } from "../../icons";
+const _sfc_main = defineComponent({
+  name: "ListItem",
+  components: {
+    CloseOutlined,
+    EyeOutlined,
+    EditOutlined,
+    SyncOutlined,
+    FileOutlined,
+    ElImage,
+    ElProgress,
+    ElIcon
+  },
+  props: {
+    /** 数据 */
+    item: {
+      type: Object,
+      required: true
+    },
+    /** 是否只读 */
+    readonly: Boolean,
+    /** 是否禁用 */
+    disabled: Boolean,
+    /** 是否可拖拽排序 */
+    sortable: Boolean,
+    /** 图片属性 */
+    imageProps: Object,
+    /** 进度条属性 */
+    progressProps: Object,
+    /** 预读图片文件 */
+    imageObjectUrls: Array,
+    /** 是否开启底部预览和修改的操作按钮 */
+    tools: Boolean,
+    /** 列表样式 */
+    listType: String,
+    /** 国际化 */
+    locale: {
+      type: Object,
+      required: true
+    }
+  },
+  emits: {
+    itemClick: (_item) => true,
+    remove: (_item) => true,
+    edit: (_item) => true,
+    preview: (_item) => true,
+    retry: (_item) => true
+  },
+  setup(props, { emit }) {
+    const imageUrl = computed(() => {
+      var _a;
+      if (props.item.url) {
+        return props.item.url;
+      }
+      if (!props.item.file || !props.imageObjectUrls) {
+        return;
+      }
+      return (_a = props.imageObjectUrls.find((d) => d.file === props.item.file)) == null ? void 0 : _a.url;
+    });
+    const uploadProgress = computed(() => {
+      const progress = props.item.progress;
+      if (!progress || progress < 0) {
+        return 0;
+      }
+      return progress > 100 ? 100 : progress;
+    });
+    const handleItemClick = () => {
+      emit("itemClick", props.item);
+    };
+    const handleRemove = () => {
+      emit("remove", props.item);
+    };
+    const handleEdit = () => {
+      emit("edit", props.item);
+    };
+    const handlePreview = () => {
+      emit("preview", props.item);
+    };
+    const handleRetry = () => {
+      emit("retry", props.item);
+    };
+    return {
+      imageUrl,
+      uploadProgress,
+      handleItemClick,
+      handleRemove,
+      handleEdit,
+      handlePreview,
+      handleRetry
+    };
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = ["title"];
+const _hoisted_2 = {
+  key: 0,
+  class: "ele-upload-thumbnail"
+};
+const _hoisted_3 = { class: "ele-upload-thumbnail-text" };
+const _hoisted_4 = {
+  key: 0,
+  class: "ele-upload-progress"
+};
+const _hoisted_5 = { class: "ele-upload-text" };
+const _hoisted_6 = ["title"];
+const _hoisted_7 = { class: "ele-upload-tool-text" };
+const _hoisted_8 = {
+  key: 1,
+  class: "ele-upload-tools"
+};
+const _hoisted_9 = ["title"];
+const _hoisted_10 = { class: "ele-upload-tool-text" };
+const _hoisted_11 = ["title"];
+const _hoisted_12 = { class: "ele-upload-tool-text" };
+const _hoisted_13 = ["title"];
+const _hoisted_14 = {
+  key: 3,
+  class: "ele-upload-handle"
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_FileOutlined = resolveComponent("FileOutlined");
+  const _component_ElIcon = resolveComponent("ElIcon");
+  const _component_ElImage = resolveComponent("ElImage");
+  const _component_ElProgress = resolveComponent("ElProgress");
+  const _component_SyncOutlined = resolveComponent("SyncOutlined");
+  const _component_EyeOutlined = resolveComponent("EyeOutlined");
+  const _component_EditOutlined = resolveComponent("EditOutlined");
+  const _component_CloseOutlined = resolveComponent("CloseOutlined");
+  return openBlock(), createElementBlock("div", {
+    title: _ctx.item.name,
+    class: "ele-upload-item",
+    onClick: _cache[4] || (_cache[4] = (...args) => _ctx.handleItemClick && _ctx.handleItemClick(...args))
+  }, [
+    renderSlot(_ctx.$slots, "thumbnail", {
+      item: _ctx.item,
+      imageUrl: _ctx.imageUrl
+    }, () => [
+      _ctx.listType === "file" || !_ctx.imageUrl ? (openBlock(), createElementBlock("div", _hoisted_2, [
+        createVNode(_component_ElIcon, { class: "ele-upload-thumbnail-icon" }, {
+          default: withCtx(() => [
+            createVNode(_component_FileOutlined)
+          ]),
+          _: 1
+        }),
+        createElementVNode("div", _hoisted_3, toDisplayString(_ctx.item.name || _ctx.item.url), 1)
+      ])) : (openBlock(), createBlock(_component_ElImage, mergeProps({
+        key: 1,
+        fit: "contain",
+        class: "ele-upload-image"
+      }, _ctx.imageProps || {}, { src: _ctx.imageUrl }), null, 16, ["src"]))
+    ]),
+    _ctx.item.status === "uploading" || _ctx.item.status === "exception" ? (openBlock(), createElementBlock("div", _hoisted_4, [
+      renderSlot(_ctx.$slots, "progress", { item: _ctx.item }, () => [
+        createElementVNode("div", _hoisted_5, toDisplayString(_ctx.item.status == "exception" ? _ctx.locale.exception : _ctx.locale.uploading), 1),
+        createVNode(_component_ElProgress, mergeProps({
+          showText: false,
+          strokeWidth: _ctx.listType === "file" ? 2 : void 0,
+          status: _ctx.item.status === "exception" ? "exception" : void 0,
+          class: "ele-upload-progress-bar"
+        }, _ctx.progressProps || {}, { percentage: _ctx.uploadProgress }), null, 16, ["strokeWidth", "status", "percentage"]),
+        !_ctx.disabled && _ctx.item.status === "exception" ? (openBlock(), createElementBlock("div", {
+          key: 0,
+          title: _ctx.locale.retry,
+          class: "ele-upload-tool ele-upload-retry",
+          onClick: _cache[0] || (_cache[0] = withModifiers((...args) => _ctx.handleRetry && _ctx.handleRetry(...args), ["stop"]))
+        }, [
+          createVNode(_component_ElIcon, { class: "ele-upload-tool-icon" }, {
+            default: withCtx(() => [
+              createVNode(_component_SyncOutlined)
+            ]),
+            _: 1
+          }),
+          createElementVNode("div", _hoisted_7, toDisplayString(_ctx.locale.retry), 1)
+        ], 8, _hoisted_6)) : createCommentVNode("", true)
+      ])
+    ])) : _ctx.tools && !_ctx.readonly && !_ctx.disabled && !_ctx.item.readonly ? (openBlock(), createElementBlock("div", _hoisted_8, [
+      createElementVNode("div", {
+        title: _ctx.locale.preview,
+        class: "ele-upload-tool",
+        onClick: _cache[1] || (_cache[1] = withModifiers((...args) => _ctx.handlePreview && _ctx.handlePreview(...args), ["stop"]))
+      }, [
+        createVNode(_component_ElIcon, { class: "ele-upload-tool-icon" }, {
+          default: withCtx(() => [
+            createVNode(_component_EyeOutlined)
+          ]),
+          _: 1
+        }),
+        createElementVNode("div", _hoisted_10, toDisplayString(_ctx.locale.preview), 1)
+      ], 8, _hoisted_9),
+      createElementVNode("div", {
+        title: _ctx.locale.edit,
+        class: "ele-upload-tool",
+        onClick: _cache[2] || (_cache[2] = withModifiers((...args) => _ctx.handleEdit && _ctx.handleEdit(...args), ["stop"]))
+      }, [
+        createVNode(_component_ElIcon, { class: "ele-upload-tool-icon" }, {
+          default: withCtx(() => [
+            createVNode(_component_EditOutlined)
+          ]),
+          _: 1
+        }),
+        createElementVNode("div", _hoisted_12, toDisplayString(_ctx.locale.edit), 1)
+      ], 8, _hoisted_11)
+    ])) : createCommentVNode("", true),
+    !_ctx.readonly && !_ctx.disabled && !_ctx.item.readonly ? (openBlock(), createElementBlock("div", {
+      key: 2,
+      title: _ctx.locale.remove,
+      class: "ele-upload-tool ele-upload-remove",
+      onClick: _cache[3] || (_cache[3] = withModifiers((...args) => _ctx.handleRemove && _ctx.handleRemove(...args), ["stop"]))
+    }, [
+      renderSlot(_ctx.$slots, "remove", { item: _ctx.item }, () => [
+        createVNode(_component_ElIcon, { class: "ele-upload-tool-icon" }, {
+          default: withCtx(() => [
+            createVNode(_component_CloseOutlined)
+          ]),
+          _: 1
+        })
+      ])
+    ], 8, _hoisted_13)) : createCommentVNode("", true),
+    _ctx.sortable ? (openBlock(), createElementBlock("div", _hoisted_14)) : createCommentVNode("", true)
+  ], 8, _hoisted_1);
+}
+const listItem = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  listItem as default
+};

package/es/ele-upload-list/index.d.ts

@@ -0,0 +1,126 @@
+import { UploadItem, UploadLocale } from './types';
+
+declare const _default: import('vue').DefineComponent<{
+    modelValue: import('vue').PropType<UploadItem[]>;
+    readonly: BooleanConstructor;
+    disabled: BooleanConstructor;
+    preview: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    limit: NumberConstructor;
+    multiple: BooleanConstructor;
+    drag: BooleanConstructor;
+    accept: {
+        type: StringConstructor;
+        default: string;
+    };
+    itemStyle: import('vue').PropType<import('../ele-app/types').StyleValue | false>;
+    buttonStyle: {
+        type: import('vue').PropType<import('../ele-app/types').StyleValue | false>;
+        default: null;
+    };
+    sortable: {
+        type: import('vue').PropType<boolean | Record<keyof any, any>>;
+        default: boolean;
+    };
+    imageProps: import('vue').PropType<import('../ele-app/el').ElImageProps>;
+    progressProps: import('vue').PropType<import('../ele-app/el').ElProgressProps>;
+    previewProps: import('vue').PropType<import('../ele-app/plus').EleImageViewerProps>;
+    tools: BooleanConstructor;
+    listType: import('vue').PropType<import('./types').ListType>;
+    beforeUploadClick: import('vue').PropType<import('./types').BeforeUploadClick>;
+    beforeItemEdit: import('vue').PropType<import('./types').BeforeItemEdit>;
+    locale: import('vue').PropType<Partial<UploadLocale>>;
+}, {
+    ownSlots: string[];
+    lang: import('vue').ComputedRef<UploadLocale>;
+    previewVisible: import('vue').Ref<boolean>;
+    previewImages: import('vue').Ref<string[]>;
+    previewCurrentIndex: import('vue').Ref<number>;
+    imageObjectUrls: import('vue').Ref<{
+        file: {
+            readonly lastModified: number;
+            readonly name: string;
+            readonly webkitRelativePath: string;
+            readonly size: number;
+            readonly type: string;
+            arrayBuffer: () => Promise<ArrayBuffer>;
+            slice: (start?: number, end?: number, contentType?: string) => Blob;
+            stream: () => ReadableStream<Uint8Array>;
+            text: () => Promise<string>;
+        };
+        url: string;
+    }[]>;
+    uploadInputRef: import('vue').Ref<HTMLInputElement | null>;
+    uploadEnable: import('vue').ComputedRef<boolean>;
+    updateModelValue: (value: UploadItem[]) => void;
+    handleUpload: (file: File) => boolean;
+    handleItemClick: (item: UploadItem) => void;
+    handleItemRemove: (item: UploadItem) => void;
+    handleItemEdit: (item: UploadItem) => void;
+    handleItemPreview: (item: UploadItem) => void;
+    handleItemRetry: (item: UploadItem) => void;
+    handleInputChange: (e: Event) => void;
+    handleUploadClick: (e: MouseEvent) => void;
+    openImagePreview: (urls: string[], index: number) => void;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    'update:modelValue': (_value: UploadItem[]) => boolean;
+    itemClick: (_item: UploadItem) => boolean;
+    upload: (_item: UploadItem) => boolean;
+    remove: (_item: UploadItem) => boolean;
+    retry: (_item: UploadItem) => boolean;
+    editUpload: (_result: import('./types').EditUploadResult) => boolean;
+    preview: (_item: UploadItem) => boolean;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: import('vue').PropType<UploadItem[]>;
+    readonly: BooleanConstructor;
+    disabled: BooleanConstructor;
+    preview: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    limit: NumberConstructor;
+    multiple: BooleanConstructor;
+    drag: BooleanConstructor;
+    accept: {
+        type: StringConstructor;
+        default: string;
+    };
+    itemStyle: import('vue').PropType<import('../ele-app/types').StyleValue | false>;
+    buttonStyle: {
+        type: import('vue').PropType<import('../ele-app/types').StyleValue | false>;
+        default: null;
+    };
+    sortable: {
+        type: import('vue').PropType<boolean | Record<keyof any, any>>;
+        default: boolean;
+    };
+    imageProps: import('vue').PropType<import('../ele-app/el').ElImageProps>;
+    progressProps: import('vue').PropType<import('../ele-app/el').ElProgressProps>;
+    previewProps: import('vue').PropType<import('../ele-app/plus').EleImageViewerProps>;
+    tools: BooleanConstructor;
+    listType: import('vue').PropType<import('./types').ListType>;
+    beforeUploadClick: import('vue').PropType<import('./types').BeforeUploadClick>;
+    beforeItemEdit: import('vue').PropType<import('./types').BeforeItemEdit>;
+    locale: import('vue').PropType<Partial<UploadLocale>>;
+}>> & {
+    "onUpdate:modelValue"?: ((_value: UploadItem[]) => any) | undefined;
+    onItemClick?: ((_item: UploadItem) => any) | undefined;
+    onRemove?: ((_item: UploadItem) => any) | undefined;
+    onPreview?: ((_item: UploadItem) => any) | undefined;
+    onRetry?: ((_item: UploadItem) => any) | undefined;
+    onUpload?: ((_item: UploadItem) => any) | undefined;
+    onEditUpload?: ((_result: import('./types').EditUploadResult) => any) | undefined;
+}, {
+    drag: boolean;
+    disabled: boolean;
+    readonly: boolean;
+    sortable: boolean | Record<string | number | symbol, any>;
+    multiple: boolean;
+    preview: boolean;
+    accept: string;
+    tools: boolean;
+    buttonStyle: false | Partial<import('vue').CSSProperties>;
+}, {}>;
+export default _default;