yuang-framework-ui-pc 1.1.41 → 1.1.42

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

@@ -2,7 +2,7 @@ import { PropType } from 'vue';
 import { ElProgressProps, ElImageProps } from '../../ele-app/el';
 import { UploadItem, UploadLocale, ImageObjectUrl, ListType } from '../types';
 
-declare const _default: import('vue').DefineComponent<{
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     /** 数据 */
     item: {
         type: PropType<UploadItem>;
@@ -29,7 +29,7 @@ declare const _default: import('vue').DefineComponent<{
         type: PropType<Partial<UploadLocale>>;
         required: true;
     };
-}, {
+}>, {
     imageUrl: import('vue').ComputedRef<string | undefined>;
     uploadProgress: import('vue').ComputedRef<number>;
     handleItemClick: () => void;
@@ -37,7 +37,7 @@ declare const _default: import('vue').DefineComponent<{
     handleEdit: () => void;
     handlePreview: () => void;
     handleRetry: () => void;
-}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     itemClick: (_item: UploadItem) => true;
     remove: (_item: UploadItem) => true;
     edit: (_item: UploadItem) => true;
@@ -70,16 +70,833 @@ declare const _default: import('vue').DefineComponent<{
         type: PropType<Partial<UploadLocale>>;
         required: true;
     };
-}>> & {
-    onEdit?: ((_item: UploadItem) => any) | undefined;
+}>> & Readonly<{
     onRetry?: ((_item: UploadItem) => any) | undefined;
     onRemove?: ((_item: UploadItem) => any) | undefined;
     onPreview?: ((_item: UploadItem) => any) | undefined;
+    onEdit?: ((_item: UploadItem) => any) | undefined;
     onItemClick?: ((_item: UploadItem) => any) | undefined;
-}, {
+}>, {
     disabled: boolean;
     readonly: boolean;
     sortable: boolean;
     tools: boolean;
-}, {}>;
+}, {}, {
+    CloseOutlined: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    EyeOutlined: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    EditOutlined: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    SyncOutlined: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    FileOutlined: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    ElImage: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+            readonly hideOnClickModal: BooleanConstructor;
+            readonly src: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly fit: {
+                readonly type: PropType<"" | "fill" | "none" | "cover" | "contain" | "scale-down">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly loading: {
+                readonly type: PropType<"lazy" | "eager">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly lazy: BooleanConstructor;
+            readonly scrollContainer: {
+                readonly type: PropType<string | HTMLElement | undefined>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly previewSrcList: {
+                readonly type: PropType<string[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => [];
+            };
+            readonly previewTeleported: BooleanConstructor;
+            readonly zIndex: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly initialIndex: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            readonly infinite: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            readonly closeOnPressEscape: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            readonly zoomRate: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 1.2;
+            };
+            readonly minScale: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0.2;
+            };
+            readonly maxScale: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 7;
+            };
+            readonly showProgress: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: false;
+            };
+            readonly crossorigin: {
+                readonly type: PropType<"" | "anonymous" | "use-credentials">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>> & {
+            onShow?: (() => any) | undefined;
+            onLoad?: ((evt: Event) => any) | undefined;
+            onError?: ((evt: Event) => any) | undefined;
+            onClose?: (() => any) | undefined;
+            onSwitch?: ((val: number) => any) | undefined;
+        }, {
+            showPreview: () => void;
+        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            switch: (val: number) => void;
+            show: () => void;
+            close: () => void;
+            error: (evt: Event) => void;
+            load: (evt: Event) => void;
+        }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+            readonly infinite: boolean;
+            readonly src: string;
+            readonly fit: "" | "fill" | "none" | "cover" | "contain" | "scale-down";
+            readonly initialIndex: number;
+            readonly lazy: boolean;
+            readonly closeOnPressEscape: boolean;
+            readonly zoomRate: number;
+            readonly minScale: number;
+            readonly maxScale: number;
+            readonly showProgress: boolean;
+            readonly hideOnClickModal: boolean;
+            readonly previewSrcList: string[];
+            readonly previewTeleported: boolean;
+        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('vue').ExtractPropTypes<{
+            readonly hideOnClickModal: BooleanConstructor;
+            readonly src: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly fit: {
+                readonly type: PropType<"" | "fill" | "none" | "cover" | "contain" | "scale-down">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly loading: {
+                readonly type: PropType<"lazy" | "eager">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly lazy: BooleanConstructor;
+            readonly scrollContainer: {
+                readonly type: PropType<string | HTMLElement | undefined>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly previewSrcList: {
+                readonly type: PropType<string[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => [];
+            };
+            readonly previewTeleported: BooleanConstructor;
+            readonly zIndex: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly initialIndex: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            readonly infinite: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            readonly closeOnPressEscape: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            readonly zoomRate: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 1.2;
+            };
+            readonly minScale: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0.2;
+            };
+            readonly maxScale: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 7;
+            };
+            readonly showProgress: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: false;
+            };
+            readonly crossorigin: {
+                readonly type: PropType<"" | "anonymous" | "use-credentials">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>> & {
+            onShow?: (() => any) | undefined;
+            onLoad?: ((evt: Event) => any) | undefined;
+            onError?: ((evt: Event) => any) | undefined;
+            onClose?: (() => any) | undefined;
+            onSwitch?: ((val: number) => any) | undefined;
+        }, {
+            showPreview: () => void;
+        }, {}, {}, {}, {
+            readonly infinite: boolean;
+            readonly src: string;
+            readonly fit: "" | "fill" | "none" | "cover" | "contain" | "scale-down";
+            readonly initialIndex: number;
+            readonly lazy: boolean;
+            readonly closeOnPressEscape: boolean;
+            readonly zoomRate: number;
+            readonly minScale: number;
+            readonly maxScale: number;
+            readonly showProgress: boolean;
+            readonly hideOnClickModal: boolean;
+            readonly previewSrcList: string[];
+            readonly previewTeleported: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+        readonly hideOnClickModal: BooleanConstructor;
+        readonly src: {
+            readonly type: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly fit: {
+            readonly type: PropType<"" | "fill" | "none" | "cover" | "contain" | "scale-down">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly loading: {
+            readonly type: PropType<"lazy" | "eager">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly lazy: BooleanConstructor;
+        readonly scrollContainer: {
+            readonly type: PropType<string | HTMLElement | undefined>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly previewSrcList: {
+            readonly type: PropType<string[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: () => [];
+        };
+        readonly previewTeleported: BooleanConstructor;
+        readonly zIndex: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly initialIndex: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 0;
+        };
+        readonly infinite: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        readonly closeOnPressEscape: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        readonly zoomRate: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 1.2;
+        };
+        readonly minScale: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 0.2;
+        };
+        readonly maxScale: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 7;
+        };
+        readonly showProgress: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: false;
+        };
+        readonly crossorigin: {
+            readonly type: PropType<"" | "anonymous" | "use-credentials">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>> & {
+        onShow?: (() => any) | undefined;
+        onLoad?: ((evt: Event) => any) | undefined;
+        onError?: ((evt: Event) => any) | undefined;
+        onClose?: (() => any) | undefined;
+        onSwitch?: ((val: number) => any) | undefined;
+    }, {
+        showPreview: () => void;
+    }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        switch: (val: number) => void;
+        show: () => void;
+        close: () => void;
+        error: (evt: Event) => void;
+        load: (evt: Event) => void;
+    }, string, {
+        readonly infinite: boolean;
+        readonly src: string;
+        readonly fit: "" | "fill" | "none" | "cover" | "contain" | "scale-down";
+        readonly initialIndex: number;
+        readonly lazy: boolean;
+        readonly closeOnPressEscape: boolean;
+        readonly zoomRate: number;
+        readonly minScale: number;
+        readonly maxScale: number;
+        readonly showProgress: boolean;
+        readonly hideOnClickModal: boolean;
+        readonly previewSrcList: string[];
+        readonly previewTeleported: boolean;
+    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: {
+            error?(_: {}): any;
+            placeholder?(_: {}): any;
+            viewer?(_: {}): any;
+            progress?(_: {
+                activeIndex: number;
+                total: number;
+            }): any;
+            toolbar?(_: {
+                actions: (action: import('element-plus').ImageViewerAction, options?: {}) => void;
+                prev: () => void;
+                next: () => void;
+                reset: () => void;
+                activeIndex: number;
+                setActiveItem: (index: number) => void;
+            }): any;
+        };
+    }) & import('vue').Plugin;
+    ElProgress: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+            readonly type: {
+                readonly type: PropType<"circle" | "line" | "dashboard">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "line";
+            };
+            readonly percentage: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            readonly status: {
+                readonly type: PropType<"" | "success" | "warning" | "exception">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly indeterminate: BooleanConstructor;
+            readonly duration: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 3;
+            };
+            readonly strokeWidth: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 6;
+            };
+            readonly strokeLinecap: {
+                readonly type: PropType<NonNullable<"round" | "inherit" | "butt" | "square" | undefined>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "round";
+            };
+            readonly textInside: BooleanConstructor;
+            readonly width: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 126;
+            };
+            readonly showText: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            readonly color: {
+                readonly type: PropType<string | import('element-plus').ProgressFn | import('element-plus').ProgressColor[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly striped: BooleanConstructor;
+            readonly stripedFlow: BooleanConstructor;
+            readonly format: {
+                readonly type: PropType<import('element-plus').ProgressFn>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: (percentage: number) => string;
+            };
+        }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+            readonly width: number;
+            readonly color: string | import('element-plus').ProgressFn | import('element-plus').ProgressColor[];
+            readonly strokeLinecap: NonNullable<"round" | "inherit" | "butt" | "square" | undefined>;
+            readonly strokeWidth: number;
+            readonly type: "circle" | "line" | "dashboard";
+            readonly format: import('element-plus').ProgressFn;
+            readonly duration: number;
+            readonly indeterminate: boolean;
+            readonly percentage: number;
+            readonly status: "" | "success" | "warning" | "exception";
+            readonly showText: boolean;
+            readonly textInside: boolean;
+            readonly striped: boolean;
+            readonly stripedFlow: boolean;
+        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('vue').ExtractPropTypes<{
+            readonly type: {
+                readonly type: PropType<"circle" | "line" | "dashboard">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "line";
+            };
+            readonly percentage: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            readonly status: {
+                readonly type: PropType<"" | "success" | "warning" | "exception">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly indeterminate: BooleanConstructor;
+            readonly duration: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 3;
+            };
+            readonly strokeWidth: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 6;
+            };
+            readonly strokeLinecap: {
+                readonly type: PropType<NonNullable<"round" | "inherit" | "butt" | "square" | undefined>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "round";
+            };
+            readonly textInside: BooleanConstructor;
+            readonly width: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 126;
+            };
+            readonly showText: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            readonly color: {
+                readonly type: PropType<string | import('element-plus').ProgressFn | import('element-plus').ProgressColor[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly striped: BooleanConstructor;
+            readonly stripedFlow: BooleanConstructor;
+            readonly format: {
+                readonly type: PropType<import('element-plus').ProgressFn>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: (percentage: number) => string;
+            };
+        }>>, {}, {}, {}, {}, {
+            readonly width: number;
+            readonly color: string | import('element-plus').ProgressFn | import('element-plus').ProgressColor[];
+            readonly strokeLinecap: NonNullable<"round" | "inherit" | "butt" | "square" | undefined>;
+            readonly strokeWidth: number;
+            readonly type: "circle" | "line" | "dashboard";
+            readonly format: import('element-plus').ProgressFn;
+            readonly duration: number;
+            readonly indeterminate: boolean;
+            readonly percentage: number;
+            readonly status: "" | "success" | "warning" | "exception";
+            readonly showText: boolean;
+            readonly textInside: boolean;
+            readonly striped: boolean;
+            readonly stripedFlow: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+        readonly type: {
+            readonly type: PropType<"circle" | "line" | "dashboard">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "line";
+        };
+        readonly percentage: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 0;
+        };
+        readonly status: {
+            readonly type: PropType<"" | "success" | "warning" | "exception">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly indeterminate: BooleanConstructor;
+        readonly duration: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 3;
+        };
+        readonly strokeWidth: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 6;
+        };
+        readonly strokeLinecap: {
+            readonly type: PropType<NonNullable<"round" | "inherit" | "butt" | "square" | undefined>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "round";
+        };
+        readonly textInside: BooleanConstructor;
+        readonly width: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 126;
+        };
+        readonly showText: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        readonly color: {
+            readonly type: PropType<string | import('element-plus').ProgressFn | import('element-plus').ProgressColor[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly striped: BooleanConstructor;
+        readonly stripedFlow: BooleanConstructor;
+        readonly format: {
+            readonly type: PropType<import('element-plus').ProgressFn>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: (percentage: number) => string;
+        };
+    }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
+        readonly width: number;
+        readonly color: string | import('element-plus').ProgressFn | import('element-plus').ProgressColor[];
+        readonly strokeLinecap: NonNullable<"round" | "inherit" | "butt" | "square" | undefined>;
+        readonly strokeWidth: number;
+        readonly type: "circle" | "line" | "dashboard";
+        readonly format: import('element-plus').ProgressFn;
+        readonly duration: number;
+        readonly indeterminate: boolean;
+        readonly percentage: number;
+        readonly status: "" | "success" | "warning" | "exception";
+        readonly showText: boolean;
+        readonly textInside: boolean;
+        readonly striped: boolean;
+        readonly stripedFlow: boolean;
+    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: {
+            default?(_: {
+                percentage: number;
+            }): any;
+            default?(_: {
+                percentage: number;
+            }): any;
+        };
+    }) & import('vue').Plugin;
+    ElIcon: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+            readonly size: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly color: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('vue').ExtractPropTypes<{
+            readonly size: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly color: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+        readonly size: {
+            readonly type: PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly color: {
+            readonly type: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: {
+            default?(_: {}): any;
+        };
+    }) & import('vue').Plugin;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;