@vunk/plus 1.8.0 → 1.8.2

package/components/scrollbar/src/thumb.d.ts

@@ -0,0 +1,15 @@
+import type { __ExtractPublicPropTypes, ExtractPropTypes } from 'vue';
+import type Thumb from './thumb.vue';
+export declare const thumbProps: {
+    vertical: BooleanConstructor;
+    size: StringConstructor;
+    move: NumberConstructor;
+    ratio: {
+        type: NumberConstructor;
+        required: true;
+    };
+    always: BooleanConstructor;
+};
+export type ThumbProps = ExtractPropTypes<typeof thumbProps>;
+export type ThumbPropsPublic = __ExtractPublicPropTypes<typeof thumbProps>;
+export type ThumbInstance = InstanceType<typeof Thumb> & unknown;

package/components/scrollbar/src/thumb.vue.d.ts

@@ -0,0 +1,97 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    vertical: BooleanConstructor;
+    size: StringConstructor;
+    move: NumberConstructor;
+    ratio: {
+        type: NumberConstructor;
+        required: true;
+    };
+    always: BooleanConstructor;
+}>, {
+    props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        vertical: BooleanConstructor;
+        size: StringConstructor;
+        move: NumberConstructor;
+        ratio: {
+            type: NumberConstructor;
+            required: true;
+        };
+        always: BooleanConstructor;
+    }>> & Readonly<{}> & {}>;
+    scrollbar: import("element-plus").ScrollbarContext;
+    ns: {
+        namespace: import("vue").ComputedRef<string>;
+        b: (blockSuffix?: string) => string;
+        e: (element?: string) => string;
+        m: (modifier?: string) => string;
+        be: (blockSuffix?: string, element?: string) => string;
+        em: (element?: string, modifier?: string) => string;
+        bm: (blockSuffix?: string, modifier?: string) => string;
+        bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+        is: {
+            (name: string, state: boolean | undefined): string;
+            (name: string): string;
+        };
+        cssVar: (object: Record<string, string>) => Record<string, string>;
+        cssVarName: (name: string) => string;
+        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+        cssVarBlockName: (name: string) => string;
+    };
+    instance: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    thumb: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    thumbState: import("vue").Ref<{
+        X?: number | undefined;
+        Y?: number | undefined;
+    }, Partial<Record<"X" | "Y", number>> | {
+        X?: number | undefined;
+        Y?: number | undefined;
+    }>;
+    visible: import("vue").Ref<boolean, boolean>;
+    cursorDown: boolean;
+    cursorLeave: boolean;
+    baseScrollHeight: number;
+    baseScrollWidth: number;
+    originalOnSelectStart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+    bar: import("vue").ComputedRef<{
+        readonly offset: "offsetHeight";
+        readonly scroll: "scrollTop";
+        readonly scrollSize: "scrollHeight";
+        readonly size: "height";
+        readonly key: "vertical";
+        readonly axis: "Y";
+        readonly client: "clientY";
+        readonly direction: "top";
+    } | {
+        readonly offset: "offsetWidth";
+        readonly scroll: "scrollLeft";
+        readonly scrollSize: "scrollWidth";
+        readonly size: "width";
+        readonly key: "horizontal";
+        readonly axis: "X";
+        readonly client: "clientX";
+        readonly direction: "left";
+    }>;
+    thumbStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+    offsetRatio: import("vue").ComputedRef<number>;
+    clickThumbHandler: (e: MouseEvent) => void;
+    clickTrackHandler: (e: MouseEvent) => void;
+    startDrag: (e: MouseEvent) => void;
+    mouseMoveDocumentHandler: (e: MouseEvent) => void;
+    mouseUpDocumentHandler: () => void;
+    mouseMoveScrollbarHandler: () => void;
+    mouseLeaveScrollbarHandler: () => void;
+    restoreOnselectstart: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    vertical: BooleanConstructor;
+    size: StringConstructor;
+    move: NumberConstructor;
+    ratio: {
+        type: NumberConstructor;
+        required: true;
+    };
+    always: BooleanConstructor;
+}>> & Readonly<{}>, {
+    vertical: boolean;
+    always: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/components/scrollbar/src/types.d.ts

@@ -0,0 +1 @@
+export {};

package/components/scrollbar/src/util.d.ts

@@ -0,0 +1,3 @@
+export declare const isNumber: (val: any) => val is number;
+export declare function isStringNumber(val: string): boolean;
+export declare function addUnit(value?: string | number, defaultUnit?: string): string | undefined;

package/components/sender/index.d.ts

@@ -0,0 +1,5 @@
+import VkSender from './src/index.vue';
+import VkSenderHeader from './src/SenderHeader.vue';
+export * as __VkSender from './src/types';
+export { VkSender, VkSenderHeader, };
+export default VkSender;

package/components/sender/index.mjs

@@ -1,10 +1,10 @@
-import { defineComponent, openBlock, createBlock, withCtx, withDirectives, createElementVNode, mergeProps, toDisplayString, createVNode, renderSlot, vShow, useSlots, computed, ref, nextTick, createSlots, createCommentVNode } from 'vue';
+import { defineComponent, openBlock, createBlock, withCtx, withDirectives, createElementVNode, mergeProps, toDisplayString, createVNode, renderSlot, vShow, useSlots, computed, ref, nextTick, createSlots, createCommentVNode, resolveDynamicComponent } from 'vue';
 import { useModelComputed, useDeferred } from '@vunk/core/composables';
 import { Button } from 'ant-design-vue';
 import { Attachments, Sender } from 'ant-design-x-vue';
 import { noop } from '@vunk/shared/function';
 import { ElCollapseTransition } from 'element-plus';
-import { C as CloseOutlined, L as LinkOutlined, a as CloudUploadOutlined, S as SendOutlined } from '../SendOutlined.mjs';
+import { C as CloseOutlined, L as LinkOutlined, a as CloudUploadOutlined } from '../LinkOutlined.mjs';
 import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
 
 const props = {
@@ -43,14 +43,53 @@ const props = {
     type: Array,
     default: () => []
   },
+  /**
+   * @description 非自定义Send Button时，禁用态
+   */
   sendDisabled: {
     type: Boolean,
     default: false
+  },
+  /**
+   * @description v-model attachments显隐 在 Attachments 模块存在时有效
+   */
+  attachmentsVisible: {
+    type: Boolean,
+    default: void 0
+  },
+  /**
+   * @description 自定义 Send Button
+   */
+  createSendButton: {
+    type: Function,
+    default: void 0
+  },
+  /**
+   * @description 自定义 Attachments Button, 在 Attachments 模块存在时有效
+   */
+  createAttachmentsButton: {
+    type: Function,
+    default: void 0
+  },
+  /**
+   * @description 调整文本域大小
+   */
+  autoSize: {
+    type: Object,
+    default: void 0
+  },
+  /**
+   * @link https://antd-design-x-vue.netlify.app/component/attachments.html
+   */
+  attachmentsProps: {
+    type: Object,
+    default: () => ({})
   }
 };
 const emits = {
   "update:fileList": (_) => true,
   "update:modelValue": (_) => true,
+  "update:headerVisible": (_) => true,
   "submit": (_) => true,
   "cancel": null
 };
@@ -178,30 +217,51 @@ var _sfc_main = /* @__PURE__ */defineComponent({
       key: "loading",
       default: false
     }, props, emit);
-    const headerOpen = ref(false);
+    const headerOpen = useModelComputed({
+      key: "attachmentsVisible",
+      default: false
+    }, props, emit);
+    function createSendButtonDefault(components = {}) {
+      const {
+        SendButton,
+        LoadingButton
+      } = components;
+      return loading.value ? createVNode(LoadingButton, null, null) : createVNode(SendButton, {
+        "disabled": props.sendDisabled
+      }, null);
+    }
+    function createSendButton(components) {
+      const fn = props.createSendButton || createSendButtonDefault;
+      return fn(components);
+    }
+    function createAttachmentsButtonDefault() {
+      return createVNode(Button, {
+        "type": "text",
+        "onClick": () => headerOpen.value = !headerOpen.value
+      }, {
+        icon: () => createVNode(LinkOutlined, null, null)
+      });
+    }
+    function createAttachmentsButton() {
+      const fn = props.createAttachmentsButton || createAttachmentsButtonDefault;
+      return hasAttachments.value ? fn() : null;
+    }
     const actionsRender = (_, info) => {
       const {
         SendButton,
         LoadingButton
       } = info.components;
-      const loadingRender = () => {
-        return createVNode(LoadingButton, null, null);
-      };
-      const sendRender = () => {
-        return createVNode(SendButton, {
-          "type": "text",
-          "icon": createVNode(SendOutlined, null, null),
-          "disabled": props.sendDisabled
-        }, null);
-      };
-      const sendAction = () => loading.value ? loadingRender() : sendRender();
+      const send = createSendButton({
+        SendButton,
+        LoadingButton
+      });
       return createVNode("div", {
         "class": "vk-sender-actions"
       }, [createVNode("div", {
         "class": "vk-sender-actions__before"
       }, [slots.actions_before?.()]), createVNode("div", {
         "class": "vk-sender-actions__after"
-      }, [slots.actions_after?.(), sendAction()])]);
+      }, [slots.actions_after?.() ?? send])]);
     };
     const attachmentsPlaceholder = type => {
       if (type === "drop") {
@@ -247,6 +307,10 @@ var _sfc_main = /* @__PURE__ */defineComponent({
       hasAttachments,
       loading,
       headerOpen,
+      createSendButtonDefault,
+      createSendButton,
+      createAttachmentsButtonDefault,
+      createAttachmentsButton,
       actionsRender,
       attachmentsPlaceholder,
       theFileList,
@@ -255,12 +319,6 @@ var _sfc_main = /* @__PURE__ */defineComponent({
       attachmentWrapResolve,
       handlePasteFile,
       handleChange,
-      get LinkOutlined() {
-        return LinkOutlined;
-      },
-      get AntButton() {
-        return Button;
-      },
       get Attachments() {
         return Attachments;
       },
@@ -288,7 +346,8 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
       !_ctx.sendDisabled && _ctx.$emit("submit", e);
     },
     "on-cancel": () => _ctx.$emit("cancel"),
-    "onUpdate:value": _cache[2] || (_cache[2] = ($event) => _ctx.$emit("update:modelValue", $event)),
+    "auto-size": _ctx.autoSize,
+    "onUpdate:value": _cache[1] || (_cache[1] = ($event) => _ctx.$emit("update:modelValue", $event)),
     onPasteFile: $setup.handlePasteFile
   }, createSlots({
     header: withCtx(() => [
@@ -300,43 +359,38 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
         "content-ref": $setup.attachmentWrapResolve
       }, {
         default: withCtx(() => [
-          createVNode($setup["Attachments"], {
+          createVNode($setup["Attachments"], mergeProps({
             ref: "attachmentsRef",
             "file-list": $setup.theFileList,
             placeholder: $setup.attachmentsPlaceholder,
             action: _ctx.action,
-            multiple: "",
-            onChange: $setup.handleChange
-          }, null, 8, ["file-list", "action"])
+            multiple: ""
+          }, _ctx.attachmentsProps, { onChange: $setup.handleChange }), null, 16, ["file-list", "action"])
         ]),
         _: 1
         /* STABLE */
-      }, 8, ["modelValue", "content-ref"])) : createCommentVNode("v-if", true)
+      }, 8, ["modelValue", "content-ref"])) : createCommentVNode("v-if", true),
+      renderSlot(_ctx.$slots, "header")
     ]),
     prefix: withCtx(() => [
-      $setup.hasAttachments ? (openBlock(), createBlock($setup["AntButton"], {
-        key: 0,
-        type: "text",
-        onClick: _cache[1] || (_cache[1] = ($event) => $setup.headerOpen = !$setup.headerOpen)
-      }, {
-        icon: withCtx(() => [
-          createVNode($setup["LinkOutlined"])
-        ]),
-        _: 1
-        /* STABLE */
-      })) : createCommentVNode("v-if", true)
+      !_ctx.$slots.prefix ? (openBlock(), createBlock(resolveDynamicComponent($setup.createAttachmentsButton()), { key: 0 })) : createCommentVNode("v-if", true),
+      renderSlot(_ctx.$slots, "prefix")
     ]),
     _: 2
     /* DYNAMIC */
   }, [
     _ctx.$slots.footer ? {
       name: "footer",
-      fn: withCtx(() => [
-        renderSlot(_ctx.$slots, "footer")
+      fn: withCtx(({ info }) => [
+        renderSlot(_ctx.$slots, "footer", {
+          sendButton: $setup.createSendButton(info.components),
+          attachmentsButton: $setup.createAttachmentsButton(),
+          info
+        })
       ]),
       key: "0"
     } : void 0
-  ]), 1032, ["value", "loading", "on-submit", "on-cancel"]);
+  ]), 1032, ["value", "loading", "on-submit", "on-cancel", "auto-size"]);
 }
 var VkSender = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/vunk-plus/vunk-plus/packages/components/sender/src/index.vue"]]);
 
@@ -348,4 +402,4 @@ VkSender.install = (app) => {
   app.component(VkSender.name || "VkSender", VkSender);
 };
 
-export { VkSender, types as __VkSender, VkSender as default };
+export { VkSender, SenderHeader as VkSenderHeader, types as __VkSender, VkSender as default };

package/components/sender/src/SenderHeader.vue.d.ts

@@ -0,0 +1,256 @@
+import type { AnyFunc } from '@vunk/shared';
+import type { PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    contentRef: {
+        type: PropType<AnyFunc>;
+        default: AnyFunc;
+    };
+}>, {
+    readonly CloseOutlined: import("@ant-design/icons-vue/lib/icons/CloseOutlined").CloseOutlinedIconType;
+    readonly AntButton: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+            prefixCls: StringConstructor;
+            type: import("vue").PropType<import("ant-design-vue/es/button").ButtonType>;
+            htmlType: {
+                type: import("vue").PropType<import("ant-design-vue/es/button/buttonTypes").ButtonHTMLType>;
+                default: string;
+            };
+            shape: {
+                type: import("vue").PropType<import("ant-design-vue/es/button").ButtonShape>;
+            };
+            size: {
+                type: import("vue").PropType<import("ant-design-vue/es/button").ButtonSize>;
+            };
+            loading: {
+                type: import("vue").PropType<boolean | {
+                    delay?: number;
+                }>;
+                default: () => boolean | {
+                    delay?: number;
+                };
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            ghost: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            block: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            danger: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            icon: import("vue-types").VueTypeValidableDef<any>;
+            href: StringConstructor;
+            target: StringConstructor;
+            title: StringConstructor;
+            onClick: {
+                type: import("vue").PropType<import("ant-design-vue/es/_util/EventInterface").MouseEventHandler | import("ant-design-vue/es/_util/EventInterface").MouseEventHandler[]>;
+            };
+            onMousedown: {
+                type: import("vue").PropType<import("ant-design-vue/es/_util/EventInterface").MouseEventHandler | import("ant-design-vue/es/_util/EventInterface").MouseEventHandler[]>;
+            };
+        }>> & Readonly<{}>, () => import("ant-design-vue/es/_util/type").VueNode, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+            block: boolean;
+            disabled: boolean;
+            danger: boolean;
+            ghost: boolean;
+            htmlType: import("ant-design-vue/es/button/buttonTypes").ButtonHTMLType;
+            loading: boolean | {
+                delay?: number;
+            };
+        }, true, {}, import("ant-design-vue/es/_util/type").CustomSlotsType<{
+            icon: any;
+            default: any;
+        }>, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            prefixCls: StringConstructor;
+            type: import("vue").PropType<import("ant-design-vue/es/button").ButtonType>;
+            htmlType: {
+                type: import("vue").PropType<import("ant-design-vue/es/button/buttonTypes").ButtonHTMLType>;
+                default: string;
+            };
+            shape: {
+                type: import("vue").PropType<import("ant-design-vue/es/button").ButtonShape>;
+            };
+            size: {
+                type: import("vue").PropType<import("ant-design-vue/es/button").ButtonSize>;
+            };
+            loading: {
+                type: import("vue").PropType<boolean | {
+                    delay?: number;
+                }>;
+                default: () => boolean | {
+                    delay?: number;
+                };
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            ghost: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            block: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            danger: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            icon: import("vue-types").VueTypeValidableDef<any>;
+            href: StringConstructor;
+            target: StringConstructor;
+            title: StringConstructor;
+            onClick: {
+                type: import("vue").PropType<import("ant-design-vue/es/_util/EventInterface").MouseEventHandler | import("ant-design-vue/es/_util/EventInterface").MouseEventHandler[]>;
+            };
+            onMousedown: {
+                type: import("vue").PropType<import("ant-design-vue/es/_util/EventInterface").MouseEventHandler | import("ant-design-vue/es/_util/EventInterface").MouseEventHandler[]>;
+            };
+        }>> & Readonly<{}>, () => import("ant-design-vue/es/_util/type").VueNode, {}, {}, {}, {
+            block: boolean;
+            disabled: boolean;
+            danger: boolean;
+            ghost: boolean;
+            htmlType: import("ant-design-vue/es/button/buttonTypes").ButtonHTMLType;
+            loading: boolean | {
+                delay?: number;
+            };
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        prefixCls: StringConstructor;
+        type: import("vue").PropType<import("ant-design-vue/es/button").ButtonType>;
+        htmlType: {
+            type: import("vue").PropType<import("ant-design-vue/es/button/buttonTypes").ButtonHTMLType>;
+            default: string;
+        };
+        shape: {
+            type: import("vue").PropType<import("ant-design-vue/es/button").ButtonShape>;
+        };
+        size: {
+            type: import("vue").PropType<import("ant-design-vue/es/button").ButtonSize>;
+        };
+        loading: {
+            type: import("vue").PropType<boolean | {
+                delay?: number;
+            }>;
+            default: () => boolean | {
+                delay?: number;
+            };
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        ghost: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        block: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        danger: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        icon: import("vue-types").VueTypeValidableDef<any>;
+        href: StringConstructor;
+        target: StringConstructor;
+        title: StringConstructor;
+        onClick: {
+            type: import("vue").PropType<import("ant-design-vue/es/_util/EventInterface").MouseEventHandler | import("ant-design-vue/es/_util/EventInterface").MouseEventHandler[]>;
+        };
+        onMousedown: {
+            type: import("vue").PropType<import("ant-design-vue/es/_util/EventInterface").MouseEventHandler | import("ant-design-vue/es/_util/EventInterface").MouseEventHandler[]>;
+        };
+    }>> & Readonly<{}>, () => import("ant-design-vue/es/_util/type").VueNode, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+        block: boolean;
+        disabled: boolean;
+        danger: boolean;
+        ghost: boolean;
+        htmlType: import("ant-design-vue/es/button/buttonTypes").ButtonHTMLType;
+        loading: boolean | {
+            delay?: number;
+        };
+    }, {}, string, import("ant-design-vue/es/_util/type").CustomSlotsType<{
+        icon: any;
+        default: any;
+    }>, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & (import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (import("vue").Plugin<any[]> & {
+        readonly Group: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            prefixCls: StringConstructor;
+            size: {
+                type: PropType<import("ant-design-vue/es/button").ButtonSize>;
+            };
+        }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            prefixCls: StringConstructor;
+            size: {
+                type: PropType<import("ant-design-vue/es/button").ButtonSize>;
+            };
+        }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }));
+    readonly ElCollapseTransition: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?(_: {}): any;
+        };
+    }) & import("vue").Plugin;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    'update:modelValue': null;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    contentRef: {
+        type: PropType<AnyFunc>;
+        default: AnyFunc;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    modelValue: boolean;
+    title: string;
+    contentRef: AnyFunc;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;