yc-design-vue 1.0.1 → 1.0.3

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/Modal.vue.js

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

package/es/Modal/Modal.vue2.js

@@ -130,13 +130,15 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
           key: 0,
           class: normalizeClass([
             "yc-modal-container",
+            _ctx.$attrs.class,
             {
               "yc-modal-simple": _ctx.simple,
               "yc-modal-position-absolute": unref(popupContainer) || !unref(renderToBody)
             }
           ]),
           style: normalizeStyle({
-            zIndex: unref(zIndex)
+            zIndex: unref(zIndex),
+            ..._ctx.$attrs.style ?? {}
           })
         }, [
           createVNode(Transition, { name: _ctx.maskAnimationName }, {
@@ -167,7 +169,6 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                   class: normalizeClass([
                     "yc-modal",
                     _ctx.modalClass,
-                    _ctx.$attrs.class,
                     {
                       // 拖拽
                       "yc-modal-draggable": unref(isDraggable),
@@ -175,10 +176,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                       "yc-modal-fullscreen": unref(fullscreen)
                     }
                   ]),
-                  style: normalizeStyle({
-                    ...modalStyle.value,
-                    ..._ctx.$attrs.style ?? {}
-                  }),
+                  style: normalizeStyle(modalStyle.value),
                   ref_key: "modalRef",
                   ref: modalRef
                 }, [

package/es/Modal/hooks/useModalClose.d.ts

@@ -1,5 +1,6 @@
 import { Ref } from 'vue';
 import { ModalEmits, OnBeforeOk, OnBeforeCancel } from '../type';
+export type CloseEventType = 'confirmBtn' | 'cancelBtn' | 'closeBtn' | 'mask' | 'esc';
 declare const _default: (params: {
     visible: Ref<boolean | undefined>;
     defaultVisible: Ref<boolean>;
@@ -12,7 +13,7 @@ declare const _default: (params: {
     asyncLoading: Ref<boolean, boolean>;
     outerVisible: Ref<boolean, boolean>;
     innerVisible: import('vue').WritableComputedRef<any, boolean>;
-    handleClose: (type: string, ev: MouseEvent | KeyboardEvent) => Promise<void>;
+    handleClose: (type: CloseEventType, ev: MouseEvent | KeyboardEvent) => Promise<void>;
     handleAfterLeave: () => void;
 };
 export default _default;

package/es/Modal/hooks/useModalClose.js

@@ -31,12 +31,7 @@ const useModalClose = (params) => {
     outerVisible.value = false;
   };
   const handleClose = async (type, ev) => {
-    const isClose = await useOnBeforeClose(
-      type,
-      asyncLoading,
-      onBeforeOk,
-      onBeforeCancel
-    );
+    const isClose = ["confirmBtn", "cancelBtn"].includes(type) ? await useOnBeforeClose(type, asyncLoading, onBeforeOk, onBeforeCancel) : true;
     if (!isClose) {
       return;
     }

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;

package/es/OverflowList/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 _OverflowList = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-13385005"]]);
+const _OverflowList = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-bf5ac246"]]);
 export {
   _OverflowList as default
 };

package/es/OverflowList/index.vue2.js

@@ -1,12 +1,12 @@
-import { defineComponent, toRefs, ref, useSlots, computed, watch, createElementBlock, openBlock, normalizeStyle, normalizeClass, unref, createCommentVNode, Fragment, renderList, createBlock, resolveDynamicComponent, renderSlot, createVNode, withCtx, createTextVNode, toDisplayString } from "vue";
+import { defineComponent, useSlots, toRefs, ref, computed, watch, createElementBlock, openBlock, normalizeStyle, normalizeClass, unref, createCommentVNode, Fragment, renderList, createBlock, resolveDynamicComponent, renderSlot, createVNode, withCtx, createTextVNode, toDisplayString } from "vue";
 import "../node_modules/tinycolor2/esm/tinycolor.js";
 import "../_shared/utils/dom.js";
 import { throttle, sleep, valueToPx } from "../_shared/utils/fn.js";
 import "../_shared/utils/time.js";
-import { findComponentsFromVnodes, unrefElement } from "../_shared/utils/vue-utils.js";
+import { findComponentsFromVnodes } from "../_shared/utils/vue-utils.js";
 import "../Empty/index.js";
 /* empty css                         */
-import { useResizeObserver } from "../node_modules/@vueuse/core/index.js";
+import { unrefElement, useResizeObserver } from "../node_modules/@vueuse/core/index.js";
 import Tag from "../Tag/index.js";
 const _sfc_main = /* @__PURE__ */ defineComponent({
   ...{
@@ -20,12 +20,12 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
   },
   emits: ["change"],
   setup(__props, { emit: __emit }) {
+    const slots = useSlots();
     const props = __props;
     const emits = __emit;
     const { min, margin, from } = toRefs(props);
     const max = ref(1e4);
     const widths = ref([]);
-    const slots = useSlots();
     const tags = computed(() => {
       var _a;
       return findComponentsFromVnodes(

package/es/OverflowList/type.d.ts

@@ -1,3 +1,4 @@
+import { VNode } from 'vue';
 export interface OverflowListProps {
     min?: number;
     margin?: number;
@@ -7,7 +8,7 @@ export interface OverflowListEmits {
     (e: 'change', value: number): void;
 }
 export interface OverflowListSlots {
-    default(): void;
-    overflow(): void;
+    default?: () => VNode[];
+    overflow?: () => VNode[];
 }
 export type OverflowListFrom = 'start' | 'end';

package/es/PageHeader/type.d.ts

@@ -1,3 +1,4 @@
+import { VNode } from 'vue';
 export interface PageHeaderProp {
     title?: string;
     subtitle?: string;
@@ -7,10 +8,10 @@ export interface PageHeaderEmits {
     (e: 'back', ev: Event): void;
 }
 export interface PageHeaderSlots {
-    default(): void;
-    breadcrumb(): void;
-    ['back-icon']: void;
-    title(): void;
-    subtitle(): void;
-    extra(): void;
+    default?: () => VNode[];
+    breadcrumb?: () => VNode[];
+    'back-icon': VNode[];
+    title?: () => VNode[];
+    subtitle?: () => VNode[];
+    extra?: () => VNode[];
 }

package/es/Pagination/type.d.ts

@@ -1,4 +1,4 @@
-import { CSSProperties } from 'vue';
+import { CSSProperties, VNode } from 'vue';
 import { Size } from '../_shared/type';
 import { SelectProps } from '../Select';
 export interface PaginationProps {
@@ -30,14 +30,14 @@ export interface PaginationEmits {
     (e: 'page-size-change', pageSize: number): void;
 }
 export interface PaginationSlots {
-    total(scope: {
+    total?: (scope: {
         total: number;
-    }): void;
-    ['page-item-ellipsis'](): void;
-    ['page-item-step'](scope: {
+    }) => VNode[];
+    ['page-item-ellipsis']?: () => VNode[];
+    ['page-item-step']?: (scope: {
         type: 'previous' | 'next';
-    }): void;
-    ['page-item'](scope: {
+    }) => VNode[];
+    ['page-item']?: (scope: {
         page: number;
-    }): void;
+    }) => VNode[];
 }

package/es/Popconfirm/index.d.ts

@@ -88,7 +88,70 @@ declare const Popconfirm: {
             $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;
             }>;
@@ -209,7 +272,7 @@ declare const Popconfirm: {
             show(): void;
             updatePosition(x: number, y: number): void;
         }> & {} & import('vue').ComponentCustomProperties & {} & {
-            $slots: any;
+            $slots: Readonly<import('..').TriggerSlots> & import('..').TriggerSlots;
         }) | null;
     }, any, import('vue').ComponentProvideOptions, {
         P: {};