@gspa/ui 0.1.3 → 0.2.0

package/dist/lib/toast.js

@@ -0,0 +1,81 @@
+import { ref as m, markRaw as f } from "vue";
+const i = m([]);
+let p = 0;
+const v = {
+  duration: 3e3,
+  position: "top-center",
+  dismissible: !0,
+  closeButton: !1
+}, w = () => `toast-${++p}-${Date.now()}`, e = (t, s = {}) => {
+  const o = w(), n = {
+    id: o,
+    message: t,
+    ...v,
+    ...s,
+    createdAt: Date.now()
+  };
+  return i.value.push(f(n)), n.duration && n.duration > 0 && setTimeout(() => {
+    r(o);
+  }, n.duration), o;
+}, r = (t) => {
+  const s = i.value.findIndex((o) => o.id === t);
+  s > -1 && i.value.splice(s, 1);
+}, g = () => {
+  i.value = [];
+}, b = Object.assign(
+  // Default toast function
+  (t, s) => e(t, { ...s }),
+  // Toast type methods
+  {
+    success: (t, s) => e(t, { ...s, variant: "success" }),
+    error: (t, s) => e(t, { ...s, variant: "error" }),
+    warning: (t, s) => e(t, { ...s, variant: "warning" }),
+    info: (t, s) => e(t, { ...s, variant: "info" }),
+    // Promise toast for async operations
+    promise: (t, s = {}) => {
+      const {
+        loading: o = "Loading...",
+        success: n = "Success",
+        error: c = "Error",
+        ...u
+      } = s, l = e(o, {
+        ...u,
+        variant: "loading",
+        duration: 0,
+        // Don't auto dismiss
+        dismissible: !1
+      });
+      return t.then((a) => {
+        r(l);
+        const d = typeof n == "function" ? n(a) : n;
+        return e(d, {
+          ...u,
+          variant: "success"
+        }), a;
+      }).catch((a) => {
+        r(l);
+        const d = typeof c == "function" ? c(a) : c;
+        throw e(d, {
+          ...u,
+          variant: "error"
+        }), a;
+      });
+    },
+    // Utility methods
+    dismiss: r,
+    dismissAll: g,
+    // Custom toast with component
+    custom: (t, s = {}) => e("", {
+      ...s,
+      component: f(t)
+    })
+  }
+), x = () => ({
+  toasts: i,
+  dismiss: r,
+  dismissAll: g
+});
+export {
+  b as toast,
+  x as useToaster
+};

package/dist/src/components/Alert.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Alert.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Alert.vue"],"names":[],"mappings":"wBAopBqB,eAAe,CAAC,OAAO,eAAe,EAAE,WAAW,CAAC;;qBAEpD,CAAC,EAAE,CAAC;;;AATzB;WAIkB,OAAO,IAAI;YADV,OAAO,CAAC,OAAO,KAAK,CAAC;;;;;;;;;2OAGrC;;;;;;AAjXH,0EAA+C;AAlB/C;;;;;;;;;EAgBE"}
+{"version":3,"file":"Alert.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Alert.vue"],"names":[],"mappings":"wBA8pBqB,eAAe,CAAC,OAAO,eAAe,EAAE,WAAW,CAAC;;qBAEpD,CAAC,EAAE,CAAC;;;AATzB;WAIkB,OAAO,IAAI;YADV,OAAO,CAAC,OAAO,KAAK,CAAC;;;;;;;;;2OAGrC;;;;;;AAtXH,0EAA+C;AAlB/C;;;;;;;;;EAgBE"}

package/dist/src/components/Button.vue.d.ts

@@ -1,34 +1,132 @@
-declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
-export default _default;
-type __VLS_WithSlots<T, S> = T & (new () => {
-    $slots: S;
-});
-declare const __VLS_component: import("vue").DefineComponent<{}, {
-    $props: Partial<typeof props>;
-    size: string;
-    variant: string;
+import { type PropType } from 'vue';
+import type { AuthRule, ButtonSize, ButtonType, ButtonUnauthorizedBehavior, ButtonVariant } from '../types.js';
+declare var __VLS_5: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_5) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    variant: {
+        type: PropType<ButtonVariant>;
+        default: string;
+        validator: (value: ButtonVariant) => boolean;
+    };
+    size: {
+        type: PropType<ButtonSize>;
+        default: string;
+        validator: (value: ButtonSize) => boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loadingText: {
+        type: StringConstructor;
+        default: any;
+    };
+    loadingLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    type: {
+        type: PropType<ButtonType>;
+        default: string;
+    };
+    icon: {
+        type: StringConstructor;
+        default: any;
+    };
+    permission: {
+        type: PropType<AuthRule>;
+        default: any;
+    };
+    role: {
+        type: PropType<AuthRule>;
+        default: any;
+    };
+    requireAll: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    unauthorized: {
+        type: PropType<ButtonUnauthorizedBehavior>;
+        default: string;
+        validator: (value: ButtonUnauthorizedBehavior) => boolean;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    variant: {
+        type: PropType<ButtonVariant>;
+        default: string;
+        validator: (value: ButtonVariant) => boolean;
+    };
+    size: {
+        type: PropType<ButtonSize>;
+        default: string;
+        validator: (value: ButtonSize) => boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loadingText: {
+        type: StringConstructor;
+        default: any;
+    };
+    loadingLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    type: {
+        type: PropType<ButtonType>;
+        default: string;
+    };
+    icon: {
+        type: StringConstructor;
+        default: any;
+    };
+    permission: {
+        type: PropType<AuthRule>;
+        default: any;
+    };
+    role: {
+        type: PropType<AuthRule>;
+        default: any;
+    };
+    requireAll: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    unauthorized: {
+        type: PropType<ButtonUnauthorizedBehavior>;
+        default: string;
+        validator: (value: ButtonUnauthorizedBehavior) => boolean;
+    };
+}>> & Readonly<{}>, {
+    type: ButtonType;
+    icon: string;
+    size: ButtonSize;
+    role: AuthRule;
+    variant: ButtonVariant;
     disabled: boolean;
     loading: boolean;
+    loadingText: string;
+    loadingLabel: string;
+    permission: AuthRule;
     requireAll: boolean;
-    unauthorized: string;
-    icon?: string;
-    role?: string | boolean | Function | unknown[];
-    loadingText?: string;
-    permission?: string | boolean | Function | unknown[];
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-type __VLS_Slots = {
-    default?: (props: {}) => any;
-};
-declare const props: {
-    readonly size: string;
-    readonly variant: string;
-    readonly disabled: boolean;
-    readonly loading: boolean;
-    readonly requireAll: boolean;
-    readonly unauthorized: string;
-    readonly icon?: string;
-    readonly role?: string | boolean | Function | unknown[];
-    readonly loadingText?: string;
-    readonly permission?: string | boolean | Function | unknown[];
+    unauthorized: ButtonUnauthorizedBehavior;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
 };
 //# sourceMappingURL=Button.vue.d.ts.map

package/dist/src/components/Button.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Button.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Button.vue"],"names":[],"mappings":"wBAomBqB,eAAe,CAAC,OAAO,eAAe,EAAE,WAAW,CAAC;;qBAEpD,CAAC,EAAE,CAAC;;;AARzB;YAGmB,OAAO,CAAC,OAAO,KAAK,CAAC;;;;;;;;;;;2OAErC;;;;AAxUH;;;;;;;;;;;EAgEE"}
+{"version":3,"file":"Button.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Button.vue"],"names":[],"mappings":"AAAA,OA6RO,EAAoB,KAAK,QAAQ,EAAE,MAAM,KAAK,CAAA;AAKrD,OAAO,KAAK,EAAgB,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,0BAA0B,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAqU5H,QAAA,IAAI,OAAO,IAAW,CAAE;AACxB,KAAK,WAAW,GAAG,EAAE,GACnB;IAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,OAAO,KAAK,GAAG,CAAA;CAAE,CAAC;AAgG/C,QAAA,MAAM,eAAe;;cAGD,QAAQ,CAAC,aAAa,CAAC;;2BAEpB,aAAa;;;cAsBhB,QAAQ,CAAC,UAAU,CAAC;;2BAEjB,UAAU;;;;;;;;;;;;;;;;;;;cAoBb,QAAQ,CAAC,UAAU,CAAC;;;;;;;;cAQQ,QAAQ,CAAC,QAAQ,CAAC;;;;cAIlB,QAAQ,CAAC,QAAQ,CAAC;;;;;;;;cAQ9C,QAAQ,CAAC,0BAA0B,CAAC;;2BAEjC,0BAA0B;;;;cApE7B,QAAQ,CAAC,aAAa,CAAC;;2BAEpB,aAAa;;;cAsBhB,QAAQ,CAAC,UAAU,CAAC;;2BAEjB,UAAU;;;;;;;;;;;;;;;;;;;cAoBb,QAAQ,CAAC,UAAU,CAAC;;;;;;;;cAQQ,QAAQ,CAAC,QAAQ,CAAC;;;;cAIlB,QAAQ,CAAC,QAAQ,CAAC;;;;;;;;cAQ9C,QAAQ,CAAC,0BAA0B,CAAC;;2BAEjC,0BAA0B;;;;;;;;;;;;;;;4EAG/C,CAAC;wBACkB,eAAe,CAAC,OAAO,eAAe,EAAE,WAAW,CAAC;AAAzE,wBAA0E;AAE1E,KAAK,eAAe,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAChC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/src/components/Checkbox.vue.d.ts

@@ -14,9 +14,9 @@ declare const __VLS_component: import("vue").DefineComponent<{}, {
     indeterminate: boolean;
     value?: string | number | boolean;
     label?: string;
+    error?: string;
     description?: string;
     id?: string;
-    error?: string;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 type __VLS_Slots = {
     default?: (props: {}) => any;
@@ -31,8 +31,8 @@ declare const props: {
     readonly indeterminate: boolean;
     readonly value?: string | number | boolean;
     readonly label?: string;
+    readonly error?: string;
     readonly description?: string;
     readonly id?: string;
-    readonly error?: string;
 };
 //# sourceMappingURL=Checkbox.vue.d.ts.map

package/dist/src/components/DataTable.vue.d.ts

@@ -91,7 +91,7 @@ type __VLS_Slots = {
 } & {
     footer?: (props: {}) => any;
 };
-declare const emit: (event: "action" | "add" | "refresh" | "row-click" | "update:density" | "toggle-column" | "add-button-click" | "update:filterRules" | "selection-change" | "sort-change" | "page-change" | "page-size-change", ...args: any[]) => void;
+declare const emit: (event: "add" | "action" | "refresh" | "row-click" | "update:density" | "toggle-column" | "add-button-click" | "update:filterRules" | "selection-change" | "sort-change" | "page-change" | "page-size-change", ...args: any[]) => void;
 declare const props: {
     readonly data: unknown[];
     readonly variant: string;

package/dist/src/components/FormField.vue.d.ts

@@ -1,42 +1,110 @@
+import { type PropType } from 'vue';
+import type { ComponentSize, FormFieldType } from '../types.js';
+declare var __VLS_8: {
+    fieldId: string;
+    hasError: boolean;
+    ariaDescribedBy: string;
+    inputType: import("../types.js").InputType;
+    showPassword: boolean;
+    togglePasswordVisibility: () => void;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    label: StringConstructor;
+    description: StringConstructor;
+    error: StringConstructor;
+    serverError: StringConstructor;
+    success: StringConstructor;
+    helpText: StringConstructor;
+    required: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    autocomplete: StringConstructor;
+    name: StringConstructor;
+    type: {
+        type: PropType<FormFieldType>;
+        default: string;
+    };
+    modelValue: {
+        type: (StringConstructor | DateConstructor)[];
+        default: string;
+    };
+    size: {
+        type: PropType<ComponentSize>;
+        default: string;
+    };
+    id: StringConstructor;
+    showPasswordLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    hidePasswordLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string | Date) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    label: StringConstructor;
+    description: StringConstructor;
+    error: StringConstructor;
+    serverError: StringConstructor;
+    success: StringConstructor;
+    helpText: StringConstructor;
+    required: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    autocomplete: StringConstructor;
+    name: StringConstructor;
+    type: {
+        type: PropType<FormFieldType>;
+        default: string;
+    };
+    modelValue: {
+        type: (StringConstructor | DateConstructor)[];
+        default: string;
+    };
+    size: {
+        type: PropType<ComponentSize>;
+        default: string;
+    };
+    id: StringConstructor;
+    showPasswordLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    hidePasswordLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: (value: string | Date) => any;
+}>, {
+    type: import("../types.js").InputType;
+    required: boolean;
+    size: ComponentSize;
+    disabled: boolean;
+    modelValue: string | Date;
+    showPasswordLabel: string;
+    hidePasswordLabel: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;
-type __VLS_WithSlots<T, S> = T & (new () => {
-    $slots: S;
-});
-declare const __VLS_component: import("vue").DefineComponent<{}, {
-    $emit: typeof emit;
-    $props: Partial<typeof props>;
-    type: string;
-    required: boolean;
-    size: string;
-    label?: string;
-    success?: string;
-    modelValue?: string | Date;
-    description?: string;
-    id?: string;
-    error?: string;
-    helpText?: string;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-type __VLS_Slots = {
-    default?: (props: {
-        fieldId: string;
-        hasError: boolean;
-        ariaDescribedBy: string;
-        showPassword: boolean;
-        togglePasswordVisibility: () => void;
-    }) => any;
-};
-declare const emit: (event: "update:modelValue", ...args: any[]) => void;
-declare const props: {
-    readonly type: string;
-    readonly required: boolean;
-    readonly size: string;
-    readonly label?: string;
-    readonly success?: string;
-    readonly modelValue?: string | Date;
-    readonly description?: string;
-    readonly id?: string;
-    readonly error?: string;
-    readonly helpText?: string;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
 };
 //# sourceMappingURL=FormField.vue.d.ts.map

package/dist/src/components/FormField.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FormField.vue.d.ts","sourceRoot":"","sources":["../../../src/components/FormField.vue"],"names":[],"mappings":"wBA4mBqB,eAAe,CAAC,OAAO,eAAe,EAAE,WAAW,CAAC;;qBAEpD,CAAC,EAAE,CAAC;;;AATzB;WAIkB,OAAO,IAAI;YADV,OAAO,CAAC,OAAO,KAAK,CAAC;;;;;;;;;;;2OAGrC;;;;;;;;;;AA1XH,yEAA+C;AAjB/C;;;;;;;;;;;EAeE"}
+{"version":3,"file":"FormField.vue.d.ts","sourceRoot":"","sources":["../../../src/components/FormField.vue"],"names":[],"mappings":"AAAA,OAoJO,EAAiC,KAAK,QAAQ,EAAE,MAAM,KAAK,CAAA;AAIlE,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAwW/D,QAAA,IAAI,OAAO;;;;;;;CAAW,CAAE;AACxB,KAAK,WAAW,GAAG,EAAE,GACnB;IAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,OAAO,KAAK,GAAG,CAAA;CAAE,CAAC;AAqD/C,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;cAaK,QAAQ,CAAC,aAAa,CAAC;;;;;;;;cAEvB,QAAQ,CAAC,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAFvB,QAAQ,CAAC,aAAa,CAAC;;;;;;;;cAEvB,QAAQ,CAAC,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;4EAK/C,CAAC;wBACkB,eAAe,CAAC,OAAO,eAAe,EAAE,WAAW,CAAC;AAAzE,wBAA0E;AAE1E,KAAK,eAAe,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAChC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/src/components/Icon.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Icon.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Icon.vue"],"names":[],"mappings":";YA6KmB,OAAO,CAAC,OAAO,KAAK,CAAC;;;;;;;;;AA3GxC;;;;;;;EAmBE"}
+{"version":3,"file":"Icon.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Icon.vue"],"names":[],"mappings":";YAyNmB,OAAO,CAAC,OAAO,KAAK,CAAC;;;;;;;;;AAxIxC;;;;;;;EAmBE"}

package/dist/src/components/Input.vue.d.ts

@@ -1,42 +1,146 @@
-declare const _default: import("vue").DefineComponent<{}, {
-    focus: () => any;
-    blur: () => any;
-    select: () => any;
-    $emit: typeof emit;
-    $props: Partial<typeof props>;
-    type: string;
+import { type Component, type PropType } from 'vue';
+import type { ComponentSize, InputType, InputVariant } from '../types.js';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    type: {
+        type: PropType<InputType>;
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<ComponentSize>;
+        default: string;
+    };
+    variant: {
+        type: PropType<InputVariant>;
+        default: string;
+    };
+    iconLeft: {
+        type: PropType<string | Component | null>;
+        default: any;
+    };
+    iconRight: {
+        type: PropType<string | Component | null>;
+        default: any;
+    };
+    clearable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    clearLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    autocomplete: StringConstructor;
+    name: StringConstructor;
+    error: StringConstructor;
+    serverError: StringConstructor;
+    helpText: StringConstructor;
+    ariaDescribedBy: StringConstructor;
+    id: StringConstructor;
+}>, {
+    focus: () => void;
+    blur: () => void;
+    select: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+    blur: (event: FocusEvent) => any;
+    focus: (event: FocusEvent) => any;
+    keydown: (event: KeyboardEvent) => any;
+    clear: () => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    type: {
+        type: PropType<InputType>;
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<ComponentSize>;
+        default: string;
+    };
+    variant: {
+        type: PropType<InputVariant>;
+        default: string;
+    };
+    iconLeft: {
+        type: PropType<string | Component | null>;
+        default: any;
+    };
+    iconRight: {
+        type: PropType<string | Component | null>;
+        default: any;
+    };
+    clearable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    clearLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    autocomplete: StringConstructor;
+    name: StringConstructor;
+    error: StringConstructor;
+    serverError: StringConstructor;
+    helpText: StringConstructor;
+    ariaDescribedBy: StringConstructor;
+    id: StringConstructor;
+}>> & Readonly<{
+    "onUpdate:modelValue"?: (value: string) => any;
+    onBlur?: (event: FocusEvent) => any;
+    onFocus?: (event: FocusEvent) => any;
+    onKeydown?: (event: KeyboardEvent) => any;
+    onClear?: () => any;
+}>, {
+    type: InputType;
     required: boolean;
     placeholder: string;
-    size: string;
-    variant: string;
+    size: ComponentSize;
+    variant: InputVariant;
     disabled: boolean;
     modelValue: string | number;
     readonly: boolean;
+    iconLeft: any;
+    iconRight: any;
     clearable: boolean;
     clearLabel: string;
-    id?: string;
-    error?: string;
-    iconLeft?: string | Record<string, any>;
-    iconRight?: string | Record<string, any>;
-    autocomplete?: string;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;
-declare const emit: (event: "update:modelValue" | "blur" | "focus" | "keydown" | "clear", ...args: any[]) => void;
-declare const props: {
-    readonly type: string;
-    readonly required: boolean;
-    readonly placeholder: string;
-    readonly size: string;
-    readonly variant: string;
-    readonly disabled: boolean;
-    readonly modelValue: string | number;
-    readonly readonly: boolean;
-    readonly clearable: boolean;
-    readonly clearLabel: string;
-    readonly id?: string;
-    readonly error?: string;
-    readonly iconLeft?: string | Record<string, any>;
-    readonly iconRight?: string | Record<string, any>;
-    readonly autocomplete?: string;
-};
 //# sourceMappingURL=Input.vue.d.ts.map

package/dist/src/components/Input.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Input.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Input.vue"],"names":[],"mappings":";;;;WA6fkB,OAAO,IAAI;YADV,OAAO,CAAC,OAAO,KAAK,CAAC;;;;;;;;;;;;;;;;;;AAnOxC,kHAAoF;AAlEpF;;;;;;;;;;;;;;;;EAgEE"}
+{"version":3,"file":"Input.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Input.vue"],"names":[],"mappings":"AAAA,OAyKO,EAAuC,KAAK,SAAS,EAAoB,KAAK,QAAQ,EAAE,MAAM,KAAK,CAAA;AAE1G,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;;;;;;;cA4V/C,QAAQ,CAAC,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;cAKnB,QAAQ,CAAC,aAAa,CAAC;;;;cACpB,QAAQ,CAAC,YAAY,CAAC;;;;cACX,QAAQ,CAAC,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;;;;cAClC,QAAQ,CAAC,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cARlD,QAAQ,CAAC,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;cAKnB,QAAQ,CAAC,aAAa,CAAC;;;;cACpB,QAAQ,CAAC,YAAY,CAAC;;;;cACX,QAAQ,CAAC,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;;;;cAClC,QAAQ,CAAC,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAb5E,wBAwBG"}

package/dist/src/components/ReusableForm.vue.d.ts

@@ -48,7 +48,7 @@ type __VLS_Slots = {
         submit: () => Promise<boolean>;
     }) => any;
 };
-declare const emit: (event: "reset" | "submit" | "cancel" | "form-change", ...args: any[]) => void;
+declare const emit: (event: "submit" | "reset" | "cancel" | "form-change", ...args: any[]) => void;
 declare const props: {
     readonly title: string;
     readonly loading: boolean;

package/dist/src/components/ReusableForm.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ReusableForm.vue.d.ts","sourceRoot":"","sources":["../../../src/components/ReusableForm.vue"],"names":[],"mappings":"wBAosFqB,eAAe,CAAC,OAAO,eAAe,EAAE,WAAW,CAAC;;qBAEpD,CAAC,EAAE,CAAC;;;AATzB;WAIkB,OAAO,IAAI;YADV,OAAO,CAAC,OAAO,KAAK,CAAC;;;;;;;;;;;;;;;2OAGrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAtxDH,mGAAsE;AAzBtE;;;;;;;;;;;;;;;EAuBE"}
+{"version":3,"file":"ReusableForm.vue.d.ts","sourceRoot":"","sources":["../../../src/components/ReusableForm.vue"],"names":[],"mappings":"wBAkwFqB,eAAe,CAAC,OAAO,eAAe,EAAE,WAAW,CAAC;;qBAEpD,CAAC,EAAE,CAAC;;;AATzB;WAIkB,OAAO,IAAI;YADV,OAAO,CAAC,OAAO,KAAK,CAAC;;;;;;;;;;;;;;;2OAGrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA/zDH,mGAAsE;AAzBtE;;;;;;;;;;;;;;;EAuBE"}

package/dist/src/components/ReusableFormModal.vue.d.ts

@@ -50,7 +50,7 @@ type __VLS_Slots = {
         submit: () => Promise<boolean>;
     }) => any;
 };
-declare const emit: (event: "update:modelValue" | "submit" | "close" | "form-change", ...args: any[]) => void;
+declare const emit: (event: "submit" | "update:modelValue" | "close" | "form-change", ...args: any[]) => void;
 declare const props: {
     readonly loading: boolean;
     readonly modelValue: boolean;

package/dist/src/components/Textarea.vue.d.ts

@@ -14,8 +14,8 @@ declare const _default: import("vue").DefineComponent<{}, {
     readonly: boolean;
     rows: number;
     autoResize: boolean;
-    id?: string;
     error?: string;
+    id?: string;
     maxlength?: number;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;
@@ -31,8 +31,8 @@ declare const props: {
     readonly readonly: boolean;
     readonly rows: number;
     readonly autoResize: boolean;
-    readonly id?: string;
     readonly error?: string;
+    readonly id?: string;
     readonly maxlength?: number;
 };
 //# sourceMappingURL=Textarea.vue.d.ts.map