@duxweb/dvha-pro 0.0.8 → 1.0.14

package/dist/types/components/data/dynamicData.d.ts

@@ -0,0 +1,56 @@
+import type { JsonSchemaNode } from '@duxweb/dvha-core';
+import type { PropType, VNode } from 'vue';
+export interface DuxDynamicDataColumn {
+    key: string;
+    title?: string;
+    copy?: boolean;
+    width?: number;
+    render?: (cell: Record<string, any>, rowIndex: number) => VNode;
+    schema?: JsonSchemaNode | JsonSchemaNode[];
+}
+export declare const DuxDynamicData: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    createAction: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    deleteAction: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    columns: PropType<DuxDynamicDataColumn[]>;
+    createCallback: PropType<(value: Record<string, any>[]) => void>;
+    onCreate: FunctionConstructor;
+    value: {
+        type: PropType<Record<string, any>[]>;
+        default: never[];
+    };
+    defaultValue: {
+        type: PropType<Record<string, any>[]>;
+        default: never[];
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    createAction: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    deleteAction: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    columns: PropType<DuxDynamicDataColumn[]>;
+    createCallback: PropType<(value: Record<string, any>[]) => void>;
+    onCreate: FunctionConstructor;
+    value: {
+        type: PropType<Record<string, any>[]>;
+        default: never[];
+    };
+    defaultValue: {
+        type: PropType<Record<string, any>[]>;
+        default: never[];
+    };
+}>> & Readonly<{}>, {
+    value: Record<string, any>[];
+    defaultValue: Record<string, any>[];
+    createAction: boolean;
+    deleteAction: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/types/components/data/dynamicSelect.d.ts

@@ -0,0 +1,49 @@
+import type { JsonSchemaNode } from '@duxweb/dvha-core';
+import type { TableColumn } from '@duxweb/dvha-naiveui';
+import type { PropType } from 'vue';
+import type { DuxDynamicDataColumn } from './dynamicData';
+type Value = Record<string, any>[];
+export declare const DuxDynamicSelect: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    rowKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    path: StringConstructor;
+    columns: PropType<DuxDynamicDataColumn[]>;
+    filterColumns: PropType<TableColumn[]>;
+    filterSchema: {
+        type: PropType<JsonSchemaNode[]>;
+    };
+    value: {
+        type: PropType<Value>;
+        default: never[];
+    };
+    defaultValue: {
+        type: PropType<Value>;
+        default: never[];
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    rowKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    path: StringConstructor;
+    columns: PropType<DuxDynamicDataColumn[]>;
+    filterColumns: PropType<TableColumn[]>;
+    filterSchema: {
+        type: PropType<JsonSchemaNode[]>;
+    };
+    value: {
+        type: PropType<Value>;
+        default: never[];
+    };
+    defaultValue: {
+        type: PropType<Value>;
+        default: never[];
+    };
+}>> & Readonly<{}>, {
+    value: Value;
+    defaultValue: Value;
+    rowKey: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export {};

package/dist/types/components/data/index.d.ts

@@ -0,0 +1,3 @@
+export * from './dynamicData';
+export * from './dynamicSelect';
+export * from './selectModal';

package/dist/types/components/data/selectModal.d.ts

@@ -0,0 +1,61 @@
+import type { TableColumn } from '@duxweb/dvha-naiveui';
+import type { PropType } from 'vue';
+import { type JsonSchemaNode } from '@duxweb/dvha-core';
+declare const Select: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    path: StringConstructor;
+    columns: {
+        (arrayLength: number): TableColumn[];
+        (...items: TableColumn[]): TableColumn[];
+        new (arrayLength: number): TableColumn[];
+        new (...items: TableColumn[]): TableColumn[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    };
+    rowKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    filterSchema: {
+        type: PropType<JsonSchemaNode[]>;
+    };
+    onConfirm: FunctionConstructor;
+    onClose: FunctionConstructor;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    path: StringConstructor;
+    columns: {
+        (arrayLength: number): TableColumn[];
+        (...items: TableColumn[]): TableColumn[];
+        new (arrayLength: number): TableColumn[];
+        new (...items: TableColumn[]): TableColumn[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    };
+    rowKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    filterSchema: {
+        type: PropType<JsonSchemaNode[]>;
+    };
+    onConfirm: FunctionConstructor;
+    onClose: FunctionConstructor;
+}>> & Readonly<{}>, {
+    rowKey: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default Select;

package/dist/types/components/dialog/dialog.d.ts

@@ -5,12 +5,14 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     content: StringConstructor;
     type: PropType<"confirm" | "success" | "error" | "prompt" | "node">;
     formSchema: PropType<JsonSchemaData>;
+    defaultValue: PropType<Record<string, any>>;
     render: FunctionConstructor;
 }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     title: StringConstructor;
     content: StringConstructor;
     type: PropType<"confirm" | "success" | "error" | "prompt" | "node">;
     formSchema: PropType<JsonSchemaData>;
+    defaultValue: PropType<Record<string, any>>;
     render: FunctionConstructor;
 }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/dist/types/components/editor/aiEditor.d.ts

@@ -0,0 +1,26 @@
+import type { PropType } from 'vue';
+export declare const DuxAiEditor: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: StringConstructor;
+    defaultValue: StringConstructor;
+    uploadUrl: StringConstructor;
+    uploadHeaders: PropType<Record<string, any>>;
+    aiUrl: StringConstructor;
+    height: {
+        type: StringConstructor;
+        default: string;
+    };
+    onUpdateValue: PropType<(value: string) => void>;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: StringConstructor;
+    defaultValue: StringConstructor;
+    uploadUrl: StringConstructor;
+    uploadHeaders: PropType<Record<string, any>>;
+    aiUrl: StringConstructor;
+    height: {
+        type: StringConstructor;
+        default: string;
+    };
+    onUpdateValue: PropType<(value: string) => void>;
+}>> & Readonly<{}>, {
+    height: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/types/components/editor/index.d.ts

@@ -0,0 +1 @@
+export * from './aiEditor';

package/dist/types/components/index.d.ts

@@ -1,17 +1,24 @@
 export * from './card';
 export * from './carousel';
 export * from './chart';
+export * from './crop';
 export * from './dashboard';
+export * from './data';
 export * from './dialog';
 export * from './draw';
 export * from './drawer';
+export * from './editor';
 export * from './form';
 export * from './layout';
+export * from './level';
 export * from './list';
 export * from './media';
 export * from './modal';
 export * from './panel';
 export * from './select';
+export * from './stats';
 export * from './status';
 export * from './table';
+export * from './upload';
+export * from './upload';
 export * from './widget';

package/dist/types/components/level/index.d.ts

@@ -0,0 +1 @@
+export * from './level';

package/dist/types/components/level/level.d.ts

@@ -0,0 +1,60 @@
+export declare const DuxLevel: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: () => string[];
+        default: () => never[];
+    };
+    path: {
+        type: StringConstructor;
+        default: string;
+    };
+    maxLevel: {
+        type: NumberConstructor;
+        default: number;
+    };
+    nameField: {
+        type: StringConstructor;
+        default: string;
+    };
+    labelField: {
+        type: StringConstructor;
+        default: string;
+    };
+    valueField: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:value"[], "update:value", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: () => string[];
+        default: () => never[];
+    };
+    path: {
+        type: StringConstructor;
+        default: string;
+    };
+    maxLevel: {
+        type: NumberConstructor;
+        default: number;
+    };
+    nameField: {
+        type: StringConstructor;
+        default: string;
+    };
+    labelField: {
+        type: StringConstructor;
+        default: string;
+    };
+    valueField: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+}>, {
+    path: string;
+    value: string[];
+    labelField: string;
+    maxLevel: number;
+    nameField: string;
+    valueField: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/types/components/modal/index.d.ts

@@ -1,3 +1,3 @@
 export * from './modal';
-export { default as ModalPage } from './modalPage';
-export { default as ModalTab } from './modalTab';
+export { default as DuxModalPage } from './modalPage';
+export { default as DuxModalTab } from './modalTab';

package/dist/types/components/modal/modal.d.ts

@@ -3,7 +3,6 @@ import type { AsyncComponentLoader, Component, PropType } from 'vue';
 export declare const DuxModal: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     title: {
         type: StringConstructor;
-        default: string;
     };
     component: {
         type: PropType<AsyncComponentLoader<any> | Component>;
@@ -23,7 +22,6 @@ export declare const DuxModal: import("vue").DefineComponent<import("vue").Extra
 }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     title: {
         type: StringConstructor;
-        default: string;
     };
     component: {
         type: PropType<AsyncComponentLoader<any> | Component>;
@@ -41,8 +39,7 @@ export declare const DuxModal: import("vue").DefineComponent<import("vue").Extra
         default: boolean;
     };
 }>> & Readonly<{}>, {
-    title: string;
-    draggable: boolean;
     width: string | number;
+    draggable: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default DuxModal;

package/dist/types/components/stats/index.d.ts

@@ -0,0 +1,2 @@
+export * from './number';
+export * from './realTime';

package/dist/types/components/stats/number.d.ts

@@ -0,0 +1,50 @@
+import type { PropType } from 'vue';
+export declare const DuxStatsNumber: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    subtitle: {
+        type: StringConstructor;
+        default: string;
+    };
+    value: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    change: {
+        type: NumberConstructor;
+        default: number;
+    };
+    changeType: {
+        type: PropType<"up" | "down">;
+        default: string;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    subtitle: {
+        type: StringConstructor;
+        default: string;
+    };
+    value: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    change: {
+        type: NumberConstructor;
+        default: number;
+    };
+    changeType: {
+        type: PropType<"up" | "down">;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    title: string;
+    value: string | number;
+    change: number;
+    subtitle: string;
+    changeType: "up" | "down";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/types/components/stats/realTime.d.ts

@@ -0,0 +1,56 @@
+import type { PropType } from 'vue';
+export interface StatsCardItem {
+    label: string;
+    value: number | string;
+    color?: string;
+}
+export interface StatsChartItem {
+    title: string;
+    value: number | string;
+    subtitle?: string;
+    change?: number;
+    changeType?: 'up' | 'down';
+    labels?: string[];
+    data: number[];
+    color?: string;
+}
+export declare const DuxStatsRealTime: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    subtitle: {
+        type: StringConstructor;
+        default: string;
+    };
+    cards: {
+        type: PropType<StatsCardItem[]>;
+        default: () => never[];
+    };
+    charts: {
+        type: PropType<StatsChartItem[]>;
+        default: () => never[];
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    subtitle: {
+        type: StringConstructor;
+        default: string;
+    };
+    cards: {
+        type: PropType<StatsCardItem[]>;
+        default: () => never[];
+    };
+    charts: {
+        type: PropType<StatsChartItem[]>;
+        default: () => never[];
+    };
+}>> & Readonly<{}>, {
+    title: string;
+    cards: StatsCardItem[];
+    subtitle: string;
+    charts: StatsChartItem[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/types/components/upload/file.d.ts

@@ -0,0 +1,9 @@
+import type { IUploadParams } from './manager';
+export interface IUploadProps extends IUploadParams {
+    managePath?: string;
+    value?: string | string[];
+    defaultValue?: string | string[];
+    onUpdateValue?: (value?: string | string[]) => void;
+    manager?: boolean;
+}
+export declare const DuxFileUpload: import("vue").DefineComponent<IUploadProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<IUploadProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/types/components/upload/image.d.ts

@@ -0,0 +1,99 @@
+import type { PropType } from 'vue';
+export declare const DuxImageUpload: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    path: {
+        type: StringConstructor;
+        default: string;
+    };
+    managePath: {
+        type: StringConstructor;
+        default: string;
+    };
+    maxNum: NumberConstructor;
+    maxSize: NumberConstructor;
+    multiple: BooleanConstructor;
+    manager: BooleanConstructor;
+    value: (StringConstructor | {
+        (arrayLength: number): string[];
+        (...items: string[]): string[];
+        new (arrayLength: number): string[];
+        new (...items: string[]): string[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    })[];
+    defaultValue: (StringConstructor | {
+        (arrayLength: number): string[];
+        (...items: string[]): string[];
+        new (arrayLength: number): string[];
+        new (...items: string[]): string[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    })[];
+    onUpdateValue: PropType<(value?: string | string[]) => void>;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    path: {
+        type: StringConstructor;
+        default: string;
+    };
+    managePath: {
+        type: StringConstructor;
+        default: string;
+    };
+    maxNum: NumberConstructor;
+    maxSize: NumberConstructor;
+    multiple: BooleanConstructor;
+    manager: BooleanConstructor;
+    value: (StringConstructor | {
+        (arrayLength: number): string[];
+        (...items: string[]): string[];
+        new (arrayLength: number): string[];
+        new (...items: string[]): string[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    })[];
+    defaultValue: (StringConstructor | {
+        (arrayLength: number): string[];
+        (...items: string[]): string[];
+        new (arrayLength: number): string[];
+        new (...items: string[]): string[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    })[];
+    onUpdateValue: PropType<(value?: string | string[]) => void>;
+}>> & Readonly<{}>, {
+    path: string;
+    multiple: boolean;
+    managePath: string;
+    manager: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/types/components/upload/index.d.ts

@@ -0,0 +1,4 @@
+export * from './file';
+export * from './image';
+export * from './manager';
+export { default as DuxFileManage } from './manager';

package/dist/types/components/upload/manage/item.d.ts

@@ -0,0 +1,22 @@
+import type { PropType } from 'vue';
+export declare const DuxFileManageItem: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    name: StringConstructor;
+    url: StringConstructor;
+    type: PropType<"file" | "folder">;
+    mime: StringConstructor;
+    time: StringConstructor;
+    value: BooleanConstructor;
+    onContextmenu: PropType<(e: MouseEvent) => void>;
+    onSelect: FunctionConstructor;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    name: StringConstructor;
+    url: StringConstructor;
+    type: PropType<"file" | "folder">;
+    mime: StringConstructor;
+    time: StringConstructor;
+    value: BooleanConstructor;
+    onContextmenu: PropType<(e: MouseEvent) => void>;
+    onSelect: FunctionConstructor;
+}>> & Readonly<{}>, {
+    value: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/types/components/upload/manager.d.ts

@@ -0,0 +1,37 @@
+import type { PropType } from 'vue';
+export interface IUploadParams {
+    path?: string;
+    accept?: string;
+    multiple?: boolean;
+    maxNum?: number;
+    maxSize?: number;
+}
+declare const DuxFileManage: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    path: StringConstructor;
+    type: StringConstructor;
+    onConfirm: PropType<(value: Record<string, any>[]) => void>;
+    onClose: PropType<() => void>;
+    multiple: BooleanConstructor;
+    page: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    handle: StringConstructor;
+    uploadParams: PropType<IUploadParams>;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    path: StringConstructor;
+    type: StringConstructor;
+    onConfirm: PropType<(value: Record<string, any>[]) => void>;
+    onClose: PropType<() => void>;
+    multiple: BooleanConstructor;
+    page: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    handle: StringConstructor;
+    uploadParams: PropType<IUploadParams>;
+}>> & Readonly<{}>, {
+    multiple: boolean;
+    page: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default DuxFileManage;