@fangzhongya/fang-ui 0.1.89 → 0.1.90

package/dist/components/alert/index.cjs

@@ -6,17 +6,18 @@ require("./src/export.cjs");
 //#region packages/components/packages/element/feedback/alert/index.ts
 var alert_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	Alert: () => Alert,
-	default: () => Alert
+	default: () => _default
 });
-var Alert = require_withInstall.withInstall(require_index$1.default, "Alert");
+var _default = require_withInstall.withInstall(require_index$1.default, "Alert");
+var Alert = _default;
 //#endregion
+exports.Alert = Alert;
 Object.defineProperty(exports, "alert_exports", {
 	enumerable: true,
 	get: function() {
 		return alert_exports;
 	}
 });
-exports.default = Alert;
 var element_plus_es_components_alert_index = require("element-plus/es/components/alert/index");
 Object.keys(element_plus_es_components_alert_index).forEach(function(k) {
 	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {

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

@@ -1,7 +1,7 @@
 import { SFCWithInstall } from '../../../utils/vues';
 import { CreateComponentPublicInstanceWithMixins, ComponentOptionsMixin, PublicProps, GlobalComponents, GlobalDirectives, ComponentProvideOptions, ComponentOptionsBase, VNodeProps, AllowedComponentProps, ComponentCustomProps } from 'vue';
 export * from './src/export';
-declare const Alert: SFCWithInstall<{
+declare const _default: SFCWithInstall<{
     new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, ObjAny, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
         P: {};
         B: {};
@@ -18,5 +18,21 @@ declare const Alert: SFCWithInstall<{
         [x: string]: ((props: any) => any) | undefined;
     };
 })>;
-export { Alert };
-export default Alert;
+export declare const Alert: SFCWithInstall<{
+    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, ObjAny, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{}> & Readonly<{}>, ObjAny, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly<{}> & Readonly<{}>, ObjAny, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+    $slots: {
+        [x: string]: ((props: any) => any) | undefined;
+    };
+})>;
+export default _default;

package/dist/components/alert/index.js

@@ -7,8 +7,9 @@ export * from "element-plus/es/components/alert/index";
 //#region packages/components/packages/element/feedback/alert/index.ts
 var alert_exports = /* @__PURE__ */ __exportAll({
 	Alert: () => Alert,
-	default: () => Alert
+	default: () => _default
 });
-var Alert = withInstall(src_default, "Alert");
+var _default = withInstall(src_default, "Alert");
+var Alert = _default;
 //#endregion
-export { alert_exports, Alert as default };
+export { Alert, alert_exports };

package/dist/components/audios/index.cjs

@@ -1,7 +1,6 @@
 const require_withInstall = require("../../utils/vues/withInstall.cjs");
 ;/* empty css                   */
 const require_index$1 = require("./src/index.cjs");
-//#region packages/components/packages/players/audios/index.ts
 var Audios = require_withInstall.withInstall(require_index$1.default, "Audios");
 //#endregion
-exports.default = Audios;
+exports.Audios = Audios;

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

@@ -1,6 +1,6 @@
 import { SFCWithInstall } from '../../../utils/vues';
 import { DefineComponent, ExtractPropTypes, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
-declare const Audios: SFCWithInstall<DefineComponent<ExtractPropTypes<{
+declare const _default: SFCWithInstall<DefineComponent<ExtractPropTypes<{
     list: {
         type: {
             (arrayLength: number): ObjAny[];
@@ -47,5 +47,51 @@ declare const Audios: SFCWithInstall<DefineComponent<ExtractPropTypes<{
 }>, {
     list: ObjAny[];
 }, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>>;
-export { Audios };
-export default Audios;
+export declare const Audios: SFCWithInstall<DefineComponent<ExtractPropTypes<{
+    list: {
+        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[];
+    };
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    change: (evt: string | string[]) => void;
+}, string, PublicProps, Readonly< ExtractPropTypes<{
+    list: {
+        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[];
+    };
+}>> & Readonly<{
+    onChange?: ((evt: string | string[]) => any) | undefined;
+}>, {
+    list: ObjAny[];
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>>;
+export default _default;

package/dist/components/audios/index.js

@@ -1,7 +1,6 @@
 import { withInstall } from "../../utils/vues/withInstall.js";
 /* empty css                 */
 import src_default from "./src/index.js";
-//#region packages/components/packages/players/audios/index.ts
 var Audios = withInstall(src_default, "Audios");
 //#endregion
-export { Audios as default };
+export { Audios };

package/dist/components/audios/src/index.vue_vue_type_script_setup_true_lang.js

@@ -1,8 +1,8 @@
 import { useCssName } from "../../../hooks/cssname/index.js";
 import { useLocale } from "../../../hooks/locale/index.js";
 import { getProps, usePropsDefault } from "../../../hooks/props-default/index.js";
-import Button from "../../button/index.js";
-import Sliders from "../../sliders/index.js";
+import _default from "../../button/index.js";
+import _default$1 from "../../sliders/index.js";
 import up_default from "../../../icons/vue/up.js";
 import down_default from "../../../icons/vue/down.js";
 import play_default from "../../../icons/vue/play.js";
@@ -125,7 +125,7 @@ var index_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComp
 		return (_ctx, _cache) => {
 			return openBlock(), createElementBlock("div", { class: normalizeClass([unref(cs).z(), unref(cs).is("playing", isPlaying.value)]) }, [
 				createElementVNode("div", { class: normalizeClass(unref(cs).z("name")) }, toDisplayString(value.value?.name), 3),
-				createElementVNode("div", { class: normalizeClass(unref(cs).z("slider")) }, [createVNode(unref(Sliders), {
+				createElementVNode("div", { class: normalizeClass(unref(cs).z("slider")) }, [createVNode(unref(_default$1), {
 					class: normalizeClass(unref(cs).z("slider-slider")),
 					onChange: onChangeSlider,
 					onMousedown,
@@ -138,32 +138,32 @@ var index_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComp
 					createElementVNode("span", { class: normalizeClass(unref(cs).z("duration-end")) }, toDisplayString(unref(hourFormat)(duration.value)), 3)
 				], 2)], 2),
 				createElementVNode("div", { class: normalizeClass(unref(cs).z("control")) }, [createElementVNode("div", { class: normalizeClass(unref(cs).z("control-buts")) }, [
-					createVNode(unref(Button), {
+					createVNode(unref(_default), {
 						size: "small",
 						icon: up_default,
 						disabled: current.value == 0,
 						circle: "",
 						onClick: _cache[1] || (_cache[1] = ($event) => onTrack(true))
 					}, null, 8, ["disabled"]),
-					createVNode(unref(Button), {
+					createVNode(unref(_default), {
 						icon: isPlaying.value ? pause_default : play_default,
 						circle: "",
 						onClick: togglePlay
 					}, null, 8, ["icon"]),
-					createVNode(unref(Button), {
+					createVNode(unref(_default), {
 						size: "small",
 						icon: down_default,
 						circle: "",
 						disabled: current.value + 1 == list.value.length,
 						onClick: _cache[2] || (_cache[2] = ($event) => onTrack(false))
 					}, null, 8, ["disabled"])
-				], 2), createElementVNode("div", { class: normalizeClass(unref(cs).z("control-volume")) }, [createVNode(unref(Button), {
+				], 2), createElementVNode("div", { class: normalizeClass(unref(cs).z("control-volume")) }, [createVNode(unref(_default), {
 					class: normalizeClass(unref(cs).z("control-volume-but")),
 					icon: isMuted.value ? mute_default : sound_default,
 					circle: "",
 					onClick: toggleMute,
 					size: "small"
-				}, null, 8, ["class", "icon"]), createVNode(unref(Sliders), {
+				}, null, 8, ["class", "icon"]), createVNode(unref(_default$1), {
 					class: normalizeClass(unref(cs).z("control-volume-slider")),
 					size: "small",
 					onChange,

package/dist/components/autocomplete/index.cjs

@@ -6,17 +6,18 @@ require("./src/export.cjs");
 //#region packages/components/packages/element/forms/inputs/autocomplete/index.ts
 var autocomplete_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	Autocomplete: () => Autocomplete,
-	default: () => Autocomplete
+	default: () => _default
 });
-var Autocomplete = require_withInstall.withInstall(require_index$1.default, "Autocomplete");
+var _default = require_withInstall.withInstall(require_index$1.default, "Autocomplete");
+var Autocomplete = _default;
 //#endregion
+exports.Autocomplete = Autocomplete;
 Object.defineProperty(exports, "autocomplete_exports", {
 	enumerable: true,
 	get: function() {
 		return autocomplete_exports;
 	}
 });
-exports.default = Autocomplete;
 var element_plus_es_components_autocomplete_index = require("element-plus/es/components/autocomplete/index");
 Object.keys(element_plus_es_components_autocomplete_index).forEach(function(k) {
 	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {

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

@@ -1,7 +1,7 @@
 import { SFCWithInstall } from '../../../utils/vues';
 import { CreateComponentPublicInstanceWithMixins, ComponentOptionsMixin, PublicProps, GlobalComponents, GlobalDirectives, ComponentProvideOptions, ComponentOptionsBase, VNodeProps, AllowedComponentProps, ComponentCustomProps } from 'vue';
 export * from './src/export';
-declare const Autocomplete: SFCWithInstall<{
+declare const _default: SFCWithInstall<{
     new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, ObjAny, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
         P: {};
         B: {};
@@ -18,5 +18,21 @@ declare const Autocomplete: SFCWithInstall<{
         [x: string]: ((props: any) => any) | undefined;
     };
 })>;
-export { Autocomplete };
-export default Autocomplete;
+export declare const Autocomplete: SFCWithInstall<{
+    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, ObjAny, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{}> & Readonly<{}>, ObjAny, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly<{}> & Readonly<{}>, ObjAny, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+    $slots: {
+        [x: string]: ((props: any) => any) | undefined;
+    };
+})>;
+export default _default;

package/dist/components/autocomplete/index.js

@@ -7,8 +7,9 @@ export * from "element-plus/es/components/autocomplete/index";
 //#region packages/components/packages/element/forms/inputs/autocomplete/index.ts
 var autocomplete_exports = /* @__PURE__ */ __exportAll({
 	Autocomplete: () => Autocomplete,
-	default: () => Autocomplete
+	default: () => _default
 });
-var Autocomplete = withInstall(src_default, "Autocomplete");
+var _default = withInstall(src_default, "Autocomplete");
+var Autocomplete = _default;
 //#endregion
-export { autocomplete_exports, Autocomplete as default };
+export { Autocomplete, autocomplete_exports };

package/dist/components/box/index.cjs

@@ -2,6 +2,8 @@ const require_withInstall = require("../../utils/vues/withInstall.cjs");
 ;/* empty css                   */
 const require_index$1 = require("./src/index.cjs");
 //#region packages/components/packages/frame/box/index.ts
-var Box = require_withInstall.withInstall(require_index$1.default, "Box");
+var _default = require_withInstall.withInstall(require_index$1.default, "Box");
+var Box = _default;
 //#endregion
-exports.default = Box;
+exports.Box = Box;
+exports.default = _default;

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

@@ -1,7 +1,7 @@
 import { SFCWithInstall } from '../../../utils/vues';
 import { CreateComponentPublicInstanceWithMixins, ExtractPropTypes, ComponentOptionsMixin, PublicProps, GlobalComponents, GlobalDirectives, ComponentProvideOptions, ComponentOptionsBase, VNodeProps, AllowedComponentProps, ComponentCustomProps } from 'vue';
 import { FunctConfig } from '../../../utils/enums';
-declare const Box: SFCWithInstall<{
+declare const _default: SFCWithInstall<{
     new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
         title: {
             type: StringConstructor;
@@ -115,5 +115,118 @@ declare const Box: SFCWithInstall<{
         default?: (props: {}) => any;
     };
 })>;
-export { Box };
-export default Box;
+export declare const Box: SFCWithInstall<{
+    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
+        title: {
+            type: StringConstructor;
+        };
+        modelValue: {
+            type: BooleanConstructor;
+        };
+        boxClass: {
+            type: StringConstructor;
+        };
+        isClose: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        to: {
+            type: StringConstructor;
+            default: FunctConfig;
+        };
+        disabled: {
+            type: BooleanConstructor;
+        };
+        cssprefix: {
+            type: StringConstructor;
+        };
+    }>> & Readonly<{}>, {
+        name: string;
+    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
+        modelValue: boolean;
+        disabled: boolean;
+        to: string;
+        isClose: boolean;
+    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly< ExtractPropTypes<{
+        title: {
+            type: StringConstructor;
+        };
+        modelValue: {
+            type: BooleanConstructor;
+        };
+        boxClass: {
+            type: StringConstructor;
+        };
+        isClose: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        to: {
+            type: StringConstructor;
+            default: FunctConfig;
+        };
+        disabled: {
+            type: BooleanConstructor;
+        };
+        cssprefix: {
+            type: StringConstructor;
+        };
+    }>> & Readonly<{}>, {
+        name: string;
+    }, {}, {}, {}, {
+        modelValue: boolean;
+        disabled: boolean;
+        to: string;
+        isClose: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly< ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+    };
+    modelValue: {
+        type: BooleanConstructor;
+    };
+    boxClass: {
+        type: StringConstructor;
+    };
+    isClose: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    to: {
+        type: StringConstructor;
+        default: FunctConfig;
+    };
+    disabled: {
+        type: BooleanConstructor;
+    };
+    cssprefix: {
+        type: StringConstructor;
+    };
+}>> & Readonly<{}>, {
+    name: string;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+    modelValue: boolean;
+    disabled: boolean;
+    to: string;
+    isClose: boolean;
+}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+    $slots: {
+        [x: string]: ((props: {}) => any) | undefined;
+    } & {
+        [x: string]: ((props: {}) => any) | undefined;
+    } & {
+        default?: (props: {}) => any;
+    };
+})>;
+export default _default;

package/dist/components/box/index.js

@@ -2,6 +2,7 @@ import { withInstall } from "../../utils/vues/withInstall.js";
 /* empty css                 */
 import src_default from "./src/index.js";
 //#region packages/components/packages/frame/box/index.ts
-var Box = withInstall(src_default, "Box");
+var _default = withInstall(src_default, "Box");
+var Box = _default;
 //#endregion
-export { Box as default };
+export { Box, _default as default };

package/dist/components/box/src/index.vue_vue_type_script_setup_true_lang.js

@@ -2,9 +2,9 @@ import { useCssName } from "../../../hooks/cssname/index.js";
 import { useLocale } from "../../../hooks/locale/index.js";
 import { getProps, usePropsDefault } from "../../../hooks/props-default/index.js";
 import { dataEmits, dataExpose, dataProps, dataSlot } from "./data.js";
-import BoxTitle from "../../box-title/index.js";
-import BoxMask from "../../box-mask/index.js";
-import BoxTeleport from "../../box-teleport/index.js";
+import _default from "../../box-title/index.js";
+import _default$1 from "../../box-mask/index.js";
+import _default$2 from "../../box-teleport/index.js";
 import { createBlock, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, normalizeClass, openBlock, renderSlot, shallowRef, unref, vShow, watch, withCtx, withDirectives } from "vue";
 //#region packages/components/packages/frame/box/src/index.vue?vue&type=script&setup=true&lang.ts
 var _hoisted_1 = ["name"];
@@ -27,18 +27,18 @@ var index_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComp
 		}
 		__expose({ ...dataExpose });
 		return (_ctx, _cache) => {
-			return openBlock(), createBlock(unref(BoxTeleport), {
+			return openBlock(), createBlock(unref(_default$2), {
 				disabled: unref(props).disabled,
 				to: unref(props).to
 			}, {
 				default: withCtx(() => [isInit.value ? withDirectives((openBlock(), createElementBlock("div", {
 					key: 0,
 					class: normalizeClass([unref(cs).z(), unref(props).boxClass])
-				}, [createVNode(unref(BoxMask), {
+				}, [createVNode(unref(_default$1), {
 					onClick: onClose,
 					cssprefix: unref(props).cssprefix || unref(cs).z()
 				}, null, 8, ["cssprefix"]), createElementVNode("div", { class: normalizeClass(unref(cs).z("body")) }, [
-					renderSlot(_ctx.$slots, unref(dataSlot).title, {}, () => [createVNode(unref(BoxTitle), {
+					renderSlot(_ctx.$slots, unref(dataSlot).title, {}, () => [createVNode(unref(_default), {
 						onClose,
 						title: unref(props).title
 					}, null, 8, ["title"])]),

package/dist/components/box-adjust/index.cjs

@@ -2,6 +2,8 @@ const require_withInstall = require("../../utils/vues/withInstall.cjs");
 ;/* empty css                   */
 const require_index$1 = require("./src/index.cjs");
 //#region packages/components/packages/frame/box-adjust/index.ts
-var BoxAdjust = require_withInstall.withInstall(require_index$1.default, "BoxAdjust");
+var _default = require_withInstall.withInstall(require_index$1.default, "BoxAdjust");
+var BoxAdjust = _default;
 //#endregion
-exports.default = BoxAdjust;
+exports.BoxAdjust = BoxAdjust;
+exports.default = _default;

package/dist/components/box-adjust/index.d.ts

@@ -1,7 +1,7 @@
 import { SFCWithInstall } from '../../../utils/vues';
 import { CreateComponentPublicInstanceWithMixins, ExtractPropTypes, ComponentOptionsMixin, PublicProps, GlobalComponents, GlobalDirectives, ComponentProvideOptions, ComponentOptionsBase, VNodeProps, AllowedComponentProps, ComponentCustomProps } from 'vue';
 import { FunctConfig } from '../../../utils/enums';
-declare const BoxAdjust: SFCWithInstall<{
+declare const _default: SFCWithInstall<{
     new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
         drag: {
             type: StringConstructor;
@@ -164,5 +164,167 @@ declare const BoxAdjust: SFCWithInstall<{
         [x: string]: ((props: {}) => any) | undefined;
     };
 })>;
-export { BoxAdjust };
-export default BoxAdjust;
+export declare const BoxAdjust: SFCWithInstall<{
+    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
+        drag: {
+            type: StringConstructor;
+        };
+        often: {
+            type: BooleanConstructor;
+        };
+        isMax: {
+            type: BooleanConstructor;
+        };
+        max: {
+            type: BooleanConstructor;
+        };
+        title: {
+            type: StringConstructor;
+        };
+        modelValue: {
+            type: BooleanConstructor;
+        };
+        boxClass: {
+            type: StringConstructor;
+        };
+        isClose: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        to: {
+            type: StringConstructor;
+            default: FunctConfig;
+        };
+        disabled: {
+            type: BooleanConstructor;
+        };
+        cssprefix: {
+            type: StringConstructor;
+        };
+    }>> & Readonly<{}>, {
+        name: string;
+    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
+        modelValue: boolean;
+        disabled: boolean;
+        max: boolean;
+        to: string;
+        isClose: boolean;
+        often: boolean;
+        isMax: boolean;
+    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly< ExtractPropTypes<{
+        drag: {
+            type: StringConstructor;
+        };
+        often: {
+            type: BooleanConstructor;
+        };
+        isMax: {
+            type: BooleanConstructor;
+        };
+        max: {
+            type: BooleanConstructor;
+        };
+        title: {
+            type: StringConstructor;
+        };
+        modelValue: {
+            type: BooleanConstructor;
+        };
+        boxClass: {
+            type: StringConstructor;
+        };
+        isClose: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        to: {
+            type: StringConstructor;
+            default: FunctConfig;
+        };
+        disabled: {
+            type: BooleanConstructor;
+        };
+        cssprefix: {
+            type: StringConstructor;
+        };
+    }>> & Readonly<{}>, {
+        name: string;
+    }, {}, {}, {}, {
+        modelValue: boolean;
+        disabled: boolean;
+        max: boolean;
+        to: string;
+        isClose: boolean;
+        often: boolean;
+        isMax: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly< ExtractPropTypes<{
+    drag: {
+        type: StringConstructor;
+    };
+    often: {
+        type: BooleanConstructor;
+    };
+    isMax: {
+        type: BooleanConstructor;
+    };
+    max: {
+        type: BooleanConstructor;
+    };
+    title: {
+        type: StringConstructor;
+    };
+    modelValue: {
+        type: BooleanConstructor;
+    };
+    boxClass: {
+        type: StringConstructor;
+    };
+    isClose: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    to: {
+        type: StringConstructor;
+        default: FunctConfig;
+    };
+    disabled: {
+        type: BooleanConstructor;
+    };
+    cssprefix: {
+        type: StringConstructor;
+    };
+}>> & Readonly<{}>, {
+    name: string;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+    modelValue: boolean;
+    disabled: boolean;
+    max: boolean;
+    to: string;
+    isClose: boolean;
+    often: boolean;
+    isMax: boolean;
+}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+    $slots: {
+        [x: string]: ((props: {}) => any) | undefined;
+    } & {
+        [x: string]: ((props: {}) => any) | undefined;
+    } & {
+        [x: string]: ((props: {}) => any) | undefined;
+    } & {
+        [x: string]: ((props: {}) => any) | undefined;
+    } & {
+        [x: string]: ((props: {}) => any) | undefined;
+    };
+})>;
+export default _default;