npm - @lingshugroup/web-plus - Versions diffs - 1.3.0 → 1.3.2 - Mend

@lingshugroup/web-plus 1.3.0 → 1.3.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (191) hide show

package/lib/types/components/form/index.d.ts ADDED Viewed

@@ -0,0 +1,2635 @@
+import { LSOptions, EpPropFinalized, EpPropMergeType } from '../_utils/types';
+import { App, CreateComponentPublicInstanceWithMixins, ComponentInternalInstance, VNodeProps, AllowedComponentProps, ComponentCustomProps, Slot, ComponentOptionsBase, PropType, ComponentOptionsMixin, GlobalComponents, GlobalDirectives, ComponentProvideOptions, DebuggerEvent, nextTick, WatchOptions, WatchStopHandle, ShallowUnwrapRef, ComponentCustomProperties, PublicProps } from 'vue';
+import { EpPropMergeType, Arrayable, EpPropFinalized } from 'element-plus/es/utils';
+import { FormItemRule, FormItemProp, FormValidateCallback, FormValidationResult, FormItemContext, FormInstance } from 'element-plus';
+import { OnCleanup } from '@vue/reactivity';
+declare const LSForm: {
+    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<globalThis.ExtractPropTypes<{
+        readonly formData: never;
+        readonly formItems: never;
+        readonly column: EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+        readonly loading: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        readonly showBtnLoading: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly read: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        readonly disabled: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        readonly showButtons: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly buttonsClass: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly buttonsLeft: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        readonly showReset: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly showSubmit: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly confirmText: EpPropFinalized<StringConstructor, unknown, unknown, "确认", boolean>;
+        readonly resetText: EpPropFinalized<StringConstructor, unknown, unknown, "重置", boolean>;
+        readonly confirmClassName: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly colon: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        readonly labelEmpty: EpPropFinalized<StringConstructor, unknown, unknown, "--", boolean>;
+        readonly hasDefReadStyle: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        readonly hideColumn: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    }>> & Readonly<{
+        onOnChange?: ((value: any, prop: string, index?: number | undefined) => any) | undefined;
+        onReset?: ((form: any) => any) | undefined;
+        onSubmit?: ((form: any) => any) | undefined;
+        "onUpdate:form-data"?: ((formData: any) => any) | undefined;
+    }>, {
+        FormRef: globalThis.Ref<({
+            $: ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                readonly inline: boolean;
+                readonly disabled: boolean;
+                readonly labelWidth: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+                readonly labelPosition: EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+                readonly inlineMessage: boolean;
+                readonly showMessage: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly requireAsteriskPosition: EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+                readonly labelSuffix: string;
+                readonly validateOnRuleChange: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly statusIcon: boolean;
+                readonly hideRequiredAsterisk: boolean;
+                readonly scrollToError: boolean;
+            }> & Omit<{
+                readonly disabled: boolean;
+                readonly inline: boolean;
+                readonly labelPosition: EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+                readonly labelWidth: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+                readonly inlineMessage: boolean;
+                readonly showMessage: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly requireAsteriskPosition: EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+                readonly labelSuffix: string;
+                readonly statusIcon: boolean;
+                readonly validateOnRuleChange: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly hideRequiredAsterisk: boolean;
+                readonly scrollToError: boolean;
+                readonly size?: EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
+                readonly rules?: Partial<Record<string, Arrayable<FormItemRule>>> | undefined;
+                readonly model?: Record<string, any> | undefined;
+                readonly scrollIntoViewOptions?: EpPropMergeType<readonly [ObjectConstructor, BooleanConstructor], unknown, unknown> | undefined;
+                onValidate?: ((prop: FormItemProp, isValid: boolean, message: string) => any) | undefined;
+            } & VNodeProps & AllowedComponentProps & ComponentCustomProps, "disabled" | "inline" | "labelPosition" | "labelWidth" | "inlineMessage" | "showMessage" | "requireAsteriskPosition" | "labelSuffix" | "statusIcon" | "validateOnRuleChange" | "hideRequiredAsterisk" | "scrollToError">;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: Slot<any> | undefined;
+            }>;
+            $root: ComponentPublicInstance | null;
+            $parent: ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: "validate", prop: FormItemProp, isValid: boolean, message: string) => void;
+            $el: any;
+            $options: ComponentOptionsBase<Readonly<globalThis.ExtractPropTypes<{
+                readonly model: ObjectConstructor;
+                readonly rules: {
+                    readonly type: PropType<Partial<Record<string, Arrayable<FormItemRule>>>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly labelPosition: EpPropFinalized<StringConstructor, "top" | "left" | "right", unknown, "right", boolean>;
+                readonly requireAsteriskPosition: EpPropFinalized<StringConstructor, "left" | "right", unknown, "left", boolean>;
+                readonly labelWidth: EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+                readonly labelSuffix: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+                readonly inline: BooleanConstructor;
+                readonly inlineMessage: BooleanConstructor;
+                readonly statusIcon: BooleanConstructor;
+                readonly showMessage: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                readonly validateOnRuleChange: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                readonly hideRequiredAsterisk: BooleanConstructor;
+                readonly scrollToError: BooleanConstructor;
+                readonly scrollIntoViewOptions: {
+                    readonly type: PropType<EpPropMergeType<readonly [ObjectConstructor, BooleanConstructor], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly size: {
+                    readonly type: PropType<EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly disabled: BooleanConstructor;
+            }>> & {
+                onValidate?: ((prop: FormItemProp, isValid: boolean, message: string) => any) | undefined;
+            }, {
+                validate: (callback?: FormValidateCallback | undefined) => FormValidationResult;
+                validateField: (props?: Arrayable<FormItemProp> | undefined, callback?: FormValidateCallback | undefined) => FormValidationResult;
+                resetFields: (props?: Arrayable<FormItemProp> | undefined) => void;
+                clearValidate: (props?: Arrayable<FormItemProp> | undefined) => void;
+                scrollToField: (prop: FormItemProp) => void;
+                fields: FormItemContext[];
+            }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+                validate: (prop: FormItemProp, isValid: boolean, message: string) => void;
+            }, string, {
+                readonly inline: boolean;
+                readonly disabled: boolean;
+                readonly labelWidth: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+                readonly labelPosition: EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+                readonly inlineMessage: boolean;
+                readonly showMessage: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly requireAsteriskPosition: EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+                readonly labelSuffix: string;
+                readonly validateOnRuleChange: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly statusIcon: boolean;
+                readonly hideRequiredAsterisk: boolean;
+                readonly scrollToError: boolean;
+            }, {}, string, {}, GlobalComponents, GlobalDirectives, string, 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: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+        } & Readonly<{
+            readonly inline: boolean;
+            readonly disabled: boolean;
+            readonly labelWidth: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly labelPosition: EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+            readonly inlineMessage: boolean;
+            readonly showMessage: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly requireAsteriskPosition: EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+            readonly labelSuffix: string;
+            readonly validateOnRuleChange: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly statusIcon: boolean;
+            readonly hideRequiredAsterisk: boolean;
+            readonly scrollToError: boolean;
+        }> & Omit<Readonly<globalThis.ExtractPropTypes<{
+            readonly model: ObjectConstructor;
+            readonly rules: {
+                readonly type: PropType<Partial<Record<string, Arrayable<FormItemRule>>>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly labelPosition: EpPropFinalized<StringConstructor, "top" | "left" | "right", unknown, "right", boolean>;
+            readonly requireAsteriskPosition: EpPropFinalized<StringConstructor, "left" | "right", unknown, "left", boolean>;
+            readonly labelWidth: EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+            readonly labelSuffix: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly inline: BooleanConstructor;
+            readonly inlineMessage: BooleanConstructor;
+            readonly statusIcon: BooleanConstructor;
+            readonly showMessage: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly validateOnRuleChange: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly hideRequiredAsterisk: BooleanConstructor;
+            readonly scrollToError: BooleanConstructor;
+            readonly scrollIntoViewOptions: {
+                readonly type: PropType<EpPropMergeType<readonly [ObjectConstructor, BooleanConstructor], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly size: {
+                readonly type: PropType<EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly disabled: BooleanConstructor;
+        }>> & {
+            onValidate?: ((prop: FormItemProp, isValid: boolean, message: string) => any) | undefined;
+        }, "disabled" | "inline" | "labelPosition" | "labelWidth" | "inlineMessage" | "showMessage" | "validate" | "clearValidate" | "requireAsteriskPosition" | "labelSuffix" | "statusIcon" | "validateOnRuleChange" | "hideRequiredAsterisk" | "scrollToError" | "validateField" | "resetFields" | "scrollToField" | "fields"> & ShallowUnwrapRef<{
+            validate: (callback?: FormValidateCallback | undefined) => FormValidationResult;
+            validateField: (props?: Arrayable<FormItemProp> | undefined, callback?: FormValidateCallback | undefined) => FormValidationResult;
+            resetFields: (props?: Arrayable<FormItemProp> | undefined) => void;
+            clearValidate: (props?: Arrayable<FormItemProp> | undefined) => void;
+            scrollToField: (prop: FormItemProp) => void;
+            fields: FormItemContext[];
+        }> & {} & ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) | undefined, ({
+            $: ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                readonly inline: boolean;
+                readonly disabled: boolean;
+                readonly labelWidth: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+                readonly labelPosition: EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+                readonly inlineMessage: boolean;
+                readonly showMessage: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly requireAsteriskPosition: EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+                readonly labelSuffix: string;
+                readonly validateOnRuleChange: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly statusIcon: boolean;
+                readonly hideRequiredAsterisk: boolean;
+                readonly scrollToError: boolean;
+            }> & Omit<{
+                readonly disabled: boolean;
+                readonly inline: boolean;
+                readonly labelPosition: EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+                readonly labelWidth: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+                readonly inlineMessage: boolean;
+                readonly showMessage: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly requireAsteriskPosition: EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+                readonly labelSuffix: string;
+                readonly statusIcon: boolean;
+                readonly validateOnRuleChange: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly hideRequiredAsterisk: boolean;
+                readonly scrollToError: boolean;
+                readonly size?: EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
+                readonly rules?: Partial<Record<string, Arrayable<FormItemRule>>> | undefined;
+                readonly model?: Record<string, any> | undefined;
+                readonly scrollIntoViewOptions?: EpPropMergeType<readonly [ObjectConstructor, BooleanConstructor], unknown, unknown> | undefined;
+                onValidate?: ((prop: FormItemProp, isValid: boolean, message: string) => any) | undefined;
+            } & VNodeProps & AllowedComponentProps & ComponentCustomProps, "disabled" | "inline" | "labelPosition" | "labelWidth" | "inlineMessage" | "showMessage" | "requireAsteriskPosition" | "labelSuffix" | "statusIcon" | "validateOnRuleChange" | "hideRequiredAsterisk" | "scrollToError">;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: Slot<any> | undefined;
+            }>;
+            $root: ComponentPublicInstance | null;
+            $parent: ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: "validate", prop: FormItemProp, isValid: boolean, message: string) => void;
+            $el: any;
+            $options: ComponentOptionsBase<Readonly<globalThis.ExtractPropTypes<{
+                readonly model: ObjectConstructor;
+                readonly rules: {
+                    readonly type: PropType<Partial<Record<string, Arrayable<FormItemRule>>>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly labelPosition: EpPropFinalized<StringConstructor, "top" | "left" | "right", unknown, "right", boolean>;
+                readonly requireAsteriskPosition: EpPropFinalized<StringConstructor, "left" | "right", unknown, "left", boolean>;
+                readonly labelWidth: EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+                readonly labelSuffix: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+                readonly inline: BooleanConstructor;
+                readonly inlineMessage: BooleanConstructor;
+                readonly statusIcon: BooleanConstructor;
+                readonly showMessage: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                readonly validateOnRuleChange: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                readonly hideRequiredAsterisk: BooleanConstructor;
+                readonly scrollToError: BooleanConstructor;
+                readonly scrollIntoViewOptions: {
+                    readonly type: PropType<EpPropMergeType<readonly [ObjectConstructor, BooleanConstructor], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly size: {
+                    readonly type: PropType<EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly disabled: BooleanConstructor;
+            }>> & {
+                onValidate?: ((prop: FormItemProp, isValid: boolean, message: string) => any) | undefined;
+            }, {
+                validate: (callback?: FormValidateCallback | undefined) => FormValidationResult;
+                validateField: (props?: Arrayable<FormItemProp> | undefined, callback?: FormValidateCallback | undefined) => FormValidationResult;
+                resetFields: (props?: Arrayable<FormItemProp> | undefined) => void;
+                clearValidate: (props?: Arrayable<FormItemProp> | undefined) => void;
+                scrollToField: (prop: FormItemProp) => void;
+                fields: FormItemContext[];
+            }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+                validate: (prop: FormItemProp, isValid: boolean, message: string) => void;
+            }, string, {
+                readonly inline: boolean;
+                readonly disabled: boolean;
+                readonly labelWidth: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+                readonly labelPosition: EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+                readonly inlineMessage: boolean;
+                readonly showMessage: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly requireAsteriskPosition: EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+                readonly labelSuffix: string;
+                readonly validateOnRuleChange: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly statusIcon: boolean;
+                readonly hideRequiredAsterisk: boolean;
+                readonly scrollToError: boolean;
+            }, {}, string, {}, GlobalComponents, GlobalDirectives, string, 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: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+        } & Readonly<{
+            readonly inline: boolean;
+            readonly disabled: boolean;
+            readonly labelWidth: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly labelPosition: EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+            readonly inlineMessage: boolean;
+            readonly showMessage: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly requireAsteriskPosition: EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+            readonly labelSuffix: string;
+            readonly validateOnRuleChange: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly statusIcon: boolean;
+            readonly hideRequiredAsterisk: boolean;
+            readonly scrollToError: boolean;
+        }> & Omit<Readonly<globalThis.ExtractPropTypes<{
+            readonly model: ObjectConstructor;
+            readonly rules: {
+                readonly type: PropType<Partial<Record<string, Arrayable<FormItemRule>>>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly labelPosition: EpPropFinalized<StringConstructor, "top" | "left" | "right", unknown, "right", boolean>;
+            readonly requireAsteriskPosition: EpPropFinalized<StringConstructor, "left" | "right", unknown, "left", boolean>;
+            readonly labelWidth: EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+            readonly labelSuffix: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly inline: BooleanConstructor;
+            readonly inlineMessage: BooleanConstructor;
+            readonly statusIcon: BooleanConstructor;
+            readonly showMessage: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly validateOnRuleChange: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly hideRequiredAsterisk: BooleanConstructor;
+            readonly scrollToError: BooleanConstructor;
+            readonly scrollIntoViewOptions: {
+                readonly type: PropType<EpPropMergeType<readonly [ObjectConstructor, BooleanConstructor], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly size: {
+                readonly type: PropType<EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly disabled: BooleanConstructor;
+        }>> & {
+            onValidate?: ((prop: FormItemProp, isValid: boolean, message: string) => any) | undefined;
+        }, "disabled" | "inline" | "labelPosition" | "labelWidth" | "inlineMessage" | "showMessage" | "validate" | "clearValidate" | "requireAsteriskPosition" | "labelSuffix" | "statusIcon" | "validateOnRuleChange" | "hideRequiredAsterisk" | "scrollToError" | "validateField" | "resetFields" | "scrollToField" | "fields"> & ShallowUnwrapRef<{
+            validate: (callback?: FormValidateCallback | undefined) => FormValidationResult;
+            validateField: (props?: Arrayable<FormItemProp> | undefined, callback?: FormValidateCallback | undefined) => FormValidationResult;
+            resetFields: (props?: Arrayable<FormItemProp> | undefined) => void;
+            clearValidate: (props?: Arrayable<FormItemProp> | undefined) => void;
+            scrollToField: (prop: FormItemProp) => void;
+            fields: FormItemContext[];
+        }> & {} & ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) | undefined>;
+        validate: () => Promise<unknown>;
+        submitForm: (formEl: FormInstance | undefined) => Promise<void>;
+        resetForm: (formEl: FormInstance | undefined) => void;
+    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+        onChange: (value: any, prop: string, index?: number | undefined) => any;
+        reset: (form: any) => any;
+        submit: (form: any) => any;
+        "update:form-data": (formData: any) => any;
+    }, PublicProps, {
+        readonly loading: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly column: number;
+        readonly showBtnLoading: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly read: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly showButtons: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly buttonsClass: string;
+        readonly buttonsLeft: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly showReset: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly showSubmit: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly confirmText: string;
+        readonly resetText: string;
+        readonly confirmClassName: string;
+        readonly colon: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly labelEmpty: string;
+        readonly hasDefReadStyle: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly hideColumn: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLDivElement, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<globalThis.ExtractPropTypes<{
+        readonly formData: never;
+        readonly formItems: never;
+        readonly column: EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+        readonly loading: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        readonly showBtnLoading: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly read: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        readonly disabled: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        readonly showButtons: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly buttonsClass: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly buttonsLeft: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        readonly showReset: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly showSubmit: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly confirmText: EpPropFinalized<StringConstructor, unknown, unknown, "确认", boolean>;
+        readonly resetText: EpPropFinalized<StringConstructor, unknown, unknown, "重置", boolean>;
+        readonly confirmClassName: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly colon: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        readonly labelEmpty: EpPropFinalized<StringConstructor, unknown, unknown, "--", boolean>;
+        readonly hasDefReadStyle: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        readonly hideColumn: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    }>> & Readonly<{
+        onOnChange?: ((value: any, prop: string, index?: number | undefined) => any) | undefined;
+        onReset?: ((form: any) => any) | undefined;
+        onSubmit?: ((form: any) => any) | undefined;
+        "onUpdate:form-data"?: ((formData: any) => any) | undefined;
+    }>, {
+        FormRef: globalThis.Ref<({
+            $: ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                readonly inline: boolean;
+                readonly disabled: boolean;
+                readonly labelWidth: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+                readonly labelPosition: EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+                readonly inlineMessage: boolean;
+                readonly showMessage: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly requireAsteriskPosition: EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+                readonly labelSuffix: string;
+                readonly validateOnRuleChange: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly statusIcon: boolean;
+                readonly hideRequiredAsterisk: boolean;
+                readonly scrollToError: boolean;
+            }> & Omit<{
+                readonly disabled: boolean;
+                readonly inline: boolean;
+                readonly labelPosition: EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+                readonly labelWidth: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+                readonly inlineMessage: boolean;
+                readonly showMessage: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly requireAsteriskPosition: EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+                readonly labelSuffix: string;
+                readonly statusIcon: boolean;
+                readonly validateOnRuleChange: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly hideRequiredAsterisk: boolean;
+                readonly scrollToError: boolean;
+                readonly size?: EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
+                readonly rules?: Partial<Record<string, Arrayable<FormItemRule>>> | undefined;
+                readonly model?: Record<string, any> | undefined;
+                readonly scrollIntoViewOptions?: EpPropMergeType<readonly [ObjectConstructor, BooleanConstructor], unknown, unknown> | undefined;
+                onValidate?: ((prop: FormItemProp, isValid: boolean, message: string) => any) | undefined;
+            } & VNodeProps & AllowedComponentProps & ComponentCustomProps, "disabled" | "inline" | "labelPosition" | "labelWidth" | "inlineMessage" | "showMessage" | "requireAsteriskPosition" | "labelSuffix" | "statusIcon" | "validateOnRuleChange" | "hideRequiredAsterisk" | "scrollToError">;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: Slot<any> | undefined;
+            }>;
+            $root: ComponentPublicInstance | null;
+            $parent: ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: "validate", prop: FormItemProp, isValid: boolean, message: string) => void;
+            $el: any;
+            $options: ComponentOptionsBase<Readonly<globalThis.ExtractPropTypes<{
+                readonly model: ObjectConstructor;
+                readonly rules: {
+                    readonly type: PropType<Partial<Record<string, Arrayable<FormItemRule>>>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly labelPosition: EpPropFinalized<StringConstructor, "top" | "left" | "right", unknown, "right", boolean>;
+                readonly requireAsteriskPosition: EpPropFinalized<StringConstructor, "left" | "right", unknown, "left", boolean>;
+                readonly labelWidth: EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+                readonly labelSuffix: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+                readonly inline: BooleanConstructor;
+                readonly inlineMessage: BooleanConstructor;
+                readonly statusIcon: BooleanConstructor;
+                readonly showMessage: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                readonly validateOnRuleChange: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                readonly hideRequiredAsterisk: BooleanConstructor;
+                readonly scrollToError: BooleanConstructor;
+                readonly scrollIntoViewOptions: {
+                    readonly type: PropType<EpPropMergeType<readonly [ObjectConstructor, BooleanConstructor], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly size: {
+                    readonly type: PropType<EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly disabled: BooleanConstructor;
+            }>> & {
+                onValidate?: ((prop: FormItemProp, isValid: boolean, message: string) => any) | undefined;
+            }, {
+                validate: (callback?: FormValidateCallback | undefined) => FormValidationResult;
+                validateField: (props?: Arrayable<FormItemProp> | undefined, callback?: FormValidateCallback | undefined) => FormValidationResult;
+                resetFields: (props?: Arrayable<FormItemProp> | undefined) => void;
+                clearValidate: (props?: Arrayable<FormItemProp> | undefined) => void;
+                scrollToField: (prop: FormItemProp) => void;
+                fields: FormItemContext[];
+            }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+                validate: (prop: FormItemProp, isValid: boolean, message: string) => void;
+            }, string, {
+                readonly inline: boolean;
+                readonly disabled: boolean;
+                readonly labelWidth: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+                readonly labelPosition: EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+                readonly inlineMessage: boolean;
+                readonly showMessage: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly requireAsteriskPosition: EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+                readonly labelSuffix: string;
+                readonly validateOnRuleChange: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly statusIcon: boolean;
+                readonly hideRequiredAsterisk: boolean;
+                readonly scrollToError: boolean;
+            }, {}, string, {}, GlobalComponents, GlobalDirectives, string, 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: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+        } & Readonly<{
+            readonly inline: boolean;
+            readonly disabled: boolean;
+            readonly labelWidth: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly labelPosition: EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+            readonly inlineMessage: boolean;
+            readonly showMessage: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly requireAsteriskPosition: EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+            readonly labelSuffix: string;
+            readonly validateOnRuleChange: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly statusIcon: boolean;
+            readonly hideRequiredAsterisk: boolean;
+            readonly scrollToError: boolean;
+        }> & Omit<Readonly<globalThis.ExtractPropTypes<{
+            readonly model: ObjectConstructor;
+            readonly rules: {
+                readonly type: PropType<Partial<Record<string, Arrayable<FormItemRule>>>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly labelPosition: EpPropFinalized<StringConstructor, "top" | "left" | "right", unknown, "right", boolean>;
+            readonly requireAsteriskPosition: EpPropFinalized<StringConstructor, "left" | "right", unknown, "left", boolean>;
+            readonly labelWidth: EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+            readonly labelSuffix: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly inline: BooleanConstructor;
+            readonly inlineMessage: BooleanConstructor;
+            readonly statusIcon: BooleanConstructor;
+            readonly showMessage: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly validateOnRuleChange: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly hideRequiredAsterisk: BooleanConstructor;
+            readonly scrollToError: BooleanConstructor;
+            readonly scrollIntoViewOptions: {
+                readonly type: PropType<EpPropMergeType<readonly [ObjectConstructor, BooleanConstructor], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly size: {
+                readonly type: PropType<EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly disabled: BooleanConstructor;
+        }>> & {
+            onValidate?: ((prop: FormItemProp, isValid: boolean, message: string) => any) | undefined;
+        }, "disabled" | "inline" | "labelPosition" | "labelWidth" | "inlineMessage" | "showMessage" | "validate" | "clearValidate" | "requireAsteriskPosition" | "labelSuffix" | "statusIcon" | "validateOnRuleChange" | "hideRequiredAsterisk" | "scrollToError" | "validateField" | "resetFields" | "scrollToField" | "fields"> & ShallowUnwrapRef<{
+            validate: (callback?: FormValidateCallback | undefined) => FormValidationResult;
+            validateField: (props?: Arrayable<FormItemProp> | undefined, callback?: FormValidateCallback | undefined) => FormValidationResult;
+            resetFields: (props?: Arrayable<FormItemProp> | undefined) => void;
+            clearValidate: (props?: Arrayable<FormItemProp> | undefined) => void;
+            scrollToField: (prop: FormItemProp) => void;
+            fields: FormItemContext[];
+        }> & {} & ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) | undefined, ({
+            $: ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                readonly inline: boolean;
+                readonly disabled: boolean;
+                readonly labelWidth: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+                readonly labelPosition: EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+                readonly inlineMessage: boolean;
+                readonly showMessage: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly requireAsteriskPosition: EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+                readonly labelSuffix: string;
+                readonly validateOnRuleChange: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly statusIcon: boolean;
+                readonly hideRequiredAsterisk: boolean;
+                readonly scrollToError: boolean;
+            }> & Omit<{
+                readonly disabled: boolean;
+                readonly inline: boolean;
+                readonly labelPosition: EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+                readonly labelWidth: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+                readonly inlineMessage: boolean;
+                readonly showMessage: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly requireAsteriskPosition: EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+                readonly labelSuffix: string;
+                readonly statusIcon: boolean;
+                readonly validateOnRuleChange: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly hideRequiredAsterisk: boolean;
+                readonly scrollToError: boolean;
+                readonly size?: EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
+                readonly rules?: Partial<Record<string, Arrayable<FormItemRule>>> | undefined;
+                readonly model?: Record<string, any> | undefined;
+                readonly scrollIntoViewOptions?: EpPropMergeType<readonly [ObjectConstructor, BooleanConstructor], unknown, unknown> | undefined;
+                onValidate?: ((prop: FormItemProp, isValid: boolean, message: string) => any) | undefined;
+            } & VNodeProps & AllowedComponentProps & ComponentCustomProps, "disabled" | "inline" | "labelPosition" | "labelWidth" | "inlineMessage" | "showMessage" | "requireAsteriskPosition" | "labelSuffix" | "statusIcon" | "validateOnRuleChange" | "hideRequiredAsterisk" | "scrollToError">;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: Slot<any> | undefined;
+            }>;
+            $root: ComponentPublicInstance | null;
+            $parent: ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: "validate", prop: FormItemProp, isValid: boolean, message: string) => void;
+            $el: any;
+            $options: ComponentOptionsBase<Readonly<globalThis.ExtractPropTypes<{
+                readonly model: ObjectConstructor;
+                readonly rules: {
+                    readonly type: PropType<Partial<Record<string, Arrayable<FormItemRule>>>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly labelPosition: EpPropFinalized<StringConstructor, "top" | "left" | "right", unknown, "right", boolean>;
+                readonly requireAsteriskPosition: EpPropFinalized<StringConstructor, "left" | "right", unknown, "left", boolean>;
+                readonly labelWidth: EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+                readonly labelSuffix: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+                readonly inline: BooleanConstructor;
+                readonly inlineMessage: BooleanConstructor;
+                readonly statusIcon: BooleanConstructor;
+                readonly showMessage: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                readonly validateOnRuleChange: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+                readonly hideRequiredAsterisk: BooleanConstructor;
+                readonly scrollToError: BooleanConstructor;
+                readonly scrollIntoViewOptions: {
+                    readonly type: PropType<EpPropMergeType<readonly [ObjectConstructor, BooleanConstructor], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly size: {
+                    readonly type: PropType<EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly disabled: BooleanConstructor;
+            }>> & {
+                onValidate?: ((prop: FormItemProp, isValid: boolean, message: string) => any) | undefined;
+            }, {
+                validate: (callback?: FormValidateCallback | undefined) => FormValidationResult;
+                validateField: (props?: Arrayable<FormItemProp> | undefined, callback?: FormValidateCallback | undefined) => FormValidationResult;
+                resetFields: (props?: Arrayable<FormItemProp> | undefined) => void;
+                clearValidate: (props?: Arrayable<FormItemProp> | undefined) => void;
+                scrollToField: (prop: FormItemProp) => void;
+                fields: FormItemContext[];
+            }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+                validate: (prop: FormItemProp, isValid: boolean, message: string) => void;
+            }, string, {
+                readonly inline: boolean;
+                readonly disabled: boolean;
+                readonly labelWidth: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+                readonly labelPosition: EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+                readonly inlineMessage: boolean;
+                readonly showMessage: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly requireAsteriskPosition: EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+                readonly labelSuffix: string;
+                readonly validateOnRuleChange: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly statusIcon: boolean;
+                readonly hideRequiredAsterisk: boolean;
+                readonly scrollToError: boolean;
+            }, {}, string, {}, GlobalComponents, GlobalDirectives, string, 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: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+        } & Readonly<{
+            readonly inline: boolean;
+            readonly disabled: boolean;
+            readonly labelWidth: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly labelPosition: EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+            readonly inlineMessage: boolean;
+            readonly showMessage: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly requireAsteriskPosition: EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+            readonly labelSuffix: string;
+            readonly validateOnRuleChange: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly statusIcon: boolean;
+            readonly hideRequiredAsterisk: boolean;
+            readonly scrollToError: boolean;
+        }> & Omit<Readonly<globalThis.ExtractPropTypes<{
+            readonly model: ObjectConstructor;
+            readonly rules: {
+                readonly type: PropType<Partial<Record<string, Arrayable<FormItemRule>>>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly labelPosition: EpPropFinalized<StringConstructor, "top" | "left" | "right", unknown, "right", boolean>;
+            readonly requireAsteriskPosition: EpPropFinalized<StringConstructor, "left" | "right", unknown, "left", boolean>;
+            readonly labelWidth: EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+            readonly labelSuffix: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly inline: BooleanConstructor;
+            readonly inlineMessage: BooleanConstructor;
+            readonly statusIcon: BooleanConstructor;
+            readonly showMessage: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly validateOnRuleChange: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly hideRequiredAsterisk: BooleanConstructor;
+            readonly scrollToError: BooleanConstructor;
+            readonly scrollIntoViewOptions: {
+                readonly type: PropType<EpPropMergeType<readonly [ObjectConstructor, BooleanConstructor], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly size: {
+                readonly type: PropType<EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly disabled: BooleanConstructor;
+        }>> & {
+            onValidate?: ((prop: FormItemProp, isValid: boolean, message: string) => any) | undefined;
+        }, "disabled" | "inline" | "labelPosition" | "labelWidth" | "inlineMessage" | "showMessage" | "validate" | "clearValidate" | "requireAsteriskPosition" | "labelSuffix" | "statusIcon" | "validateOnRuleChange" | "hideRequiredAsterisk" | "scrollToError" | "validateField" | "resetFields" | "scrollToField" | "fields"> & ShallowUnwrapRef<{
+            validate: (callback?: FormValidateCallback | undefined) => FormValidationResult;
+            validateField: (props?: Arrayable<FormItemProp> | undefined, callback?: FormValidateCallback | undefined) => FormValidationResult;
+            resetFields: (props?: Arrayable<FormItemProp> | undefined) => void;
+            clearValidate: (props?: Arrayable<FormItemProp> | undefined) => void;
+            scrollToField: (prop: FormItemProp) => void;
+            fields: FormItemContext[];
+        }> & {} & ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) | undefined>;
+        validate: () => Promise<unknown>;
+        submitForm: (formEl: FormInstance | undefined) => Promise<void>;
+        resetForm: (formEl: FormInstance | undefined) => void;
+    }, {}, {}, {}, {
+        readonly loading: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly column: number;
+        readonly showBtnLoading: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly read: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly showButtons: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly buttonsClass: string;
+        readonly buttonsLeft: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly showReset: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly showSubmit: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly confirmText: string;
+        readonly resetText: string;
+        readonly confirmClassName: string;
+        readonly colon: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly labelEmpty: string;
+        readonly hasDefReadStyle: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly hideColumn: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly<globalThis.ExtractPropTypes<{
+    readonly formData: never;
+    readonly formItems: never;
+    readonly column: EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+    readonly loading: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly showBtnLoading: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly read: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly disabled: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly showButtons: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly buttonsClass: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly buttonsLeft: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly showReset: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showSubmit: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly confirmText: EpPropFinalized<StringConstructor, unknown, unknown, "确认", boolean>;
+    readonly resetText: EpPropFinalized<StringConstructor, unknown, unknown, "重置", boolean>;
+    readonly confirmClassName: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly colon: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly labelEmpty: EpPropFinalized<StringConstructor, unknown, unknown, "--", boolean>;
+    readonly hasDefReadStyle: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly hideColumn: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+}>> & Readonly<{
+    onOnChange?: ((value: any, prop: string, index?: number | undefined) => any) | undefined;
+    onReset?: ((form: any) => any) | undefined;
+    onSubmit?: ((form: any) => any) | undefined;
+    "onUpdate:form-data"?: ((formData: any) => any) | undefined;
+}>, {
+    FormRef: globalThis.Ref<({
+        $: ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            readonly inline: boolean;
+            readonly disabled: boolean;
+            readonly labelWidth: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly labelPosition: EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+            readonly inlineMessage: boolean;
+            readonly showMessage: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly requireAsteriskPosition: EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+            readonly labelSuffix: string;
+            readonly validateOnRuleChange: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly statusIcon: boolean;
+            readonly hideRequiredAsterisk: boolean;
+            readonly scrollToError: boolean;
+        }> & Omit<{
+            readonly disabled: boolean;
+            readonly inline: boolean;
+            readonly labelPosition: EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+            readonly labelWidth: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly inlineMessage: boolean;
+            readonly showMessage: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly requireAsteriskPosition: EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+            readonly labelSuffix: string;
+            readonly statusIcon: boolean;
+            readonly validateOnRuleChange: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly hideRequiredAsterisk: boolean;
+            readonly scrollToError: boolean;
+            readonly size?: EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
+            readonly rules?: Partial<Record<string, Arrayable<FormItemRule>>> | undefined;
+            readonly model?: Record<string, any> | undefined;
+            readonly scrollIntoViewOptions?: EpPropMergeType<readonly [ObjectConstructor, BooleanConstructor], unknown, unknown> | undefined;
+            onValidate?: ((prop: FormItemProp, isValid: boolean, message: string) => any) | undefined;
+        } & VNodeProps & AllowedComponentProps & ComponentCustomProps, "disabled" | "inline" | "labelPosition" | "labelWidth" | "inlineMessage" | "showMessage" | "requireAsteriskPosition" | "labelSuffix" | "statusIcon" | "validateOnRuleChange" | "hideRequiredAsterisk" | "scrollToError">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: Slot<any> | undefined;
+        }>;
+        $root: ComponentPublicInstance | null;
+        $parent: ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: "validate", prop: FormItemProp, isValid: boolean, message: string) => void;
+        $el: any;
+        $options: ComponentOptionsBase<Readonly<globalThis.ExtractPropTypes<{
+            readonly model: ObjectConstructor;
+            readonly rules: {
+                readonly type: PropType<Partial<Record<string, Arrayable<FormItemRule>>>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly labelPosition: EpPropFinalized<StringConstructor, "top" | "left" | "right", unknown, "right", boolean>;
+            readonly requireAsteriskPosition: EpPropFinalized<StringConstructor, "left" | "right", unknown, "left", boolean>;
+            readonly labelWidth: EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+            readonly labelSuffix: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly inline: BooleanConstructor;
+            readonly inlineMessage: BooleanConstructor;
+            readonly statusIcon: BooleanConstructor;
+            readonly showMessage: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly validateOnRuleChange: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly hideRequiredAsterisk: BooleanConstructor;
+            readonly scrollToError: BooleanConstructor;
+            readonly scrollIntoViewOptions: {
+                readonly type: PropType<EpPropMergeType<readonly [ObjectConstructor, BooleanConstructor], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly size: {
+                readonly type: PropType<EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly disabled: BooleanConstructor;
+        }>> & {
+            onValidate?: ((prop: FormItemProp, isValid: boolean, message: string) => any) | undefined;
+        }, {
+            validate: (callback?: FormValidateCallback | undefined) => FormValidationResult;
+            validateField: (props?: Arrayable<FormItemProp> | undefined, callback?: FormValidateCallback | undefined) => FormValidationResult;
+            resetFields: (props?: Arrayable<FormItemProp> | undefined) => void;
+            clearValidate: (props?: Arrayable<FormItemProp> | undefined) => void;
+            scrollToField: (prop: FormItemProp) => void;
+            fields: FormItemContext[];
+        }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+            validate: (prop: FormItemProp, isValid: boolean, message: string) => void;
+        }, string, {
+            readonly inline: boolean;
+            readonly disabled: boolean;
+            readonly labelWidth: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly labelPosition: EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+            readonly inlineMessage: boolean;
+            readonly showMessage: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly requireAsteriskPosition: EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+            readonly labelSuffix: string;
+            readonly validateOnRuleChange: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly statusIcon: boolean;
+            readonly hideRequiredAsterisk: boolean;
+            readonly scrollToError: boolean;
+        }, {}, string, {}, GlobalComponents, GlobalDirectives, string, 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: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+    } & Readonly<{
+        readonly inline: boolean;
+        readonly disabled: boolean;
+        readonly labelWidth: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+        readonly labelPosition: EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+        readonly inlineMessage: boolean;
+        readonly showMessage: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly requireAsteriskPosition: EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+        readonly labelSuffix: string;
+        readonly validateOnRuleChange: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly statusIcon: boolean;
+        readonly hideRequiredAsterisk: boolean;
+        readonly scrollToError: boolean;
+    }> & Omit<Readonly<globalThis.ExtractPropTypes<{
+        readonly model: ObjectConstructor;
+        readonly rules: {
+            readonly type: PropType<Partial<Record<string, Arrayable<FormItemRule>>>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly labelPosition: EpPropFinalized<StringConstructor, "top" | "left" | "right", unknown, "right", boolean>;
+        readonly requireAsteriskPosition: EpPropFinalized<StringConstructor, "left" | "right", unknown, "left", boolean>;
+        readonly labelWidth: EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+        readonly labelSuffix: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly inline: BooleanConstructor;
+        readonly inlineMessage: BooleanConstructor;
+        readonly statusIcon: BooleanConstructor;
+        readonly showMessage: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly validateOnRuleChange: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly hideRequiredAsterisk: BooleanConstructor;
+        readonly scrollToError: BooleanConstructor;
+        readonly scrollIntoViewOptions: {
+            readonly type: PropType<EpPropMergeType<readonly [ObjectConstructor, BooleanConstructor], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly size: {
+            readonly type: PropType<EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly disabled: BooleanConstructor;
+    }>> & {
+        onValidate?: ((prop: FormItemProp, isValid: boolean, message: string) => any) | undefined;
+    }, "disabled" | "inline" | "labelPosition" | "labelWidth" | "inlineMessage" | "showMessage" | "validate" | "clearValidate" | "requireAsteriskPosition" | "labelSuffix" | "statusIcon" | "validateOnRuleChange" | "hideRequiredAsterisk" | "scrollToError" | "validateField" | "resetFields" | "scrollToField" | "fields"> & ShallowUnwrapRef<{
+        validate: (callback?: FormValidateCallback | undefined) => FormValidationResult;
+        validateField: (props?: Arrayable<FormItemProp> | undefined, callback?: FormValidateCallback | undefined) => FormValidationResult;
+        resetFields: (props?: Arrayable<FormItemProp> | undefined) => void;
+        clearValidate: (props?: Arrayable<FormItemProp> | undefined) => void;
+        scrollToField: (prop: FormItemProp) => void;
+        fields: FormItemContext[];
+    }> & {} & ComponentCustomProperties & {} & {
+        $slots: {
+            default?(_: {}): any;
+        };
+    }) | undefined, ({
+        $: ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            readonly inline: boolean;
+            readonly disabled: boolean;
+            readonly labelWidth: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly labelPosition: EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+            readonly inlineMessage: boolean;
+            readonly showMessage: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly requireAsteriskPosition: EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+            readonly labelSuffix: string;
+            readonly validateOnRuleChange: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly statusIcon: boolean;
+            readonly hideRequiredAsterisk: boolean;
+            readonly scrollToError: boolean;
+        }> & Omit<{
+            readonly disabled: boolean;
+            readonly inline: boolean;
+            readonly labelPosition: EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+            readonly labelWidth: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly inlineMessage: boolean;
+            readonly showMessage: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly requireAsteriskPosition: EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+            readonly labelSuffix: string;
+            readonly statusIcon: boolean;
+            readonly validateOnRuleChange: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly hideRequiredAsterisk: boolean;
+            readonly scrollToError: boolean;
+            readonly size?: EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown> | undefined;
+            readonly rules?: Partial<Record<string, Arrayable<FormItemRule>>> | undefined;
+            readonly model?: Record<string, any> | undefined;
+            readonly scrollIntoViewOptions?: EpPropMergeType<readonly [ObjectConstructor, BooleanConstructor], unknown, unknown> | undefined;
+            onValidate?: ((prop: FormItemProp, isValid: boolean, message: string) => any) | undefined;
+        } & VNodeProps & AllowedComponentProps & ComponentCustomProps, "disabled" | "inline" | "labelPosition" | "labelWidth" | "inlineMessage" | "showMessage" | "requireAsteriskPosition" | "labelSuffix" | "statusIcon" | "validateOnRuleChange" | "hideRequiredAsterisk" | "scrollToError">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: Slot<any> | undefined;
+        }>;
+        $root: ComponentPublicInstance | null;
+        $parent: ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: "validate", prop: FormItemProp, isValid: boolean, message: string) => void;
+        $el: any;
+        $options: ComponentOptionsBase<Readonly<globalThis.ExtractPropTypes<{
+            readonly model: ObjectConstructor;
+            readonly rules: {
+                readonly type: PropType<Partial<Record<string, Arrayable<FormItemRule>>>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly labelPosition: EpPropFinalized<StringConstructor, "top" | "left" | "right", unknown, "right", boolean>;
+            readonly requireAsteriskPosition: EpPropFinalized<StringConstructor, "left" | "right", unknown, "left", boolean>;
+            readonly labelWidth: EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+            readonly labelSuffix: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly inline: BooleanConstructor;
+            readonly inlineMessage: BooleanConstructor;
+            readonly statusIcon: BooleanConstructor;
+            readonly showMessage: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly validateOnRuleChange: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly hideRequiredAsterisk: BooleanConstructor;
+            readonly scrollToError: BooleanConstructor;
+            readonly scrollIntoViewOptions: {
+                readonly type: PropType<EpPropMergeType<readonly [ObjectConstructor, BooleanConstructor], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly size: {
+                readonly type: PropType<EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly disabled: BooleanConstructor;
+        }>> & {
+            onValidate?: ((prop: FormItemProp, isValid: boolean, message: string) => any) | undefined;
+        }, {
+            validate: (callback?: FormValidateCallback | undefined) => FormValidationResult;
+            validateField: (props?: Arrayable<FormItemProp> | undefined, callback?: FormValidateCallback | undefined) => FormValidationResult;
+            resetFields: (props?: Arrayable<FormItemProp> | undefined) => void;
+            clearValidate: (props?: Arrayable<FormItemProp> | undefined) => void;
+            scrollToField: (prop: FormItemProp) => void;
+            fields: FormItemContext[];
+        }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+            validate: (prop: FormItemProp, isValid: boolean, message: string) => void;
+        }, string, {
+            readonly inline: boolean;
+            readonly disabled: boolean;
+            readonly labelWidth: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly labelPosition: EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+            readonly inlineMessage: boolean;
+            readonly showMessage: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly requireAsteriskPosition: EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+            readonly labelSuffix: string;
+            readonly validateOnRuleChange: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly statusIcon: boolean;
+            readonly hideRequiredAsterisk: boolean;
+            readonly scrollToError: boolean;
+        }, {}, string, {}, GlobalComponents, GlobalDirectives, string, 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: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+    } & Readonly<{
+        readonly inline: boolean;
+        readonly disabled: boolean;
+        readonly labelWidth: EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+        readonly labelPosition: EpPropMergeType<StringConstructor, "top" | "left" | "right", unknown>;
+        readonly inlineMessage: boolean;
+        readonly showMessage: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly requireAsteriskPosition: EpPropMergeType<StringConstructor, "left" | "right", unknown>;
+        readonly labelSuffix: string;
+        readonly validateOnRuleChange: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly statusIcon: boolean;
+        readonly hideRequiredAsterisk: boolean;
+        readonly scrollToError: boolean;
+    }> & Omit<Readonly<globalThis.ExtractPropTypes<{
+        readonly model: ObjectConstructor;
+        readonly rules: {
+            readonly type: PropType<Partial<Record<string, Arrayable<FormItemRule>>>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly labelPosition: EpPropFinalized<StringConstructor, "top" | "left" | "right", unknown, "right", boolean>;
+        readonly requireAsteriskPosition: EpPropFinalized<StringConstructor, "left" | "right", unknown, "left", boolean>;
+        readonly labelWidth: EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+        readonly labelSuffix: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly inline: BooleanConstructor;
+        readonly inlineMessage: BooleanConstructor;
+        readonly statusIcon: BooleanConstructor;
+        readonly showMessage: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly validateOnRuleChange: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly hideRequiredAsterisk: BooleanConstructor;
+        readonly scrollToError: BooleanConstructor;
+        readonly scrollIntoViewOptions: {
+            readonly type: PropType<EpPropMergeType<readonly [ObjectConstructor, BooleanConstructor], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly size: {
+            readonly type: PropType<EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly disabled: BooleanConstructor;
+    }>> & {
+        onValidate?: ((prop: FormItemProp, isValid: boolean, message: string) => any) | undefined;
+    }, "disabled" | "inline" | "labelPosition" | "labelWidth" | "inlineMessage" | "showMessage" | "validate" | "clearValidate" | "requireAsteriskPosition" | "labelSuffix" | "statusIcon" | "validateOnRuleChange" | "hideRequiredAsterisk" | "scrollToError" | "validateField" | "resetFields" | "scrollToField" | "fields"> & ShallowUnwrapRef<{
+        validate: (callback?: FormValidateCallback | undefined) => FormValidationResult;
+        validateField: (props?: Arrayable<FormItemProp> | undefined, callback?: FormValidateCallback | undefined) => FormValidationResult;
+        resetFields: (props?: Arrayable<FormItemProp> | undefined) => void;
+        clearValidate: (props?: Arrayable<FormItemProp> | undefined) => void;
+        scrollToField: (prop: FormItemProp) => void;
+        fields: FormItemContext[];
+    }> & {} & ComponentCustomProperties & {} & {
+        $slots: {
+            default?(_: {}): any;
+        };
+    }) | undefined>;
+    validate: () => Promise<unknown>;
+    submitForm: (formEl: FormInstance | undefined) => Promise<void>;
+    resetForm: (formEl: FormInstance | undefined) => void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    onChange: (value: any, prop: string, index?: number | undefined) => any;
+    reset: (form: any) => any;
+    submit: (form: any) => any;
+    "update:form-data": (formData: any) => any;
+}, string, {
+    readonly loading: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly column: number;
+    readonly showBtnLoading: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly read: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showButtons: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly buttonsClass: string;
+    readonly buttonsLeft: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showReset: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showSubmit: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly confirmText: string;
+    readonly resetText: string;
+    readonly confirmClassName: string;
+    readonly colon: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly labelEmpty: string;
+    readonly hasDefReadStyle: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly hideColumn: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+    $slots: Partial<Record<any, (_: {
+        slotRow: any;
+        value: any;
+        updateFormData: (key: string | number | string[], value: any) => void;
+    }) => any>> & Partial<Record<NonNullable<string | number>, (_: any) => any>> & Partial<Record<any, (_: {
+        slotRow: any;
+        value: any;
+        updateFormData: (key: string | number | string[], value: any) => void;
+    }) => any>> & Partial<Record<any, (_: {
+        slotRow: any;
+        value: any;
+        updateFormData: (key: string | number | string[], value: any) => void;
+    }) => any>> & Partial<Record<NonNullable<string | number>, (_: any) => any>> & Partial<Record<any, (_: {
+        slotRow: any;
+        value: any;
+        updateFormData: (key: string | number | string[], value: any) => void;
+    }) => any>> & {
+        default?(_: {}): any;
+        "buttons-prepend"?(_: {}): any;
+    };
+}) & {
+    install: (app: App, options?: LSOptions) => void;
+};
+declare const LSFormItem: {
+    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<globalThis.ExtractPropTypes<{
+        isValue: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        value: {
+            readonly type: globalThis.PropType< EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, ObjectConstructor, ArrayConstructor], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        type: {
+            readonly type: globalThis.PropType< EpPropMergeType<StringConstructor, "number" | "input" | "select" | "label" | "slot" | "textarea" | "switch" | "date" | "radio" | "checkbox" | "datetimerange" | "timePicker" | "timeSelect" | "cascader" | "multipleCascader" | "inputRange" | "inputNumberRange" | "itemSlot", unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        label: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        prop: EpPropFinalized<readonly [StringConstructor, {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        }], unknown, unknown, "", boolean>;
+        rules: EpPropFinalized<ObjectConstructor, unknown, unknown, () => void, boolean>;
+        className: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        labelClass: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        labelIconClass: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        tooltip: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        options: EpPropFinalized<{
+            (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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        }, unknown, unknown, () => never[], boolean>;
+        attrs: EpPropFinalized<ObjectConstructor, unknown, unknown, () => void, boolean>;
+        listeners: EpPropFinalized<ObjectConstructor, unknown, unknown, () => void, boolean>;
+        colon: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        disabled: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        read: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        labelEmpty: EpPropFinalized<StringConstructor, unknown, unknown, "--", boolean>;
+        labelNumber: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        dateFormat: EpPropFinalized<StringConstructor, unknown, unknown, "YYYY-MM-DD HH:mm:ss", boolean>;
+        formatReadValue: {
+            readonly type: globalThis.PropType<Function>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        rangeSeparator: EpPropFinalized<StringConstructor, unknown, unknown, "~", boolean>;
+        rangeProps: EpPropFinalized<{
+            (arrayLength: number): String[];
+            (...items: String[]): String[];
+            new (arrayLength: number): String[];
+            new (...items: String[]): String[];
+            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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        }, unknown, unknown, () => string[], boolean>;
+        radioType: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        isRow: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        selectAll: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        index: EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+        slotKey: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        levelMatch: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        modelValue: {
+            type: globalThis.PropType<any>;
+        };
+    }>> & Readonly<{
+        onOnChange?: ((value: any, prop: string, index: number) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+        "onUpdate:value"?: ((key: string | number | string[], value: any) => any) | undefined;
+    }>, {
+        FormItemRef: globalThis.Ref<any, any>;
+    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+        onChange: (value: any, prop: string, index: number) => any;
+        "update:modelValue": (value: any) => any;
+        "update:value": (key: string | number | string[], value: any) => any;
+    }, PublicProps, {
+        label: string;
+        options: any[];
+        attrs: Record<string, any>;
+        disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        index: number;
+        tooltip: string;
+        className: string;
+        read: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        colon: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        labelEmpty: string;
+        isValue: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        prop: EpPropMergeType<readonly [StringConstructor, {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        }], unknown, unknown>;
+        rules: Record<string, any>;
+        labelClass: string;
+        labelIconClass: string;
+        listeners: Record<string, any>;
+        labelNumber: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        dateFormat: string;
+        rangeSeparator: string;
+        rangeProps: String[];
+        radioType: string;
+        isRow: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        selectAll: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        slotKey: string;
+        levelMatch: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<globalThis.ExtractPropTypes<{
+        isValue: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        value: {
+            readonly type: globalThis.PropType< EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, ObjectConstructor, ArrayConstructor], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        type: {
+            readonly type: globalThis.PropType< EpPropMergeType<StringConstructor, "number" | "input" | "select" | "label" | "slot" | "textarea" | "switch" | "date" | "radio" | "checkbox" | "datetimerange" | "timePicker" | "timeSelect" | "cascader" | "multipleCascader" | "inputRange" | "inputNumberRange" | "itemSlot", unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        label: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        prop: EpPropFinalized<readonly [StringConstructor, {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        }], unknown, unknown, "", boolean>;
+        rules: EpPropFinalized<ObjectConstructor, unknown, unknown, () => void, boolean>;
+        className: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        labelClass: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        labelIconClass: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        tooltip: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        options: EpPropFinalized<{
+            (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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        }, unknown, unknown, () => never[], boolean>;
+        attrs: EpPropFinalized<ObjectConstructor, unknown, unknown, () => void, boolean>;
+        listeners: EpPropFinalized<ObjectConstructor, unknown, unknown, () => void, boolean>;
+        colon: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        disabled: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        read: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        labelEmpty: EpPropFinalized<StringConstructor, unknown, unknown, "--", boolean>;
+        labelNumber: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        dateFormat: EpPropFinalized<StringConstructor, unknown, unknown, "YYYY-MM-DD HH:mm:ss", boolean>;
+        formatReadValue: {
+            readonly type: globalThis.PropType<Function>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        rangeSeparator: EpPropFinalized<StringConstructor, unknown, unknown, "~", boolean>;
+        rangeProps: EpPropFinalized<{
+            (arrayLength: number): String[];
+            (...items: String[]): String[];
+            new (arrayLength: number): String[];
+            new (...items: String[]): String[];
+            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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        }, unknown, unknown, () => string[], boolean>;
+        radioType: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        isRow: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        selectAll: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        index: EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+        slotKey: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        levelMatch: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+        modelValue: {
+            type: globalThis.PropType<any>;
+        };
+    }>> & Readonly<{
+        onOnChange?: ((value: any, prop: string, index: number) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+        "onUpdate:value"?: ((key: string | number | string[], value: any) => any) | undefined;
+    }>, {
+        FormItemRef: globalThis.Ref<any, any>;
+    }, {}, {}, {}, {
+        label: string;
+        options: any[];
+        attrs: Record<string, any>;
+        disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        index: number;
+        tooltip: string;
+        className: string;
+        read: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        colon: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        labelEmpty: string;
+        isValue: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        prop: EpPropMergeType<readonly [StringConstructor, {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        }], unknown, unknown>;
+        rules: Record<string, any>;
+        labelClass: string;
+        labelIconClass: string;
+        listeners: Record<string, any>;
+        labelNumber: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        dateFormat: string;
+        rangeSeparator: string;
+        rangeProps: String[];
+        radioType: string;
+        isRow: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        selectAll: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        slotKey: string;
+        levelMatch: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly<globalThis.ExtractPropTypes<{
+    isValue: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    value: {
+        readonly type: globalThis.PropType< EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, ObjectConstructor, ArrayConstructor], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    type: {
+        readonly type: globalThis.PropType< EpPropMergeType<StringConstructor, "number" | "input" | "select" | "label" | "slot" | "textarea" | "switch" | "date" | "radio" | "checkbox" | "datetimerange" | "timePicker" | "timeSelect" | "cascader" | "multipleCascader" | "inputRange" | "inputNumberRange" | "itemSlot", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    label: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    prop: EpPropFinalized<readonly [StringConstructor, {
+        (arrayLength: number): string[];
+        (...items: string[]): string[];
+        new (arrayLength: number): string[];
+        new (...items: string[]): string[];
+        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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    }], unknown, unknown, "", boolean>;
+    rules: EpPropFinalized<ObjectConstructor, unknown, unknown, () => void, boolean>;
+    className: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    labelClass: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    labelIconClass: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    tooltip: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    options: EpPropFinalized<{
+        (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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, () => never[], boolean>;
+    attrs: EpPropFinalized<ObjectConstructor, unknown, unknown, () => void, boolean>;
+    listeners: EpPropFinalized<ObjectConstructor, unknown, unknown, () => void, boolean>;
+    colon: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    disabled: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    read: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    labelEmpty: EpPropFinalized<StringConstructor, unknown, unknown, "--", boolean>;
+    labelNumber: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    dateFormat: EpPropFinalized<StringConstructor, unknown, unknown, "YYYY-MM-DD HH:mm:ss", boolean>;
+    formatReadValue: {
+        readonly type: globalThis.PropType<Function>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    rangeSeparator: EpPropFinalized<StringConstructor, unknown, unknown, "~", boolean>;
+    rangeProps: EpPropFinalized<{
+        (arrayLength: number): String[];
+        (...items: String[]): String[];
+        new (arrayLength: number): String[];
+        new (...items: String[]): String[];
+        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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, () => string[], boolean>;
+    radioType: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    isRow: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    selectAll: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    index: EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    slotKey: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    levelMatch: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    modelValue: {
+        type: globalThis.PropType<any>;
+    };
+}>> & Readonly<{
+    onOnChange?: ((value: any, prop: string, index: number) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+    "onUpdate:value"?: ((key: string | number | string[], value: any) => any) | undefined;
+}>, {
+    FormItemRef: globalThis.Ref<any, any>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    onChange: (value: any, prop: string, index: number) => any;
+    "update:modelValue": (value: any) => any;
+    "update:value": (key: string | number | string[], value: any) => any;
+}, string, {
+    label: string;
+    options: any[];
+    attrs: Record<string, any>;
+    disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    index: number;
+    tooltip: string;
+    className: string;
+    read: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    colon: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    labelEmpty: string;
+    isValue: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    prop: EpPropMergeType<readonly [StringConstructor, {
+        (arrayLength: number): string[];
+        (...items: string[]): string[];
+        new (arrayLength: number): string[];
+        new (...items: string[]): string[];
+        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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    }], unknown, unknown>;
+    rules: Record<string, any>;
+    labelClass: string;
+    labelIconClass: string;
+    listeners: Record<string, any>;
+    labelNumber: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    dateFormat: string;
+    rangeSeparator: string;
+    rangeProps: String[];
+    radioType: string;
+    isRow: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    selectAll: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    slotKey: string;
+    levelMatch: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+    $slots: Partial<Record<NonNullable< EpPropMergeType<readonly [StringConstructor, {
+        (arrayLength: number): string[];
+        (...items: string[]): string[];
+        new (arrayLength: number): string[];
+        new (...items: string[]): string[];
+        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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    }], unknown, unknown>>, (_: {
+        slotRow: {
+            label: string;
+            options: any[];
+            attrs: Record<string, any>;
+            disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            index: number;
+            tooltip: string;
+            className: string;
+            read: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            colon: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            labelEmpty: string;
+            isValue: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            prop: EpPropMergeType<readonly [StringConstructor, {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            }], unknown, unknown>;
+            rules: Record<string, any>;
+            labelClass: string;
+            labelIconClass: string;
+            listeners: Record<string, any>;
+            labelNumber: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            dateFormat: string;
+            rangeSeparator: string;
+            rangeProps: String[];
+            radioType: string;
+            isRow: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            selectAll: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            slotKey: string;
+            levelMatch: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            type?: EpPropMergeType<StringConstructor, "number" | "input" | "select" | "label" | "slot" | "textarea" | "switch" | "date" | "radio" | "checkbox" | "datetimerange" | "timePicker" | "timeSelect" | "cascader" | "multipleCascader" | "inputRange" | "inputNumberRange" | "itemSlot", unknown> | undefined;
+            value?: EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, ObjectConstructor, ArrayConstructor], unknown, unknown> | undefined;
+            formatReadValue?: Function | undefined;
+        };
+        value: any;
+        updateModelValue: (val: any) => void;
+    }) => any>> & Partial<Record<"tooltip-icon", (_: {
+        slotRow: {
+            label: string;
+            options: any[];
+            attrs: Record<string, any>;
+            disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            index: number;
+            tooltip: string;
+            className: string;
+            read: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            colon: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            labelEmpty: string;
+            isValue: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            prop: EpPropMergeType<readonly [StringConstructor, {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            }], unknown, unknown>;
+            rules: Record<string, any>;
+            labelClass: string;
+            labelIconClass: string;
+            listeners: Record<string, any>;
+            labelNumber: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            dateFormat: string;
+            rangeSeparator: string;
+            rangeProps: String[];
+            radioType: string;
+            isRow: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            selectAll: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            slotKey: string;
+            levelMatch: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            type?: EpPropMergeType<StringConstructor, "number" | "input" | "select" | "label" | "slot" | "textarea" | "switch" | "date" | "radio" | "checkbox" | "datetimerange" | "timePicker" | "timeSelect" | "cascader" | "multipleCascader" | "inputRange" | "inputNumberRange" | "itemSlot", unknown> | undefined;
+            value?: EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, ObjectConstructor, ArrayConstructor], unknown, unknown> | undefined;
+            formatReadValue?: Function | undefined;
+        };
+    }) => any>> & Partial<Record<`${string}-label-icon`, (_: {
+        slotRow: {
+            label: string;
+            options: any[];
+            attrs: Record<string, any>;
+            disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            index: number;
+            tooltip: string;
+            className: string;
+            read: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            colon: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            labelEmpty: string;
+            isValue: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            prop: EpPropMergeType<readonly [StringConstructor, {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            }], unknown, unknown>;
+            rules: Record<string, any>;
+            labelClass: string;
+            labelIconClass: string;
+            listeners: Record<string, any>;
+            labelNumber: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            dateFormat: string;
+            rangeSeparator: string;
+            rangeProps: String[];
+            radioType: string;
+            isRow: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            selectAll: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            slotKey: string;
+            levelMatch: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            type?: EpPropMergeType<StringConstructor, "number" | "input" | "select" | "label" | "slot" | "textarea" | "switch" | "date" | "radio" | "checkbox" | "datetimerange" | "timePicker" | "timeSelect" | "cascader" | "multipleCascader" | "inputRange" | "inputNumberRange" | "itemSlot", unknown> | undefined;
+            value?: EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, ObjectConstructor, ArrayConstructor], unknown, unknown> | undefined;
+            formatReadValue?: Function | undefined;
+        };
+    }) => any>> & Partial<Record<`${string}-prepend`, (_: {
+        slotRow: {
+            props: {
+                readonly label: string;
+                readonly options: any[];
+                readonly attrs: Record<string, any>;
+                readonly disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly index: number;
+                readonly tooltip: string;
+                readonly className: string;
+                readonly read: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly colon: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly labelEmpty: string;
+                readonly isValue: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly prop: EpPropMergeType<readonly [StringConstructor, {
+                    (arrayLength: number): string[];
+                    (...items: string[]): string[];
+                    new (arrayLength: number): string[];
+                    new (...items: string[]): string[];
+                    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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                    readonly [Symbol.species]: ArrayConstructor;
+                }], unknown, unknown>;
+                readonly rules: Record<string, any>;
+                readonly labelClass: string;
+                readonly labelIconClass: string;
+                readonly listeners: Record<string, any>;
+                readonly labelNumber: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly dateFormat: string;
+                readonly rangeSeparator: string;
+                readonly rangeProps: String[];
+                readonly radioType: string;
+                readonly isRow: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly selectAll: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly slotKey: string;
+                readonly levelMatch: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+                readonly type?: EpPropMergeType<StringConstructor, "number" | "input" | "select" | "label" | "slot" | "textarea" | "switch" | "date" | "radio" | "checkbox" | "datetimerange" | "timePicker" | "timeSelect" | "cascader" | "multipleCascader" | "inputRange" | "inputNumberRange" | "itemSlot", unknown> | undefined;
+                readonly value?: EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, ObjectConstructor, ArrayConstructor], unknown, unknown> | undefined;
+                readonly formatReadValue?: Function | undefined;
+            };
+        };
+    }) => any>> & Partial<Record<`${string}-slot`, (_: {
+        slotRow: {
+            label: string;
+            options: any[];
+            attrs: Record<string, any>;
+            disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            index: number;
+            tooltip: string;
+            className: string;
+            read: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            colon: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            labelEmpty: string;
+            isValue: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            prop: EpPropMergeType<readonly [StringConstructor, {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            }], unknown, unknown>;
+            rules: Record<string, any>;
+            labelClass: string;
+            labelIconClass: string;
+            listeners: Record<string, any>;
+            labelNumber: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            dateFormat: string;
+            rangeSeparator: string;
+            rangeProps: String[];
+            radioType: string;
+            isRow: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            selectAll: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            slotKey: string;
+            levelMatch: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            type?: EpPropMergeType<StringConstructor, "number" | "input" | "select" | "label" | "slot" | "textarea" | "switch" | "date" | "radio" | "checkbox" | "datetimerange" | "timePicker" | "timeSelect" | "cascader" | "multipleCascader" | "inputRange" | "inputNumberRange" | "itemSlot", unknown> | undefined;
+            value?: EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, ObjectConstructor, ArrayConstructor], unknown, unknown> | undefined;
+            formatReadValue?: Function | undefined;
+        };
+        value: any;
+        updateModelValue: (val: any) => void;
+    }) => any>> & Partial<Record<`${string}-read-slot`, (_: {
+        value: any;
+        slotRow: {
+            label: string;
+            options: any[];
+            attrs: Record<string, any>;
+            disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            index: number;
+            tooltip: string;
+            className: string;
+            read: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            colon: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            labelEmpty: string;
+            isValue: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            prop: EpPropMergeType<readonly [StringConstructor, {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            }], unknown, unknown>;
+            rules: Record<string, any>;
+            labelClass: string;
+            labelIconClass: string;
+            listeners: Record<string, any>;
+            labelNumber: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            dateFormat: string;
+            rangeSeparator: string;
+            rangeProps: String[];
+            radioType: string;
+            isRow: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            selectAll: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            slotKey: string;
+            levelMatch: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            type?: EpPropMergeType<StringConstructor, "number" | "input" | "select" | "label" | "slot" | "textarea" | "switch" | "date" | "radio" | "checkbox" | "datetimerange" | "timePicker" | "timeSelect" | "cascader" | "multipleCascader" | "inputRange" | "inputNumberRange" | "itemSlot", unknown> | undefined;
+            value?: EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, ObjectConstructor, ArrayConstructor], unknown, unknown> | undefined;
+            formatReadValue?: Function | undefined;
+        };
+    }) => any>> & Partial<Record<NonNullable<"undefined-read-slot" | "number-read-slot" | "input-read-slot" | "select-read-slot" | "label-read-slot" | "textarea-read-slot" | "switch-read-slot" | "date-read-slot" | "radio-read-slot" | "checkbox-read-slot" | "datetimerange-read-slot" | "timePicker-read-slot" | "timeSelect-read-slot" | "cascader-read-slot" | "multipleCascader-read-slot" | "inputRange-read-slot" | "inputNumberRange-read-slot" | "itemSlot-read-slot">, (_: {
+        value: any;
+        slotRow: {
+            label: string;
+            options: any[];
+            attrs: Record<string, any>;
+            disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            index: number;
+            tooltip: string;
+            className: string;
+            read: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            colon: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            labelEmpty: string;
+            isValue: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            prop: EpPropMergeType<readonly [StringConstructor, {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            }], unknown, unknown>;
+            rules: Record<string, any>;
+            labelClass: string;
+            labelIconClass: string;
+            listeners: Record<string, any>;
+            labelNumber: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            dateFormat: string;
+            rangeSeparator: string;
+            rangeProps: String[];
+            radioType: string;
+            isRow: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            selectAll: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            slotKey: string;
+            levelMatch: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            type?: EpPropMergeType<StringConstructor, "number" | "input" | "select" | "label" | "slot" | "textarea" | "switch" | "date" | "radio" | "checkbox" | "datetimerange" | "timePicker" | "timeSelect" | "cascader" | "multipleCascader" | "inputRange" | "inputNumberRange" | "itemSlot", unknown> | undefined;
+            value?: EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, ObjectConstructor, ArrayConstructor], unknown, unknown> | undefined;
+            formatReadValue?: Function | undefined;
+        };
+    }) => any>> & Partial<Record<`${string}-input-prefix`, (_: {
+        slotRow: {
+            label: string;
+            options: any[];
+            attrs: Record<string, any>;
+            disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            index: number;
+            tooltip: string;
+            className: string;
+            read: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            colon: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            labelEmpty: string;
+            isValue: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            prop: EpPropMergeType<readonly [StringConstructor, {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            }], unknown, unknown>;
+            rules: Record<string, any>;
+            labelClass: string;
+            labelIconClass: string;
+            listeners: Record<string, any>;
+            labelNumber: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            dateFormat: string;
+            rangeSeparator: string;
+            rangeProps: String[];
+            radioType: string;
+            isRow: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            selectAll: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            slotKey: string;
+            levelMatch: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            type?: EpPropMergeType<StringConstructor, "number" | "input" | "select" | "label" | "slot" | "textarea" | "switch" | "date" | "radio" | "checkbox" | "datetimerange" | "timePicker" | "timeSelect" | "cascader" | "multipleCascader" | "inputRange" | "inputNumberRange" | "itemSlot", unknown> | undefined;
+            value?: EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, ObjectConstructor, ArrayConstructor], unknown, unknown> | undefined;
+            formatReadValue?: Function | undefined;
+        };
+    }) => any>> & Partial<Record<`${string}-input-suffix`, (_: {
+        slotRow: {
+            label: string;
+            options: any[];
+            attrs: Record<string, any>;
+            disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            index: number;
+            tooltip: string;
+            className: string;
+            read: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            colon: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            labelEmpty: string;
+            isValue: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            prop: EpPropMergeType<readonly [StringConstructor, {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            }], unknown, unknown>;
+            rules: Record<string, any>;
+            labelClass: string;
+            labelIconClass: string;
+            listeners: Record<string, any>;
+            labelNumber: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            dateFormat: string;
+            rangeSeparator: string;
+            rangeProps: String[];
+            radioType: string;
+            isRow: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            selectAll: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            slotKey: string;
+            levelMatch: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            type?: EpPropMergeType<StringConstructor, "number" | "input" | "select" | "label" | "slot" | "textarea" | "switch" | "date" | "radio" | "checkbox" | "datetimerange" | "timePicker" | "timeSelect" | "cascader" | "multipleCascader" | "inputRange" | "inputNumberRange" | "itemSlot", unknown> | undefined;
+            value?: EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, ObjectConstructor, ArrayConstructor], unknown, unknown> | undefined;
+            formatReadValue?: Function | undefined;
+        };
+    }) => any>> & Partial<Record<`${string}-input-prepend`, (_: {
+        slotRow: {
+            label: string;
+            options: any[];
+            attrs: Record<string, any>;
+            disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            index: number;
+            tooltip: string;
+            className: string;
+            read: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            colon: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            labelEmpty: string;
+            isValue: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            prop: EpPropMergeType<readonly [StringConstructor, {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            }], unknown, unknown>;
+            rules: Record<string, any>;
+            labelClass: string;
+            labelIconClass: string;
+            listeners: Record<string, any>;
+            labelNumber: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            dateFormat: string;
+            rangeSeparator: string;
+            rangeProps: String[];
+            radioType: string;
+            isRow: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            selectAll: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            slotKey: string;
+            levelMatch: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            type?: EpPropMergeType<StringConstructor, "number" | "input" | "select" | "label" | "slot" | "textarea" | "switch" | "date" | "radio" | "checkbox" | "datetimerange" | "timePicker" | "timeSelect" | "cascader" | "multipleCascader" | "inputRange" | "inputNumberRange" | "itemSlot", unknown> | undefined;
+            value?: EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, ObjectConstructor, ArrayConstructor], unknown, unknown> | undefined;
+            formatReadValue?: Function | undefined;
+        };
+    }) => any>> & Partial<Record<`${string}-input-append`, (_: {
+        slotRow: {
+            label: string;
+            options: any[];
+            attrs: Record<string, any>;
+            disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            index: number;
+            tooltip: string;
+            className: string;
+            read: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            colon: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            labelEmpty: string;
+            isValue: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            prop: EpPropMergeType<readonly [StringConstructor, {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            }], unknown, unknown>;
+            rules: Record<string, any>;
+            labelClass: string;
+            labelIconClass: string;
+            listeners: Record<string, any>;
+            labelNumber: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            dateFormat: string;
+            rangeSeparator: string;
+            rangeProps: String[];
+            radioType: string;
+            isRow: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            selectAll: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            slotKey: string;
+            levelMatch: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            type?: EpPropMergeType<StringConstructor, "number" | "input" | "select" | "label" | "slot" | "textarea" | "switch" | "date" | "radio" | "checkbox" | "datetimerange" | "timePicker" | "timeSelect" | "cascader" | "multipleCascader" | "inputRange" | "inputNumberRange" | "itemSlot", unknown> | undefined;
+            value?: EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, ObjectConstructor, ArrayConstructor], unknown, unknown> | undefined;
+            formatReadValue?: Function | undefined;
+        };
+    }) => any>> & Partial<Record<`${string}-input-prefix`, (_: {
+        slotRow: {
+            label: string;
+            options: any[];
+            attrs: Record<string, any>;
+            disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            index: number;
+            tooltip: string;
+            className: string;
+            read: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            colon: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            labelEmpty: string;
+            isValue: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            prop: EpPropMergeType<readonly [StringConstructor, {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            }], unknown, unknown>;
+            rules: Record<string, any>;
+            labelClass: string;
+            labelIconClass: string;
+            listeners: Record<string, any>;
+            labelNumber: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            dateFormat: string;
+            rangeSeparator: string;
+            rangeProps: String[];
+            radioType: string;
+            isRow: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            selectAll: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            slotKey: string;
+            levelMatch: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            type?: EpPropMergeType<StringConstructor, "number" | "input" | "select" | "label" | "slot" | "textarea" | "switch" | "date" | "radio" | "checkbox" | "datetimerange" | "timePicker" | "timeSelect" | "cascader" | "multipleCascader" | "inputRange" | "inputNumberRange" | "itemSlot", unknown> | undefined;
+            value?: EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, ObjectConstructor, ArrayConstructor], unknown, unknown> | undefined;
+            formatReadValue?: Function | undefined;
+        };
+    }) => any>> & Partial<Record<`${string}-input-suffix`, (_: {
+        slotRow: {
+            label: string;
+            options: any[];
+            attrs: Record<string, any>;
+            disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            index: number;
+            tooltip: string;
+            className: string;
+            read: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            colon: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            labelEmpty: string;
+            isValue: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            prop: EpPropMergeType<readonly [StringConstructor, {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            }], unknown, unknown>;
+            rules: Record<string, any>;
+            labelClass: string;
+            labelIconClass: string;
+            listeners: Record<string, any>;
+            labelNumber: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            dateFormat: string;
+            rangeSeparator: string;
+            rangeProps: String[];
+            radioType: string;
+            isRow: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            selectAll: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            slotKey: string;
+            levelMatch: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            type?: EpPropMergeType<StringConstructor, "number" | "input" | "select" | "label" | "slot" | "textarea" | "switch" | "date" | "radio" | "checkbox" | "datetimerange" | "timePicker" | "timeSelect" | "cascader" | "multipleCascader" | "inputRange" | "inputNumberRange" | "itemSlot", unknown> | undefined;
+            value?: EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, ObjectConstructor, ArrayConstructor], unknown, unknown> | undefined;
+            formatReadValue?: Function | undefined;
+        };
+    }) => any>> & Partial<Record<`${string}-input-prepend`, (_: {
+        slotRow: {
+            label: string;
+            options: any[];
+            attrs: Record<string, any>;
+            disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            index: number;
+            tooltip: string;
+            className: string;
+            read: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            colon: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            labelEmpty: string;
+            isValue: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            prop: EpPropMergeType<readonly [StringConstructor, {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            }], unknown, unknown>;
+            rules: Record<string, any>;
+            labelClass: string;
+            labelIconClass: string;
+            listeners: Record<string, any>;
+            labelNumber: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            dateFormat: string;
+            rangeSeparator: string;
+            rangeProps: String[];
+            radioType: string;
+            isRow: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            selectAll: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            slotKey: string;
+            levelMatch: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            type?: EpPropMergeType<StringConstructor, "number" | "input" | "select" | "label" | "slot" | "textarea" | "switch" | "date" | "radio" | "checkbox" | "datetimerange" | "timePicker" | "timeSelect" | "cascader" | "multipleCascader" | "inputRange" | "inputNumberRange" | "itemSlot", unknown> | undefined;
+            value?: EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, ObjectConstructor, ArrayConstructor], unknown, unknown> | undefined;
+            formatReadValue?: Function | undefined;
+        };
+    }) => any>> & Partial<Record<`${string}-input-append`, (_: {
+        slotRow: {
+            label: string;
+            options: any[];
+            attrs: Record<string, any>;
+            disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            index: number;
+            tooltip: string;
+            className: string;
+            read: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            colon: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            labelEmpty: string;
+            isValue: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            prop: EpPropMergeType<readonly [StringConstructor, {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            }], unknown, unknown>;
+            rules: Record<string, any>;
+            labelClass: string;
+            labelIconClass: string;
+            listeners: Record<string, any>;
+            labelNumber: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            dateFormat: string;
+            rangeSeparator: string;
+            rangeProps: String[];
+            radioType: string;
+            isRow: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            selectAll: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            slotKey: string;
+            levelMatch: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            type?: EpPropMergeType<StringConstructor, "number" | "input" | "select" | "label" | "slot" | "textarea" | "switch" | "date" | "radio" | "checkbox" | "datetimerange" | "timePicker" | "timeSelect" | "cascader" | "multipleCascader" | "inputRange" | "inputNumberRange" | "itemSlot", unknown> | undefined;
+            value?: EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, ObjectConstructor, ArrayConstructor], unknown, unknown> | undefined;
+            formatReadValue?: Function | undefined;
+        };
+    }) => any>> & Partial<Record<`${string}-input-prefix`, (_: {
+        slotRow: {
+            label: string;
+            options: any[];
+            attrs: Record<string, any>;
+            disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            index: number;
+            tooltip: string;
+            className: string;
+            read: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            colon: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            labelEmpty: string;
+            isValue: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            prop: EpPropMergeType<readonly [StringConstructor, {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            }], unknown, unknown>;
+            rules: Record<string, any>;
+            labelClass: string;
+            labelIconClass: string;
+            listeners: Record<string, any>;
+            labelNumber: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            dateFormat: string;
+            rangeSeparator: string;
+            rangeProps: String[];
+            radioType: string;
+            isRow: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            selectAll: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            slotKey: string;
+            levelMatch: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            type?: EpPropMergeType<StringConstructor, "number" | "input" | "select" | "label" | "slot" | "textarea" | "switch" | "date" | "radio" | "checkbox" | "datetimerange" | "timePicker" | "timeSelect" | "cascader" | "multipleCascader" | "inputRange" | "inputNumberRange" | "itemSlot", unknown> | undefined;
+            value?: EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, ObjectConstructor, ArrayConstructor], unknown, unknown> | undefined;
+            formatReadValue?: Function | undefined;
+        };
+    }) => any>> & Partial<Record<`${string}-input-suffix`, (_: {
+        slotRow: {
+            label: string;
+            options: any[];
+            attrs: Record<string, any>;
+            disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            index: number;
+            tooltip: string;
+            className: string;
+            read: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            colon: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            labelEmpty: string;
+            isValue: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            prop: EpPropMergeType<readonly [StringConstructor, {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            }], unknown, unknown>;
+            rules: Record<string, any>;
+            labelClass: string;
+            labelIconClass: string;
+            listeners: Record<string, any>;
+            labelNumber: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            dateFormat: string;
+            rangeSeparator: string;
+            rangeProps: String[];
+            radioType: string;
+            isRow: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            selectAll: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            slotKey: string;
+            levelMatch: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            type?: EpPropMergeType<StringConstructor, "number" | "input" | "select" | "label" | "slot" | "textarea" | "switch" | "date" | "radio" | "checkbox" | "datetimerange" | "timePicker" | "timeSelect" | "cascader" | "multipleCascader" | "inputRange" | "inputNumberRange" | "itemSlot", unknown> | undefined;
+            value?: EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, ObjectConstructor, ArrayConstructor], unknown, unknown> | undefined;
+            formatReadValue?: Function | undefined;
+        };
+    }) => any>> & Partial<Record<`${string}-slot`, (_: {
+        slotRow: {
+            label: string;
+            options: any[];
+            attrs: Record<string, any>;
+            disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            index: number;
+            tooltip: string;
+            className: string;
+            read: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            colon: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            labelEmpty: string;
+            isValue: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            prop: EpPropMergeType<readonly [StringConstructor, {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            }], unknown, unknown>;
+            rules: Record<string, any>;
+            labelClass: string;
+            labelIconClass: string;
+            listeners: Record<string, any>;
+            labelNumber: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            dateFormat: string;
+            rangeSeparator: string;
+            rangeProps: String[];
+            radioType: string;
+            isRow: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            selectAll: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            slotKey: string;
+            levelMatch: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            type?: EpPropMergeType<StringConstructor, "number" | "input" | "select" | "label" | "slot" | "textarea" | "switch" | "date" | "radio" | "checkbox" | "datetimerange" | "timePicker" | "timeSelect" | "cascader" | "multipleCascader" | "inputRange" | "inputNumberRange" | "itemSlot", unknown> | undefined;
+            value?: EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, ObjectConstructor, ArrayConstructor], unknown, unknown> | undefined;
+            formatReadValue?: Function | undefined;
+        };
+        value: any;
+        updateModelValue: (val: any) => void;
+    }) => any>> & Partial<Record<`${string}-append`, (_: {
+        slotRow: {
+            label: string;
+            options: any[];
+            attrs: Record<string, any>;
+            disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            index: number;
+            tooltip: string;
+            className: string;
+            read: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            colon: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            labelEmpty: string;
+            isValue: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            prop: EpPropMergeType<readonly [StringConstructor, {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                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>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            }], unknown, unknown>;
+            rules: Record<string, any>;
+            labelClass: string;
+            labelIconClass: string;
+            listeners: Record<string, any>;
+            labelNumber: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            dateFormat: string;
+            rangeSeparator: string;
+            rangeProps: String[];
+            radioType: string;
+            isRow: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            selectAll: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            slotKey: string;
+            levelMatch: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            type?: EpPropMergeType<StringConstructor, "number" | "input" | "select" | "label" | "slot" | "textarea" | "switch" | "date" | "radio" | "checkbox" | "datetimerange" | "timePicker" | "timeSelect" | "cascader" | "multipleCascader" | "inputRange" | "inputNumberRange" | "itemSlot", unknown> | undefined;
+            value?: EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, ObjectConstructor, ArrayConstructor], unknown, unknown> | undefined;
+            formatReadValue?: Function | undefined;
+        };
+    }) => any>>;
+}) & {
+    install: (app: App, options?: LSOptions) => void;
+};
+export { LSForm, LSFormItem };