@fangzhongya/fang-ui 0.0.12 → 0.0.14

package/dist/components/checks/index.d.ts

@@ -1,44 +1,129 @@
-declare const Checks: import('../../utils/vues').WithInstall<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
-    list: {
-        type: {
-            (arrayLength: number): import('../../types/object').ObjAny[];
-            (...items: import('../../types/object').ObjAny[]): import('../../types/object').ObjAny[];
-            new (arrayLength: number): import('../../types/object').ObjAny[];
-            new (...items: import('../../types/object').ObjAny[]): import('../../types/object').ObjAny[];
-            isArray(arg: any): arg is any[];
-            readonly prototype: any[];
-            from<T>(arrayLike: ArrayLike<T>): T[];
-            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
-            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
-            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
-            of<T>(...items: T[]): T[];
-            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
-            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
-            readonly [Symbol.species]: ArrayConstructor;
+declare const Checks: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        but: {
+            type: BooleanConstructor;
         };
-        default(): never[];
-    };
-    label: {
-        type: (StringConstructor | FunctionConstructor)[];
-        default: string;
-    };
-    prop: {
-        type: (StringConstructor | FunctionConstructor)[];
-        default: string;
-    };
-    modelValue: {
-        type: null;
-    };
-    multiple: {
-        type: (BooleanConstructor | StringConstructor)[];
+        options: {
+            type: {
+                (arrayLength: number): ObjAny[];
+                (...items: ObjAny[]): ObjAny[];
+                new (arrayLength: number): ObjAny[];
+                new (...items: ObjAny[]): ObjAny[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default(): never[];
+        };
+        clearAbsent: {
+            type: BooleanConstructor;
+        };
+        label: {
+            type: (FunctionConstructor | StringConstructor)[];
+            default: string;
+        };
+        prop: {
+            type: (FunctionConstructor | StringConstructor)[];
+            default: string;
+        };
+        modelValue: {
+            type: null;
+        };
+        multiple: {
+            type: (BooleanConstructor | StringConstructor)[];
+        };
+        load: {
+            type: BooleanConstructor[];
+        };
+        optobj: {
+            type: BooleanConstructor[];
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        label: string | Function;
+        options: ObjAny[];
+        prop: string | Function;
+        but: boolean;
+        clearAbsent: boolean;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        but: {
+            type: BooleanConstructor;
+        };
+        options: {
+            type: {
+                (arrayLength: number): ObjAny[];
+                (...items: ObjAny[]): ObjAny[];
+                new (arrayLength: number): ObjAny[];
+                new (...items: ObjAny[]): ObjAny[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default(): never[];
+        };
+        clearAbsent: {
+            type: BooleanConstructor;
+        };
+        label: {
+            type: (FunctionConstructor | StringConstructor)[];
+            default: string;
+        };
+        prop: {
+            type: (FunctionConstructor | StringConstructor)[];
+            default: string;
+        };
+        modelValue: {
+            type: null;
+        };
+        multiple: {
+            type: (BooleanConstructor | StringConstructor)[];
+        };
+        load: {
+            type: BooleanConstructor[];
+        };
+        optobj: {
+            type: BooleanConstructor[];
+        };
+    }>> & Readonly<{}>, {}, {}, {}, {}, {
+        label: string | Function;
+        options: ObjAny[];
+        prop: string | Function;
+        but: boolean;
+        clearAbsent: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+    but: {
+        type: BooleanConstructor;
     };
-}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
-    list: {
+    options: {
         type: {
-            (arrayLength: number): import('../../types/object').ObjAny[];
-            (...items: import('../../types/object').ObjAny[]): import('../../types/object').ObjAny[];
-            new (arrayLength: number): import('../../types/object').ObjAny[];
-            new (...items: import('../../types/object').ObjAny[]): import('../../types/object').ObjAny[];
+            (arrayLength: number): ObjAny[];
+            (...items: ObjAny[]): ObjAny[];
+            new (arrayLength: number): ObjAny[];
+            new (...items: ObjAny[]): ObjAny[];
             isArray(arg: any): arg is any[];
             readonly prototype: any[];
             from<T>(arrayLike: ArrayLike<T>): T[];
@@ -52,12 +137,15 @@ declare const Checks: import('../../utils/vues').WithInstall<import('vue').Defin
         };
         default(): never[];
     };
+    clearAbsent: {
+        type: BooleanConstructor;
+    };
     label: {
-        type: (StringConstructor | FunctionConstructor)[];
+        type: (FunctionConstructor | StringConstructor)[];
         default: string;
     };
     prop: {
-        type: (StringConstructor | FunctionConstructor)[];
+        type: (FunctionConstructor | StringConstructor)[];
         default: string;
     };
     modelValue: {
@@ -66,9 +154,17 @@ declare const Checks: import('../../utils/vues').WithInstall<import('vue').Defin
     multiple: {
         type: (BooleanConstructor | StringConstructor)[];
     };
-}>> & Readonly<{}>, {
+    load: {
+        type: BooleanConstructor[];
+    };
+    optobj: {
+        type: BooleanConstructor[];
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
     label: string | Function;
-    list: import('../../types/object').ObjAny[];
+    options: ObjAny[];
     prop: string | Function;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>> & Record<string, any>;
+    but: boolean;
+    clearAbsent: boolean;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & import('vue').Plugin;
 export { Checks, Checks as default };

package/dist/components/checks/index.js

@@ -1,3 +1,4 @@
+/* empty css                 */
 import { withInstall } from "../../utils/vues/withInstall.js";
 import _sfc_main from "./src/index.js";
 const Checks = withInstall(_sfc_main, "Checks");

package/dist/components/checks/index.scss

@@ -0,0 +1,12 @@
+@use '../css/common.scss' as *;
+
+$checks: 'checks';
+@include b($checks) {
+	&-check {
+		height: 100%;
+		display: flex;
+		align-items: center;
+		flex-wrap: wrap;
+		font-size: 0;
+	}
+}

package/dist/components/checks/src/data.cjs

@@ -1,10 +1,18 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const buildProps = require("../../../utils/vues/buildProps.cjs");
-const list = require("../../common/data/list.cjs");
-const dataProps = buildProps.buildProps(list.props);
+const list = require("../../common/list.cjs");
+const dataProps = {
+  ...list.props,
+  /**
+   * @props { Boolean } but= ( )
+   * 是否用按钮模式
+   */
+  but: {
+    type: Boolean
+  }
+};
 const dataHandle = list.comHandle;
-const dataEmits = [...list.emits];
+const dataEmits = [...list.emits, "click-multiple"];
 exports.dataEmits = dataEmits;
 exports.dataHandle = dataHandle;
 exports.dataProps = dataProps;

package/dist/components/checks/src/data.d.ts

@@ -1,12 +1,19 @@
-import { ExtractPublicPropTypes } from 'vue';
-import { comHandle } from '../../common/data/list';
+import { ExtractPropTypes } from 'vue';
+import { comHandle } from '../../common/list';
 export declare const dataProps: {
-    list: {
+    /**
+     * @props { Boolean } but= ( )
+     * 是否用按钮模式
+     */
+    but: {
+        type: BooleanConstructor;
+    };
+    options: {
         type: {
-            (arrayLength: number): import('../../../types/object').ObjAny[];
-            (...items: import('../../../types/object').ObjAny[]): import('../../../types/object').ObjAny[];
-            new (arrayLength: number): import('../../../types/object').ObjAny[];
-            new (...items: import('../../../types/object').ObjAny[]): import('../../../types/object').ObjAny[];
+            (arrayLength: number): ObjAny[];
+            (...items: ObjAny[]): ObjAny[];
+            new (arrayLength: number): ObjAny[];
+            new (...items: ObjAny[]): ObjAny[];
             isArray(arg: any): arg is any[];
             readonly prototype: any[];
             from<T>(arrayLike: ArrayLike<T>): T[];
@@ -20,12 +27,15 @@ export declare const dataProps: {
         };
         default(): never[];
     };
+    clearAbsent: {
+        type: BooleanConstructor;
+    };
     label: {
-        type: (StringConstructor | FunctionConstructor)[];
+        type: (FunctionConstructor | StringConstructor)[];
         default: string;
     };
     prop: {
-        type: (StringConstructor | FunctionConstructor)[];
+        type: (FunctionConstructor | StringConstructor)[];
         default: string;
     };
     modelValue: {
@@ -34,8 +44,14 @@ export declare const dataProps: {
     multiple: {
         type: (BooleanConstructor | StringConstructor)[];
     };
+    load: {
+        type: BooleanConstructor[];
+    };
+    optobj: {
+        type: BooleanConstructor[];
+    };
 };
-export type DataProps = ExtractPublicPropTypes<typeof dataProps>;
+export type DataProps = ExtractPropTypes<typeof dataProps>;
 export declare const dataHandle: typeof comHandle;
 export declare const dataEmits: string[];
 export type DataEmits = typeof dataEmits;

package/dist/components/checks/src/data.js

@@ -1,8 +1,16 @@
-import { buildProps } from "../../../utils/vues/buildProps.js";
-import { emits, comHandle, props } from "../../common/data/list.js";
-const dataProps = buildProps(props);
+import { emits, props, comHandle } from "../../common/list.js";
+const dataProps = {
+  ...props,
+  /**
+   * @props { Boolean } but= ( )
+   * 是否用按钮模式
+   */
+  but: {
+    type: Boolean
+  }
+};
 const dataHandle = comHandle;
-const dataEmits = [...emits];
+const dataEmits = [...emits, "click-multiple"];
 export {
   dataEmits,
   dataHandle,

package/dist/components/checks/src/index.cjs

@@ -1,70 +1,95 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const vue = require("vue");
+const require$$0 = require("vue");
+const index$2 = require("../../../directives/expose/index.cjs");
 const elementPlus = require("element-plus");
-const common = require("../../../utils/vues/common.cjs");
 const index = require("../../../hooks/cssname/index.cjs");
 const data = require("./data.cjs");
-const index$1 = require("../../../directives/expose/index.cjs");
-const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+const index$1 = require("../../../hooks/inherit/index.cjs");
+const use = require("../../common/use.cjs");
+const _sfc_main = /* @__PURE__ */ require$$0.defineComponent({
   __name: "index",
   props: data.dataProps,
   emits: data.dataEmits,
   setup(__props, { emit: __emit }) {
     const cs = index.useCssName("checks");
+    const attrs = index$1.useInherit(require$$0.useAttrs());
     const props = __props;
     const emit = __emit;
     const listFuObj = data.dataHandle(props, emit);
     const value = listFuObj.value;
     const multiple = listFuObj.multiple;
+    const comps = require$$0.computed(() => {
+      if (multiple.value) {
+        if (props.but) {
+          return elementPlus.ElCheckboxButton;
+        } else {
+          return elementPlus.ElCheckbox;
+        }
+      } else {
+        if (props.but) {
+          return elementPlus.ElRadioButton;
+        } else {
+          return elementPlus.ElRadio;
+        }
+      }
+    });
+    const onChange = (item, is) => {
+      emit("click-multiple", item, is);
+    };
     return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createElementBlock("div", {
-        class: vue.normalizeClass(vue.unref(cs).z())
-      }, [
-        vue.unref(multiple) ? vue.withDirectives((vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElCheckboxGroup), vue.mergeProps({
+      return require$$0.openBlock(), require$$0.createElementBlock("div", require$$0.mergeProps({
+        class: require$$0.unref(cs).z()
+      }, require$$0.unref(attrs).root), [
+        require$$0.unref(multiple) ? require$$0.withDirectives((require$$0.openBlock(), require$$0.createBlock(require$$0.unref(elementPlus.ElCheckboxGroup), require$$0.mergeProps({
           key: 0,
-          modelValue: vue.unref(value),
-          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => vue.isRef(value) ? value.value = $event : null)
-        }, _ctx.$attrs), {
-          default: vue.withCtx(() => [
-            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(props.list, (item) => {
-              return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElCheckbox), {
-                label: vue.unref(common.setVueValue)(item, props.prop),
-                disabled: item == null ? void 0 : item.disabled
+          class: require$$0.unref(cs).z("check"),
+          modelValue: require$$0.unref(value),
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => require$$0.isRef(value) ? value.value = $event : null)
+        }, require$$0.unref(attrs).assem), {
+          default: require$$0.withCtx(() => [
+            (require$$0.openBlock(true), require$$0.createElementBlock(require$$0.Fragment, null, require$$0.renderList(props.options, (item) => {
+              return require$$0.openBlock(), require$$0.createBlock(require$$0.resolveDynamicComponent(comps.value), {
+                value: require$$0.unref(use.useVueValue)(item, props.prop),
+                border: item == null ? void 0 : item.border,
+                disabled: item == null ? void 0 : item.disabled,
+                onChange: (is) => onChange(item, is)
               }, {
-                default: vue.withCtx(() => [
-                  vue.createTextVNode(vue.toDisplayString(vue.unref(common.setVueValue)(item, props.label)), 1)
+                default: require$$0.withCtx(() => [
+                  require$$0.createTextVNode(require$$0.toDisplayString(require$$0.unref(use.useVueValue)(item, props.label)), 1)
                 ]),
                 _: 2
-              }, 1032, ["label", "disabled"]);
+              }, 1064, ["value", "border", "disabled", "onChange"]);
             }), 256))
           ]),
           _: 1
-        }, 16, ["modelValue"])), [
-          [vue.unref(index$1.default)]
-        ]) : vue.withDirectives((vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElRadioGroup), vue.mergeProps({
+        }, 16, ["class", "modelValue"])), [
+          [require$$0.unref(index$2.default), {}]
+        ]) : require$$0.withDirectives((require$$0.openBlock(), require$$0.createBlock(require$$0.unref(elementPlus.ElRadioGroup), require$$0.mergeProps({
           key: 1,
-          modelValue: vue.unref(value),
-          "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => vue.isRef(value) ? value.value = $event : null)
-        }, _ctx.$attrs), {
-          default: vue.withCtx(() => [
-            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(props.list, (item) => {
-              return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElRadio), {
-                label: vue.unref(common.setVueValue)(item, props.prop),
+          class: require$$0.unref(cs).z("check"),
+          modelValue: require$$0.unref(value),
+          "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => require$$0.isRef(value) ? value.value = $event : null)
+        }, require$$0.unref(attrs).assem), {
+          default: require$$0.withCtx(() => [
+            (require$$0.openBlock(true), require$$0.createElementBlock(require$$0.Fragment, null, require$$0.renderList(props.options, (item) => {
+              return require$$0.openBlock(), require$$0.createBlock(require$$0.resolveDynamicComponent(comps.value), {
+                border: item == null ? void 0 : item.border,
+                value: require$$0.unref(use.useVueValue)(item, props.prop),
                 disabled: item == null ? void 0 : item.disabled
               }, {
-                default: vue.withCtx(() => [
-                  vue.createTextVNode(vue.toDisplayString(vue.unref(common.setVueValue)(item, props.label)), 1)
+                default: require$$0.withCtx(() => [
+                  require$$0.createTextVNode(require$$0.toDisplayString(require$$0.unref(use.useVueValue)(item, props.label)), 1)
                 ]),
                 _: 2
-              }, 1032, ["label", "disabled"]);
+              }, 1032, ["border", "value", "disabled"]);
             }), 256))
           ]),
           _: 1
-        }, 16, ["modelValue"])), [
-          [vue.unref(index$1.default)]
+        }, 16, ["class", "modelValue"])), [
+          [require$$0.unref(index$2.default), {}]
         ])
-      ], 2);
+      ], 16);
     };
   }
 });

package/dist/components/checks/src/index.d.ts

@@ -1,10 +1,13 @@
 declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
-    list: {
+    but: {
+        type: BooleanConstructor;
+    };
+    options: {
         type: {
-            (arrayLength: number): import('../../../types/object').ObjAny[];
-            (...items: import('../../../types/object').ObjAny[]): import('../../../types/object').ObjAny[];
-            new (arrayLength: number): import('../../../types/object').ObjAny[];
-            new (...items: import('../../../types/object').ObjAny[]): import('../../../types/object').ObjAny[];
+            (arrayLength: number): ObjAny[];
+            (...items: ObjAny[]): ObjAny[];
+            new (arrayLength: number): ObjAny[];
+            new (...items: ObjAny[]): ObjAny[];
             isArray(arg: any): arg is any[];
             readonly prototype: any[];
             from<T>(arrayLike: ArrayLike<T>): T[];
@@ -18,12 +21,15 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
         };
         default(): never[];
     };
+    clearAbsent: {
+        type: BooleanConstructor;
+    };
     label: {
-        type: (StringConstructor | FunctionConstructor)[];
+        type: (FunctionConstructor | StringConstructor)[];
         default: string;
     };
     prop: {
-        type: (StringConstructor | FunctionConstructor)[];
+        type: (FunctionConstructor | StringConstructor)[];
         default: string;
     };
     modelValue: {
@@ -32,13 +38,22 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
     multiple: {
         type: (BooleanConstructor | StringConstructor)[];
     };
+    load: {
+        type: BooleanConstructor[];
+    };
+    optobj: {
+        type: BooleanConstructor[];
+    };
 }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
-    list: {
+    but: {
+        type: BooleanConstructor;
+    };
+    options: {
         type: {
-            (arrayLength: number): import('../../../types/object').ObjAny[];
-            (...items: import('../../../types/object').ObjAny[]): import('../../../types/object').ObjAny[];
-            new (arrayLength: number): import('../../../types/object').ObjAny[];
-            new (...items: import('../../../types/object').ObjAny[]): import('../../../types/object').ObjAny[];
+            (arrayLength: number): ObjAny[];
+            (...items: ObjAny[]): ObjAny[];
+            new (arrayLength: number): ObjAny[];
+            new (...items: ObjAny[]): ObjAny[];
             isArray(arg: any): arg is any[];
             readonly prototype: any[];
             from<T>(arrayLike: ArrayLike<T>): T[];
@@ -52,12 +67,15 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
         };
         default(): never[];
     };
+    clearAbsent: {
+        type: BooleanConstructor;
+    };
     label: {
-        type: (StringConstructor | FunctionConstructor)[];
+        type: (FunctionConstructor | StringConstructor)[];
         default: string;
     };
     prop: {
-        type: (StringConstructor | FunctionConstructor)[];
+        type: (FunctionConstructor | StringConstructor)[];
         default: string;
     };
     modelValue: {
@@ -66,9 +84,17 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
     multiple: {
         type: (BooleanConstructor | StringConstructor)[];
     };
+    load: {
+        type: BooleanConstructor[];
+    };
+    optobj: {
+        type: BooleanConstructor[];
+    };
 }>> & Readonly<{}>, {
     label: string | Function;
-    list: import('../../../types/object').ObjAny[];
+    options: ObjAny[];
     prop: string | Function;
+    but: boolean;
+    clearAbsent: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
 export default _default;