vlite3 0.1.0 → 0.1.2

package/components/Heatmap/Heatmap.vue2.js

@@ -0,0 +1,326 @@
+import { defineComponent as te, ref as p, computed as c, onMounted as ae, nextTick as U, onUnmounted as le, watch as oe, openBlock as d, createElementBlock as m, normalizeClass as z, createElementVNode as b, normalizeStyle as k, Fragment as E, renderList as W, createBlock as ne, withCtx as se, toDisplayString as j, createCommentVNode as I } from "vue";
+import ie from "../Tooltip.vue.js";
+import { debounce as re } from "../../utils/functions.js";
+const ue = ["onClick", "onMouseenter"], ce = {
+  key: 0,
+  class: "heatmap-cell-label"
+}, fe = ["onClick", "onMouseenter"], de = {
+  key: 0,
+  class: "heatmap-cell-label"
+}, ve = {
+  key: 0,
+  class: "heatmap-legend"
+}, me = { class: "heatmap-legend-colors" }, ge = ["title"], ye = /* @__PURE__ */ te({
+  __name: "Heatmap",
+  props: {
+    data: {},
+    layout: { default: "grid" },
+    colorConfig: {},
+    minValue: { default: void 0 },
+    maxValue: { default: void 0 },
+    gridConfig: {},
+    sequentialConfig: {},
+    tooltipConfig: {},
+    showLegend: { type: Boolean, default: !0 },
+    showLabels: { type: Boolean, default: !1 },
+    interactive: { type: Boolean, default: !0 },
+    responsive: { type: Boolean, default: !0 },
+    minCellSize: { default: 8 },
+    maxCellSize: { default: 20 },
+    class: { default: "" },
+    cellClass: { default: "" },
+    emptyCellClass: { default: "" }
+  },
+  emits: ["cell-click", "cell-hover"],
+  setup(r, { emit: G }) {
+    const l = r, S = G, g = p(null), J = p(null), K = p(null), C = p(null), h = p(0), M = p(0), y = p(null), q = {
+      github: ["#ebedf0", "#9be9a8", "#40c463", "#30a14e", "#216e39"],
+      green: ["#f0f9f4", "#a7f3d0", "#34d399", "#10b981", "#059669"],
+      blue: ["#eff6ff", "#bfdbfe", "#60a5fa", "#3b82f6", "#2563eb"],
+      red: ["#fef2f2", "#fecaca", "#f87171", "#ef4444", "#dc2626"],
+      purple: ["#faf5ff", "#e9d5ff", "#c084fc", "#a855f7", "#9333ea"],
+      orange: ["#fff7ed", "#fed7aa", "#fb923c", "#f97316", "#ea580c"],
+      grayscale: ["#f9fafb", "#e5e7eb", "#9ca3af", "#6b7280", "#374151"],
+      custom: []
+    }, P = c(() => {
+      const t = l.colorConfig || {}, a = t.scheme || "github";
+      return a === "custom" && t.colors ? t.colors : t.minColor && t.maxColor ? [t.minColor, t.maxColor] : q[a] || q.github;
+    }), A = c(() => l.colorConfig?.emptyColor || "#ebedf0"), $ = c(() => l.minValue !== void 0 ? l.minValue : l.data.length === 0 ? 0 : Math.min(...l.data.map((t) => t.value))), Q = c(() => l.maxValue !== void 0 ? l.maxValue : l.data.length === 0 ? 1 : Math.max(...l.data.map((t) => t.value))), V = c(() => Q.value - $.value || 1), R = (t) => V.value === 0 ? 0 : (t - $.value) / V.value, L = (t) => {
+      if (t === 0) return A.value;
+      const a = P.value;
+      if (a.length === 0) return A.value;
+      if (a.length === 1) return a[0];
+      if (a.length === 2) {
+        const n = parseInt(a[0].slice(1, 3), 16), o = parseInt(a[0].slice(3, 5), 16), s = parseInt(a[0].slice(5, 7), 16), i = parseInt(a[1].slice(1, 3), 16), v = parseInt(a[1].slice(3, 5), 16), u = parseInt(a[1].slice(5, 7), 16), f = Math.round(n + (i - n) * t), x = Math.round(o + (v - o) * t), N = Math.round(s + (u - s) * t);
+        return `rgb(${f}, ${x}, ${N})`;
+      }
+      const e = Math.min(Math.floor(t * (a.length - 1)), a.length - 1);
+      return a[e];
+    }, X = c(() => {
+      const t = /* @__PURE__ */ new Map();
+      l.data.forEach((e) => {
+        const n = `${e.x},${e.y}`, o = t.get(n);
+        (!o || e.value > o.value) && t.set(n, e);
+      });
+      const a = [];
+      if (l.layout === "grid") {
+        const e = l.gridConfig || {}, n = e.rows || 7, o = e.cols || Math.ceil(l.data.length / n);
+        for (let s = 0; s < n; s++)
+          for (let i = 0; i < o; i++) {
+            const v = `${i},${s}`, u = t.get(v), f = u?.value || 0, x = R(f);
+            a.push({
+              x: i,
+              y: s,
+              value: f,
+              normalizedValue: x,
+              displayValue: u?.displayValue || f,
+              tooltip: l.tooltipConfig?.formatter ? l.tooltipConfig.formatter(
+                {
+                  x: i,
+                  y: s,
+                  value: f,
+                  normalizedValue: x
+                },
+                u || { x: i, y: s, value: f }
+              ) : u?.tooltip || `${f} at (${i}, ${s})`,
+              ...u
+            });
+          }
+      } else if (l.layout === "sequential") {
+        const n = (l.sequentialConfig || {}).itemsPerRow || 7;
+        l.data.forEach((o, s) => {
+          const i = s % n, v = Math.floor(s / n), u = R(o.value);
+          a.push({
+            x: i,
+            y: v,
+            value: o.value,
+            normalizedValue: u,
+            displayValue: o.displayValue || o.value,
+            tooltip: l.tooltipConfig?.formatter ? l.tooltipConfig.formatter(
+              {
+                x: i,
+                y: v,
+                value: o.value,
+                normalizedValue: u
+              },
+              o
+            ) : o.tooltip || `${o.value}`,
+            ...o
+          });
+        });
+      } else
+        l.data.forEach((e) => {
+          const n = R(e.value);
+          a.push({
+            x: e.x,
+            y: e.y,
+            value: e.value,
+            normalizedValue: n,
+            displayValue: e.displayValue || e.value,
+            tooltip: l.tooltipConfig?.formatter ? l.tooltipConfig.formatter(
+              {
+                x: e.x,
+                y: e.y,
+                value: e.value,
+                normalizedValue: n
+              },
+              e
+            ) : e.tooltip || `${e.value}`,
+            ...e
+          });
+        });
+      return a;
+    }), B = c(() => X.value), O = (t, a, e, n, o) => {
+      if (t === 0 || a === 0 || e === 0 || n === 0)
+        return l.minCellSize;
+      const s = 32, i = Math.max(0, t - s), v = Math.max(0, a - s);
+      if (i <= 0 || v <= 0)
+        return l.minCellSize;
+      const u = (i - (e - 1) * o) / e, f = (v - (n - 1) * o) / n, x = Math.min(u, f);
+      return Math.max(
+        l.minCellSize,
+        Math.min(l.maxCellSize, Math.floor(x))
+      );
+    }, Y = c(() => {
+      const t = l.gridConfig || {}, a = t.rows || 7, e = t.cols || Math.ceil(B.value.length / a);
+      let n = t.cellSize;
+      const o = t.gap || 3;
+      return l.responsive && !n && h.value > 0 ? n = O(
+        h.value,
+        M.value,
+        e,
+        a,
+        o
+      ) : n || (n = 12), {
+        rows: a,
+        cols: e,
+        cellSize: n,
+        gap: o
+      };
+    }), Z = c(() => {
+      const t = l.sequentialConfig || {}, a = t.itemsPerRow || 7, e = B.value.length, n = Math.ceil(e / a);
+      let o = t.cellSize;
+      const s = t.gap || 3;
+      return l.responsive && !o && h.value > 0 ? o = O(
+        h.value,
+        M.value,
+        a,
+        n,
+        s
+      ) : o || (o = 12), {
+        itemsPerRow: a,
+        cellSize: o,
+        gap: s,
+        rows: n
+      };
+    }), _ = c(() => {
+      if (l.layout === "grid") {
+        const t = Y.value;
+        return {
+          display: "grid",
+          gridTemplateColumns: `repeat(${t.cols}, ${t.cellSize}px)`,
+          gap: `${t.gap}px`,
+          gridAutoRows: `${t.cellSize}px`
+        };
+      } else if (l.layout === "sequential") {
+        const t = Z.value;
+        return {
+          display: "grid",
+          gridTemplateColumns: `repeat(${t.itemsPerRow}, ${t.cellSize}px)`,
+          gap: `${t.gap}px`,
+          gridAutoRows: `${t.cellSize}px`
+        };
+      } else
+        return {
+          display: "grid",
+          gridAutoColumns: "auto",
+          gap: "4px"
+        };
+    }), T = c(() => {
+      if (!l.showLegend) return [];
+      const t = P.value, a = Math.min(t.length, 5), e = [];
+      for (let n = 0; n < a; n++) {
+        const o = n / (a - 1), s = $.value + o * V.value;
+        e.push({
+          value: Math.round(s * 100) / 100,
+          color: L(o),
+          label: n === 0 ? "Less" : n === a - 1 ? "More" : void 0
+        });
+      }
+      return e;
+    }), D = (t, a) => {
+      l.interactive && S("cell-click", t, a);
+    }, F = (t, a) => {
+      l.interactive && (C.value = t, S("cell-hover", t, a));
+    }, H = () => {
+      l.interactive && (C.value = null, S("cell-hover", null, null));
+    }, w = () => {
+      if (g.value) {
+        const t = g.value.getBoundingClientRect();
+        h.value = Math.max(0, t.width), M.value = Math.max(0, t.height);
+      }
+    }, ee = re((t) => {
+      const a = t[0];
+      a && l.responsive && (h.value = Math.max(0, a.contentRect.width), M.value = Math.max(0, a.contentRect.height));
+    }, 100);
+    return ae(() => {
+      U(() => {
+        w(), g.value && (y.value = new ResizeObserver(ee), y.value.observe(g.value)), window.addEventListener("resize", w);
+      });
+    }), le(() => {
+      y.value && g.value && (y.value.unobserve(g.value), y.value.disconnect(), y.value = null), window.removeEventListener("resize", w);
+    }), oe(
+      () => [h.value, M.value, l.responsive, l.data.length],
+      () => {
+        l.responsive && U(() => {
+          w();
+        });
+      }
+    ), (t, a) => (d(), m("div", {
+      ref_key: "containerRef",
+      ref: g,
+      class: z(["heatmap-container", l.class])
+    }, [
+      b("div", {
+        ref_key: "wrapperRef",
+        ref: J,
+        class: "heatmap-wrapper"
+      }, [
+        b("div", {
+          ref_key: "gridRef",
+          ref: K,
+          class: z(["heatmap-grid", l.layout]),
+          style: k(_.value)
+        }, [
+          (d(!0), m(E, null, W(B.value, (e, n) => (d(), m(E, {
+            key: `${e.x}-${e.y}-${n}`
+          }, [
+            r.tooltipConfig?.enabled !== !1 && e.tooltip ? (d(), ne(ie, {
+              key: 0,
+              content: e.tooltip,
+              placement: r.tooltipConfig?.position || "top",
+              triggerClass: "w-full"
+            }, {
+              default: se(() => [
+                b("div", {
+                  class: z([
+                    "heatmap-cell",
+                    {
+                      "heatmap-cell-empty": e.value === 0,
+                      "heatmap-cell-hovered": C.value?.x === e.x && C.value?.y === e.y,
+                      "heatmap-cell-interactive": r.interactive
+                    },
+                    e.value === 0 ? r.emptyCellClass : r.cellClass
+                  ]),
+                  style: k({
+                    backgroundColor: L(e.normalizedValue)
+                  }),
+                  onClick: (o) => D(e, o),
+                  onMouseenter: (o) => F(e, o),
+                  onMouseleave: H
+                }, [
+                  r.showLabels && e.displayValue !== void 0 ? (d(), m("span", ce, j(e.displayValue), 1)) : I("", !0)
+                ], 46, ue)
+              ]),
+              _: 2
+            }, 1032, ["content", "placement"])) : (d(), m("div", {
+              key: 1,
+              class: z([
+                "heatmap-cell",
+                {
+                  "heatmap-cell-empty": e.value === 0,
+                  "heatmap-cell-hovered": C.value?.x === e.x && C.value?.y === e.y,
+                  "heatmap-cell-interactive": r.interactive
+                },
+                e.value === 0 ? r.emptyCellClass : r.cellClass
+              ]),
+              style: k({
+                backgroundColor: L(e.normalizedValue)
+              }),
+              onClick: (o) => D(e, o),
+              onMouseenter: (o) => F(e, o),
+              onMouseleave: H
+            }, [
+              r.showLabels && e.displayValue !== void 0 ? (d(), m("span", de, j(e.displayValue), 1)) : I("", !0)
+            ], 46, fe))
+          ], 64))), 128))
+        ], 6)
+      ], 512),
+      r.showLegend && T.value.length > 0 ? (d(), m("div", ve, [
+        a[0] || (a[0] = b("span", { class: "heatmap-legend-label" }, "Less", -1)),
+        b("div", me, [
+          (d(!0), m(E, null, W(T.value, (e, n) => (d(), m("div", {
+            key: n,
+            class: "heatmap-legend-item",
+            style: k({ backgroundColor: e.color }),
+            title: `${e.value}`
+          }, null, 12, ge))), 128))
+        ]),
+        a[1] || (a[1] = b("span", { class: "heatmap-legend-label" }, "More", -1))
+      ])) : I("", !0)
+    ], 2));
+  }
+});
+export {
+  ye as default
+};

package/components/Heatmap/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Heatmap } from './Heatmap.vue';
+export * from './types';

package/components/Heatmap/types.d.ts

@@ -0,0 +1,66 @@
+export interface HeatmapDataPoint {
+    x: number;
+    y: number;
+    value: number;
+    [key: string]: any;
+}
+export interface HeatmapCell {
+    x: number;
+    y: number;
+    value: number;
+    normalizedValue: number;
+    displayValue?: string | number;
+    tooltip?: string;
+    [key: string]: any;
+}
+export type HeatmapColorScheme = 'github' | 'green' | 'blue' | 'red' | 'purple' | 'orange' | 'grayscale' | 'custom';
+export interface HeatmapColorConfig {
+    scheme?: HeatmapColorScheme;
+    colors?: string[];
+    minColor?: string;
+    maxColor?: string;
+    emptyColor?: string;
+}
+export type HeatmapLayout = 'grid' | 'sequential' | 'custom';
+export interface HeatmapGridConfig {
+    rows?: number;
+    cols?: number;
+    cellSize?: number;
+    gap?: number;
+}
+export interface HeatmapSequentialConfig {
+    itemsPerRow?: number;
+    cellSize?: number;
+    gap?: number;
+    startDate?: Date;
+    endDate?: Date;
+}
+export interface HeatmapTooltipConfig {
+    enabled?: boolean;
+    formatter?: (cell: HeatmapCell, dataPoint: HeatmapDataPoint) => string;
+    position?: 'top' | 'bottom' | 'left' | 'right' | 'auto';
+}
+export interface HeatmapProps {
+    data: HeatmapDataPoint[];
+    layout?: HeatmapLayout;
+    colorConfig?: HeatmapColorConfig;
+    minValue?: number;
+    maxValue?: number;
+    gridConfig?: HeatmapGridConfig;
+    sequentialConfig?: HeatmapSequentialConfig;
+    tooltipConfig?: HeatmapTooltipConfig;
+    showLegend?: boolean;
+    showLabels?: boolean;
+    interactive?: boolean;
+    responsive?: boolean;
+    minCellSize?: number;
+    maxCellSize?: number;
+    class?: string;
+    cellClass?: string;
+    emptyCellClass?: string;
+}
+export interface HeatmapLegendItem {
+    value: number;
+    color: string;
+    label?: string;
+}

package/components/Icon.vue.d.ts

@@ -0,0 +1,7 @@
+type __VLS_Props = {
+    icon?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    icon: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/components/Icon.vue.js

@@ -0,0 +1,25 @@
+import { defineComponent as c, computed as a, openBlock as i, createElementBlock as l, mergeProps as s, createBlock as u, unref as f } from "vue";
+import { Icon as m } from "@iconify/vue";
+const p = ["src"], h = /* @__PURE__ */ c({
+  inheritAttrs: !1,
+  __name: "Icon",
+  props: {
+    icon: { default: "" }
+  },
+  setup(e) {
+    const t = e, r = a(() => t.icon ? t.icon.startsWith("http://") || t.icon.startsWith("https://") || t.icon.startsWith("data:image/") ? !0 : [".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp", ".ico", ".avif"].some((o) => t.icon.toLowerCase().endsWith(o)) : !1);
+    return (n, o) => e.icon && r.value ? (i(), l("img", s({
+      key: 0,
+      src: e.icon
+    }, n.$attrs, {
+      alt: "icon",
+      class: "rounded-full scale-105"
+    }), null, 16, p)) : (i(), u(f(m), s({
+      key: 1,
+      icon: e.icon
+    }, n.$attrs), null, 16, ["icon"]));
+  }
+});
+export {
+  h as default
+};

package/components/Icon.vue2.js

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

package/components/IconPicker.vue.d.ts

@@ -0,0 +1,38 @@
+import { ButtonProps } from '../types';
+import { TooltTipPlacement } from 'v-tooltip-lite/types';
+interface Props {
+    btnProps?: ButtonProps;
+    value?: string;
+    position?: TooltTipPlacement;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        'menu-top'?(_: {
+            close: () => void;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    onSelect: (value: string, svg: string) => any;
+    onClose: () => any;
+    onTrigger: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onOnSelect?: (value: string, svg: string) => any;
+    onOnClose?: () => any;
+    onOnTrigger?: () => any;
+}>, {
+    value: string;
+    position: TooltTipPlacement;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/components/IconPicker.vue.js

@@ -0,0 +1,124 @@
+import { defineComponent as p, ref as f, openBlock as b, createBlock as g, unref as n, withCtx as a, renderSlot as l, createVNode as s, mergeProps as v } from "vue";
+import w from "./Dropdown/Dropdown.vue.js";
+import "@iconify/vue";
+import y from "./Button.vue.js";
+import k from "iconify-icon-picker";
+import "iconify-icon-picker/style.css";
+const O = /* @__PURE__ */ p({
+  __name: "IconPicker",
+  props: {
+    btnProps: {},
+    value: { default: "tabler:icons-filled" },
+    position: { default: "bottom" }
+  },
+  emits: ["onSelect", "onTrigger", "onClose"],
+  setup(r, { emit: c }) {
+    const t = c, m = f(!1), i = () => {
+      m.value = !1;
+    }, d = (o, e) => {
+      t("onSelect", o, e), i();
+    }, u = [
+      "ri:alert-line",
+      "heroicons:arrow-right",
+      "lucide:arrow-left",
+      "tabler:arrow-down",
+      "feather:arrow-up",
+      "tabler:battery",
+      "lucide:bookmark",
+      "flowbite:briefcase-outline",
+      "heroicons:calendar",
+      "material-symbols:menu-rounded",
+      "lucide:chevron-down",
+      "lucide:chevron-up",
+      "lucide:chevron-left",
+      "lucide:chevron-right",
+      "tabler:aperture",
+      "feather:archive",
+      "mdi:cart-outline",
+      "mdi:settings",
+      "tabler:dots",
+      "mingcute:check-fill",
+      "mdi:user",
+      "feather:power",
+      "lucide:phone",
+      "tabler:dots-vertical",
+      "material-symbols:home-outline-rounded",
+      "mdi:microphone",
+      "bytesize:message",
+      "feather:activity",
+      "mdi:brush",
+      "tabler:eraser",
+      "mdi:database",
+      "heroicons:pencil",
+      "mdi:crop",
+      "heroicons:magnifying-glass-plus",
+      "heroicons:magnifying-glass-minus",
+      "tabler:corner-up-left",
+      "heroicons:arrow-path",
+      "mi:layers",
+      "mdi:palette",
+      "mdi:eye",
+      "mdi:eye-off",
+      "heroicons:arrows-pointing-in",
+      "tabler:scissors",
+      "heroicons:photo",
+      "feather:grid",
+      "lucide:ruler",
+      "lucide:alert-octagon",
+      "tabler:battery-4",
+      "lucide:bookmark-minus",
+      "heroicons:calendar",
+      "tabler:share",
+      "heroicons:power",
+      "feather:phone",
+      "tabler:microphone-2",
+      "lucide:bar-chart",
+      "famicons:brush-outline",
+      "mdi:eraser",
+      "fa6-regular:pen-to-square",
+      "tabler:refresh",
+      "lucide:palette",
+      "lucide:move-diagonal",
+      "feather:scissors",
+      "tabler:rotate-clockwise",
+      "lucide:type",
+      "heroicons:photo",
+      "feather:grid",
+      "tabler:ruler-2",
+      "material-symbols:download-rounded"
+    ];
+    return (o, e) => (b(), g(n(w), {
+      className: "max-h-[392px]! min-w-[250px]",
+      onOnClose: e[1] || (e[1] = (h) => t("onClose")),
+      position: r.position
+    }, {
+      trigger: a(() => [
+        l(o.$slots, "default", {}, () => [
+          s(y, v({
+            icon: r.value,
+            rounded: "md",
+            variant: "outline",
+            ...r.btnProps || {}
+          }, {
+            onClick: e[0] || (e[0] = (h) => t("onTrigger"))
+          }), null, 16)
+        ])
+      ]),
+      menu: a(() => [
+        l(o.$slots, "menu-top", { close: i }),
+        s(n(k), {
+          id: "icon-picker",
+          placeholder: "Search 1000+ icons...",
+          "items-per-page": 35,
+          value: r.value,
+          onOnSelect: d,
+          defaultIcons: u
+        }, null, 8, ["value"])
+      ]),
+      _: 3
+    }, 8, ["position"]));
+  }
+});
+export {
+  O as default
+};

package/components/IconPicker.vue2.js

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

package/components/Input.vue.d.ts

@@ -0,0 +1,54 @@
+import { InputProps, InputRounded, InputSize, InputVariant } from '../types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'addon-left'?(_: {}): any;
+        'addon-right'?(_: {}): any;
+    };
+    refs: {
+        inputRef: HTMLInputElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<InputProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: string | number) => any;
+    change: (value: string | number) => any;
+    blur: (event: FocusEvent) => any;
+    focus: (event: FocusEvent) => any;
+    "click:icon": (event: MouseEvent) => any;
+    "click:icon-right": (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<InputProps> & Readonly<{
+    "onUpdate:modelValue"?: (value: string | number) => any;
+    onChange?: (value: string | number) => any;
+    onBlur?: (event: FocusEvent) => any;
+    onFocus?: (event: FocusEvent) => any;
+    "onClick:icon"?: (event: MouseEvent) => any;
+    "onClick:icon-right"?: (event: MouseEvent) => any;
+}>, {
+    disabled: boolean;
+    type: import('../types').InputType;
+    class: string;
+    size: InputSize;
+    variant: InputVariant;
+    modelValue: string | number;
+    loading: boolean;
+    rounded: InputRounded;
+    rows: number;
+    showClearButton: boolean;
+    autofocus: boolean;
+    inputClass: string;
+    lazy: boolean;
+    labelPosition: import('../types').LabelPosition;
+    addonLeftClass: string;
+    addonRightClass: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    inputRef: HTMLInputElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};