ep-craft 0.1.26 → 0.1.27

package/dist/components/date-picker/src/date-picker.js

@@ -1,68 +1,72 @@
-import { defineComponent as u, computed as _, provide as a, reactive as E, toRef as P, ref as O, createVNode as n, mergeProps as i, isVNode as s } from "vue";
+import { defineComponent as _, computed as P, provide as a, reactive as s, toRef as O, ref as T, createVNode as n, mergeProps as l, isVNode as b } from "vue";
 import "../../time-picker/index.js";
-import { UPDATE_MODEL_EVENT as l } from "../../../constants/event.js";
-import { EpDatePickerPanel as T } from "../../date-picker-panel/index.js";
-import { datePickerProps as D } from "./props.js";
-import { ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY as b } from "../../date-picker-panel/src/constants.js";
-import { PICKER_POPPER_OPTIONS_INJECTION_KEY as A, DEFAULT_FORMATS_DATEPICKER as I, DEFAULT_FORMATS_DATE as R } from "../../time-picker/src/constants.js";
-import C from "../../time-picker/src/common/picker.vue.js";
-function N(t) {
-  return typeof t == "function" || Object.prototype.toString.call(t) === "[object Object]" && !s(t);
+import { UPDATE_MODEL_EVENT as i } from "../../../constants/event.js";
+import { EpDatePickerPanel as D } from "../../date-picker-panel/index.js";
+import { datePickerProps as A } from "./props.js";
+import { ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY as I } from "../../date-picker-panel/src/constants.js";
+import { PICKER_POPPER_OPTIONS_INJECTION_KEY as R, DEFAULT_FORMATS_DATEPICKER as C, DEFAULT_FORMATS_DATE as N } from "../../time-picker/src/constants.js";
+import F from "../../time-picker/src/common/picker.vue.js";
+function k(t) {
+  return typeof t == "function" || Object.prototype.toString.call(t) === "[object Object]" && !b(t);
 }
-const g = /* @__PURE__ */ u({
+const h = /* @__PURE__ */ _({
   name: "EpDatePicker",
   install: null,
-  props: D,
-  emits: [l],
+  props: A,
+  emits: [i],
   setup(t, {
-    expose: m,
-    emit: f,
-    slots: o
+    expose: f,
+    emit: m,
+    slots: r
   }) {
-    const d = _(() => !t.format);
-    a(b, d), a(A, E(P(t, "popperOptions")));
-    const r = O();
-    m({
+    const c = P(() => !t.format);
+    a(I, c), a(R, s(O(t, "popperOptions")));
+    const o = T();
+    f({
       focus: () => {
         var e;
-        (e = r.value) == null || e.focus();
+        (e = o.value) == null || e.focus();
       },
       blur: () => {
         var e;
-        (e = r.value) == null || e.blur();
+        (e = o.value) == null || e.blur();
       },
       handleOpen: () => {
         var e;
-        (e = r.value) == null || e.handleOpen();
+        (e = o.value) == null || e.handleOpen();
       },
       handleClose: () => {
         var e;
-        (e = r.value) == null || e.handleClose();
+        (e = o.value) == null || e.handleClose();
       }
     });
-    const c = (e) => {
-      f(l, e);
+    const d = (e) => {
+      m(i, e);
     };
     return () => {
-      const e = t.format ?? (I[t.type] || R);
-      return n(C, i(t, {
+      const e = t.format ?? (C[t.type] || N), {
+        floatLabel: p,
+        ...u
+      } = t;
+      return n(F, l(u, {
+        floatLabelEnabled: p,
         format: e,
         type: t.type,
-        ref: r,
-        "onUpdate:modelValue": c
+        ref: o,
+        "onUpdate:modelValue": d
       }), {
-        default: (p) => n(T, i({
+        default: (E) => n(D, l({
           disabled: t.disabled,
           editable: t.editable,
           border: !1
-        }, p), N(o) ? o : {
-          default: () => [o]
+        }, E), k(r) ? r : {
+          default: () => [r]
         }),
-        "range-separator": o["range-separator"]
+        "range-separator": r["range-separator"]
       });
     };
   }
 });
 export {
-  g as default
+  h as default
 };

package/dist/components/date-picker/src/props.js

@@ -1,21 +1,33 @@
 import "../../time-picker/index.js";
+import "vue";
 import "@vue/shared";
 import "lodash-unified";
 import "@vueuse/core";
 import "@element-plus/icons-vue";
-import { buildProps as r, definePropType as t } from "../../../utils/vue/props/runtime.js";
-import "vue";
-import { timePickerDefaultProps as o } from "../../time-picker/src/common/props.js";
-const s = r({
-  ...o,
+import { buildProps as r, definePropType as o } from "../../../utils/vue/props/runtime.js";
+import "../../../hooks/use-size/index.js";
+import "@popperjs/core";
+import "../../../hooks/use-z-index/index.js";
+import "../../../hooks/use-delayed-toggle/index.js";
+import "../../../hooks/use-aria/index.js";
+import "../../../hooks/use-model-toggle/index.js";
+import "../../../hooks/use-empty-values/index.js";
+import { floatLabelProp as t } from "../../../hooks/use-float-label/index.js";
+import { timePickerDefaultProps as p } from "../../time-picker/src/common/props.js";
+const x = r({
+  ...p,
+  // 浮动标签仅由 date-picker 对外提供:time-picker 与 date-picker 共用
+  // timePickerDefaultProps 基座,故该属性在此单独声明,不放进共享基座,
+  // 以免独立 EpTimePicker 顺带获得浮动能力(见 design.md Out of Boundary)。
+  ...t,
   /**
    * @description type of the picker
    */
   type: {
-    type: t(String),
+    type: o(String),
     default: "date"
   }
 });
 export {
-  s as datePickerProps
+  x as datePickerProps
 };

package/dist/components/form/src/types.d.ts

@@ -8,7 +8,7 @@ export interface FormItemContext {
     size?: ComponentSize;
     $el?: HTMLDivElement | undefined;
     validateMessage?: string;
-    validateState?: string;
+    validateState?: '' | 'error' | 'validating' | 'success';
     isGroup?: boolean;
     labelId?: string;
     inputIds?: string[];

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

@@ -4,3 +4,4 @@ export declare const EpScrollbar: typeof ElScrollbar & Plugin;
 export default EpScrollbar;
 export { scrollbarEmits } from './src/scrollbar';
 export type { ScrollbarDirection, ScrollbarEmits, ScrollbarInstance, } from './src/scrollbar';
+export * from './src/util';

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

@@ -0,0 +1,40 @@
+import type { CSSProperties } from 'vue';
+/**
+ * scrollbar 源码化子集 —— 仅为 virtual-list 的 scrollbar 包装提供工具导出。
+ *
+ * scrollbar 组件本体仍走薄包装(见 index.ts),此处仅补齐
+ * virtual-list/src/components/scrollbar 依赖的 `BAR_MAP` 等命名导出。
+ * 上游 renderThumbStyle 的入参类型引用 `Pick<ThumbProps, 'move' | 'size'>`,
+ * 因本地未 vendor `thumb.ts`(ThumbProps 来源缺失),故将 `Pick<ThumbProps,
+ * 'move' | 'size'>` 就地内联为等价结构类型 `{ move?: number; size?: string }`
+ * (上游 `size` 为可选 string、`move` 为可选 number)。
+ */
+export declare const GAP = 4;
+export declare const BAR_MAP: {
+    readonly vertical: {
+        readonly offset: "offsetHeight";
+        readonly scroll: "scrollTop";
+        readonly scrollSize: "scrollHeight";
+        readonly size: "height";
+        readonly key: "vertical";
+        readonly axis: "Y";
+        readonly client: "clientY";
+        readonly direction: "top";
+    };
+    readonly horizontal: {
+        readonly offset: "offsetWidth";
+        readonly scroll: "scrollLeft";
+        readonly scrollSize: "scrollWidth";
+        readonly size: "width";
+        readonly key: "horizontal";
+        readonly axis: "X";
+        readonly client: "clientX";
+        readonly direction: "left";
+    };
+};
+export declare const renderThumbStyle: ({ move, size, bar, }: {
+    move?: number;
+    size?: string;
+} & {
+    bar: (typeof BAR_MAP)[keyof typeof BAR_MAP];
+}) => CSSProperties;

package/dist/components/scrollbar/src/util.js

@@ -0,0 +1,25 @@
+const l = {
+  vertical: {
+    offset: "offsetHeight",
+    scroll: "scrollTop",
+    scrollSize: "scrollHeight",
+    size: "height",
+    key: "vertical",
+    axis: "Y",
+    client: "clientY",
+    direction: "top"
+  },
+  horizontal: {
+    offset: "offsetWidth",
+    scroll: "scrollLeft",
+    scrollSize: "scrollWidth",
+    size: "width",
+    key: "horizontal",
+    axis: "X",
+    client: "clientX",
+    direction: "left"
+  }
+};
+export {
+  l as BAR_MAP
+};

package/dist/components/select/select.vue.d.ts

@@ -92,7 +92,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
 }>, {
     modelValue: import("vue").ComputedRef<string | number | boolean | any[] | Record<string, any> | null | undefined>;
     selectedLabel: import("vue").ComputedRef<string | string[]>;
-    floatLabelClass: import("vue").ComputedRef<Record<"is-floating", boolean>>;
+    floatLabelClass: import("vue").ComputedRef<import("@element-plus/hooks").FloatLabelClass>;
     floatLabelText: import("vue").ComputedRef<string>;
     calculatorRef: import("vue").ShallowRef<HTMLElement | undefined, HTMLElement | undefined>;
     inputStyle: import("vue").ComputedRef<{
@@ -188,8 +188,8 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     showClearBtn: import("vue").ComputedRef<boolean>;
     iconComponent: import("vue").ComputedRef<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
     iconReverse: import("vue").ComputedRef<string>;
-    validateState: import("vue").ComputedRef<string>;
-    validateIcon: import("vue").ComputedRef<"" | import("vue").Component>;
+    validateState: import("vue").ComputedRef<"" | "error" | "success" | "validating">;
+    validateIcon: import("vue").ComputedRef<import("vue").Component | "">;
     showNewOption: import("vue").ComputedRef<boolean>;
     updateOptions: () => void;
     collapseTagSize: import("vue").ComputedRef<"default" | "small">;
@@ -369,11 +369,11 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     onBlur?: ((evt: FocusEvent) => any) | undefined;
     "onEnd-reached"?: ((direction: import("@element-plus/components/scrollbar").ScrollbarDirection) => any) | undefined;
     "onVisible-change"?: ((visible: boolean) => any) | undefined;
+    "onRemove-tag"?: ((val: unknown) => any) | undefined;
     "onPopup-scroll"?: ((args_0: {
         scrollTop: number;
         scrollLeft: number;
     }) => any) | undefined;
-    "onRemove-tag"?: ((val: unknown) => any) | undefined;
 }>, {
     props: import("@element-plus/components/select-v2/src/useProps").Props;
     offset: number;
@@ -407,12 +407,12 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     tagType: import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => "primary" | "success" | "warning" | "info" | "danger") | (() => "primary" | "success" | "warning" | "info" | "danger") | (((new (...args: any[]) => "primary" | "success" | "warning" | "info" | "danger") | (() => "primary" | "success" | "warning" | "info" | "danger")) | null)[], "primary" | "success" | "warning" | "info" | "danger", unknown>;
     tagEffect: import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => "dark" | "light" | "plain") | (() => "dark" | "light" | "plain") | (((new (...args: any[]) => "dark" | "light" | "plain") | (() => "dark" | "light" | "plain")) | null)[], "dark" | "light" | "plain", unknown>;
     automaticDropdown: boolean;
-    allowCreate: boolean;
-    remote: boolean;
+    tagTooltip: import("./select").TagTooltipProps;
     multipleLimit: number;
-    defaultFirstOption: boolean;
     reserveKeyword: import("@element-plus/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
-    tagTooltip: import("./select").TagTooltipProps;
+    allowCreate: boolean;
+    defaultFirstOption: boolean;
+    remote: boolean;
     remoteShowSuffix: boolean;
 }, {}, {
     ElSelectMenu: import("vue").DefineComponent<{}, {

package/dist/components/select/src/useSelect.d.ts

@@ -85,8 +85,8 @@ export declare const useSelect: (props: SelectProps, emit: SelectEmits) => {
     showClearBtn: import("vue").ComputedRef<boolean>;
     iconComponent: import("vue").ComputedRef<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => (string | Component) & {}) | (() => string | Component) | (((new (...args: any[]) => (string | Component) & {}) | (() => string | Component)) | null)[], unknown, unknown>>;
     iconReverse: import("vue").ComputedRef<string>;
-    validateState: import("vue").ComputedRef<string>;
-    validateIcon: import("vue").ComputedRef<"" | Component>;
+    validateState: import("vue").ComputedRef<"" | "error" | "success" | "validating">;
+    validateIcon: import("vue").ComputedRef<Component | "">;
     showNewOption: import("vue").ComputedRef<boolean>;
     updateOptions: () => void;
     collapseTagSize: import("vue").ComputedRef<"default" | "small">;

package/dist/components/select-v2/index.d.ts

@@ -1,4 +1,8 @@
 import type { Plugin } from 'vue';
-import { ElSelectV2 } from 'element-plus';
-export declare const EpSelectV2: typeof ElSelectV2 & Plugin;
+import _EpSelectV2 from './src/select.vue';
+export declare const EpSelectV2: typeof _EpSelectV2 & Plugin;
 export default EpSelectV2;
+export { selectV2Emits, selectV2Props } from './src/defaults';
+export { selectV2InjectionKey } from './src/token';
+export type { OptionV2EmitFn, OptionV2Props, OptionV2PropsPublic, SelectV2EmitFn, SelectV2Instance, SelectV2Props, SelectV2PropsPublic, } from './src/defaults';
+export type { SelectV2Context } from './src/token';

package/dist/components/select-v2/index.js

@@ -1,6 +1,9 @@
-import { ElSelectV2 as e } from "element-plus";
-import { withInstall as t } from "../../utils/with-install.js";
-const c = Object.assign({}, e, { name: "EpSelectV2" }), p = t(c, "ep-select-v2");
+import { withInstall as e } from "../../utils/with-install.js";
+import t from "./src/select.vue.js";
+import { selectV2Emits as c, selectV2Props as m } from "./src/defaults.js";
+const r = e(t, "ep-select-v2");
 export {
-  p as EpSelectV2
+  r as EpSelectV2,
+  c as selectV2Emits,
+  m as selectV2Props
 };

package/dist/components/select-v2/src/defaults.d.ts

@@ -0,0 +1,258 @@
+import type SelectV2 from './select.vue';
+import type { Option, OptionType } from './select.types';
+import type { Props } from './useProps';
+import type { EmitFn } from '@element-plus/utils/vue/typescript';
+import type { CSSProperties, ExtractPropTypes, ExtractPublicPropTypes } from 'vue';
+import type { Options, Placement, PopperEffect } from '@element-plus/components/popper';
+/**
+ * @description Tag tooltip configuration interface
+ */
+export interface TagTooltipProps {
+    appendTo?: string | HTMLElement;
+    placement?: Placement;
+    fallbackPlacements?: Placement[];
+    effect?: PopperEffect;
+    popperClass?: string;
+    popperStyle?: string | CSSProperties;
+    transition?: string;
+    teleported?: boolean;
+    popperOptions?: Partial<Options>;
+    showAfter?: number;
+    hideAfter?: number;
+    autoClose?: number;
+    offset?: number;
+}
+export declare const selectV2Props: {
+    readonly ariaLabel: StringConstructor;
+    readonly emptyValues: ArrayConstructor;
+    readonly valueOnClear: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown, undefined, boolean>;
+    readonly floatLabel: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly allowCreate: BooleanConstructor;
+    readonly autocomplete: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => "none" | "both" | "inline" | "list") | (() => "none" | "both" | "inline" | "list") | (((new (...args: any[]) => "none" | "both" | "inline" | "list") | (() => "none" | "both" | "inline" | "list")) | null)[], unknown, unknown, "none", boolean>;
+    readonly automaticDropdown: BooleanConstructor;
+    readonly clearable: BooleanConstructor;
+    readonly clearIcon: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown, import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, boolean>;
+    readonly effect: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string) | (() => PopperEffect) | (((new (...args: any[]) => string) | (() => PopperEffect)) | null)[], unknown, unknown, "light", boolean>;
+    readonly collapseTags: BooleanConstructor;
+    readonly collapseTagsTooltip: BooleanConstructor;
+    readonly tagTooltip: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => TagTooltipProps) | (() => TagTooltipProps) | (((new (...args: any[]) => TagTooltipProps) | (() => TagTooltipProps)) | null)[], unknown, unknown, () => {}, boolean>;
+    readonly maxCollapseTags: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+    readonly defaultFirstOption: BooleanConstructor;
+    readonly disabled: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    readonly estimatedOptionHeight: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, undefined, boolean>;
+    readonly filterable: BooleanConstructor;
+    readonly filterMethod: {
+        readonly type: import("vue").PropType<(query: string) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly height: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 274, boolean>;
+    readonly itemHeight: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 34, boolean>;
+    readonly id: StringConstructor;
+    readonly loading: BooleanConstructor;
+    readonly loadingText: StringConstructor;
+    readonly modelValue: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => any) | (() => any) | {
+        (): any;
+        new (): any;
+        readonly prototype: any;
+    } | (((new (...args: any[]) => any) | (() => any) | {
+        (): any;
+        new (): any;
+        readonly prototype: any;
+    }) | null)[], unknown, unknown, undefined, boolean>;
+    readonly multiple: BooleanConstructor;
+    readonly multipleLimit: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly name: StringConstructor;
+    readonly noDataText: StringConstructor;
+    readonly noMatchText: StringConstructor;
+    readonly remoteMethod: {
+        readonly type: import("vue").PropType<(query: string) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly reserveKeyword: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly options: {
+        readonly type: import("vue").PropType<OptionType[]>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly placeholder: {
+        readonly type: import("vue").PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly teleported: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly persistent: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly popperClass: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | (((new (...args: any[]) => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[])) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly popperStyle: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string | false | CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+    readonly popperOptions: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => Partial<Options>) | (() => Partial<Options>) | (((new (...args: any[]) => Partial<Options>) | (() => Partial<Options>)) | null)[], unknown, unknown, () => Partial<Options>, boolean>;
+    readonly remote: BooleanConstructor;
+    readonly debounce: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 300, boolean>;
+    readonly size: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly props: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => Props) | (() => Props) | (((new (...args: any[]) => Props) | (() => Props)) | null)[], unknown, unknown, () => Required<Props>, boolean>;
+    readonly valueKey: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "value", boolean>;
+    readonly scrollbarAlwaysOn: BooleanConstructor;
+    readonly validateEvent: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly offset: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 12, boolean>;
+    readonly remoteShowSuffix: BooleanConstructor;
+    readonly showArrow: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly placement: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => Placement) | (((new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => Placement)) | null)[], Placement, unknown, "bottom-start", boolean>;
+    readonly fallbackPlacements: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => Placement[]) | (() => Placement[]) | (((new (...args: any[]) => Placement[]) | (() => Placement[])) | null)[], unknown, unknown, readonly ["bottom-start", "top-start", "right", "left"], boolean>;
+    readonly tagType: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => "primary" | "success" | "warning" | "info" | "danger") | (() => "primary" | "success" | "warning" | "info" | "danger") | (((new (...args: any[]) => "primary" | "success" | "warning" | "info" | "danger") | (() => "primary" | "success" | "warning" | "info" | "danger")) | null)[], "primary" | "success" | "warning" | "info" | "danger", unknown, "info", boolean>;
+    readonly tagEffect: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => "dark" | "light" | "plain") | (() => "dark" | "light" | "plain") | (((new (...args: any[]) => "dark" | "light" | "plain") | (() => "dark" | "light" | "plain")) | null)[], "dark" | "light" | "plain", unknown, "light", boolean>;
+    readonly tabindex: import("@element-plus/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, 0, boolean>;
+    readonly appendTo: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement) | (((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly fitInputWidth: import("@element-plus/utils").EpPropFinalized<readonly [BooleanConstructor, NumberConstructor], unknown, number | boolean, true, boolean>;
+    readonly suffixIcon: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown, import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, boolean>;
+};
+export declare const optionV2Props: {
+    readonly data: ArrayConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly hovering: BooleanConstructor;
+    readonly item: {
+        readonly type: import("vue").PropType<Option>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly index: NumberConstructor;
+    readonly style: ObjectConstructor;
+    readonly selected: BooleanConstructor;
+    readonly created: BooleanConstructor;
+};
+export declare const selectV2Emits: {
+    "update:modelValue": (val: SelectV2Props["modelValue"]) => boolean;
+    change: (val: SelectV2Props["modelValue"]) => boolean;
+    'end-reached': (direction: import("@element-plus/components/scrollbar").ScrollbarDirection) => boolean;
+    'remove-tag': (val: unknown) => boolean;
+    'visible-change': (visible: boolean) => boolean;
+    focus: (evt: FocusEvent) => boolean;
+    blur: (evt: FocusEvent) => boolean;
+    clear: () => boolean;
+};
+export declare const optionV2Emits: {
+    hover: (index?: number) => index is number;
+    select: (val: Option, index?: number) => boolean;
+};
+export type SelectV2Props = ExtractPropTypes<typeof selectV2Props>;
+export type SelectV2PropsPublic = ExtractPublicPropTypes<typeof selectV2Props>;
+export type OptionV2Props = ExtractPropTypes<typeof optionV2Props>;
+export type OptionV2PropsPublic = ExtractPublicPropTypes<typeof optionV2Props>;
+export type SelectV2EmitFn = EmitFn<typeof selectV2Emits>;
+export type OptionV2EmitFn = EmitFn<typeof optionV2Emits>;
+export type SelectV2Instance = InstanceType<typeof SelectV2> & unknown;