vlite3 0.1.0 → 0.1.2

package/components/Workbook/Sheet.vue.js

@@ -0,0 +1,141 @@
+import { defineComponent as V, ref as h, computed as x, openBlock as c, createElementBlock as d, normalizeClass as D, createElementVNode as r, withModifiers as g, createBlock as b, withCtx as u, createVNode as m, createCommentVNode as y, withDirectives as N, vModelText as $, toDisplayString as k, unref as M, createTextVNode as O, nextTick as R } from "vue";
+import f from "../Icon.vue.js";
+import j from "../Dropdown/Dropdown.vue.js";
+import z from "../IconPicker.vue.js";
+const A = {
+  type: "button",
+  class: "flex items-center justify-center rounded hover:bg-accent transition-colors p-0.5 outline-none focus-visible:ring-2 focus-visible:ring-primary/20"
+}, K = { class: "flex-1 min-w-0 pr-1" }, U = {
+  key: 1,
+  class: "block truncate text-sm font-medium leading-normal"
+}, _ = { class: "opacity-0 group-hover:opacity-100 transition-opacity ml-auto pl-1 flex items-center bg-inherit" }, q = { class: "p-1 rounded-md hover:bg-accent text-muted-foreground hover:text-foreground transition-colors" }, F = {
+  class: /* @__PURE__ */ D(["flex items-center"])
+}, L = /* @__PURE__ */ V({
+  __name: "Sheet",
+  props: {
+    sheet: {},
+    isActive: { type: Boolean },
+    isEditing: { type: Boolean, default: !1 },
+    canDelete: { type: Boolean, default: !0 },
+    confirmDelete: { type: Boolean, default: !1 },
+    confirmDeleteTexts: {}
+  },
+  emits: ["select", "update:title", "update:icon", "edit-start", "edit-end", "duplicate", "delete"],
+  setup(n, { emit: w }) {
+    const e = n, o = w, a = h(null), s = h(e.sheet.title), p = () => {
+      s.value = e.sheet.title, o("edit-start", e.sheet.id), R(() => {
+        a.value?.focus(), a.value?.select();
+      });
+    }, v = () => {
+      if (!e.isEditing) return;
+      const t = s.value.trim();
+      t ? o("update:title", e.sheet.id, t) : s.value = e.sheet.title, o("edit-end", e.sheet.id);
+    }, E = () => {
+      s.value = e.sheet.title, o("edit-end", e.sheet.id);
+    }, T = (t) => {
+      t.key === "Enter" && v(), t.key === "Escape" && E();
+    }, B = x(() => [
+      { label: "Rename", value: "rename", icon: "lucide:pencil" },
+      { label: "Duplicate", value: "duplicate", icon: "lucide:copy" },
+      {
+        label: "Delete",
+        value: "delete",
+        icon: "lucide:trash-2",
+        class: "text-danger",
+        disabled: !e.canDelete,
+        confirmation: e.confirmDelete ? {
+          title: e.confirmDeleteTexts?.title,
+          description: e.confirmDeleteTexts?.description,
+          confirmText: e.confirmDeleteTexts?.confirm,
+          cancelText: e.confirmDeleteTexts?.cancel,
+          variant: "danger"
+        } : void 0
+      }
+    ]), C = (t) => {
+      if (t.value === "rename" && p(), t.value === "duplicate" && o("duplicate", e.sheet.id), t.value === "delete") {
+        if (!e.canDelete) return;
+        o("delete", e.sheet.id);
+      }
+    }, S = x(() => [
+      "group relative flex items-center min-w-[120px] max-w-[240px] h-9 px-3 border-r border-border select-none cursor-pointer transition-all duration-200 ease-out",
+      e.isActive ? "bg-muted text-foreground ring-1 ring-border ring-b-0 z-10" : "text-muted-foreground hover:bg-accent/50",
+      e.isEditing ? "cursor-text" : ""
+    ].join(" "));
+    return (t, i) => (c(), d("div", {
+      class: D(S.value),
+      onClick: i[4] || (i[4] = (l) => o("select", n.sheet.id)),
+      onDblclick: p
+    }, [
+      r("div", {
+        onClick: i[1] || (i[1] = g(() => {
+        }, ["stop"])),
+        class: "mr-2 flex items-center shrink-0"
+      }, [
+        n.sheet.icon || n.isEditing ? (c(), b(z, {
+          key: 0,
+          value: n.sheet.icon || "lucide:file",
+          position: "bottom-start",
+          onOnSelect: i[0] || (i[0] = (l) => o("update:icon", n.sheet.id, l))
+        }, {
+          default: u(() => [
+            r("button", A, [
+              m(f, {
+                icon: n.sheet.icon || "lucide:file",
+                class: "w-4 h-4 opacity-70 hover:opacity-100 transition-opacity"
+              }, null, 8, ["icon"])
+            ])
+          ]),
+          _: 1
+        }, 8, ["value"])) : y("", !0)
+      ]),
+      r("div", K, [
+        n.isEditing ? N((c(), d("input", {
+          key: 0,
+          ref_key: "inputRef",
+          ref: a,
+          "onUpdate:modelValue": i[2] || (i[2] = (l) => s.value = l),
+          type: "text",
+          class: "w-full bg-transparent border-none outline-none p-0 text-sm font-medium text-foreground placeholder-muted-foreground focus:ring-0",
+          onBlur: v,
+          onKeydown: T,
+          onClick: i[3] || (i[3] = g(() => {
+          }, ["stop"]))
+        }, null, 544)), [
+          [$, s.value]
+        ]) : (c(), d("span", U, k(n.sheet.title), 1))
+      ]),
+      r("div", _, [
+        m(M(j), {
+          options: B.value,
+          position: "bottom-end",
+          width: "140px",
+          teleport: !0,
+          onOnSelect: C
+        }, {
+          trigger: u(() => [
+            r("button", q, [
+              m(f, {
+                icon: "lucide:more-vertical",
+                class: "w-3.5 h-3.5"
+              })
+            ])
+          ]),
+          item: u(({ option: l }) => [
+            r("div", F, [
+              l?.icon ? (c(), b(f, {
+                key: 0,
+                icon: l?.icon,
+                class: "w-3.5 h-3.5 mr-2 opacity-70"
+              }, null, 8, ["icon"])) : y("", !0),
+              O(" " + k(l?.label), 1)
+            ])
+          ]),
+          _: 1
+        }, 8, ["options"])
+      ])
+    ], 34));
+  }
+});
+export {
+  L as default
+};

package/components/Workbook/Sheet.vue2.js

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

package/components/Workbook/Workbook.vue.d.ts

@@ -0,0 +1,54 @@
+import { WorkbookSheet, WorkbookProps, AddButtonPosition } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'left-addons'?(_: {}): any;
+        'right-addons'?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {
+        scrollContainer: HTMLDivElement;
+        parent: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<WorkbookProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (id: string) => any;
+    change: (id: string) => any;
+    delete: (id: string) => any;
+    add: () => any;
+    "edit-start": (id: string) => any;
+    "edit-end": (id: string) => any;
+    duplicate: (id: string) => any;
+    "update:sheets": (sheets: WorkbookSheet[]) => any;
+}, string, import('vue').PublicProps, Readonly<WorkbookProps> & Readonly<{
+    "onUpdate:modelValue"?: (id: string) => any;
+    onChange?: (id: string) => any;
+    onDelete?: (id: string) => any;
+    onAdd?: () => any;
+    "onEdit-start"?: (id: string) => any;
+    "onEdit-end"?: (id: string) => any;
+    onDuplicate?: (id: string) => any;
+    "onUpdate:sheets"?: (sheets: WorkbookSheet[]) => any;
+}>, {
+    variant: "chrome" | "folder" | "simple" | "card";
+    modelValue: string;
+    editable: boolean;
+    draggable: boolean;
+    confirmDelete: boolean;
+    sheets: WorkbookSheet[];
+    addable: boolean;
+    addButtonPosition: AddButtonPosition;
+    maxSheets: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    scrollContainer: HTMLDivElement;
+    parent: HTMLDivElement;
+}, 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/Workbook/Workbook.vue.js

@@ -0,0 +1,7 @@
+import o from "./Workbook.vue2.js";
+/* empty css              */
+import r from "../../_virtual/_plugin-vue_export-helper.js";
+const _ = /* @__PURE__ */ r(o, [["__scopeId", "data-v-88d33842"]]);
+export {
+  _ as default
+};

package/components/Workbook/Workbook.vue2.js

@@ -0,0 +1,146 @@
+import { defineComponent as N, ref as g, watch as p, nextTick as T, computed as U, openBlock as a, createElementBlock as i, createElementVNode as r, renderSlot as m, createCommentVNode as u, Fragment as A, renderList as L, unref as P, createBlock as J, createVNode as x } from "vue";
+import { useDragAndDrop as O } from "@formkit/drag-and-drop/vue";
+import { animations as W } from "@formkit/drag-and-drop";
+import Y from "./Sheet.vue.js";
+import b from "./WorkbookAddButton.vue.js";
+const z = { class: "flex flex-col w-full font-sans" }, F = { class: "flex items-end w-full border-b px-1 gap-2" }, M = {
+  key: 0,
+  class: "flex items-center mb-1 mr-2"
+}, j = {
+  key: 0,
+  class: "shrink-0 mb-1"
+}, q = { class: "flex items-center mb-0.5 z-20 sticky right-0 ml-auto box-decoration-clone" }, G = { key: 0 }, H = { key: 1 }, K = { class: "flex-1 relative bg-white w-full" }, te = /* @__PURE__ */ N({
+  __name: "Workbook",
+  props: {
+    modelValue: { default: "" },
+    sheets: { default: () => [] },
+    editable: { type: Boolean, default: !0 },
+    addable: { type: Boolean, default: !0 },
+    draggable: { type: Boolean, default: !0 },
+    addButtonPosition: { default: "fixed-right" },
+    maxSheets: { default: 50 },
+    variant: { default: "chrome" },
+    class: {},
+    confirmDelete: { type: Boolean, default: !1 },
+    confirmDeleteTexts: {}
+  },
+  emits: ["update:modelValue", "update:sheets", "change", "add", "delete", "duplicate", "edit-start", "edit-end"],
+  setup(o, { emit: k }) {
+    const l = o, s = k, f = g(null), c = g(null), [y, h] = O(l.sheets, {
+      plugins: [W()],
+      draggable: (e) => l.draggable && !c.value,
+      onSort: (e) => {
+        s("update:sheets", e.values);
+      }
+    });
+    p(
+      () => l.sheets,
+      (e) => {
+        JSON.stringify(e) !== JSON.stringify(h.value) && (h.value = [...e]);
+      },
+      { deep: !0 }
+    );
+    const S = (e) => {
+      s("update:modelValue", e), s("change", e);
+    }, v = () => {
+      l.sheets.length >= l.maxSheets || s("add");
+    }, w = (e, d) => {
+      const t = l.sheets.findIndex((n) => n.id === e);
+      if (t !== -1) {
+        const n = [...l.sheets];
+        n[t] = { ...n[t], title: d }, s("update:sheets", n);
+      }
+    }, D = (e, d) => {
+      const t = l.sheets.findIndex((n) => n.id === e);
+      if (t !== -1) {
+        const n = [...l.sheets];
+        n[t] = { ...n[t], icon: d }, s("update:sheets", n);
+      }
+    }, B = (e) => {
+      c.value = e, s("edit-start", e);
+    }, V = (e) => {
+      c.value = null, s("edit-end", e);
+    }, E = (e) => {
+      s("duplicate", e);
+    }, I = (e) => {
+      const d = l.sheets.findIndex((n) => n.id === e);
+      if (d === -1) return;
+      const t = [...l.sheets];
+      if (t.splice(d, 1), s("update:sheets", t), s("delete", e), l.modelValue === e) {
+        let n = "";
+        if (t.length > 0) {
+          const C = Math.min(d, t.length - 1);
+          n = t[C].id;
+        }
+        s("update:modelValue", n), s("change", n);
+      }
+    };
+    p(
+      () => l.sheets.length,
+      (e, d) => {
+        e > d && l.addable && T(() => {
+          const t = l.sheets[l.sheets.length - 1];
+          t.id === l.modelValue && (c.value = t.id);
+        });
+      }
+    );
+    const _ = (e) => {
+      f.value && e.deltaY !== 0 && (f.value.scrollLeft += e.deltaY, e.preventDefault());
+    }, $ = U(() => l.sheets.length > 1);
+    return (e, d) => (a(), i("div", z, [
+      r("div", F, [
+        e.$slots["left-addons"] ? (a(), i("div", M, [
+          m(e.$slots, "left-addons", {}, void 0, !0)
+        ])) : u("", !0),
+        r("div", {
+          ref_key: "scrollContainer",
+          ref: f,
+          class: "flex-1 flex items-end overflow-x-auto scrollbar-none overscroll-contain",
+          style: { "scrollbar-width": "none", "-ms-overflow-style": "none" },
+          onWheel: _
+        }, [
+          r("div", {
+            ref_key: "parent",
+            ref: y,
+            class: "flex items-end"
+          }, [
+            (a(!0), i(A, null, L(P(h), (t) => (a(), J(Y, {
+              key: t.id,
+              sheet: t,
+              "is-active": o.modelValue === t.id,
+              "is-editing": c.value === t.id,
+              "can-delete": $.value,
+              "confirm-delete": o.confirmDelete,
+              "confirm-delete-texts": o.confirmDeleteTexts,
+              onSelect: S,
+              "onUpdate:title": w,
+              "onUpdate:icon": D,
+              onEditStart: B,
+              onEditEnd: V,
+              onDuplicate: E,
+              onDelete: I
+            }, null, 8, ["sheet", "is-active", "is-editing", "can-delete", "confirm-delete", "confirm-delete-texts"]))), 128))
+          ], 512),
+          o.addable && o.addButtonPosition === "attached" ? (a(), i("div", j, [
+            x(b, { onClick: v })
+          ])) : u("", !0),
+          d[0] || (d[0] = r("div", { class: "w-1 shrink-0" }, null, -1))
+        ], 544),
+        r("div", q, [
+          o.addable && o.addButtonPosition === "fixed-right" ? (a(), i("div", G, [
+            x(b, { onClick: v })
+          ])) : u("", !0),
+          e.$slots["right-addons"] ? (a(), i("div", H, [
+            m(e.$slots, "right-addons", {}, void 0, !0)
+          ])) : u("", !0)
+        ])
+      ]),
+      r("div", K, [
+        m(e.$slots, "default", {}, void 0, !0)
+      ])
+    ]));
+  }
+});
+export {
+  te as default
+};

package/components/Workbook/WorkbookAddButton.vue.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    click: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{
+    onClick?: (event: MouseEvent) => any;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLButtonElement>;
+export default _default;

package/components/Workbook/WorkbookAddButton.vue.js

@@ -0,0 +1,20 @@
+import { defineComponent as i, openBlock as r, createBlock as c } from "vue";
+import m from "../Button.vue.js";
+const u = /* @__PURE__ */ i({
+  __name: "WorkbookAddButton",
+  emits: ["click"],
+  setup(s, { emit: o }) {
+    const t = o;
+    return (d, e) => (r(), c(m, {
+      variant: "ghost",
+      size: "sm",
+      icon: "lucide:plus",
+      title: "Add New Sheet",
+      rounded: "none",
+      onClick: e[0] || (e[0] = (n) => t("click", n))
+    }));
+  }
+});
+export {
+  u as default
+};

package/components/Workbook/WorkbookAddButton.vue2.js

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

package/components/Workbook/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Workbook } from './Workbook.vue';
+export { default as Sheet } from './Sheet.vue';
+export * from './types';

package/components/Workbook/types.d.ts

@@ -0,0 +1,34 @@
+export interface WorkbookSheet {
+    id: string;
+    title: string;
+    icon?: string;
+    content?: string;
+    closable?: boolean;
+    disabled?: boolean;
+    [key: string]: any;
+}
+export type SheetPosition = 'top' | 'bottom' | 'left' | 'right';
+export type AddButtonPosition = 'attached' | 'fixed-right';
+export interface WorkbookProps {
+    modelValue?: string;
+    sheets?: WorkbookSheet[];
+    editable?: boolean;
+    addable?: boolean;
+    draggable?: boolean;
+    addButtonPosition?: AddButtonPosition;
+    maxSheets?: number;
+    variant?: 'chrome' | 'folder' | 'simple' | 'card';
+    class?: string;
+    confirmDelete?: boolean;
+    confirmDeleteTexts?: {
+        title?: string;
+        description?: string;
+        confirm?: string;
+        cancel?: string;
+    };
+}
+export interface SheetEvent {
+    id: string;
+    sheet: WorkbookSheet;
+    originalEvent?: Event;
+}

package/composables/useKeyStroke.d.ts

@@ -0,0 +1,21 @@
+import { Ref } from 'vue';
+type KeyStrokeHandler = (event: KeyboardEvent) => void;
+type KeyStrokeOptions = {
+    target?: Ref<HTMLElement | null> | HTMLElement | null;
+    preventDefault?: boolean;
+    stopPropagation?: boolean;
+    passive?: boolean;
+    capture?: boolean;
+};
+interface KeyStrokeComposable {
+    onKeyStroke: (key: string | string[], handler: KeyStrokeHandler, options?: KeyStrokeOptions) => void;
+    offKeyStroke: (key: string | string[], handler?: KeyStrokeHandler) => void;
+    destroy: () => void;
+}
+export declare const useKeyStroke: () => KeyStrokeComposable;
+export declare const useAdvancedKeyStroke: () => {
+    onKeyStroke: (keys: string, handler: KeyStrokeHandler) => void;
+    offKeyStroke: (keys: string, handler?: KeyStrokeHandler) => void;
+    destroy: () => void;
+};
+export {};

package/composables/useKeyStroke.js

@@ -0,0 +1,93 @@
+import { onUnmounted as E } from "vue";
+const S = () => {
+  const o = /* @__PURE__ */ new Map(), r = (s) => {
+    const d = n(s.key), c = o.get(d);
+    c && c.forEach(({ handler: y, options: u }) => {
+      u?.preventDefault && s.preventDefault(), u?.stopPropagation && s.stopPropagation(), y(s);
+    });
+  }, n = (s) => s.toLowerCase(), p = (s) => s ? "value" in s ? s.value || document : s || document : document, w = (s, d, c = {}) => {
+    const y = Array.isArray(s) ? s : [s], u = p(c.target);
+    y.forEach((f) => {
+      const m = n(f);
+      o.has(m) || (o.set(m, /* @__PURE__ */ new Set()), u.addEventListener("keydown", r, {
+        passive: c.passive ?? !0,
+        capture: c.capture ?? !1
+      })), o.get(m).add({ handler: d, options: c });
+    });
+  }, v = (s, d) => {
+    (Array.isArray(s) ? s : [s]).forEach((y) => {
+      const u = n(y), f = o.get(u);
+      f && (d ? f.forEach((m) => {
+        m.handler === d && f.delete(m);
+      }) : f.clear(), f.size === 0 && (o.delete(u), document.removeEventListener("keydown", r)));
+    });
+  }, K = () => {
+    document.removeEventListener("keydown", r), o.clear();
+  };
+  return E(() => {
+    K();
+  }), {
+    onKeyStroke: w,
+    offKeyStroke: v,
+    destroy: K
+  };
+}, M = () => {
+  const o = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Map();
+  let n = null;
+  const p = (t) => {
+    const e = t.toLowerCase();
+    return e === "cmd" || e === "meta" || e === "metakey" ? "meta" : e === "ctrl" || e === "control" || e === "controlkey" ? "ctrl" : e === "alt" || e === "option" || e === "altkey" ? "alt" : e === "shift" || e === "shiftkey" ? "shift" : e;
+  }, w = (t) => t.toLowerCase().split("+").map((e) => e.trim()).map(p).sort(), v = (t) => {
+    const e = [t.join("+")], h = t.includes("meta"), l = t.includes("ctrl");
+    if (h) {
+      const i = t.map((a) => a === "meta" ? "ctrl" : a);
+      e.push(i.join("+"));
+    } else if (l) {
+      const i = t.map((a) => a === "ctrl" ? "meta" : a);
+      e.push(i.join("+"));
+    }
+    return e;
+  }, K = (t) => {
+    const e = [];
+    return t.metaKey && e.push("meta"), t.ctrlKey && e.push("ctrl"), t.altKey && e.push("alt"), t.shiftKey && e.push("shift"), e.sort();
+  }, s = (t, e) => t.length !== e.length ? !1 : t.every((h, l) => h === e[l]), d = (t) => {
+    const e = p(t.key);
+    n && (clearTimeout(n), n = null);
+    const l = [...K(t)];
+    ["meta", "ctrl", "alt", "shift"].includes(e) || l.push(e), l.sort(), r.forEach((i, a) => {
+      const b = w(a);
+      s(b, l) && i.forEach((C) => C(t));
+    }), n = window.setTimeout(() => {
+      o.clear(), n = null;
+    }, 100);
+  }, c = (t) => {
+    const e = p(t.key);
+    o.delete(e), n && (clearTimeout(n), n = null);
+  }, y = () => {
+    o.clear(), n && (clearTimeout(n), n = null);
+  }, u = () => {
+    document.hidden && (o.clear(), n && (clearTimeout(n), n = null));
+  }, f = () => {
+    window.addEventListener("keydown", d, { passive: !1 }), window.addEventListener("keyup", c, { passive: !1 }), window.addEventListener("blur", y, { passive: !0 }), document.addEventListener("visibilitychange", u, { passive: !0 });
+  }, m = () => {
+    window.removeEventListener("keydown", d), window.removeEventListener("keyup", c), window.removeEventListener("blur", y), document.removeEventListener("visibilitychange", u), n && (clearTimeout(n), n = null);
+  }, L = (t, e) => {
+    const h = w(t), l = v(h);
+    l.forEach((i) => {
+      r.has(i) || r.set(i, /* @__PURE__ */ new Set()), r.get(i).add(e);
+    }), r.size === l.length && f();
+  }, g = (t, e) => {
+    const h = w(t);
+    v(h).forEach((i) => {
+      const a = r.get(i);
+      a && (e ? a.delete(e) : a.clear(), a.size === 0 && r.delete(i));
+    }), r.size === 0 && m();
+  }, k = () => {
+    m(), r.clear(), o.clear();
+  };
+  return E(k), { onKeyStroke: L, offKeyStroke: g, destroy: k };
+};
+export {
+  M as useAdvancedKeyStroke,
+  S as useKeyStroke
+};

package/composables/useNotifications.d.ts

@@ -0,0 +1,113 @@
+export type ToastPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+interface NotificationAction {
+    label: string;
+    onClick: () => void;
+}
+export interface Notification {
+    id: number;
+    message: string;
+    description?: string;
+    type: 'success' | 'error' | 'info' | 'warning' | 'default';
+    duration?: number;
+    action?: NotificationAction;
+    position: ToastPosition;
+    promise?: Promise<any>;
+    isFirst?: boolean;
+}
+export interface ToastOptions {
+    description?: string;
+    duration?: number;
+    action?: NotificationAction;
+    position?: ToastPosition;
+}
+export interface ToastConfig {
+    position?: ToastPosition;
+    duration?: number;
+    expand?: boolean;
+    variant?: 'success' | 'error' | 'info' | 'warning' | 'default';
+}
+declare function pauseTimers(): void;
+declare function resumeTimers(): void;
+declare function showToast(message: string, type?: Notification['type'], options?: ToastOptions): number;
+declare const toast: {
+    (message: string, options?: ToastOptions): number;
+    success(message: string, options?: ToastOptions): number;
+    error(message: string, options?: ToastOptions): number;
+    info(message: string, options?: ToastOptions): number;
+    warning(message: string, options?: ToastOptions): number;
+    promise<T = any>(promise: Promise<T>, data: {
+        loading: string;
+        success: (data: T) => string;
+        error: string | ((err: any) => string);
+    }): Promise<T>;
+};
+declare function removeToast(id: number): void;
+declare function configure(config: ToastConfig): void;
+export declare function useNotifications(): {
+    notifications: import('vue').Ref<{
+        id: number;
+        message: string;
+        description?: string;
+        type: "success" | "error" | "info" | "warning" | "default";
+        duration?: number;
+        action?: {
+            label: string;
+            onClick: () => void;
+        };
+        position: ToastPosition;
+        promise?: {
+            then: <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>;
+            catch: <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<any>;
+            finally: (onfinally?: () => void) => Promise<any>;
+            readonly [Symbol.toStringTag]: string;
+        };
+        isFirst?: boolean;
+    }[], Notification[] | {
+        id: number;
+        message: string;
+        description?: string;
+        type: "success" | "error" | "info" | "warning" | "default";
+        duration?: number;
+        action?: {
+            label: string;
+            onClick: () => void;
+        };
+        position: ToastPosition;
+        promise?: {
+            then: <TResult1 = any, TResult2 = never>(onfulfilled?: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>) => Promise<TResult1 | TResult2>;
+            catch: <TResult = never>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>) => Promise<any>;
+            finally: (onfinally?: () => void) => Promise<any>;
+            readonly [Symbol.toStringTag]: string;
+        };
+        isFirst?: boolean;
+    }[]>;
+    showToast: typeof showToast;
+    toast: {
+        (message: string, options?: ToastOptions): number;
+        success(message: string, options?: ToastOptions): number;
+        error(message: string, options?: ToastOptions): number;
+        info(message: string, options?: ToastOptions): number;
+        warning(message: string, options?: ToastOptions): number;
+        promise<T = any>(promise: Promise<T>, data: {
+            loading: string;
+            success: (data: T) => string;
+            error: string | ((err: any) => string);
+        }): Promise<T>;
+    };
+    removeToast: typeof removeToast;
+    configure: typeof configure;
+    globalConfig: import('vue').Ref<{
+        position?: ToastPosition;
+        duration?: number;
+        expand?: boolean;
+        variant?: "success" | "error" | "info" | "warning" | "default";
+    }, ToastConfig | {
+        position?: ToastPosition;
+        duration?: number;
+        expand?: boolean;
+        variant?: "success" | "error" | "info" | "warning" | "default";
+    }>;
+    pauseTimers: typeof pauseTimers;
+    resumeTimers: typeof resumeTimers;
+};
+export { showToast, toast, removeToast, configure, pauseTimers, resumeTimers };