ep-craft 0.1.28 → 0.1.29

package/dist/components/config-provider/src/hooks/use-global-config.js

@@ -1,24 +1,66 @@
-import { ref as p, getCurrentInstance as n, inject as e, computed as c } from "vue";
+import { ref as c, getCurrentInstance as f, inject as v, computed as i, unref as d, provide as C } from "vue";
 import "@vue/shared";
 import "lodash-unified";
 import "@vueuse/core";
+import { debugWarn as g } from "../../../../utils/error.js";
+import { keysOf as u } from "../../../../utils/objects.js";
 import "@element-plus/icons-vue";
-import "../../../../hooks/use-size/index.js";
+import { namespaceContextKey as y } from "../../../../hooks/use-namespace/index.js";
+import { localeContextKey as x } from "../../../../hooks/use-locale/index.js";
+import { SIZE_INJECTION_KEY as b } from "../../../../hooks/use-size/index.js";
 import "@popperjs/core";
-import "../../../../hooks/use-z-index/index.js";
+import { zIndexContextKey as I } from "../../../../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 { configProviderContextKey as f } from "../constants.js";
-const t = p();
-function I(r, i = void 0) {
-  const m = n() ? e(f, t) : t;
-  return c(() => {
-    var o;
-    return ((o = m.value) == null ? void 0 : o[r]) ?? i;
-  });
+import { emptyValuesContextKey as K } from "../../../../hooks/use-empty-values/index.js";
+import { configProviderContextKey as s } from "../constants.js";
+const m = c();
+function z(r, l = void 0) {
+  const a = f() ? v(s, m) : m;
+  return r ? i(() => {
+    var t;
+    return ((t = a.value) == null ? void 0 : t[r]) ?? l;
+  }) : a;
 }
+const q = (r, l, a = !1) => {
+  const t = !!f(), e = t ? z() : void 0, n = t ? C : void 0;
+  if (!n) {
+    g(
+      "provideGlobalConfig",
+      "provideGlobalConfig() can only be used inside setup()."
+    );
+    return;
+  }
+  const o = i(() => {
+    const p = d(r);
+    return e != null && e.value ? G(e.value, p) : p;
+  });
+  return n(s, o), n(
+    x,
+    i(() => o.value.locale)
+  ), n(
+    y,
+    i(() => o.value.namespace)
+  ), n(
+    I,
+    i(() => o.value.zIndex)
+  ), n(b, {
+    size: i(() => o.value.size || "")
+  }), n(
+    K,
+    i(() => ({
+      emptyValues: o.value.emptyValues,
+      valueOnClear: o.value.valueOnClear
+    }))
+  ), (a || !m.value) && (m.value = o.value), o;
+}, G = (r, l) => {
+  const a = [.../* @__PURE__ */ new Set([...u(r), ...u(l)])], t = {};
+  for (const e of a)
+    t[e] = l[e] !== void 0 ? l[e] : r[e];
+  return t;
+};
 export {
-  I as useGlobalConfig
+  q as provideGlobalConfig,
+  z as useGlobalConfig
 };

package/dist/components/input-number/EpInputNumber.vue.d.ts

@@ -0,0 +1,51 @@
+import type { InputNumberProps } from './input-number';
+declare var __VLS_1: {}, __VLS_15: {}, __VLS_43: {}, __VLS_45: {};
+type __VLS_Slots = {} & {
+    'decrease-icon'?: (props: typeof __VLS_1) => any;
+} & {
+    'increase-icon'?: (props: typeof __VLS_15) => any;
+} & {
+    prefix?: (props: typeof __VLS_43) => any;
+} & {
+    suffix?: (props: typeof __VLS_45) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<InputNumberProps, {
+    /** @description get focus the input component */
+    focus: () => void;
+    /** @description remove focus the input component */
+    blur: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (val: number | undefined) => void;
+    change: (cur: number | undefined, prev: number | undefined) => void;
+    input: (val: number | null | undefined) => void;
+    focus: (e: FocusEvent) => void;
+    blur: (e: FocusEvent) => void;
+}, string, import("vue").PublicProps, Readonly<InputNumberProps> & Readonly<{
+    "onUpdate:modelValue"?: ((val: number | undefined) => any) | undefined;
+    onChange?: ((cur: number | undefined, prev: number | undefined) => any) | undefined;
+    onInput?: ((val: number | null | undefined) => any) | undefined;
+    onFocus?: ((e: FocusEvent) => any) | undefined;
+    onBlur?: ((e: FocusEvent) => any) | undefined;
+}>, {
+    disabled: boolean;
+    tabindex: string | number;
+    id: string;
+    valueOnClear: "min" | "max" | number | null;
+    readonly: boolean;
+    validateEvent: boolean;
+    inputmode: "search" | "none" | "text" | "email" | "tel" | "url" | "numeric" | "decimal";
+    max: number;
+    min: number;
+    controls: boolean;
+    step: number;
+    align: "left" | "right" | "center";
+    controlsPosition: "" | "right";
+    stepStrictly: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/input-number/EpInputNumber.vue.js

@@ -0,0 +1,310 @@
+import { defineComponent as Ne, ref as J, reactive as ve, computed as v, toRef as Q, watch as Y, onMounted as he, onUpdated as Ve, openBlock as p, createElementBlock as w, withModifiers as ye, normalizeClass as S, unref as l, toDisplayString as Ee, createCommentVNode as R, withDirectives as Z, withKeys as _, renderSlot as A, createVNode as $, withCtx as I, createBlock as F, createSlots as ge } from "vue";
+import { isNil as k } from "lodash-unified";
+import { EpInput as xe } from "../input/index.js";
+import { ElIcon as ee } from "../icon/index.js";
+import "../form/index.js";
+import "../../directives/click-outside/index.js";
+import { vRepeatClick as te } from "../../directives/repeat-click/index.js";
+import { isNumber as h, isUndefined as C } from "../../utils/types.js";
+import "@vueuse/core";
+import { debugWarn as z, throwError as we } from "../../utils/error.js";
+import { isString as Se, NOOP as re } from "@vue/shared";
+import { getEventCode as Ae, getEventKey as Ie } from "../../utils/dom/event.js";
+import { ArrowDown as Fe, Minus as ke, ArrowUp as Ce, Plus as De } from "@element-plus/icons-vue";
+import { EVENT_CODE as ne } from "../../constants/aria.js";
+import { UPDATE_MODEL_EVENT as V, INPUT_EVENT as K, CHANGE_EVENT as Le } from "../../constants/event.js";
+import "normalize-wheel-es";
+import { useNamespace as Me } from "../../hooks/use-namespace/index.js";
+import { useLocale as Pe } from "../../hooks/use-locale/index.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 { useFloatLabel as Te } from "../../hooks/use-float-label/index.js";
+import { inputNumberEmits as Be } from "./input-number.js";
+import { useFormItem as Oe } from "../form/src/hooks/use-form-item.js";
+import { useFormSize as Re, useFormDisabled as $e } from "../form/src/hooks/use-form-common-props.js";
+const ze = ["aria-label"], Ke = ["aria-label"], vt = /* @__PURE__ */ Ne({
+  name: "ElInputNumber",
+  __name: "EpInputNumber",
+  props: {
+    id: { default: void 0 },
+    step: { default: 1 },
+    stepStrictly: { type: Boolean, default: !1 },
+    max: { default: Number.MAX_SAFE_INTEGER },
+    min: { default: Number.MIN_SAFE_INTEGER },
+    modelValue: {},
+    readonly: { type: Boolean, default: !1 },
+    disabled: { type: Boolean, default: void 0 },
+    size: {},
+    controls: { type: Boolean, default: !0 },
+    controlsPosition: { default: "" },
+    valueOnClear: { default: null },
+    name: {},
+    placeholder: {},
+    precision: {},
+    validateEvent: { type: Boolean, default: !0 },
+    ariaLabel: {},
+    inputmode: { default: void 0 },
+    align: { default: "center" },
+    disabledScientific: { type: Boolean },
+    formatter: {},
+    parser: {},
+    tabindex: { default: 0 },
+    floatLabel: { type: Boolean }
+  },
+  emits: Be,
+  setup(u, { expose: ae, emit: le }) {
+    const r = u, s = le, { t: G } = Pe(), m = Me("input-number"), b = J(), i = ve({
+      currentValue: r.modelValue,
+      userInput: null
+    }), { formItem: c } = Oe(), U = v(
+      () => h(r.modelValue) && r.modelValue <= r.min
+    ), W = v(
+      () => h(r.modelValue) && r.modelValue >= r.max
+    ), ie = v(() => {
+      const e = H(r.step);
+      return C(r.precision) ? Math.max(H(r.modelValue), e) : (e > r.precision && z(
+        "InputNumber",
+        "precision should not be less than the decimal places of step"
+      ), r.precision);
+    }), D = v(() => r.controls && r.controlsPosition === "right"), X = Re(), N = $e(), L = J(!1), ue = v(() => !k(i.currentValue)), { floatLabelClass: oe } = Te({
+      floatLabel: Q(r, "floatLabel"),
+      isFocused: L,
+      hasValue: ue,
+      isDisabled: N,
+      isReadonly: Q(r, "readonly")
+    }), M = v(() => {
+      if (i.userInput !== null)
+        return i.userInput;
+      let e = i.currentValue;
+      if (k(e)) return "";
+      if (h(e)) {
+        if (Number.isNaN(e)) return "";
+        C(r.precision) || (e = e.toFixed(r.precision));
+      }
+      return e;
+    }), y = (e, t) => {
+      if (C(t) && (t = ie.value), t === 0) return Math.round(e);
+      let n = String(e);
+      const a = n.indexOf(".");
+      if (a === -1 || !n.replace(".", "").split("")[a + t]) return e;
+      const g = n.length;
+      return n.charAt(g - 1) === "5" && (n = `${n.slice(0, Math.max(0, g - 1))}6`), Number.parseFloat(Number(n).toFixed(t));
+    }, H = (e) => {
+      if (k(e)) return 0;
+      const t = e.toString(), n = t.indexOf(".");
+      let a = 0;
+      return n !== -1 && (a = t.length - n - 1), a;
+    }, j = (e, t = 1) => h(e) ? e >= Number.MAX_SAFE_INTEGER && t === 1 ? (z(
+      "InputNumber",
+      "The value has reached the maximum safe integer limit."
+    ), e) : e <= Number.MIN_SAFE_INTEGER && t === -1 ? (z(
+      "InputNumber",
+      "The value has reached the minimum safe integer limit."
+    ), e) : y(e + r.step * t) : i.currentValue, se = (e) => {
+      const t = Ae(e), n = Ie(e);
+      if (r.disabledScientific && ["e", "E"].includes(n)) {
+        e.preventDefault();
+        return;
+      }
+      switch (t) {
+        case ne.up: {
+          e.preventDefault(), P();
+          break;
+        }
+        case ne.down: {
+          e.preventDefault(), T();
+          break;
+        }
+      }
+    }, P = () => {
+      if (r.readonly || N.value || W.value) return;
+      const e = Number(M.value) || 0, t = j(e);
+      E(t), s(K, i.currentValue), O();
+    }, T = () => {
+      if (r.readonly || N.value || U.value) return;
+      const e = Number(M.value) || 0, t = j(e, -1);
+      E(t), s(K, i.currentValue), O();
+    }, B = (e, t) => {
+      const { max: n, min: a, step: d, precision: f, stepStrictly: g, valueOnClear: x } = r;
+      n < a && we("InputNumber", "min should not be greater than max.");
+      let o = e ? Number.parseFloat(String(e)) : Number(e);
+      if (k(e) || Number.isNaN(o))
+        return null;
+      if (e === "") {
+        if (x === null)
+          return null;
+        o = Se(x) ? { min: a, max: n }[x] : x;
+      }
+      return g && (o = y(
+        Math.round(y(o / d)) * d,
+        f
+      ), o !== e && t && s(V, o)), C(f) || (o = y(o, f)), (o > n || o < a) && (o = o > n ? n : a, t && s(V, o)), o;
+    }, E = (e, t = !0) => {
+      var d;
+      const n = i.currentValue, a = B(e);
+      if (!t) {
+        s(V, a);
+        return;
+      }
+      i.userInput = null, !(n === a && e) && (s(V, a), n !== a && s(Le, a, n), r.validateEvent && ((d = c == null ? void 0 : c.validate) == null || d.call(c, "change").catch(re)), i.currentValue = a);
+    }, me = (e) => {
+      i.userInput = e;
+      let t = e === "" ? null : Number.parseFloat(e);
+      Number.isNaN(t) && (t = null), s(K, t), E(t, !1);
+    }, ce = (e) => {
+      const t = e !== "" ? Number.parseFloat(e) : "";
+      (h(t) && !Number.isNaN(t) || r.formatter && Number.isNaN(t) || t === "") && E(t), O(), i.userInput = null;
+    }, q = () => {
+      var e, t;
+      (t = (e = b.value) == null ? void 0 : e.focus) == null || t.call(e);
+    }, de = () => {
+      var e, t;
+      (t = (e = b.value) == null ? void 0 : e.blur) == null || t.call(e);
+    }, fe = (e) => {
+      L.value = !0, s("focus", e);
+    }, pe = (e) => {
+      var t, n, a;
+      L.value = !1, i.userInput = null, i.currentValue === null && ((t = b.value) != null && t.input) && (b.value.input.value = ((n = r.formatter) == null ? void 0 : n.call(r, "")) ?? ""), s("blur", e), r.validateEvent && ((a = c == null ? void 0 : c.validate) == null || a.call(c, "blur").catch(re));
+    }, O = () => {
+      i.currentValue !== r.modelValue && (i.currentValue = r.modelValue);
+    }, be = (e) => {
+      document.activeElement === e.target && e.preventDefault();
+    };
+    return Y(
+      () => r.modelValue,
+      (e, t) => {
+        const n = B(e, !0);
+        i.userInput === null && n !== t && (i.currentValue = n);
+      },
+      { immediate: !0 }
+    ), Y(
+      () => r.precision,
+      () => {
+        i.currentValue = B(r.modelValue);
+      }
+    ), he(() => {
+      var d;
+      const { min: e, max: t, modelValue: n } = r, a = (d = b.value) == null ? void 0 : d.input;
+      if (a.setAttribute("role", "spinbutton"), Number.isFinite(t) ? a.setAttribute("aria-valuemax", String(t)) : a.removeAttribute("aria-valuemax"), Number.isFinite(e) ? a.setAttribute("aria-valuemin", String(e)) : a.removeAttribute("aria-valuemin"), a.setAttribute(
+        "aria-valuenow",
+        i.currentValue || i.currentValue === 0 ? String(i.currentValue) : ""
+      ), a.setAttribute("aria-disabled", String(N.value)), !h(n) && n != null) {
+        let f = Number(n);
+        Number.isNaN(f) && (f = null), s(V, f);
+      }
+      a.addEventListener("wheel", be, { passive: !1 });
+    }), Ve(() => {
+      var t;
+      const e = (t = b.value) == null ? void 0 : t.input;
+      e == null || e.setAttribute("aria-valuenow", `${i.currentValue ?? ""}`);
+    }), ae({
+      /** @description get focus the input component */
+      focus: q,
+      /** @description remove focus the input component */
+      blur: de
+    }), (e, t) => (p(), w("div", {
+      class: S([
+        l(m).b(),
+        l(m).m(l(X)),
+        l(m).is("disabled", l(N)),
+        l(m).is("without-controls", !u.controls),
+        l(m).is("controls-right", D.value),
+        l(m).is(u.align, !!u.align),
+        l(m).is("float-label", r.floatLabel)
+      ]),
+      onDragstart: t[0] || (t[0] = ye(() => {
+      }, ["prevent"]))
+    }, [
+      r.floatLabel ? (p(), w("span", {
+        key: 0,
+        class: S(["el-float-label", l(oe)]),
+        onClick: q
+      }, Ee(u.placeholder), 3)) : R("", !0),
+      u.controls ? Z((p(), w("span", {
+        key: 1,
+        role: "button",
+        "aria-label": l(G)("el.inputNumber.decrease"),
+        class: S([l(m).e("decrease"), l(m).is("disabled", U.value)]),
+        onKeydown: _(T, ["enter"])
+      }, [
+        A(e.$slots, "decrease-icon", {}, () => [
+          $(l(ee), null, {
+            default: I(() => [
+              D.value ? (p(), F(l(Fe), { key: 0 })) : (p(), F(l(ke), { key: 1 }))
+            ]),
+            _: 1
+          })
+        ])
+      ], 42, ze)), [
+        [l(te), T]
+      ]) : R("", !0),
+      u.controls ? Z((p(), w("span", {
+        key: 2,
+        role: "button",
+        "aria-label": l(G)("el.inputNumber.increase"),
+        class: S([l(m).e("increase"), l(m).is("disabled", W.value)]),
+        onKeydown: _(P, ["enter"])
+      }, [
+        A(e.$slots, "increase-icon", {}, () => [
+          $(l(ee), null, {
+            default: I(() => [
+              D.value ? (p(), F(l(Ce), { key: 0 })) : (p(), F(l(De), { key: 1 }))
+            ]),
+            _: 1
+          })
+        ])
+      ], 42, Ke)), [
+        [l(te), P]
+      ]) : R("", !0),
+      $(l(xe), {
+        id: u.id,
+        ref_key: "input",
+        ref: b,
+        type: u.formatter ? "text" : "number",
+        step: u.step,
+        "model-value": M.value,
+        placeholder: r.floatLabel ? void 0 : u.placeholder,
+        readonly: u.readonly,
+        disabled: l(N),
+        size: l(X),
+        max: u.max,
+        min: u.min,
+        name: u.name,
+        "aria-label": u.ariaLabel,
+        "validate-event": !1,
+        inputmode: u.inputmode,
+        formatter: u.formatter,
+        parser: u.parser,
+        tabindex: u.tabindex,
+        onKeydown: se,
+        onBlur: pe,
+        onFocus: fe,
+        onInput: me,
+        onChange: ce
+      }, ge({ _: 2 }, [
+        e.$slots.prefix ? {
+          name: "prefix",
+          fn: I(() => [
+            A(e.$slots, "prefix")
+          ]),
+          key: "0"
+        } : void 0,
+        e.$slots.suffix ? {
+          name: "suffix",
+          fn: I(() => [
+            A(e.$slots, "suffix")
+          ]),
+          key: "1"
+        } : void 0
+      ]), 1032, ["id", "type", "step", "model-value", "placeholder", "readonly", "disabled", "size", "max", "min", "name", "aria-label", "inputmode", "formatter", "parser", "tabindex"])
+    ], 34));
+  }
+});
+export {
+  vt as default
+};

package/dist/components/input-number/EpInputNumber2.vue.js

@@ -0,0 +1,4 @@
+import f from "./EpInputNumber.vue.js";
+export {
+  f as default
+};

package/dist/components/input-number/index.d.ts

@@ -1,4 +1,7 @@
 import type { Plugin } from 'vue';
-import { ElInputNumber } from 'element-plus';
-export declare const EpInputNumber: typeof ElInputNumber & Plugin;
+import _EpInputNumber from './EpInputNumber.vue';
+export declare const EpInputNumber: typeof _EpInputNumber & Plugin;
 export default EpInputNumber;
+export { inputNumberEmits, inputNumberProps } from './input-number';
+export type { InputNumberEmits, InputNumberProps, InputNumberPropsPublic, } from './input-number';
+export type { InputNumberInstance } from './instance';

package/dist/components/input-number/index.js

@@ -1,6 +1,11 @@
-import { ElInputNumber as t } from "element-plus";
-import { withInstall as p } from "../../utils/with-install.js";
-const n = Object.assign({}, t, { name: "EpInputNumber" }), u = p(n, "ep-input-number");
+import { withInstall as t } from "../../utils/with-install.js";
+import m from "./EpInputNumber.vue.js";
+import { inputNumberEmits as e } from "./input-number.js";
+const o = t(
+  m,
+  "ep-input-number"
+);
 export {
-  u as EpInputNumber
+  o as EpInputNumber,
+  e as inputNumberEmits
 };

package/dist/components/input-number/input-number.d.ts

@@ -0,0 +1,169 @@
+import type { ExtractPublicPropTypes, HTMLAttributes } from 'vue';
+import type { ComponentSize } from '@element-plus/constants';
+/**
+ * @description input-number component props
+ */
+export interface InputNumberProps {
+    /**
+     * @description same as `id` in native input
+     */
+    id?: string;
+    /**
+     * @description incremental step
+     */
+    step?: number;
+    /**
+     * @description whether input value can only be multiple of step
+     */
+    stepStrictly?: boolean;
+    /**
+     * @description the maximum allowed value
+     */
+    max?: number;
+    /**
+     * @description the minimum allowed value
+     */
+    min?: number;
+    /**
+     * @description binding value
+     */
+    modelValue?: number | null;
+    /**
+     * @description same as `readonly` in native input
+     */
+    readonly?: boolean;
+    /**
+     * @description whether the component is disabled
+     */
+    disabled?: boolean;
+    /**
+     * @description size of the component
+     */
+    size?: ComponentSize;
+    /**
+     * @description whether to enable the control buttons
+     */
+    controls?: boolean;
+    /**
+     * @description position of the control buttons
+     */
+    controlsPosition?: '' | 'right';
+    /**
+     * @description value should be set when input box is cleared
+     */
+    valueOnClear?: 'min' | 'max' | number | null;
+    /**
+     * @description same as `name` in native input
+     */
+    name?: string;
+    /**
+     * @description same as `placeholder` in native input
+     */
+    placeholder?: string;
+    /**
+     * @description precision of input value
+     */
+    precision?: number;
+    /**
+     * @description whether to trigger form validation
+     */
+    validateEvent?: boolean;
+    /**
+     * @description native aria-label attribute
+     */
+    ariaLabel?: string;
+    /**
+     * @description native input mode for virtual keyboards
+     */
+    inputmode?: HTMLAttributes['inputmode'];
+    /**
+     * @description alignment for the inner input text
+     */
+    align?: 'left' | 'right' | 'center';
+    /**
+     * @description whether to disable scientific notation input (e.g. 'e', 'E')
+     */
+    disabledScientific?: boolean;
+    /**
+     * @description specifies the format of the value presented in the input
+     */
+    formatter?: (value: string) => string;
+    /**
+     * @description specifies the value extracted from the formatted input
+     */
+    parser?: (value: string) => string;
+    /**
+     * @description same as `tabindex` in native input
+     */
+    tabindex?: string | number;
+    /**
+     * @description whether to enable the floating label (Material style)
+     */
+    floatLabel?: boolean;
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `InputNumberProps` instead.
+ */
+export declare const inputNumberProps: {
+    readonly floatLabel: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly inputmode: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => "search" | "none" | "text" | "email" | "tel" | "url" | "numeric" | "decimal") | (() => "search" | "none" | "text" | "email" | "tel" | "url" | "numeric" | "decimal" | undefined) | (((new (...args: any[]) => "search" | "none" | "text" | "email" | "tel" | "url" | "numeric" | "decimal") | (() => "search" | "none" | "text" | "email" | "tel" | "url" | "numeric" | "decimal" | undefined)) | null)[], unknown, unknown, undefined, boolean>;
+    readonly align: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => "left" | "right" | "center") | (() => "left" | "right" | "center") | (((new (...args: any[]) => "left" | "right" | "center") | (() => "left" | "right" | "center")) | null)[], unknown, unknown, "center", boolean>;
+    readonly disabledScientific: BooleanConstructor;
+    readonly formatter: {
+        readonly type: import("vue").PropType<Function>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly parser: {
+        readonly type: import("vue").PropType<Function>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly tabindex: import("@element-plus/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, 0, boolean>;
+    readonly ariaLabel: StringConstructor;
+    readonly id: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+    readonly step: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;
+    readonly stepStrictly: BooleanConstructor;
+    readonly max: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    readonly min: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    readonly modelValue: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<readonly [NumberConstructor, null], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly readonly: BooleanConstructor;
+    readonly disabled: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, 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 controls: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly controlsPosition: import("@element-plus/utils").EpPropFinalized<StringConstructor, "" | "right", unknown, "", boolean>;
+    readonly valueOnClear: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => number | "max" | "min") | (() => number | "max" | "min" | null) | (((new (...args: any[]) => number | "max" | "min") | (() => number | "max" | "min" | null)) | null)[], unknown, unknown, null, boolean>;
+    readonly name: StringConstructor;
+    readonly placeholder: StringConstructor;
+    readonly precision: {
+        readonly type: import("vue").PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly validateEvent: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `InputNumberProps` instead.
+ */
+export type InputNumberPropsPublic = ExtractPublicPropTypes<typeof inputNumberProps>;
+export declare const inputNumberEmits: {
+    change: (cur: number | undefined, prev: number | undefined) => boolean;
+    blur: (e: FocusEvent) => boolean;
+    focus: (e: FocusEvent) => boolean;
+    input: (val: number | null | undefined) => boolean;
+    "update:modelValue": (val: number | undefined) => boolean;
+};
+export type InputNumberEmits = typeof inputNumberEmits;