yc-design-vue 1.0.1 → 1.0.3

package/es/Affix/type.d.ts

@@ -1,4 +1,5 @@
 import { TargetContainer } from '../_shared/type';
+import { VNode } from 'vue';
 export interface AffixProps {
     offsetTop?: number;
     offsetBottom?: number;
@@ -9,8 +10,8 @@ export interface AffixEmits {
     (e: 'change', fixed: boolean): void;
 }
 export interface AffixSlots {
-    default(): void;
+    default?: () => VNode[];
 }
 export interface AffixExpose {
-    'updatePosition'(): void;
+    updatePosition(): void;
 }

package/es/Alert/type.d.ts

@@ -1,3 +1,4 @@
+import { VNode } from 'vue';
 export interface AlertProps {
     type?: AlertType;
     showIcon?: boolean;
@@ -11,10 +12,10 @@ export interface AlertEmits {
     (e: 'after-close'): void;
 }
 export interface AlertSlots {
-    default(): void;
-    icon(): void;
-    title(): void;
-    action(): void;
-    ['close-element'](): void;
+    default?: () => VNode[];
+    icon?: () => VNode[];
+    title?: () => VNode[];
+    action?: () => VNode[];
+    'close-element'?: () => VNode[];
 }
 export type AlertType = 'warning' | 'success' | 'info' | 'error' | 'normal';

package/es/Anchor/type.d.ts

@@ -1,4 +1,5 @@
 import { TargetContainer } from '../_shared/type';
+import { VNode } from 'vue';
 export interface AnchorProps {
     boundary?: AnchorBoundary;
     lineLess?: boolean;
@@ -7,14 +8,14 @@ export interface AnchorProps {
     smooth?: boolean;
 }
 export interface AnchorSlots {
-    default(): void;
+    default?: () => VNode[];
 }
 export interface AnchorLinkProps {
     title?: string;
     href?: string;
 }
 export interface AnchorLinkSlots {
-    default(): void;
-    sublist(): void;
+    default?: () => VNode[];
+    sublist?: () => VNode[];
 }
 export type AnchorBoundary = 'start' | 'end' | 'center' | 'nearest' | number;

package/es/AutoComplete/index.d.ts

@@ -160,7 +160,70 @@ declare const AutoComplete: {
                     $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;
                     }>;
@@ -281,7 +344,7 @@ declare const AutoComplete: {
                     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/AutoComplete/index.vue.d.ts

@@ -118,7 +118,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;
                     }>;
@@ -239,7 +302,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;
@@ -768,7 +831,70 @@ declare const __VLS_component: import('vue').DefineComponent<AutoCompleteProps,
                 $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;
                 }>;
@@ -889,7 +1015,7 @@ declare const __VLS_component: import('vue').DefineComponent<AutoCompleteProps,
                 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/AutoComplete/type.d.ts

@@ -1,6 +1,7 @@
 import { SelectOptions, SelectOptionData, VirtualListProps } from '../Select';
 import { PopupContainer, ObjectData } from '../_shared/type';
 import { TriggerProps } from '../Trigger';
+import { VNode } from 'vue';
 export type AutoCompleteProps = {
     modelValue?: string;
     defaultValue?: string;
@@ -30,11 +31,11 @@ export interface AutoCompleteEmits {
     (e: 'keydown', ev: KeyboardEvent): void;
 }
 export interface AutoCompleteSlots {
-    option(scope: {
+    option?: (scope: {
         data: ObjectData;
-    }): void;
-    footer(): void;
-    trigger(): void;
+    }) => VNode[];
+    footer?: () => VNode[];
+    trigger?: () => VNode[];
 }
 export interface AutoCompleteExpose {
     focus(): void;

package/es/Avatar/AvatarGroup.vue.js

@@ -1,7 +1,7 @@
 import _sfc_main from "./AvatarGroup.vue2.js";
 /* empty css                 */
 import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
-const AvatarGroup = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-a468c247"]]);
+const AvatarGroup = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-9eceed96"]]);
 export {
   AvatarGroup as default
 };

package/es/Avatar/AvatarGroup.vue2.js

@@ -1,4 +1,4 @@
-import { defineComponent, toRefs, useSlots, computed, createElementBlock, openBlock, createBlock, createCommentVNode, Fragment, renderList, resolveDynamicComponent, normalizeStyle, unref, withCtx, createVNode, createTextVNode, toDisplayString } from "vue";
+import { defineComponent, useSlots, toRefs, computed, createElementBlock, openBlock, createBlock, createCommentVNode, Fragment, renderList, resolveDynamicComponent, normalizeStyle, unref, withCtx, createVNode, createTextVNode, toDisplayString } from "vue";
 import "../node_modules/tinycolor2/esm/tinycolor.js";
 import "../_shared/utils/dom.js";
 import { valueToPx } from "../_shared/utils/fn.js";
@@ -29,10 +29,10 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     } }
   },
   setup(__props) {
+    const slots = useSlots();
     const props = __props;
     const { maxCount } = toRefs(props);
     useContext().provide(props);
-    const slots = useSlots();
     const nodes = computed(() => {
       var _a;
       const avatars = findComponentsFromVnodes(

package/es/Avatar/type.d.ts

@@ -1,4 +1,4 @@
-import { CSSProperties } from 'vue';
+import { CSSProperties, VNode } from 'vue';
 import { TriggerProps } from '../Trigger';
 export interface AvatarProps {
     shape?: AvatarShape;
@@ -15,8 +15,8 @@ export interface AvatarEmits {
     (e: 'load', ev: Event): void;
 }
 export interface AvatarSlots {
-    default(): void;
-    ['trigger-icon'](): void;
+    default?: () => VNode[];
+    'trigger-icon'?: () => VNode[];
 }
 export interface AvatarGroupProps {
     shape?: AvatarShape;
@@ -28,7 +28,7 @@ export interface AvatarGroupProps {
     maxPopoverTriggerProps?: TriggerProps;
 }
 export interface AvatarGroupSlots {
-    default(): void;
+    default?: () => VNode[];
 }
 export type AvatarShape = 'square' | 'round';
 export type AvatarTriggerType = 'mask' | 'button';

package/es/BackTop/type.d.ts

@@ -1,4 +1,5 @@
 import { TargetContainer } from '../_shared/type';
+import { VNode } from 'vue';
 export interface BackTopProps {
     visibleHeight?: number;
     targetContainer?: TargetContainer;
@@ -6,5 +7,5 @@ export interface BackTopProps {
     duration?: number;
 }
 export interface BackTopSlots {
-    default(): void;
+    default?: () => VNode[];
 }

package/es/Badge/index.vue.js

@@ -1,7 +1,7 @@
 import _sfc_main from "./index.vue2.js";
 /* empty css           */
 import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
-const _Badge = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-7f171981"]]);
+const _Badge = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-d3df3cf9"]]);
 export {
   _Badge as default
 };

package/es/Badge/index.vue2.js

@@ -1,4 +1,4 @@
-import { defineComponent, toRefs, useSlots, computed, createElementBlock, openBlock, normalizeClass, renderSlot, createCommentVNode, createElementVNode, normalizeStyle, unref, toDisplayString, createTextVNode } from "vue";
+import { defineComponent, useSlots, toRefs, computed, createElementBlock, openBlock, normalizeClass, renderSlot, createCommentVNode, createElementVNode, normalizeStyle, unref, toDisplayString, createTextVNode } from "vue";
 import "../node_modules/tinycolor2/esm/tinycolor.js";
 import "../_shared/utils/dom.js";
 import { valueToPx } from "../_shared/utils/fn.js";
@@ -34,9 +34,9 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     count: { default: void 0 }
   },
   setup(__props) {
+    const slots = useSlots();
     const props = __props;
     const { text, dot, count, maxCount, offset, dotStyle, status, color } = toRefs(props);
-    const slots = useSlots();
     const style = computed(() => {
       return {
         margin: `${valueToPx(offset.value[1])} ${valueToPx(-offset.value[0])} 0 0`,

package/es/Badge/type.d.ts

@@ -1,4 +1,4 @@
-import { CSSProperties } from 'vue';
+import { CSSProperties, VNode } from 'vue';
 export interface BadgeProps {
     text?: string;
     dot?: boolean;
@@ -10,7 +10,7 @@ export interface BadgeProps {
     count?: number;
 }
 export interface BadgeSlots {
-    default(): void;
-    content(): void;
+    default?: () => VNode[];
+    content?: () => VNode[];
 }
 export type BadgeStatus = 'normal' | 'processing' | 'success' | 'warning' | 'danger';

package/es/Breadcrumb/type.d.ts

@@ -1,4 +1,5 @@
 import { DropdownProps } from '../Dropdown';
+import { VNode } from 'vue';
 export interface BreadcrumbProps {
     maxCount?: number;
     routes?: BreadcrumbRoute[];
@@ -6,14 +7,14 @@ export interface BreadcrumbProps {
     customUrl?: CustomUrl;
 }
 export interface BreadcrumbSlots {
-    default(): void;
-    ['item-render'](scope: {
+    default?: () => VNode[];
+    'item-render': (scope: {
         route: BreadcrumbRoute;
         routes: BreadcrumbRoute[];
         paths: string[];
-    }): void;
-    ['more-icon'](): void;
-    separator(): void;
+    }) => VNode[];
+    'more-icon'?: () => VNode[];
+    separator?: () => VNode[];
 }
 export interface BreadcrumbItemProps {
     separator?: BreadcrumbSeparator;
@@ -23,9 +24,9 @@ export interface BreadcrumbItemProps {
     showSeparator?: boolean;
 }
 export interface BreadcrumbItemSlots {
-    default(): void;
-    droplist(): void;
-    separator(): void;
+    default?: () => VNode[];
+    droplist?: () => VNode[];
+    separator?: () => VNode[];
 }
 export interface BreadcrumbRoute {
     label?: string;

package/es/Button/Button.vue.js

@@ -1,7 +1,7 @@
 import _sfc_main from "./Button.vue2.js";
 /* empty css            */
 import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
-const _Button = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-70cfe83d"]]);
+const _Button = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-2327bc3e"]]);
 export {
   _Button as default
 };

package/es/Button/Button.vue2.js

@@ -1,4 +1,4 @@
-import { defineComponent, toRefs, useSlots, computed, createElementBlock, openBlock, mergeProps, createCommentVNode, renderSlot, unref, createBlock } from "vue";
+import { defineComponent, useSlots, toRefs, computed, createElementBlock, openBlock, mergeProps, createCommentVNode, renderSlot, unref, createBlock } from "vue";
 import useContext from "./hooks/useContext.js";
 import Spin from "../Spin/index.js";
 const _hoisted_1 = ["href"];
@@ -29,6 +29,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
   },
   emits: ["mousedown", "mouseup", "click", "dblclick", "contextmenu"],
   setup(__props, { emit: __emit }) {
+    const slots = useSlots();
     const props = __props;
     const emits = __emit;
     const {
@@ -40,7 +41,6 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       long
     } = toRefs(props);
     const { size, disabled, type, status, shape } = useContext().inject(props);
-    const slots = useSlots();
     const className = computed(() => {
       return [
         "yc-button",

package/es/Button/type.d.ts

@@ -1,4 +1,5 @@
 import { Size } from '../_shared/type';
+import { VNode } from 'vue';
 export interface ButtonProps {
     type?: ButtonType;
     shape?: ButtonShape;
@@ -18,8 +19,8 @@ export interface ButtonEmits {
     (e: 'contextmenu', event: MouseEvent): void;
 }
 export interface ButtonSlots {
-    default(): void;
-    icon(): void;
+    default?: () => VNode[];
+    icon?: () => VNode[];
 }
 export interface ButtonGroupProps {
     type?: ButtonType;
@@ -29,7 +30,7 @@ export interface ButtonGroupProps {
     disabled?: boolean;
 }
 export interface ButtonGroupSlots {
-    default(): void;
+    default?: () => VNode[];
 }
 export type ButtonStatus = 'normal' | 'warning' | 'success' | 'danger';
 export type ButtonShape = 'square' | 'circle' | 'round';

package/es/Calendar/type.d.ts

@@ -1,3 +1,4 @@
+import { VNode } from 'vue';
 export interface CalendarProps {
     modelValue?: Date;
     defaultValue?: Date;
@@ -12,14 +13,14 @@ export interface CalendarEmits {
     (e: 'panel-change', value: Date): void;
 }
 export interface CalendarSlots {
-    header(scope: {
+    header: (scope: {
         year: number;
         month: number;
-    }): void;
-    default(scope: {
+    }) => VNode[];
+    default: (scope: {
         year: number;
         month: number;
         day: number;
-    }): void;
+    }) => VNode[];
 }
 export type CalendarMode = 'month' | 'year';

package/es/Card/type.d.ts

@@ -1,4 +1,4 @@
-import { CSSProperties } from 'vue';
+import { CSSProperties, VNode } from 'vue';
 export interface CardProps {
     bordered?: boolean;
     loading?: boolean;
@@ -10,25 +10,25 @@ export interface CardProps {
     extra?: string;
 }
 export interface CardSlots {
-    actions(): void;
-    cover(): void;
-    extra(): void;
-    title(): void;
-    default(): void;
+    actions?: () => VNode[];
+    cover?: () => VNode[];
+    extra?: () => VNode[];
+    title?: () => VNode[];
+    default?: () => VNode[];
 }
 export interface CardMetaProps {
     title?: string;
     description?: string;
 }
 export interface CardMetaSlots {
-    description(): void;
-    title(): void;
-    avatar(): void;
+    description?: () => VNode[];
+    title?: () => VNode[];
+    avatar?: () => VNode[];
 }
 export interface CardGridProps {
     hoverable?: boolean;
 }
 export interface CardGridSlots {
-    default(): void;
+    default?: () => VNode[];
 }
 export type CardSize = 'medium' | 'small';

package/es/Carousel/type.d.ts

@@ -1,4 +1,5 @@
 import { ClassName, Direction } from '../_shared/type';
+import { VNode } from 'vue';
 export interface CarouselProps {
     current?: number;
     defaultCurrent?: number;
@@ -19,10 +20,10 @@ export interface CarouselEmits {
     (e: 'change', index: number, preIndex: number, isManual: boolean): void;
 }
 export interface CarouselSlots {
-    default(): void;
+    default?: () => VNode[];
 }
 export interface CarouselItemSlots {
-    default(): void;
+    default?: () => VNode[];
 }
 export type CarouselAnimationName = 'slide' | 'fade';
 export type CarouselShowArrow = 'always' | 'hover' | 'never';