yc-design-vue 1.0.2 → 1.0.3

package/es/Image/type.d.ts

@@ -1,4 +1,5 @@
 import { ClassName, PopupContainer } from '../_shared/type';
+import { VNode } from 'vue';
 export interface ImageProps {
     src?: string;
     width?: number | string;
@@ -21,11 +22,11 @@ export interface ImageEmits {
     (e: 'preview-visible-change', visible: boolean): void;
 }
 export interface ImageSlots {
-    error(): void;
-    ['error-icon'](): void;
-    loader(): void;
-    extra(): void;
-    ['preview-actions'](): void;
+    error?: () => VNode[];
+    'error-icon'?: () => VNode[];
+    loader?: () => VNode[];
+    extra?: () => VNode[];
+    'preview-actions'?: () => VNode[];
 }
 export interface ImagePreviewProps {
     src?: string;
@@ -46,8 +47,8 @@ export interface ImagePreviewEmits {
     (e: 'close'): void;
 }
 export interface ImagePreviewSlots {
-    actions(): void;
-    arrow(): void;
+    actions?: () => VNode[];
+    arrow?: () => VNode[];
 }
 export interface ImagePreviewGroupProps extends Omit<ImagePreviewProps, 'src'> {
     srcList?: string[];
@@ -62,8 +63,8 @@ export interface ImagePreviewGroupEmits {
     (e: 'visible-change', value: boolean): void;
 }
 export interface ImagePreviewGroupSlots {
-    actions(): void;
-    default(): void;
+    actions?: () => VNode[];
+    default?: () => VNode[];
 }
 export interface ImagePreviewActionProps {
     name?: string;
@@ -75,7 +76,7 @@ export interface ImagePreviewActionEmits {
     (e: 'contextmenu', ev: MouseEvent): void;
 }
 export interface ImagePreviewActionSlots {
-    default(): void;
+    default?: () => VNode[];
 }
 export type ImageObjectFit = 'contain' | 'cover' | 'fill' | 'none' | 'scale-down';
 export type HideFooter = boolean | 'never';

package/es/Input/hooks/useCursor.d.ts

@@ -1,5 +1,5 @@
 import { Ref } from 'vue';
-export default function useCursor(input: Ref<HTMLInputElement | HTMLTextAreaElement | undefined>): {
+declare const _default: (input: Ref<HTMLInputElement | HTMLTextAreaElement | undefined>) => {
     recordCursor: () => void;
     setCursor: () => void;
     getCursor: () => number | undefined;
@@ -17,3 +17,4 @@ export default function useCursor(input: Ref<HTMLInputElement | HTMLTextAreaElem
         afterTxt?: string;
     } | undefined>;
 };
+export default _default;

package/es/Input/hooks/useCursor.js

@@ -1,5 +1,5 @@
 import { ref } from "vue";
-function useCursor(input) {
+const useCursor = (input) => {
   const selectionRef = ref();
   function recordCursor() {
     if (!input.value) return;
@@ -46,7 +46,7 @@ function useCursor(input) {
     getCursor,
     selectionRef
   };
-}
+};
 export {
   useCursor as default
 };

package/es/Input/type.d.ts

@@ -1,4 +1,5 @@
 import { Size, ObjectData } from '../_shared/type';
+import { VNode } from 'vue';
 export interface InputProps {
     modelValue?: string;
     defaultValue?: string;
@@ -32,11 +33,11 @@ export interface InputEmits {
     (e: 'blur', ev: FocusEvent): void;
 }
 export interface InputSlots {
-    prefix(): void;
-    suffix(): void;
-    prepend(): void;
-    append(): void;
-    label(): void;
+    prefix?: () => VNode[];
+    suffix?: () => VNode[];
+    prepend?: () => VNode[];
+    append?: () => VNode[];
+    label?: () => VNode[];
 }
 export interface InputExpose {
     focus(): void;

package/es/InputNumber/type.d.ts

@@ -1,4 +1,5 @@
 import { Size, ObjectData } from '../_shared/type';
+import { VNode } from 'vue';
 export interface InputNumberProps {
     modelValue?: InputNumberValue;
     defaultValue?: InputNumberValue;
@@ -30,14 +31,13 @@ export interface InputNumberEmits {
     (e: 'pressEnter', ev: KeyboardEvent): void;
 }
 export interface InputNumberSlots {
-    plus(): void;
-    minus(): void;
-    suffix(): void;
-    prefix(): void;
-    suffix(): void;
-    prepend(): void;
-    append(): void;
-    label(): void;
+    plus?: () => VNode[];
+    minus?: () => VNode[];
+    prefix?: () => VNode[];
+    suffix?: () => VNode[];
+    prepend?: () => VNode[];
+    append?: () => VNode[];
+    label?: () => VNode[];
 }
 export interface InputNumberExpose {
     focus(): void;

package/es/InputTag/type.d.ts

@@ -1,5 +1,6 @@
 import { Size, ObjectData } from '../_shared/type';
 import { TagProps } from '../Tag';
+import { VNode } from 'vue';
 export interface InputTagProps {
     modelValue?: InputTagValue;
     defaultValue?: InputTagValue;
@@ -31,11 +32,11 @@ export interface InputTagEmits {
     (e: 'clear', ev: MouseEvent): void;
 }
 export interface InputTagSlots {
-    tag(scope: {
+    tag?: (scope: {
         tag: ObjectData;
-    }): void;
-    prefix(): void;
-    suffix(): void;
+    }) => VNode[];
+    prefix?: () => VNode[];
+    suffix?: () => VNode[];
 }
 export interface InputTagExpose {
     focus(): void;

package/es/Layout/Layout.vue.js

@@ -1,7 +1,7 @@
 import _sfc_main from "./Layout.vue2.js";
 /* empty css            */
 import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
-const _Layout = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-89d3b476"]]);
+const _Layout = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-4f591662"]]);
 export {
   _Layout as default
 };

package/es/Layout/Layout.vue2.js

@@ -1,4 +1,4 @@
-import { defineComponent, toRefs, useSlots, computed, createElementBlock, openBlock, normalizeClass, renderSlot } from "vue";
+import { defineComponent, useSlots, toRefs, computed, createElementBlock, openBlock, normalizeClass, renderSlot } from "vue";
 import "../node_modules/tinycolor2/esm/tinycolor.js";
 import "../_shared/utils/dom.js";
 import { isUndefined } from "../_shared/utils/is.js";
@@ -15,9 +15,9 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     hasSider: { type: Boolean, default: void 0 }
   },
   setup(__props) {
+    const slots = useSlots();
     const props = __props;
     const { hasSider: _hasSider } = toRefs(props);
-    const slots = useSlots();
     const hasSider = computed(() => {
       var _a;
       if (!isUndefined(_hasSider.value)) return _hasSider.value;

package/es/Layout/type.d.ts

@@ -1,19 +1,20 @@
 import { BreakpointName } from '../Grid';
 import { Theme } from '../_shared/type';
+import { VNode } from 'vue';
 export interface LayoutProps {
     hasSider?: boolean;
 }
 export interface LayoutSlots {
-    default(): void;
+    default?: () => VNode[];
 }
 export interface LayoutHeaderSlots {
-    default(): void;
+    default?: () => VNode[];
 }
 export interface LayoutContentSlots {
-    default(): void;
+    default?: () => VNode[];
 }
 export interface LayoutFooterSlots {
-    default(): void;
+    default?: () => VNode[];
 }
 export interface LayoutSiderProps {
     theme?: Theme;
@@ -33,9 +34,9 @@ export interface LayoutSiderEmits {
     (e: 'breakpoint', collapsed: boolean): void;
 }
 export interface LayoutSiderSlots {
-    default(): void;
-    trigger(scope: {
+    default?: () => VNode[];
+    trigger?: (scope: {
         collapsed: boolean;
-    }): void;
+    }) => VNode[];
 }
 export type ResizeDirections = Array<'left' | 'right' | 'top' | 'bottom'>;

package/es/Link/type.d.ts

@@ -1,3 +1,4 @@
+import { VNode } from 'vue';
 export interface LinkProps {
     href?: string;
     icon?: boolean;
@@ -12,7 +13,7 @@ export interface LinkEmits {
     (e: 'contextmenu', event: MouseEvent): void;
 }
 export interface LinkSlots {
-    default(): void;
-    icon(): void;
+    default?: () => VNode[];
+    icon?: () => VNode[];
 }
 export type LinkStatus = 'normal' | 'warning' | 'success' | 'danger';

package/es/List/type.d.ts

@@ -2,6 +2,7 @@ import { Direction, ObjectData } from '../_shared/type';
 import { GridProps } from '../Grid';
 import { PaginationProps } from '../Pagination';
 import { VirtualListProps } from '../Select';
+import { VNode } from 'vue';
 export interface ListProps {
     data?: ObjectData[];
     size?: ListSize;
@@ -23,32 +24,32 @@ export interface ListEmits {
     (e: 'page-size-change', value: number): void;
 }
 export interface ListSlots {
-    empty(): void;
-    header(): void;
-    footer(): void;
-    default(): void;
-    ['scroll-loading'](): void;
-    item(scope: {
+    empty?: () => VNode[];
+    header?: () => VNode[];
+    footer?: () => VNode[];
+    default?: () => VNode[];
+    'scroll-loading'?: () => VNode[];
+    item?: (scope: {
         index: number;
         item: ObjectData;
-    }): void;
+    }) => VNode[];
 }
 export interface ListItemProps {
     actionLayout?: Direction;
 }
 export interface ListItemSlots {
-    default(): void;
-    meta(): void;
-    extra(): void;
-    actions(): void;
+    default?: () => VNode[];
+    meta?: () => VNode[];
+    extra?: () => VNode[];
+    actions?: () => VNode[];
 }
 export interface ListItemMetaProps {
     title?: string;
     description?: string;
 }
 export interface ListItemMetaSlots {
-    avatar(): void;
-    title(): void;
-    description(): void;
+    avatar?: () => VNode[];
+    title?: () => VNode[];
+    description?: () => VNode[];
 }
 export type ListSize = 'small' | 'medium' | 'large';

package/es/Mention/index.d.ts

@@ -182,7 +182,70 @@ declare const Mention: {
                             $attrs: {
                                 [x: string]: unknown;
                             };
-                            $refs: any;
+                            $refs: {
+                                [x: string]: unknown;
+                            } & {
+                                triggerRef: unknown;
+                                popupRef: ({
+                                    $: import('vue').ComponentInternalInstance;
+                                    $data: {};
+                                    $props: {
+                                        readonly preventFocus?: boolean | undefined;
+                                        readonly tag?: string | undefined;
+                                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                                    $attrs: {
+                                        [x: string]: unknown;
+                                    };
+                                    $refs: {
+                                        [x: string]: unknown;
+                                    };
+                                    $slots: Readonly<{
+                                        [name: string]: import('vue').Slot<any> | undefined;
+                                    }>;
+                                    $root: import('vue').ComponentPublicInstance | null;
+                                    $parent: import('vue').ComponentPublicInstance | null;
+                                    $host: Element | null;
+                                    $emit: (event: string, ...args: any[]) => void;
+                                    $el: any;
+                                    $options: import('vue').ComponentOptionsBase<Readonly<{
+                                        preventFocus?: boolean;
+                                        tag?: string;
+                                    }> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                                        preventFocus: boolean;
+                                        tag: string;
+                                    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                                        beforeCreate?: (() => void) | (() => void)[];
+                                        created?: (() => void) | (() => void)[];
+                                        beforeMount?: (() => void) | (() => void)[];
+                                        mounted?: (() => void) | (() => void)[];
+                                        beforeUpdate?: (() => void) | (() => void)[];
+                                        updated?: (() => void) | (() => void)[];
+                                        activated?: (() => void) | (() => void)[];
+                                        deactivated?: (() => void) | (() => void)[];
+                                        beforeDestroy?: (() => void) | (() => void)[];
+                                        beforeUnmount?: (() => void) | (() => void)[];
+                                        destroyed?: (() => void) | (() => void)[];
+                                        unmounted?: (() => void) | (() => void)[];
+                                        renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                                        renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                                        errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                                    };
+                                    $forceUpdate: () => void;
+                                    $nextTick: typeof import('vue').nextTick;
+                                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+                                } & Readonly<{
+                                    preventFocus: boolean;
+                                    tag: string;
+                                }> & Omit<Readonly<{
+                                    preventFocus?: boolean;
+                                    tag?: string;
+                                }> & Readonly<{}>, "preventFocus" | "tag"> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+                                    $slots: {
+                                        default?(_: {}): any;
+                                    };
+                                }) | null;
+                                arrowRef: HTMLDivElement;
+                            };
                             $slots: Readonly<{
                                 [name: string]: import('vue').Slot<any> | undefined;
                             }>;
@@ -303,7 +366,7 @@ declare const Mention: {
                             show(): void;
                             updatePosition(x: number, y: number): void;
                         }> & {} & import('vue').ComponentCustomProperties & {} & {
-                            $slots: any;
+                            $slots: Readonly<import('..').TriggerSlots> & import('..').TriggerSlots;
                         }) | null;
                         inputRef: ({
                             $: import('vue').ComponentInternalInstance;

package/es/Mention/index.vue.d.ts

@@ -153,7 +153,70 @@ declare function __VLS_template(): {
                             $attrs: {
                                 [x: string]: unknown;
                             };
-                            $refs: any;
+                            $refs: {
+                                [x: string]: unknown;
+                            } & {
+                                triggerRef: unknown;
+                                popupRef: ({
+                                    $: import('vue').ComponentInternalInstance;
+                                    $data: {};
+                                    $props: {
+                                        readonly preventFocus?: boolean | undefined;
+                                        readonly tag?: string | undefined;
+                                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                                    $attrs: {
+                                        [x: string]: unknown;
+                                    };
+                                    $refs: {
+                                        [x: string]: unknown;
+                                    };
+                                    $slots: Readonly<{
+                                        [name: string]: import('vue').Slot<any> | undefined;
+                                    }>;
+                                    $root: import('vue').ComponentPublicInstance | null;
+                                    $parent: import('vue').ComponentPublicInstance | null;
+                                    $host: Element | null;
+                                    $emit: (event: string, ...args: any[]) => void;
+                                    $el: any;
+                                    $options: import('vue').ComponentOptionsBase<Readonly<{
+                                        preventFocus?: boolean;
+                                        tag?: string;
+                                    }> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                                        preventFocus: boolean;
+                                        tag: string;
+                                    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                                        beforeCreate?: (() => void) | (() => void)[];
+                                        created?: (() => void) | (() => void)[];
+                                        beforeMount?: (() => void) | (() => void)[];
+                                        mounted?: (() => void) | (() => void)[];
+                                        beforeUpdate?: (() => void) | (() => void)[];
+                                        updated?: (() => void) | (() => void)[];
+                                        activated?: (() => void) | (() => void)[];
+                                        deactivated?: (() => void) | (() => void)[];
+                                        beforeDestroy?: (() => void) | (() => void)[];
+                                        beforeUnmount?: (() => void) | (() => void)[];
+                                        destroyed?: (() => void) | (() => void)[];
+                                        unmounted?: (() => void) | (() => void)[];
+                                        renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                                        renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                                        errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                                    };
+                                    $forceUpdate: () => void;
+                                    $nextTick: typeof nextTick;
+                                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+                                } & Readonly<{
+                                    preventFocus: boolean;
+                                    tag: string;
+                                }> & Omit<Readonly<{
+                                    preventFocus?: boolean;
+                                    tag?: string;
+                                }> & Readonly<{}>, "preventFocus" | "tag"> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+                                    $slots: {
+                                        default?(_: {}): any;
+                                    };
+                                }) | null;
+                                arrowRef: HTMLDivElement;
+                            };
                             $slots: Readonly<{
                                 [name: string]: import('vue').Slot<any> | undefined;
                             }>;
@@ -274,7 +337,7 @@ declare function __VLS_template(): {
                             show(): void;
                             updatePosition(x: number, y: number): void;
                         }> & {} & import('vue').ComponentCustomProperties & {} & {
-                            $slots: any;
+                            $slots: Readonly<import('..').TriggerSlots> & import('..').TriggerSlots;
                         }) | null;
                         inputRef: ({
                             $: import('vue').ComponentInternalInstance;
@@ -931,7 +994,70 @@ declare const __VLS_component: import('vue').DefineComponent<MentionProps, {
                         $attrs: {
                             [x: string]: unknown;
                         };
-                        $refs: any;
+                        $refs: {
+                            [x: string]: unknown;
+                        } & {
+                            triggerRef: unknown;
+                            popupRef: ({
+                                $: import('vue').ComponentInternalInstance;
+                                $data: {};
+                                $props: {
+                                    readonly preventFocus?: boolean | undefined;
+                                    readonly tag?: string | undefined;
+                                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                                $attrs: {
+                                    [x: string]: unknown;
+                                };
+                                $refs: {
+                                    [x: string]: unknown;
+                                };
+                                $slots: Readonly<{
+                                    [name: string]: import('vue').Slot<any> | undefined;
+                                }>;
+                                $root: import('vue').ComponentPublicInstance | null;
+                                $parent: import('vue').ComponentPublicInstance | null;
+                                $host: Element | null;
+                                $emit: (event: string, ...args: any[]) => void;
+                                $el: any;
+                                $options: import('vue').ComponentOptionsBase<Readonly<{
+                                    preventFocus?: boolean;
+                                    tag?: string;
+                                }> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                                    preventFocus: boolean;
+                                    tag: string;
+                                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                                    beforeCreate?: (() => void) | (() => void)[];
+                                    created?: (() => void) | (() => void)[];
+                                    beforeMount?: (() => void) | (() => void)[];
+                                    mounted?: (() => void) | (() => void)[];
+                                    beforeUpdate?: (() => void) | (() => void)[];
+                                    updated?: (() => void) | (() => void)[];
+                                    activated?: (() => void) | (() => void)[];
+                                    deactivated?: (() => void) | (() => void)[];
+                                    beforeDestroy?: (() => void) | (() => void)[];
+                                    beforeUnmount?: (() => void) | (() => void)[];
+                                    destroyed?: (() => void) | (() => void)[];
+                                    unmounted?: (() => void) | (() => void)[];
+                                    renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                                    renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                                    errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                                };
+                                $forceUpdate: () => void;
+                                $nextTick: typeof nextTick;
+                                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+                            } & Readonly<{
+                                preventFocus: boolean;
+                                tag: string;
+                            }> & Omit<Readonly<{
+                                preventFocus?: boolean;
+                                tag?: string;
+                            }> & Readonly<{}>, "preventFocus" | "tag"> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+                                $slots: {
+                                    default?(_: {}): any;
+                                };
+                            }) | null;
+                            arrowRef: HTMLDivElement;
+                        };
                         $slots: Readonly<{
                             [name: string]: import('vue').Slot<any> | undefined;
                         }>;
@@ -1052,7 +1178,7 @@ declare const __VLS_component: import('vue').DefineComponent<MentionProps, {
                         show(): void;
                         updatePosition(x: number, y: number): void;
                     }> & {} & import('vue').ComponentCustomProperties & {} & {
-                        $slots: any;
+                        $slots: Readonly<import('..').TriggerSlots> & import('..').TriggerSlots;
                     }) | null;
                     inputRef: ({
                         $: import('vue').ComponentInternalInstance;

package/es/Mention/type.d.ts

@@ -1,5 +1,6 @@
 import { SelectOptions, SelectValue } from '../Select';
 import { ObjectData } from '../_shared/type';
+import { VNode } from 'vue';
 export interface MentionProps {
     modelValue?: string;
     defaultValue?: string;
@@ -25,7 +26,7 @@ export interface MentionExpose {
     blur(): void;
 }
 export interface MentionSlots {
-    option(scope: {
+    option?: (scope: {
         data: ObjectData;
-    }): void;
+    }) => VNode[];
 }

package/es/Menu/type.d.ts

@@ -2,6 +2,7 @@ import { BreakpointName } from '../Grid';
 import { TooltipProps } from '../Tooltip';
 import { TriggerProps } from '../Trigger';
 import { Theme } from '../_shared/type';
+import { VNode } from 'vue';
 export interface MenuProps {
     theme?: Theme;
     mode?: MenuMode;
@@ -33,7 +34,7 @@ export interface MenuEmits {
     (e: 'sub-menu-click', key: string, openKeys: string[]): void;
 }
 export interface MenuSlots {
-    default(): void;
+    default?: () => VNode[];
 }
 export interface SubMenuProps {
     path?: string;
@@ -43,26 +44,26 @@ export interface SubMenuProps {
     popupMaxHeight?: PopupMaxHeight;
 }
 export interface SubMenuSlots {
-    default(): void;
-    title(): void;
-    icon(): void;
-    ['expand-icon-down'](): void;
+    default?: () => VNode[];
+    title?: () => VNode[];
+    icon?: () => VNode[];
+    'expand-icon-down'?: () => VNode[];
 }
 export interface MenuItemProps {
     path?: string;
     disabled?: boolean;
 }
 export interface MenuItemSlots {
-    default(): void;
-    icon(): void;
-    suffix(): void;
+    default?: () => VNode[];
+    icon?: () => VNode[];
+    suffix?: () => VNode[];
 }
 export interface MenuItemGroupProps {
     title?: string;
 }
 export interface MenuItemGroupSlots {
-    default(): void;
-    title(): void;
+    default?: () => VNode[];
+    title?: () => VNode[];
 }
 export type MenuMode = 'vertical' | 'horizontal';
 export type PopupMaxHeight = boolean | number;

package/es/Message/type.d.ts

@@ -19,7 +19,7 @@ export interface MessageContainerProps {
 }
 export type MessageConfig = Omit<MessageProps, 'type' | 'onDestory'> & MessageContainerProps;
 export type MessageReturn = {
-    close(): void;
+    close?: () => void;
 };
 export type MessageMethod = {
     info: (config: string | MessageConfig) => MessageReturn;

package/es/Modal/type.d.ts

@@ -1,4 +1,4 @@
-import { CSSProperties } from 'vue';
+import { CSSProperties, VNode } from 'vue';
 import { ButtonProps } from '../Button';
 import { RenderContent, PopupContainer, ClassName } from '../_shared/type';
 import { ModuleStatus } from 'vm';
@@ -48,10 +48,10 @@ export interface ModalEmits {
     (e: 'before-close'): void;
 }
 export interface ModalSlots {
-    default(): void;
-    header(): void;
-    footer(): void;
-    title(): void;
+    default?: () => VNode[];
+    header?: () => VNode[];
+    footer?: () => VNode[];
+    title?: () => VNode[];
 }
 export type ModalConfig = Omit<ModalProps, 'visible' | 'defaultVisible'> & {
     title?: RenderContent;

package/es/Notification/type.d.ts

@@ -24,7 +24,7 @@ export interface NotificationContainerProps {
 }
 export type NotificationConfig = Omit<NotificationProps, 'type' | 'onDestory'> & NotificationContainerProps;
 export type NotificationReturn = {
-    close(): void;
+    close?: () => void;
 };
 export type NotificationMethods = {
     info: (config: string | NotificationConfig) => NotificationReturn;