@ironsource/shared-ui 1.4.2-test.19 → 1.4.2-test.3

package/components/input/Input.vue.js

@@ -1,233 +1,7 @@
-import { defineComponent, ref, computed, onMounted, nextTick, openBlock, createElementBlock, normalizeClass, createVNode, unref, withCtx, createTextVNode, toDisplayString, createBlock, createCommentVNode, createElementVNode, renderSlot, mergeProps, withKeys, withModifiers } from 'vue';
-/* empty css                                                                     */import _export_sfc from '../../_virtual/plugin-vue_export-helper.vue.js';
-import Text from '../typography/Text.vue.js';
-import Icon from '../icon/Icon.vue.js';
-import _sfc_main$1 from '../tooltip/Tooltip.vue.js';
-/* empty css                                                                    *//* empty css                                                                */import IconButton from '../button/IconButton.vue.js';
-/* empty css                                                                      */import { useEditableContext } from '../table-cells/EditableContext.vue.js';
-import '@vueuse/core';
-/* empty css                                                                       *//* empty css                                                       */
-import "../../Input.vue_vue_type_style_index_0_scoped_true_lang.css";
-const _hoisted_1 = { class: "info-icon-wrapper" };
-const _hoisted_2 = {
-  key: 0,
-  class: "icon-container icon-before"
+import o from "./Input.vue2.js";
+import "./Input.vue3.js";
+import t from "../../_virtual/_plugin-vue_export-helper.js";
+const _ = /* @__PURE__ */ t(o, [["__scopeId", "data-v-b49b2b32"]]);
+export {
+  _ as default
 };
-const _hoisted_3 = ["value", "placeholder", "disabled", "type", "step", "onKeyup"];
-const _hoisted_4 = {
-  key: 1,
-  class: "icon-container icon-after"
-};
-const _hoisted_5 = { key: 2 };
-const _hoisted_6 = { key: 3 };
-const _hoisted_7 = {
-  key: 1,
-  class: "extra-text-container"
-};
-const __default__ = {
-  inheritAttrs: false
-};
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  ...__default__,
-  __name: "Input",
-  props: {
-    modelValue: { default: "" },
-    placeholder: { default: "" },
-    disabled: { type: Boolean, default: false },
-    viewOnly: { type: Boolean, default: false },
-    size: { default: "lg" },
-    label: { default: "" },
-    labelDirection: { default: "top" },
-    mandatory: { type: Boolean, default: false },
-    feedbackHelpText: { default: "" },
-    autoFocus: { type: Boolean, default: false },
-    feedbackErrorText: { default: "" },
-    type: { default: "text" },
-    hideNumberArrows: { type: Boolean, default: false },
-    step: { default: 1 },
-    hoverHelpText: { default: "" },
-    hoverHelpTextPlacement: { default: "top" }
-  },
-  emits: ["update:modelValue"],
-  setup(__props, { emit }) {
-    const props = __props;
-    const onConfirm = (e) => {
-      api.onClose?.();
-    };
-    const onEnter = () => {
-      if (api?.confirmable && !api?.error?.value) {
-        api.onClose?.();
-      }
-    };
-    const inputRef = ref(null);
-    const isFocused = ref(false);
-    const showLabelInside = computed(() => {
-      return props.label && props.labelDirection === "inside" && !isFocused.value;
-    });
-    const api = useEditableContext();
-    onMounted(async () => {
-      await nextTick();
-      if (!props.autoFocus && !api.focusable) {
-        return;
-      }
-      if (!inputRef.value) {
-        return;
-      }
-      inputRef.value.focus();
-    });
-    const labelText = computed(() => {
-      if (showLabelInside.value) {
-        let label = props.label;
-        if (props.mandatory) {
-          label += " *";
-        }
-        return label;
-      }
-      return props.placeholder;
-    });
-    const sizeClass = computed(() => {
-      return `input-size-${props.size}`;
-    });
-    const handleInput = (event) => {
-      api.onChange?.(event.target.value);
-      emit("update:modelValue", event.target.value);
-    };
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        class: normalizeClass({
-          "input-with-label-container": true,
-          "label-direction-left": __props.labelDirection === "left",
-          disabled: __props.disabled
-        })
-      }, [
-        __props.label && __props.labelDirection !== "inside" ? (openBlock(), createElementBlock("div", {
-          key: 0,
-          class: normalizeClass(["label-container", "direction-" + __props.labelDirection])
-        }, [
-          createVNode(unref(Text), { class: "label" }, {
-            default: withCtx(() => [
-              createTextVNode(toDisplayString(__props.label), 1)
-            ]),
-            _: 1
-          }),
-          __props.mandatory ? (openBlock(), createBlock(unref(Text), {
-            key: 0,
-            size: "lg",
-            class: "mandatory"
-          }, {
-            default: withCtx(() => [
-              createTextVNode("*")
-            ]),
-            _: 1
-          })) : createCommentVNode("", true),
-          __props.hoverHelpText ? (openBlock(), createBlock(unref(_sfc_main$1), {
-            key: 1,
-            triggers: ["hover"],
-            text: __props.hoverHelpText,
-            placement: __props.hoverHelpTextPlacement,
-            size: "xs",
-            strong: true
-          }, {
-            default: withCtx(() => [
-              createElementVNode("div", _hoisted_1, [
-                createVNode(unref(Icon), {
-                  class: "info-icon",
-                  name: "info",
-                  "font-size": "sm"
-                })
-              ])
-            ]),
-            _: 1
-          }, 8, ["text", "placement"])) : createCommentVNode("", true)
-        ], 2)) : createCommentVNode("", true),
-        createElementVNode("div", {
-          class: normalizeClass({
-            "input-container": true,
-            "label-inside": unref(showLabelInside),
-            error: unref(api).error?.value || __props.feedbackErrorText,
-            focused: isFocused.value
-          })
-        }, [
-          _ctx.$slots["iconBefore"] ? (openBlock(), createElementBlock("div", _hoisted_2, [
-            renderSlot(_ctx.$slots, "iconBefore", {}, void 0, true)
-          ])) : createCommentVNode("", true),
-          createElementVNode("input", mergeProps(_ctx.$attrs, {
-            ref_key: "inputRef",
-            ref: inputRef,
-            value: unref(api).value?.value ?? __props.modelValue,
-            placeholder: unref(labelText),
-            disabled: __props.disabled || __props.viewOnly,
-            type: __props.type,
-            class: ["input", {
-              [unref(sizeClass)]: true,
-              "view-only": __props.viewOnly,
-              "label-inside": unref(showLabelInside),
-              "hide-arrows": __props.hideNumberArrows,
-              "input-type": __props.type
-            }],
-            step: __props.step,
-            onInput: handleInput,
-            onFocus: _cache[0] || (_cache[0] = ($event) => isFocused.value = true),
-            onBlur: _cache[1] || (_cache[1] = ($event) => isFocused.value = false),
-            onKeyup: withKeys(withModifiers(onEnter, ["prevent"]), ["enter"])
-          }), null, 16, _hoisted_3),
-          _ctx.$slots["iconAfter"] ? (openBlock(), createElementBlock("div", _hoisted_4, [
-            renderSlot(_ctx.$slots, "iconAfter", {}, void 0, true)
-          ])) : createCommentVNode("", true),
-          unref(api)?.confirmable && !unref(api)?.error?.value ? (openBlock(), createElementBlock("div", _hoisted_5, [
-            createVNode(unref(IconButton), {
-              class: "confirm-icon",
-              theme: "secondary",
-              variant: "colorized",
-              onClick: withModifiers(onConfirm, ["stop", "prevent"])
-            }, {
-              default: withCtx(() => [
-                createVNode(unref(Icon), {
-                  name: "check-bold",
-                  "font-size": "sm"
-                })
-              ]),
-              _: 1
-            }, 8, ["onClick"])
-          ])) : createCommentVNode("", true),
-          unref(api)?.error?.value ? (openBlock(), createElementBlock("div", _hoisted_6, [
-            createVNode(unref(_sfc_main$1), {
-              text: unref(api)?.error?.value
-            }, {
-              default: withCtx(() => [
-                createVNode(unref(IconButton), {
-                  class: "error-icon",
-                  theme: "secondary",
-                  variant: "colorized"
-                }, {
-                  default: withCtx(() => [
-                    createVNode(unref(Icon), {
-                      name: "error",
-                      "font-size": "sm"
-                    })
-                  ]),
-                  _: 1
-                })
-              ]),
-              _: 1
-            }, 8, ["text"])
-          ])) : createCommentVNode("", true)
-        ], 2),
-        __props.feedbackErrorText || __props.feedbackHelpText ? (openBlock(), createElementBlock("div", _hoisted_7, [
-          createVNode(unref(Text), {
-            class: normalizeClass(__props.feedbackErrorText ? "error" : "help"),
-            size: "caption"
-          }, {
-            default: withCtx(() => [
-              createTextVNode(toDisplayString(__props.feedbackErrorText || __props.feedbackHelpText), 1)
-            ]),
-            _: 1
-          }, 8, ["class"])
-        ])) : createCommentVNode("", true)
-      ], 2);
-    };
-  }
-});
-var Input = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-3e4dac7b"]]);
-
-export { Input as default };

package/components/input/Input.vue2.js

@@ -0,0 +1,201 @@
+import { defineComponent as A, ref as x, computed as b, onMounted as F, nextTick as K, openBlock as a, createElementBlock as s, normalizeClass as f, createVNode as r, unref as t, withCtx as d, createTextVNode as y, toDisplayString as T, createBlock as w, createCommentVNode as n, createElementVNode as p, renderSlot as z, mergeProps as O, withKeys as P, withModifiers as B } from "vue";
+import "../typography/Heading.vue2.js";
+import h from "../typography/Text.vue.js";
+import k from "../icon/Icon.vue.js";
+import C from "../tooltip/Tooltip.vue.js";
+import "../tooltip/Tooltip.vue2.js";
+import "../button/ButtonBase.vue.js";
+import "../button/Button.vue3.js";
+import g from "../button/IconButton.vue.js";
+import "../button/ScrollButton.vue3.js";
+import { useEditableContext as M } from "../table-cells/EditableContext.js";
+import "@vueuse/core";
+import "../table-cells/Editable.vue3.js";
+const R = { class: "info-icon-wrapper" }, S = {
+  key: 0,
+  class: "icon-container icon-before"
+}, L = ["value", "placeholder", "disabled", "type", "step", "onKeyup"], j = {
+  key: 1,
+  class: "icon-container icon-after"
+}, q = { key: 2 }, G = { key: 3 }, J = {
+  key: 1,
+  class: "extra-text-container"
+}, Q = {
+  inheritAttrs: !1
+}, ie = /* @__PURE__ */ A({
+  ...Q,
+  __name: "Input",
+  props: {
+    modelValue: { default: "" },
+    placeholder: { default: "" },
+    disabled: { type: Boolean, default: !1 },
+    viewOnly: { type: Boolean, default: !1 },
+    size: { default: "lg" },
+    label: { default: "" },
+    labelDirection: { default: "top" },
+    mandatory: { type: Boolean, default: !1 },
+    feedbackHelpText: { default: "" },
+    autoFocus: { type: Boolean, default: !1 },
+    feedbackErrorText: { default: "" },
+    type: { default: "text" },
+    hideNumberArrows: { type: Boolean, default: !1 },
+    step: { default: 1 },
+    hoverHelpText: { default: "" },
+    hoverHelpTextPlacement: { default: "top" }
+  },
+  emits: ["update:modelValue"],
+  setup(e, { emit: E }) {
+    const i = e, $ = (o) => {
+      l.onClose?.();
+    }, H = () => {
+      l?.confirmable && !l?.error?.value && l.onClose?.();
+    }, m = x(null), u = x(!1), v = b(() => i.label && i.labelDirection === "inside" && !u.value), l = M();
+    F(async () => {
+      await K(), !(!i.autoFocus && !l.focusable) && m.value && m.value.focus();
+    });
+    const V = b(() => {
+      if (v.value) {
+        let o = i.label;
+        return i.mandatory && (o += " *"), o;
+      }
+      return i.placeholder;
+    }), D = b(() => `input-size-${i.size}`), I = (o) => {
+      l.onChange?.(o.target.value), E("update:modelValue", o.target.value);
+    };
+    return (o, c) => (a(), s("div", {
+      class: f({
+        "input-with-label-container": !0,
+        "label-direction-left": e.labelDirection === "left",
+        disabled: e.disabled
+      })
+    }, [
+      e.label && e.labelDirection !== "inside" ? (a(), s("div", {
+        key: 0,
+        class: f(["label-container", "direction-" + e.labelDirection])
+      }, [
+        r(t(h), { class: "label" }, {
+          default: d(() => [
+            y(T(e.label), 1)
+          ]),
+          _: 1
+        }),
+        e.mandatory ? (a(), w(t(h), {
+          key: 0,
+          size: "lg",
+          class: "mandatory"
+        }, {
+          default: d(() => [
+            y("*")
+          ]),
+          _: 1
+        })) : n("", !0),
+        e.hoverHelpText ? (a(), w(t(C), {
+          key: 1,
+          triggers: ["hover"],
+          text: e.hoverHelpText,
+          placement: e.hoverHelpTextPlacement,
+          size: "xs",
+          strong: !0
+        }, {
+          default: d(() => [
+            p("div", R, [
+              r(t(k), {
+                class: "info-icon",
+                name: "info",
+                "font-size": "sm"
+              })
+            ])
+          ]),
+          _: 1
+        }, 8, ["text", "placement"])) : n("", !0)
+      ], 2)) : n("", !0),
+      p("div", {
+        class: f({
+          "input-container": !0,
+          "label-inside": t(v),
+          error: t(l).error?.value || e.feedbackErrorText,
+          focused: u.value
+        })
+      }, [
+        o.$slots.iconBefore ? (a(), s("div", S, [
+          z(o.$slots, "iconBefore", {}, void 0, !0)
+        ])) : n("", !0),
+        p("input", O(o.$attrs, {
+          ref_key: "inputRef",
+          ref: m,
+          value: t(l).value?.value ?? e.modelValue,
+          placeholder: t(V),
+          disabled: e.disabled || e.viewOnly,
+          type: e.type,
+          class: ["input", {
+            [t(D)]: !0,
+            "view-only": e.viewOnly,
+            "label-inside": t(v),
+            "hide-arrows": e.hideNumberArrows,
+            "input-type": e.type
+          }],
+          step: e.step,
+          onInput: I,
+          onFocus: c[0] || (c[0] = (N) => u.value = !0),
+          onBlur: c[1] || (c[1] = (N) => u.value = !1),
+          onKeyup: P(B(H, ["prevent"]), ["enter"])
+        }), null, 16, L),
+        o.$slots.iconAfter ? (a(), s("div", j, [
+          z(o.$slots, "iconAfter", {}, void 0, !0)
+        ])) : n("", !0),
+        t(l)?.confirmable && !t(l)?.error?.value ? (a(), s("div", q, [
+          r(t(g), {
+            class: "confirm-icon",
+            theme: "secondary",
+            variant: "colorized",
+            onClick: B($, ["stop", "prevent"])
+          }, {
+            default: d(() => [
+              r(t(k), {
+                name: "check-bold",
+                "font-size": "sm"
+              })
+            ]),
+            _: 1
+          }, 8, ["onClick"])
+        ])) : n("", !0),
+        t(l)?.error?.value ? (a(), s("div", G, [
+          r(t(C), {
+            text: t(l)?.error?.value
+          }, {
+            default: d(() => [
+              r(t(g), {
+                class: "error-icon",
+                theme: "secondary",
+                variant: "colorized"
+              }, {
+                default: d(() => [
+                  r(t(k), {
+                    name: "error",
+                    "font-size": "sm"
+                  })
+                ]),
+                _: 1
+              })
+            ]),
+            _: 1
+          }, 8, ["text"])
+        ])) : n("", !0)
+      ], 2),
+      e.feedbackErrorText || e.feedbackHelpText ? (a(), s("div", J, [
+        r(t(h), {
+          class: f(e.feedbackErrorText ? "error" : "help"),
+          size: "caption"
+        }, {
+          default: d(() => [
+            y(T(e.feedbackErrorText || e.feedbackHelpText), 1)
+          ]),
+          _: 1
+        }, 8, ["class"])
+      ])) : n("", !0)
+    ], 2));
+  }
+});
+export {
+  ie as default
+};

package/components/input/Input.vue3.js

@@ -0,0 +1,4 @@
+const _ = "";
+export {
+  _ as default
+};

package/components/input/PasswordInput.vue.d.ts

@@ -3,18 +3,231 @@ import { ExtractComponentProps } from '../../utils/extract-props';
 export type PasswordPropsType = Omit<ExtractComponentProps<typeof Input>, 'type' | 'hideNumberArrows' | 'step'>;
 export interface PasswordProps extends PasswordPropsType {
 }
-declare const _default: import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<PasswordProps>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+declare const _default: import("vue").DefineComponent<{
+    size: {
+        type: import("vue").PropType<"sm" | "lg">;
+    };
+    label: {
+        type: import("vue").PropType<string>;
+    };
+    style: {
+        type: import("vue").PropType<unknown>;
+    };
+    class: {
+        type: import("vue").PropType<unknown>;
+    };
+    placeholder: {
+        type: import("vue").PropType<string>;
+    };
+    key: {
+        type: import("vue").PropType<string | number | symbol>;
+    };
+    ref: {
+        type: import("vue").PropType<import("vue").VNodeRef>;
+    };
+    ref_for: {
+        type: import("vue").PropType<boolean>;
+    };
+    ref_key: {
+        type: import("vue").PropType<string>;
+    };
+    onVnodeBeforeMount: {
+        type: import("vue").PropType<((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void)[]>;
+    };
+    onVnodeMounted: {
+        type: import("vue").PropType<((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void)[]>;
+    };
+    onVnodeBeforeUpdate: {
+        type: import("vue").PropType<((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void)[]>;
+    };
+    onVnodeUpdated: {
+        type: import("vue").PropType<((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void)[]>;
+    };
+    onVnodeBeforeUnmount: {
+        type: import("vue").PropType<((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void)[]>;
+    };
+    onVnodeUnmounted: {
+        type: import("vue").PropType<((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void)[]>;
+    };
+    disabled: {
+        type: import("vue").PropType<boolean>;
+    };
+    modelValue: {
+        type: import("vue").PropType<string | number>;
+    };
+    "onUpdate:modelValue": {
+        type: import("vue").PropType<(value: string | number) => any>;
+    };
+    mandatory: {
+        type: import("vue").PropType<boolean>;
+    };
+    autoFocus: {
+        type: import("vue").PropType<boolean>;
+    };
+    viewOnly: {
+        type: import("vue").PropType<boolean>;
+    };
+    labelDirection: {
+        type: import("vue").PropType<"top" | "left" | "inside">;
+    };
+    feedbackHelpText: {
+        type: import("vue").PropType<string>;
+    };
+    feedbackErrorText: {
+        type: import("vue").PropType<string>;
+    };
+    hoverHelpText: {
+        type: import("vue").PropType<string>;
+    };
+    hoverHelpTextPlacement: {
+        type: import("vue").PropType<"auto" | "auto-start" | "auto-end" | "top" | "top-start" | "top-end" | "right" | "right-start" | "right-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end">;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (value: string | number) => void;
-}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<PasswordProps>>> & {
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    size: {
+        type: import("vue").PropType<"sm" | "lg">;
+    };
+    label: {
+        type: import("vue").PropType<string>;
+    };
+    style: {
+        type: import("vue").PropType<unknown>;
+    };
+    class: {
+        type: import("vue").PropType<unknown>;
+    };
+    placeholder: {
+        type: import("vue").PropType<string>;
+    };
+    key: {
+        type: import("vue").PropType<string | number | symbol>;
+    };
+    ref: {
+        type: import("vue").PropType<import("vue").VNodeRef>;
+    };
+    ref_for: {
+        type: import("vue").PropType<boolean>;
+    };
+    ref_key: {
+        type: import("vue").PropType<string>;
+    };
+    onVnodeBeforeMount: {
+        type: import("vue").PropType<((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void)[]>;
+    };
+    onVnodeMounted: {
+        type: import("vue").PropType<((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void)[]>;
+    };
+    onVnodeBeforeUpdate: {
+        type: import("vue").PropType<((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void)[]>;
+    };
+    onVnodeUpdated: {
+        type: import("vue").PropType<((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void)[]>;
+    };
+    onVnodeBeforeUnmount: {
+        type: import("vue").PropType<((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void)[]>;
+    };
+    onVnodeUnmounted: {
+        type: import("vue").PropType<((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>) => void)[]>;
+    };
+    disabled: {
+        type: import("vue").PropType<boolean>;
+    };
+    modelValue: {
+        type: import("vue").PropType<string | number>;
+    };
+    "onUpdate:modelValue": {
+        type: import("vue").PropType<(value: string | number) => any>;
+    };
+    mandatory: {
+        type: import("vue").PropType<boolean>;
+    };
+    autoFocus: {
+        type: import("vue").PropType<boolean>;
+    };
+    viewOnly: {
+        type: import("vue").PropType<boolean>;
+    };
+    labelDirection: {
+        type: import("vue").PropType<"top" | "left" | "inside">;
+    };
+    feedbackHelpText: {
+        type: import("vue").PropType<string>;
+    };
+    feedbackErrorText: {
+        type: import("vue").PropType<string>;
+    };
+    hoverHelpText: {
+        type: import("vue").PropType<string>;
+    };
+    hoverHelpTextPlacement: {
+        type: import("vue").PropType<"auto" | "auto-start" | "auto-end" | "top" | "top-start" | "top-end" | "right" | "right-start" | "right-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end">;
+    };
+}>> & {
     "onUpdate:modelValue"?: (value: string | number) => any;
 }, {}>;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToRuntimeProps<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};