@dt-frames/ui 2.0.13 → 2.0.15

package/es/packages/ui/src/components/form/src/types/items.type.d.ts

@@ -0,0 +1,409 @@
+import { UploadFile } from '../../../upload';
+import { DtEvent, Recordable, SelectOptions } from "@dt-frames/core";
+import { UploadRequestOption } from "ant-design-vue/es/vc-upload/interface";
+import dayjs from "dayjs";
+import { Ref, Slot, VNode, CSSProperties, ComputedRef } from "vue";
+declare type StrOrDynamicStr = string | Ref<string> | ComputedRef<string>;
+declare type BaseInput = {
+    placeholder?: StrOrDynamicStr;
+    addonAfter?: string | VNode;
+    addonBefore?: string | VNode;
+    allowClear?: boolean;
+    bordered?: boolean;
+    defaultValue?: string;
+    disabled?: boolean | Ref<boolean>;
+    id?: string;
+    maxlength?: number;
+    prefix?: string | VNode;
+    showCount?: boolean;
+    size?: 'large' | 'default' | 'small';
+    suffix?: string | VNode;
+    [key: string]: any;
+};
+export declare type Input = BaseInput & {
+    onChange?: (e: DtEvent, model: Recordable) => void;
+    onPressEnter?: (e: DtEvent, model: Recordable) => void;
+};
+export declare type InputGroup = {
+    defaultValue?: any[];
+    compact?: boolean;
+    size?: 'large' | 'default' | 'small';
+    [key: string]: any;
+};
+export declare type InputPassword = Input & {
+    visibilityToggle?: boolean;
+    onChange?: (e: DtEvent, model: Recordable) => void;
+};
+export declare type InputSearch = Input & {
+    enterButton?: boolean | VNode;
+    loading?: boolean | Ref<boolean>;
+    onSearch?: (searchValue: string) => void;
+    onChange?: (e: DtEvent, model: Recordable) => void;
+};
+export declare type InputTextArea = Input & {
+    autosize?: boolean | object;
+    rows?: number;
+    onPressEnter?: (e: DtEvent, model: Recordable) => void;
+    onChange?: (e: DtEvent, model: Recordable) => void;
+};
+export declare type InputNumber = {
+    addonAfter?: string | VNode;
+    addonBefore?: string | VNode;
+    autofocus?: boolean;
+    bordered?: boolean;
+    controls?: boolean;
+    decimalSeparator?: string;
+    defaultValue?: number;
+    disabled?: boolean | Ref<boolean>;
+    formatter?: (value: number | string, info: {
+        userTyping: boolean;
+        input: string;
+    }) => string;
+    parser?: (value: string) => number | string;
+    keyboard?: boolean;
+    max?: number;
+    min?: number;
+    precision?: number;
+    prefix?: string | VNode;
+    size?: 'large' | 'default' | 'small';
+    step?: number | string;
+    stringMode?: boolean;
+    onChange?: (value: number | string, model: Recordable) => void;
+    onPressEnter?: (e: DtEvent, model: Recordable) => void;
+    onStep?: (value: number, info: {
+        offset: number;
+        type: 'up' | 'down';
+    }, model: Recordable) => void;
+    [key: string]: any;
+};
+export declare type Select = {
+    allowClear?: boolean;
+    autoClearSearchValue?: boolean;
+    autofocus?: boolean;
+    bordered?: boolean;
+    clearIcon?: VNode | Slot;
+    defaultActiveFirstOption?: boolean;
+    defaultOpen?: boolean;
+    disabled?: boolean | Ref<boolean>;
+    dropdownClassName?: string;
+    dropdownMatchSelectWidth?: boolean | number;
+    dropdownMenuStyle?: CSSProperties;
+    dropdownRender?: ({ menuNode, props }: {
+        menuNode: any;
+        props: any;
+    }) => VNode | Slot;
+    dropdownStyle?: CSSProperties;
+    fieldNames?: {
+        options?: string;
+        label?: string;
+        value?: string;
+    };
+    filterOption?: boolean | ((inputValue: string, option: SelectOptions) => object);
+    firstActiveValue?: string | string[];
+    getPopupContainer?: () => object;
+    listHeight?: number;
+    maxTagCount?: number;
+    maxTagPlaceholder?: Slot;
+    maxTagTextLength?: number;
+    menuItemSelectedIcon?: VNode | Slot;
+    mode?: 'multiple' | 'tags' | 'combobox';
+    notFoundContent?: string | Slot;
+    open?: boolean;
+    optionFilterProp?: string;
+    options?: SelectOptions[] | ComputedRef<SelectOptions[]> | Ref<SelectOptions[]>;
+    placeholder?: StrOrDynamicStr;
+    removeIcon?: VNode | Slot;
+    searchValue?: string;
+    showArrow?: boolean;
+    showSearch?: boolean;
+    size?: 'large' | 'default' | 'small';
+    suffixIcon?: VNode | Slot;
+    virtual?: boolean;
+    onBlur?: (e: DtEvent, model: Recordable) => void;
+    onChange?: (value: string | number | boolean, option: SelectOptions, model: Recordable) => void;
+    onDeselect?: (value: string | number | boolean, option: SelectOptions, model: Recordable) => void;
+    dropdownVisibleChange?: (option: SelectOptions, model: Recordable) => void;
+    onFocus?: (e: DtEvent, model: Recordable) => void;
+    onInputKeyDown?: (e: DtEvent, model: Recordable) => void;
+    onPopupScroll?: (e: DtEvent, model: Recordable) => void;
+    onSearch?: (val: string, model: Recordable) => void;
+    onSelect?: (value: string | number | boolean, option: SelectOptions, model: Recordable) => void;
+    [key: string]: any;
+};
+declare type TreeNode = {
+    checkable?: boolean;
+    disableCheckbox?: boolean;
+    disabled?: boolean;
+    isLeaf?: boolean;
+    key?: string | number;
+    selectable?: boolean;
+    title?: string | Slot;
+    value?: string;
+    children?: TreeNode[];
+    [key: string]: any;
+};
+export declare type TreeSelect = {
+    allowClear?: boolean;
+    defaultValue?: string | string[];
+    disabled?: boolean | Ref<boolean>;
+    dropdownClassName?: string;
+    dropdownMatchSelectWidth?: boolean | number;
+    dropdownStyle?: CSSProperties;
+    fieldNames?: {
+        children?: string;
+        label?: string;
+        value?: string;
+    };
+    filterTreeNode?: boolean | ((inputValue: string, treeNode: TreeNode) => boolean);
+    getPopupContainer?: () => object;
+    listHeight?: number;
+    maxTagCount?: number;
+    multiple?: boolean;
+    placeholder?: StrOrDynamicStr;
+    replaceFields?: {
+        children?: string;
+        label?: string;
+        value?: string;
+    };
+    searchPlaceholder?: string;
+    showSearch?: boolean;
+    size?: 'large' | 'default' | 'small';
+    treeCheckable?: boolean;
+    treeCheckStrictly?: boolean;
+    treeData?: TreeNode[];
+    treeDataSimpleMode?: boolean;
+    treeDefaultExpandAll?: boolean;
+    treeDefaultExpandedKeys?: string[] | number[];
+    treeExpandedKeys?: string[] | number[];
+    treeIcon?: boolean;
+    treeLine?: boolean;
+    treeNodeFilterProp?: string;
+    treeNodeLabelProp?: string;
+    virtual?: boolean;
+    onChange?: (value: string | number, label: string, extra: object, model: Recordable) => void;
+    onDropdownVisibleChange?: (open: boolean, model: Recordable) => void;
+    onSearch?: (val: string, model: Recordable) => void;
+    onSelect?: (val: string | number, node: TreeNode, extra: object, model: Recordable) => void;
+    onTreeExpand?: (expandedKeys: (string | number)[], model: Recordable) => void;
+    [key: string]: any;
+};
+export declare type Radio = {
+    autofocus?: boolean;
+    defaultValue?: string | number;
+    disabled?: boolean | Ref<boolean>;
+    value?: string | number;
+    [key: string]: any;
+};
+export declare type RadioGroup = {
+    buttonStyle?: 'outline' | 'solid';
+    disabled?: boolean;
+    name?: string;
+    options?: string[] | number[] | SelectOptions[] | ComputedRef<SelectOptions[]> | Ref<SelectOptions[]>;
+    optionType?: 'default' | 'button';
+    size?: 'large' | 'default' | 'small';
+    defaultValue?: string | number | boolean;
+    [key: string]: any;
+};
+export declare type Checkbox = {
+    autofocus?: boolean;
+    defaultValue?: string | number | boolean;
+    disabled?: boolean;
+    indeterminate?: boolean;
+    value?: boolean | string | number;
+    onChange?: (e: Event, model: Recordable) => void;
+    [key: string]: any;
+};
+export declare type CheckboxGroup = {
+    defaultValue?: (string | number | boolean)[];
+    disabled?: boolean;
+    name?: string;
+    options?: string[] | (SelectOptions & {
+        indeterminate?: boolean;
+    })[] | ComputedRef<(SelectOptions & {
+        indeterminate?: boolean;
+    })[]> | Ref<(SelectOptions & {
+        indeterminate?: boolean;
+    })[]>;
+    onChange?: (checkedValue: (string | number | boolean)[], model: Recordable) => void;
+    [key: string]: any;
+};
+declare type CascaderOption = {
+    value?: string | number;
+    label?: any;
+    disabled?: boolean;
+    isLeaf?: boolean;
+    children?: CascaderOption[];
+    [key: string]: any;
+};
+export declare type Cascader = {
+    allowClear?: boolean;
+    autofocus?: boolean;
+    bordered?: boolean;
+    clearIcon?: VNode;
+    changeOnSelect?: boolean;
+    defaultValue?: string[] | number[];
+    disabled?: boolean;
+    dropdownClassName?: string;
+    dropdownStyle?: CSSProperties;
+    expandIcon?: VNode;
+    expandTrigger?: 'click' | 'hover';
+    fieldNames?: {
+        children?: string;
+        label?: string;
+        value?: string;
+    };
+    getPopupContainer?: () => object;
+    loadData?: (selectedOptions: CascaderOption) => void;
+    maxTagCount?: number | 'responsive';
+    multiple?: boolean;
+    notFoundContent?: string | VNode;
+    open?: boolean;
+    options?: CascaderOption[] | ComputedRef<CascaderOption[]> | Ref<CascaderOption[]>;
+    placement?: 'bottomLeft' | 'bottomRight' | 'topLeft' | 'topRight';
+    searchValue?: string;
+    showSearch?: boolean | object;
+    size?: 'large' | 'default' | 'small';
+    suffixIcon?: string | VNode | Slot;
+    filter?: (inputValue: string | number, path: any) => boolean;
+    limit?: number | false;
+    matchInputWidth?: boolean;
+    render?: (inputValue: string | number, path: any) => VNode;
+    sort?: (a: Recordable, b: Recordable, inputValue: string | number) => boolean;
+    onChange?: (value: string | number, selectedOptions: CascaderOption, model: Recordable) => void;
+    dropdownVisibleChange?: (val: boolean, model: Recordable) => void;
+    onSearch?: (val: string | number, model: Recordable) => void;
+    [key: string]: any;
+};
+declare type BaseDatepicker = {
+    allowClear?: boolean;
+    autofocus?: boolean;
+    bordered?: boolean;
+    disabled?: boolean;
+    disabledDate?: (currentDate: any) => boolean;
+    dropdownClassName?: string;
+    getPopupContainer?: object;
+    inputReadOnly?: boolean;
+    mode?: 'time' | 'date' | 'month' | 'year' | 'decade';
+    open?: boolean | Ref<boolean>;
+    picker?: 'date' | 'week' | 'month' | 'quarter' | 'year';
+    placeholder?: StrOrDynamicStr;
+    popupStyle?: CSSProperties;
+    size?: 'large' | 'middle' | 'small';
+    onOpenChange?: (status: boolean, model: Recordable) => void;
+    onPanelChange?: (val: any, mode: any, model: Recordable) => void;
+};
+export declare type DatePicker = BaseDatepicker & {
+    defaultPickerValue?: dayjs.Dayjs;
+    disabledTime?: (date: dayjs.Dayjs) => boolean;
+    format?: string | ((value: dayjs.Dayjs) => string) | (string | ((value: dayjs.Dayjs) => string))[];
+    showNow?: boolean;
+    showTime?: boolean | {
+        defaultValue?: dayjs.Dayjs;
+    };
+    showToday?: boolean;
+    onChange?: (date: dayjs.Dayjs | string, dateString: string, model: Recordable) => void;
+    onOk?: (date: dayjs.Dayjs | string, model: Recordable) => void;
+    [key: string]: any;
+};
+export declare type RangePicker = BaseDatepicker & {
+    allowEmpty?: [boolean, boolean];
+    defaultPickerValue?: dayjs.Dayjs[];
+    disabled?: [boolean, boolean];
+    disabledTime?: (date: dayjs.Dayjs, partial: 'start' | 'end') => boolean;
+    format?: string;
+    showTime?: boolean | {
+        defaultValue?: dayjs.Dayjs[];
+    };
+    onCalendarChange?: (dates: [dayjs.Dayjs, dayjs.Dayjs] | [string, string], dateStrings: [string, string], info: {
+        range: 'start' | 'end';
+    }, model: Recordable) => void;
+    onChange?: (date: [dayjs.Dayjs, dayjs.Dayjs] | [string, string], dateString: [string, string], model: Recordable) => void;
+    onOk?: (date: [dayjs.Dayjs, dayjs.Dayjs] | [string, string], model: Recordable) => void;
+    [key: string]: any;
+};
+export declare type TimePicker = {
+    allowClear?: boolean;
+    autofocus?: boolean;
+    defaultPickerValue?: string | dayjs.Dayjs;
+    bordered?: boolean;
+    clearText?: string;
+    disabled?: boolean;
+    format?: string;
+    getPopupContainer?: () => object;
+    hideDisabledOptions?: boolean;
+    hourStep?: number;
+    inputReadOnly?: boolean;
+    minuteStep?: number;
+    open?: boolean | Ref<boolean>;
+    placeholder?: string | [string | string];
+    popupClassName?: string;
+    popupStyle?: CSSProperties;
+    secondStep?: number;
+    showNow?: boolean;
+    use12Hours?: boolean;
+    onChange?: (time: dayjs.Dayjs | string, dateString: string, model: Recordable) => void;
+    onOpenChange?: (open: boolean) => void;
+    [key: string]: any;
+};
+export declare type Switch = {
+    autofocus?: boolean;
+    checkedChildren?: string | VNode;
+    defaultPickerValue?: boolean | string | number;
+    checkedValue?: boolean | string | number;
+    disabled?: boolean;
+    loading?: boolean | Ref<boolean>;
+    size?: 'default' | 'small';
+    unCheckedChildren?: string | VNode;
+    unCheckedValue?: boolean | string | number;
+    onChange?: (checked: boolean | string | number, event: Event, model: Recordable) => void;
+    onClick?: (checked: boolean | string | number, event: Event, model: Recordable) => void;
+    [key: string]: any;
+};
+export declare type Rate = {
+    allowClear?: boolean;
+    allowHalf?: boolean;
+    autofocus?: boolean;
+    defaultPickerValue?: number;
+    character?: string | VNode;
+    count?: number;
+    disabled?: boolean;
+    tooltips?: string[];
+    onBlur?: (e: any, model: Recordable) => void;
+    onChange?: (value: number) => void;
+    [key: string]: any;
+};
+export declare type Divider = {
+    dashed?: boolean;
+    orientation?: boolean;
+    orientationMargin?: string | number;
+    plain?: boolean;
+    type?: 'horizontal' | 'vertical';
+    [key: string]: any;
+};
+export declare type InputWithDialog = Input & {
+    openDialog?: (model: Recordable) => void;
+};
+export declare type Upload = {
+    uploadUrl?: string;
+    downloadUrl?: string;
+    buttonText?: string;
+    preIcon?: string;
+    data?: object | ((file: UploadFile) => object);
+    filename?: string;
+    accept?: string[];
+    customRequest?: (params: UploadRequestOption) => void;
+    disabled?: boolean | Ref<boolean> | ComputedRef<boolean>;
+    defaultFiles?: UploadFile[];
+    headers?: object;
+    listType?: 'text' | 'picture-card';
+    maxCount?: number;
+    maxSize?: number;
+    helpText?: string;
+    multiple?: boolean;
+    onChange?: (ids: string[] | number[], files: UploadFile[]) => void;
+    extraParams?: Recordable;
+    showView?: boolean;
+    showDownload?: boolean;
+    showDelete?: boolean;
+};
+export {};

package/es/packages/ui/src/components/iframe/index.d.ts

@@ -0,0 +1,2 @@
+import DtIframe from "./src/index";
+export { DtIframe };

package/es/packages/ui/src/components/modal/index.d.ts

@@ -0,0 +1,4 @@
+import { useModal, useModalOut } from './src/hooks/useModal';
+import { default as DtModal } from "./src/index";
+import { basicProps } from './src/props';
+export { basicProps, DtModal, useModalOut, useModal };

package/es/packages/ui/src/components/modal/src/hooks/useModal.d.ts

@@ -0,0 +1,5 @@
+import { ExtractPropTypes } from "vue";
+import { basicProps } from "../props";
+import { UseModalReturnType, UseModalInnerReturnType } from "../types/modal.type";
+export declare function useModalOut(): UseModalReturnType;
+export declare function useModal(props: Partial<ExtractPropTypes<typeof basicProps>>, setModalData?: (params: any) => void): UseModalInnerReturnType;

package/es/packages/ui/src/components/modal/src/props.d.ts

@@ -0,0 +1,101 @@
+import { ButtonProps } from '../../form/src/types/form.type';
+import { Recordable } from "@dt-frames/core";
+import { ComputedRef, CSSProperties, PropType } from "vue";
+export declare const basicProps: {
+    t: {
+        type: StringConstructor;
+    };
+    visible: {
+        type: BooleanConstructor;
+    };
+    closable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    destroyOnClose: {
+        type: BooleanConstructor;
+    };
+    scrollTop: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    height: {
+        type: NumberConstructor;
+    };
+    minHeight: {
+        type: NumberConstructor;
+    };
+    width: {
+        type: PropType<String | Number>;
+    };
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    defaultFullscreen: {
+        type: BooleanConstructor;
+    };
+    canFullscreen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: PropType<String | ComputedRef<String> | ((data: Recordable) => String)>;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loadingTip: {
+        type: StringConstructor;
+        default: string;
+    };
+    useWrapper: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    wrapClassName: {
+        type: StringConstructor;
+    };
+    zIndex: {
+        type: NumberConstructor;
+    };
+    centered: {
+        type: BooleanConstructor;
+    };
+    showOkBtn: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showCancelBtn: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    okText: {
+        type: StringConstructor;
+    };
+    cancelText: {
+        type: StringConstructor;
+    };
+    mask: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maskClosable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    keyboard: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maskStyle: PropType<CSSProperties>;
+    footer: {
+        type: PropType<ButtonProps[]>;
+    };
+    bodyStyle: PropType<CSSProperties>;
+    wrapperProps: ObjectConstructor;
+    getContainer: PropType<() => any>;
+    closeFunc: PropType<() => Promise<boolean>>;
+    afterClose: FunctionConstructor;
+};

package/es/packages/ui/src/components/modal/src/types/modal.type.d.ts

@@ -0,0 +1,17 @@
+import { ExtractPropTypes } from "vue";
+import { basicProps } from "../props";
+export declare type ModalMethods = {
+    setModalProps: (props: Partial<ExtractPropTypes<typeof basicProps>>) => void;
+    redoModalHeight?: () => void;
+};
+export interface ReturnMethods extends ModalMethods {
+    openModal: <T = any, U = any>(params?: T, afterClose?: (res: U) => void) => void;
+    closeModal: () => void;
+}
+export interface ReturnInnerMethods extends ModalMethods {
+    closeModal: <T = any>(res?: T) => void;
+    setLoading: (loading: boolean) => void;
+}
+export declare type RegisterFn = (modalMethods: ModalMethods, uuid?: string) => void;
+export declare type UseModalReturnType = [RegisterFn, ReturnMethods];
+export declare type UseModalInnerReturnType = [RegisterFn, ReturnInnerMethods];

package/es/packages/ui/src/components/upload/index.d.ts

@@ -0,0 +1,4 @@
+import { default as DtUpload } from "./src/index";
+import { UploadFile } from './src/type/file';
+export { DtUpload };
+export type { UploadFile };

package/es/packages/ui/src/components/upload/src/basicProps.d.ts

@@ -0,0 +1,87 @@
+import { PropType, Ref, ComputedRef } from "vue";
+import { UploadFile } from "./type/file";
+import { UploadRequestOption } from "ant-design-vue/es/vc-upload/interface";
+import { Recordable } from "@dt-frames/core";
+export declare const basicProps: {
+    uploadUrl: {
+        type: StringConstructor;
+    };
+    downloadUrl: {
+        type: StringConstructor;
+    };
+    buttonText: {
+        type: StringConstructor;
+        default: string;
+    };
+    preIcon: {
+        type: StringConstructor;
+        default: string;
+    };
+    data: {
+        type: PropType<object | ((file: UploadFile) => object)>;
+        default: {};
+    };
+    filename: {
+        type: StringConstructor;
+        default: string;
+    };
+    accept: {
+        type: PropType<string[]>;
+        default: () => any[];
+    };
+    beforeUpload: {
+        type: PropType<(<T = any>(file: UploadFile, fileList: UploadFile[]) => boolean | Promise<T>)>;
+    };
+    customRequest: {
+        type: PropType<(params: UploadRequestOption) => void>;
+    };
+    disabled: {
+        type: PropType<Boolean | Ref<Boolean> | ComputedRef<Boolean>>;
+        default: boolean;
+    };
+    defaultFiles: {
+        type: PropType<UploadFile[]>;
+        default: () => any[];
+    };
+    headers: {
+        type: ObjectConstructor;
+    };
+    listType: {
+        type: PropType<"text" | "picture-card">;
+        default: string;
+    };
+    maxCount: {
+        type: NumberConstructor;
+    };
+    maxSize: {
+        type: NumberConstructor;
+        default: number;
+    };
+    helpText: {
+        type: StringConstructor;
+        default: string;
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onChange: {
+        type: PropType<(ids: string[] | number[], files: UploadFile[]) => void>;
+    };
+    extraParams: {
+        type: PropType<Recordable<any>>;
+        default: () => {};
+    };
+    showView: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showDownload: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showDelete: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};

package/es/packages/ui/src/components/upload/src/components/PdfView.d.ts

@@ -0,0 +1,9 @@
+declare const _sfc_main: import("vue").DefineComponent<{}, {
+    exeReduce: import("vue").Ref<number>;
+    pdfUrlRef: import("vue").Ref<any>;
+    register: import("../../../modal/src/types/modal.type").RegisterFn;
+    toggleFullscreen: (isFullscreen: boolean) => void;
+    readonly DtModal: import("vue").DefineComponent<{}, {}, any, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+    readonly DtIframe: import("vue").DefineComponent<{}, {}, any, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+export default _sfc_main;

package/es/packages/ui/src/components/upload/src/components/WordView.d.ts

@@ -0,0 +1,6 @@
+declare const _sfc_main: import("vue").DefineComponent<{}, {
+    ID: string;
+    register: import("../../../modal/src/types/modal.type").RegisterFn;
+    readonly DtModal: import("vue").DefineComponent<{}, {}, any, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+export default _sfc_main;

package/es/packages/ui/src/components/upload/src/hooks/useFile.d.ts

@@ -0,0 +1,16 @@
+import { Ref } from "vue";
+import { UploadFile } from "../type/file";
+export declare function useFile({ fileListRef, acceptRef, helpTextRef, maxCountRef, maxSizeRef, }: {
+    fileListRef: Ref<UploadFile[]>;
+    acceptRef: Ref<string[]>;
+    helpTextRef: Ref<string>;
+    maxCountRef: Ref<number>;
+    maxSizeRef: Ref<number>;
+}): {
+    getAccept: import("vue").ComputedRef<string[]>;
+    getStringAccept: import("vue").ComputedRef<string>;
+    getHelpText: import("vue").ComputedRef<string>;
+    fileList: Ref<any[]>;
+    setFile: (file: any) => any;
+    beforeUpload: (file: File) => void;
+};