@minilo/ui 0.0.1

package/minilo/lib/index.d.ts

@@ -0,0 +1,1087 @@
+import { App } from 'vue';
+export * from './components';
+export declare const MsUIComponentsInstance: (({
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./components/virtual-list/type').MlVirtualListProps> & Readonly<{
+        "onLoad-more"?: (() => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        "load-more": () => any;
+    }, import('vue').PublicProps, {
+        height: number;
+        itemHeight: number;
+        estimatedItemHeight: number;
+        itemEqual: boolean;
+        preLoadCount: number;
+        threshold: number;
+        dataSource: any[];
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        containerRef: HTMLDivElement;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./components/virtual-list/type').MlVirtualListProps> & Readonly<{
+        "onLoad-more"?: (() => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        height: number;
+        itemHeight: number;
+        estimatedItemHeight: number;
+        itemEqual: boolean;
+        preLoadCount: number;
+        threshold: number;
+        dataSource: any[];
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./components/virtual-list/type').MlVirtualListProps> & Readonly<{
+    "onLoad-more"?: (() => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "load-more": () => any;
+}, string, {
+    height: number;
+    itemHeight: number;
+    estimatedItemHeight: number;
+    itemEqual: boolean;
+    preLoadCount: number;
+    threshold: number;
+    dataSource: any[];
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {
+            item: any;
+            index: number;
+        }): any;
+        loading?(_: {}): any;
+        finished?(_: {}): any;
+    };
+})) | ({
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./components/chart/type').MlChartProps> & Readonly<{
+        [x: `on${Capitalize<string>}`]: ((...args: unknown[] & []) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        [x: string]: ((...args: unknown[]) => any) | (() => any);
+    }, import('vue').PublicProps, {
+        options: Record<string, any>;
+        id: string;
+        theme: string;
+        isEmpty: boolean | ((options: Record<string, any>) => boolean);
+        description: string;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        echartRef: HTMLDivElement;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./components/chart/type').MlChartProps> & Readonly<{
+        [x: `on${Capitalize<string>}`]: ((...args: unknown[] & []) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        options: Record<string, any>;
+        id: string;
+        theme: string;
+        isEmpty: boolean | ((options: Record<string, any>) => boolean);
+        description: string;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./components/chart/type').MlChartProps> & Readonly<{
+    [x: `on${Capitalize<string>}`]: ((...args: unknown[] & []) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    [x: string]: ((...args: unknown[]) => any) | (() => any);
+}, string, {
+    options: Record<string, any>;
+    id: string;
+    theme: string;
+    isEmpty: boolean | ((options: Record<string, any>) => boolean);
+    description: string;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        empty?(_: {}): any;
+        default?(_: {}): any;
+    };
+})) | ({
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        inline: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        labelWidth: {
+            type: (StringConstructor | NumberConstructor)[];
+            default: string;
+        };
+        labelPosition: {
+            type: import('vue').PropType<"left" | "right" | "top">;
+            default: string;
+        };
+        size: {
+            type: import('vue').PropType<"" | "large" | "default" | "small">;
+            default: string;
+        };
+        gutter: {
+            type: NumberConstructor[];
+            default: number;
+        };
+        span: {
+            type: NumberConstructor;
+            default: number;
+        };
+        submitBtnText: {
+            type: StringConstructor;
+            default: string;
+        };
+        resetBtnText: {
+            type: StringConstructor;
+            default: string;
+        };
+        slots: {
+            type: {
+                (arrayLength: number): import('./components/search/props').CustomSlot[];
+                (...items: import('./components/search/props').CustomSlot[]): import('./components/search/props').CustomSlot[];
+                new (arrayLength: number): import('./components/search/props').CustomSlot[];
+                new (...items: import('./components/search/props').CustomSlot[]): import('./components/search/props').CustomSlot[];
+                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[];
+        };
+        item: {
+            type: {
+                (arrayLength: number): import('./components/search/props').SearchItem[];
+                (...items: import('./components/search/props').SearchItem[]): import('./components/search/props').SearchItem[];
+                new (arrayLength: number): import('./components/search/props').SearchItem[];
+                new (...items: import('./components/search/props').SearchItem[]): import('./components/search/props').SearchItem[];
+                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[];
+        };
+        modelValue: {
+            type: import('vue').PropType<import('./components/search/props').SearchModel>;
+        };
+    }>> & Readonly<{
+        onSubmit?: ((...args: any[]) => any) | undefined;
+        onReset?: ((...args: any[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('./components/search/props').SearchModel) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        submit: (...args: any[]) => void;
+        reset: (...args: any[]) => void;
+        "update:modelValue": (value: import('./components/search/props').SearchModel) => void;
+    }, import('vue').PublicProps, {
+        size: "" | "small" | "default" | "large";
+        span: number;
+        item: import('./components/search/props').SearchItem[];
+        slots: import('./components/search/props').CustomSlot[];
+        labelWidth: string | number;
+        inline: boolean;
+        disabled: boolean;
+        labelPosition: "top" | "left" | "right";
+        gutter: number;
+        submitBtnText: string;
+        resetBtnText: string;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        searchFormRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                readonly disabled: boolean;
+                readonly inline: boolean;
+                readonly labelWidth: string | number;
+                readonly labelPosition: "top" | "left" | "right";
+                readonly inlineMessage: boolean;
+                readonly showMessage: boolean;
+                readonly requireAsteriskPosition: "left" | "right";
+                readonly labelSuffix: string;
+                readonly validateOnRuleChange: boolean;
+                readonly scrollIntoViewOptions: boolean | Record<string, any>;
+                readonly statusIcon: boolean;
+                readonly hideRequiredAsterisk: boolean;
+                readonly scrollToError: boolean;
+            }> & Omit<{
+                readonly labelWidth: string | number;
+                readonly inline: boolean;
+                readonly disabled: boolean;
+                readonly labelPosition: "top" | "left" | "right";
+                readonly requireAsteriskPosition: "left" | "right";
+                readonly labelSuffix: string;
+                readonly inlineMessage: boolean;
+                readonly statusIcon: boolean;
+                readonly showMessage: boolean;
+                readonly validateOnRuleChange: boolean;
+                readonly hideRequiredAsterisk: boolean;
+                readonly scrollToError: boolean;
+                readonly scrollIntoViewOptions: boolean | Record<string, any>;
+                readonly size?: ("" | "small" | "default" | "large") | undefined;
+                readonly model?: Record<string, any> | undefined;
+                readonly rules?: Partial<Record<string, import('element-plus').FormItemRule | import('element-plus').FormItemRule[]>> | undefined;
+                onValidate?: ((prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => any) | undefined | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "labelWidth" | "inline" | "disabled" | "labelPosition" | "requireAsteriskPosition" | "labelSuffix" | "inlineMessage" | "statusIcon" | "showMessage" | "validateOnRuleChange" | "hideRequiredAsterisk" | "scrollToError" | "scrollIntoViewOptions">;
+            $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: "validate", prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => void;
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+                readonly model: ObjectConstructor;
+                readonly rules: {
+                    readonly type: import('vue').PropType<Partial<Record<string, import('element-plus').FormItemRule | import('element-plus').FormItemRule[]>>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly labelPosition: {
+                    readonly type: import('vue').PropType<"top" | "left" | "right">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "right";
+                };
+                readonly requireAsteriskPosition: {
+                    readonly type: import('vue').PropType<"left" | "right">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "left";
+                };
+                readonly labelWidth: {
+                    readonly type: import('vue').PropType<string | number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly labelSuffix: {
+                    readonly type: import('vue').PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly inline: BooleanConstructor;
+                readonly inlineMessage: BooleanConstructor;
+                readonly statusIcon: BooleanConstructor;
+                readonly showMessage: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                readonly validateOnRuleChange: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                readonly hideRequiredAsterisk: BooleanConstructor;
+                readonly scrollToError: BooleanConstructor;
+                readonly scrollIntoViewOptions: {
+                    readonly type: import('vue').PropType<boolean | Record<string, any>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                readonly size: {
+                    readonly type: import('vue').PropType<"" | "small" | "default" | "large">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly disabled: BooleanConstructor;
+            }>> & {
+                onValidate?: ((prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => any) | undefined;
+            }, {
+                validate: (callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                validateField: (props?: import('element-plus').FormItemProp | import('element-plus').FormItemProp[], callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+                resetFields: (props?: import('element-plus').FormItemProp | import('element-plus').FormItemProp[]) => void;
+                clearValidate: (props?: import('element-plus').FormItemProp | import('element-plus').FormItemProp[]) => void;
+                scrollToField: (prop: import('element-plus').FormItemProp) => void;
+                getField: (prop: import('element-plus').FormItemProp) => import('element-plus').FormItemContext | undefined;
+                fields: import('vue').Reactive<import('element-plus').FormItemContext[]>;
+            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                validate: (prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => void;
+            }, string, {
+                readonly disabled: boolean;
+                readonly inline: boolean;
+                readonly labelWidth: string | number;
+                readonly labelPosition: "top" | "left" | "right";
+                readonly inlineMessage: boolean;
+                readonly showMessage: boolean;
+                readonly requireAsteriskPosition: "left" | "right";
+                readonly labelSuffix: string;
+                readonly validateOnRuleChange: boolean;
+                readonly scrollIntoViewOptions: boolean | Record<string, any>;
+                readonly statusIcon: boolean;
+                readonly hideRequiredAsterisk: boolean;
+                readonly scrollToError: boolean;
+            }, {}, 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<{
+            readonly disabled: boolean;
+            readonly inline: boolean;
+            readonly labelWidth: string | number;
+            readonly labelPosition: "top" | "left" | "right";
+            readonly inlineMessage: boolean;
+            readonly showMessage: boolean;
+            readonly requireAsteriskPosition: "left" | "right";
+            readonly labelSuffix: string;
+            readonly validateOnRuleChange: boolean;
+            readonly scrollIntoViewOptions: boolean | Record<string, any>;
+            readonly statusIcon: boolean;
+            readonly hideRequiredAsterisk: boolean;
+            readonly scrollToError: boolean;
+        }> & Omit<Readonly<import('vue').ExtractPropTypes<{
+            readonly model: ObjectConstructor;
+            readonly rules: {
+                readonly type: import('vue').PropType<Partial<Record<string, import('element-plus').FormItemRule | import('element-plus').FormItemRule[]>>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly labelPosition: {
+                readonly type: import('vue').PropType<"top" | "left" | "right">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "right";
+            };
+            readonly requireAsteriskPosition: {
+                readonly type: import('vue').PropType<"left" | "right">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "left";
+            };
+            readonly labelWidth: {
+                readonly type: import('vue').PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly labelSuffix: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly inline: BooleanConstructor;
+            readonly inlineMessage: BooleanConstructor;
+            readonly statusIcon: BooleanConstructor;
+            readonly showMessage: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            readonly validateOnRuleChange: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            readonly hideRequiredAsterisk: BooleanConstructor;
+            readonly scrollToError: BooleanConstructor;
+            readonly scrollIntoViewOptions: {
+                readonly type: import('vue').PropType<boolean | Record<string, any>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            readonly size: {
+                readonly type: import('vue').PropType<"" | "small" | "default" | "large">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly disabled: BooleanConstructor;
+        }>> & {
+            onValidate?: ((prop: import('element-plus').FormItemProp, isValid: boolean, message: string) => any) | undefined;
+        }, "labelWidth" | "inline" | "disabled" | "labelPosition" | "requireAsteriskPosition" | "labelSuffix" | "inlineMessage" | "statusIcon" | "showMessage" | "validateOnRuleChange" | "hideRequiredAsterisk" | "scrollToError" | "scrollIntoViewOptions" | "validate" | "validateField" | "resetFields" | "clearValidate" | "scrollToField" | "getField" | "fields"> & import('vue').ShallowUnwrapRef<{
+            validate: (callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+            validateField: (props?: import('element-plus').FormItemProp | import('element-plus').FormItemProp[], callback?: import('element-plus').FormValidateCallback) => import('element-plus').FormValidationResult;
+            resetFields: (props?: import('element-plus').FormItemProp | import('element-plus').FormItemProp[]) => void;
+            clearValidate: (props?: import('element-plus').FormItemProp | import('element-plus').FormItemProp[]) => void;
+            scrollToField: (prop: import('element-plus').FormItemProp) => void;
+            getField: (prop: import('element-plus').FormItemProp) => import('element-plus').FormItemContext | undefined;
+            fields: import('vue').Reactive<import('element-plus').FormItemContext[]>;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) | null;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        inline: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        labelWidth: {
+            type: (StringConstructor | NumberConstructor)[];
+            default: string;
+        };
+        labelPosition: {
+            type: import('vue').PropType<"left" | "right" | "top">;
+            default: string;
+        };
+        size: {
+            type: import('vue').PropType<"" | "large" | "default" | "small">;
+            default: string;
+        };
+        gutter: {
+            type: NumberConstructor[];
+            default: number;
+        };
+        span: {
+            type: NumberConstructor;
+            default: number;
+        };
+        submitBtnText: {
+            type: StringConstructor;
+            default: string;
+        };
+        resetBtnText: {
+            type: StringConstructor;
+            default: string;
+        };
+        slots: {
+            type: {
+                (arrayLength: number): import('./components/search/props').CustomSlot[];
+                (...items: import('./components/search/props').CustomSlot[]): import('./components/search/props').CustomSlot[];
+                new (arrayLength: number): import('./components/search/props').CustomSlot[];
+                new (...items: import('./components/search/props').CustomSlot[]): import('./components/search/props').CustomSlot[];
+                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[];
+        };
+        item: {
+            type: {
+                (arrayLength: number): import('./components/search/props').SearchItem[];
+                (...items: import('./components/search/props').SearchItem[]): import('./components/search/props').SearchItem[];
+                new (arrayLength: number): import('./components/search/props').SearchItem[];
+                new (...items: import('./components/search/props').SearchItem[]): import('./components/search/props').SearchItem[];
+                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[];
+        };
+        modelValue: {
+            type: import('vue').PropType<import('./components/search/props').SearchModel>;
+        };
+    }>> & Readonly<{
+        onSubmit?: ((...args: any[]) => any) | undefined;
+        onReset?: ((...args: any[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('./components/search/props').SearchModel) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        size: "" | "small" | "default" | "large";
+        span: number;
+        item: import('./components/search/props').SearchItem[];
+        slots: import('./components/search/props').CustomSlot[];
+        labelWidth: string | number;
+        inline: boolean;
+        disabled: boolean;
+        labelPosition: "top" | "left" | "right";
+        gutter: number;
+        submitBtnText: string;
+        resetBtnText: string;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+    inline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    labelWidth: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    labelPosition: {
+        type: import('vue').PropType<"left" | "right" | "top">;
+        default: string;
+    };
+    size: {
+        type: import('vue').PropType<"" | "large" | "default" | "small">;
+        default: string;
+    };
+    gutter: {
+        type: NumberConstructor[];
+        default: number;
+    };
+    span: {
+        type: NumberConstructor;
+        default: number;
+    };
+    submitBtnText: {
+        type: StringConstructor;
+        default: string;
+    };
+    resetBtnText: {
+        type: StringConstructor;
+        default: string;
+    };
+    slots: {
+        type: {
+            (arrayLength: number): import('./components/search/props').CustomSlot[];
+            (...items: import('./components/search/props').CustomSlot[]): import('./components/search/props').CustomSlot[];
+            new (arrayLength: number): import('./components/search/props').CustomSlot[];
+            new (...items: import('./components/search/props').CustomSlot[]): import('./components/search/props').CustomSlot[];
+            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[];
+    };
+    item: {
+        type: {
+            (arrayLength: number): import('./components/search/props').SearchItem[];
+            (...items: import('./components/search/props').SearchItem[]): import('./components/search/props').SearchItem[];
+            new (arrayLength: number): import('./components/search/props').SearchItem[];
+            new (...items: import('./components/search/props').SearchItem[]): import('./components/search/props').SearchItem[];
+            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[];
+    };
+    modelValue: {
+        type: import('vue').PropType<import('./components/search/props').SearchModel>;
+    };
+}>> & Readonly<{
+    onSubmit?: ((...args: any[]) => any) | undefined;
+    onReset?: ((...args: any[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: import('./components/search/props').SearchModel) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    submit: (...args: any[]) => void;
+    reset: (...args: any[]) => void;
+    "update:modelValue": (value: import('./components/search/props').SearchModel) => void;
+}, string, {
+    size: "" | "small" | "default" | "large";
+    span: number;
+    item: import('./components/search/props').SearchItem[];
+    slots: import('./components/search/props').CustomSlot[];
+    labelWidth: string | number;
+    inline: boolean;
+    disabled: boolean;
+    labelPosition: "top" | "left" | "right";
+    gutter: number;
+    submitBtnText: string;
+    resetBtnText: string;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: Partial<Record<string, (_: {
+        searchModel: import('./components/search/props').SearchModel | undefined;
+    }) => any>>;
+})) | ({
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        methodType: {
+            type: () => import('./components/search-table/props').RequestMethodType;
+            default: string;
+        };
+        url: {
+            type: StringConstructor;
+            default: string;
+        };
+        responseDataField: {
+            type: StringConstructor;
+            default: string;
+        };
+        responseTotalField: {
+            type: StringConstructor;
+            default: string;
+        };
+        headers: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        showPagination: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        paramsHandler: {
+            type: FunctionConstructor;
+            default: null;
+        };
+        render: {
+            type: FunctionConstructor;
+            default: null;
+        };
+        searchProps: {
+            type: ObjectConstructor;
+            default: () => void;
+        };
+        tableProps: {
+            type: ObjectConstructor;
+            default: () => {
+                border: boolean;
+            };
+        };
+        columns: {
+            type: {
+                (arrayLength: number): any[];
+                (...items: any[]): any[];
+                new (arrayLength: number): any[];
+                new (...items: any[]): any[];
+                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[];
+        };
+        search: {
+            type: import('vue').PropType<import('./components/search/props').SearchModel>;
+        };
+    }>> & Readonly<{
+        onReset?: ((...args: any[]) => any) | undefined;
+        "onUpdate:search"?: ((value: import('./components/search/props').SearchModel) => any) | undefined;
+    }>, {
+        handleSearch: (reset?: boolean) => Promise<void>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        reset: (...args: any[]) => void;
+        "update:search": (value: import('./components/search/props').SearchModel) => void;
+    }, import('vue').PublicProps, {
+        url: string;
+        render: Function;
+        methodType: import('./components/search-table/props').RequestMethodType;
+        responseDataField: string;
+        responseTotalField: string;
+        headers: Record<string, any>;
+        showPagination: boolean;
+        paramsHandler: Function;
+        searchProps: Record<string, any>;
+        tableProps: Record<string, any>;
+        columns: any[];
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        methodType: {
+            type: () => import('./components/search-table/props').RequestMethodType;
+            default: string;
+        };
+        url: {
+            type: StringConstructor;
+            default: string;
+        };
+        responseDataField: {
+            type: StringConstructor;
+            default: string;
+        };
+        responseTotalField: {
+            type: StringConstructor;
+            default: string;
+        };
+        headers: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        showPagination: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        paramsHandler: {
+            type: FunctionConstructor;
+            default: null;
+        };
+        render: {
+            type: FunctionConstructor;
+            default: null;
+        };
+        searchProps: {
+            type: ObjectConstructor;
+            default: () => void;
+        };
+        tableProps: {
+            type: ObjectConstructor;
+            default: () => {
+                border: boolean;
+            };
+        };
+        columns: {
+            type: {
+                (arrayLength: number): any[];
+                (...items: any[]): any[];
+                new (arrayLength: number): any[];
+                new (...items: any[]): any[];
+                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[];
+        };
+        search: {
+            type: import('vue').PropType<import('./components/search/props').SearchModel>;
+        };
+    }>> & Readonly<{
+        onReset?: ((...args: any[]) => any) | undefined;
+        "onUpdate:search"?: ((value: import('./components/search/props').SearchModel) => any) | undefined;
+    }>, {
+        handleSearch: (reset?: boolean) => Promise<void>;
+    }, {}, {}, {}, {
+        url: string;
+        render: Function;
+        methodType: import('./components/search-table/props').RequestMethodType;
+        responseDataField: string;
+        responseTotalField: string;
+        headers: Record<string, any>;
+        showPagination: boolean;
+        paramsHandler: Function;
+        searchProps: Record<string, any>;
+        tableProps: Record<string, any>;
+        columns: any[];
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+    methodType: {
+        type: () => import('./components/search-table/props').RequestMethodType;
+        default: string;
+    };
+    url: {
+        type: StringConstructor;
+        default: string;
+    };
+    responseDataField: {
+        type: StringConstructor;
+        default: string;
+    };
+    responseTotalField: {
+        type: StringConstructor;
+        default: string;
+    };
+    headers: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    showPagination: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    paramsHandler: {
+        type: FunctionConstructor;
+        default: null;
+    };
+    render: {
+        type: FunctionConstructor;
+        default: null;
+    };
+    searchProps: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    tableProps: {
+        type: ObjectConstructor;
+        default: () => {
+            border: boolean;
+        };
+    };
+    columns: {
+        type: {
+            (arrayLength: number): any[];
+            (...items: any[]): any[];
+            new (arrayLength: number): any[];
+            new (...items: any[]): any[];
+            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[];
+    };
+    search: {
+        type: import('vue').PropType<import('./components/search/props').SearchModel>;
+    };
+}>> & Readonly<{
+    onReset?: ((...args: any[]) => any) | undefined;
+    "onUpdate:search"?: ((value: import('./components/search/props').SearchModel) => any) | undefined;
+}>, {
+    handleSearch: (reset?: boolean) => Promise<void>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    reset: (...args: any[]) => void;
+    "update:search": (value: import('./components/search/props').SearchModel) => void;
+}, string, {
+    url: string;
+    render: Function;
+    methodType: import('./components/search-table/props').RequestMethodType;
+    responseDataField: string;
+    responseTotalField: string;
+    headers: Record<string, any>;
+    showPagination: boolean;
+    paramsHandler: Function;
+    searchProps: Record<string, any>;
+    tableProps: Record<string, any>;
+    columns: any[];
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: Partial<Record<any, (_: {}) => any>> & Partial<Record<any, (_: {
+        index: any;
+        row: any;
+    }) => any>> & {
+        prefix?(_: {}): any;
+        suffix?(_: {}): any;
+    };
+})) | ({
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./components/detail/type').MlDetailProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        descColumn: number;
+        dataList: Record<string, any>;
+        listTypeInfo: Record<string, any>;
+        descData: import('./components/detail/type').DescItem[];
+        isColon: boolean;
+        isLabelBold: boolean;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./components/detail/type').MlDetailProps> & Readonly<{}>, {}, {}, {}, {}, {
+        descColumn: number;
+        dataList: Record<string, any>;
+        listTypeInfo: Record<string, any>;
+        descData: import('./components/detail/type').DescItem[];
+        isColon: boolean;
+        isLabelBold: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./components/detail/type').MlDetailProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    descColumn: number;
+    dataList: Record<string, any>;
+    listTypeInfo: Record<string, any>;
+    descData: import('./components/detail/type').DescItem[];
+    isColon: boolean;
+    isLabelBold: boolean;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: Partial<Record<string, (_: {}) => any>>;
+})) | ({
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./components/button/type').MlButtonSelfProps> & Readonly<{
+        onClick?: ((...args: any[]) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        click: (...args: any[]) => void;
+    }, import('vue').PublicProps, {
+        time: number;
+        placement: string;
+        tip: string;
+        tipProps: Record<string, any>;
+        isDebounce: boolean;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./components/button/type').MlButtonSelfProps> & Readonly<{
+        onClick?: ((...args: any[]) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        time: number;
+        placement: string;
+        tip: string;
+        tipProps: Record<string, any>;
+        isDebounce: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./components/button/type').MlButtonSelfProps> & Readonly<{
+    onClick?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (...args: any[]) => void;
+}, string, {
+    time: number;
+    placement: string;
+    tip: string;
+    tipProps: Record<string, any>;
+    isDebounce: boolean;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+        default?(_: {}): any;
+    };
+})) | ({
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        modelValue?: import('./components/number-range-input/props').NumberRangeValue;
+    } & import('./components/number-range-input/props').NumberRangeInputProps> & Readonly<{
+        "onUpdate:modelValue"?: ((value: import('./components/number-range-input/props').NumberRangeValue) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        "update:modelValue": (value: import('./components/number-range-input/props').NumberRangeValue) => any;
+    }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        modelValue?: import('./components/number-range-input/props').NumberRangeValue;
+    } & import('./components/number-range-input/props').NumberRangeInputProps> & Readonly<{
+        "onUpdate:modelValue"?: ((value: import('./components/number-range-input/props').NumberRangeValue) => any) | undefined;
+    }>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<{
+    modelValue?: import('./components/number-range-input/props').NumberRangeValue;
+} & import('./components/number-range-input/props').NumberRangeInputProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: import('./components/number-range-input/props').NumberRangeValue) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: import('./components/number-range-input/props').NumberRangeValue) => any;
+}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        'min-prefix'?(_: {}): any;
+        'min-suffix'?(_: {}): any;
+        'min-prepend'?(_: {}): any;
+        'min-append'?(_: {}): any;
+        'max-prefix'?(_: {}): any;
+        'max-suffix'?(_: {}): any;
+        'max-prepend'?(_: {}): any;
+        'max-append'?(_: {}): any;
+    };
+})))[];
+export declare const MsUIComponentsName: string[];
+declare const _default: {
+    install: (app: App) => void;
+};
+export default _default;