@witchcraft/ui 0.2.1 → 0.2.3

package/dist/runtime/components/LibInputDeprecated/LibInputDeprecated.d.vue.ts

@@ -0,0 +1,165 @@
+import { type HTMLAttributes, type InputHTMLAttributes } from "vue";
+import { type BaseInteractiveProps, type LabelProps, type LinkableByIdProps, type SuggestionsProps, type TailwindClassProp, type WrapperProps } from "../shared/props.js.js";
+type WrapperTypes = WrapperProps<"suggestions", HTMLAttributes> & WrapperProps<"wrapper", HTMLAttributes> & WrapperProps<"inner-wrapper", HTMLAttributes>;
+type RealProps = SuggestionsProps & LinkableByIdProps & LabelProps & BaseInteractiveProps & {
+    suggestions?: SuggestionsProps["suggestions"];
+    valid?: boolean;
+};
+interface Props extends 
+/** @vue-ignore */
+Partial<Omit<InputHTMLAttributes, "class" | "readonly" | "disabled" | "onSubmit"> & TailwindClassProp>, 
+/** @vue-ignore */
+Partial<WrapperTypes>, RealProps {
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<Props & {
+    values?: string[] | undefined;
+    modelValue: string;
+    inputValue?: string;
+}, {
+    suggestionsComponent: import("vue").Ref<{
+        suggestions: {
+            list: any[] | undefined;
+            filtered: any[] | undefined;
+            active: number;
+            available: boolean;
+            moreThanOneAvailable: boolean;
+            hasExactlyMatching: string | object | undefined;
+            hasValidSuggestion: boolean;
+            openable: boolean | undefined;
+            getLabel: (item: any) => string;
+            $open: boolean;
+            open: () => void;
+            close: () => void;
+            enterSelected: (doClose?: boolean) => void;
+            enterIndex: (num: number, doClose?: boolean) => void;
+            toggle: () => void;
+            cancel: () => void;
+            select: (num: number) => void;
+            prev: () => void;
+            next: () => void;
+            first: () => void;
+            last: () => void;
+        };
+        el: HTMLElement | null;
+        inputKeydownHandler: (e: KeyboardEvent) => void;
+        inputBlurHandler: (e: MouseEvent) => void;
+        inputFocusHandler: (e: FocusEvent) => void;
+    } | null, import("vue").ShallowUnwrapRef<{
+        suggestions: {
+            list: any[] | undefined;
+            filtered: any[] | undefined;
+            active: number;
+            available: boolean;
+            moreThanOneAvailable: boolean;
+            hasExactlyMatching: string | object | undefined;
+            hasValidSuggestion: boolean;
+            openable: boolean | undefined;
+            getLabel: (item: any) => string;
+            $open: boolean;
+            open: () => void;
+            close: () => void;
+            enterSelected: (doClose?: boolean) => void;
+            enterIndex: (num: number, doClose?: boolean) => void;
+            toggle: () => void;
+            cancel: () => void;
+            select: (num: number) => void;
+            prev: () => void;
+            next: () => void;
+            first: () => void;
+            last: () => void;
+        };
+        el: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+        inputKeydownHandler: (e: KeyboardEvent) => void;
+        inputBlurHandler: (e: MouseEvent) => void;
+        inputFocusHandler: (e: FocusEvent) => void;
+    }> | {
+        suggestions: {
+            list: any[] | undefined;
+            filtered: any[] | undefined;
+            active: number;
+            available: boolean;
+            moreThanOneAvailable: boolean;
+            hasExactlyMatching: string | object | undefined;
+            hasValidSuggestion: boolean;
+            openable: boolean | undefined;
+            getLabel: (item: any) => string;
+            $open: boolean;
+            open: () => void;
+            close: () => void;
+            enterSelected: (doClose?: boolean) => void;
+            enterIndex: (num: number, doClose?: boolean) => void;
+            toggle: () => void;
+            cancel: () => void;
+            select: (num: number) => void;
+            prev: () => void;
+            next: () => void;
+            first: () => void;
+            last: () => void;
+        };
+        el: HTMLElement | null;
+        inputKeydownHandler: (e: KeyboardEvent) => void;
+        inputBlurHandler: (e: MouseEvent) => void;
+        inputFocusHandler: (e: FocusEvent) => void;
+    } | null>;
+    el: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+    "update:inputValue": (value: string) => any;
+    "update:values": (value: string[] | undefined) => any;
+} & {
+    blur: (val: FocusEvent) => any;
+    input: (val: InputEvent) => any;
+    submit: (val: string, suggestion?: any) => any;
+    keydown: (val: KeyboardEvent) => any;
+    focus: (val: FocusEvent) => any;
+    indicatorClick: (val: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<Props & {
+    values?: string[] | undefined;
+    modelValue: string;
+    inputValue?: string;
+}> & Readonly<{
+    onBlur?: ((val: FocusEvent) => any) | undefined;
+    onInput?: ((val: InputEvent) => any) | undefined;
+    onSubmit?: ((val: string, suggestion?: any) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    "onUpdate:inputValue"?: ((value: string) => any) | undefined;
+    "onUpdate:values"?: ((value: string[] | undefined) => any) | undefined;
+    onKeydown?: ((val: KeyboardEvent) => any) | undefined;
+    onFocus?: ((val: FocusEvent) => any) | undefined;
+    onIndicatorClick?: ((val: MouseEvent) => any) | undefined;
+}>, {
+    disabled: boolean;
+    readonly: boolean;
+    border: boolean;
+    unstyle: boolean;
+    valid: boolean;
+    suggestions: any[];
+    updateOnlyOnSubmit: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    label?: (props: any) => any;
+} & {
+    default?: (props: any) => any;
+} & {
+    left?: (props: any) => any;
+} & {
+    input?: (props: any) => any;
+} & {
+    indicator?: (props: {
+        isOpen: any;
+        suggestionsIndicatorClickHandler: any;
+    }) => any;
+} & {
+    values?: (props: any) => any;
+} & {
+    right?: (props: any) => any;
+} & {
+    suggestions?: (props: any) => any;
+} & {
+    'suggestion-item'?: (props: any) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/LibLabel/LibLabel.d.vue.ts

@@ -0,0 +1,26 @@
+import type { LabelHTMLAttributes } from "vue";
+import type { BaseInteractiveProps, LabelProps, LinkableByIdProps, TailwindClassProp } from "../shared/props.js.js";
+type RealProps = LinkableByIdProps & LabelProps & BaseInteractiveProps & {
+    unstyled?: boolean;
+    valid?: boolean;
+};
+interface Props extends 
+/** @vue-ignore */
+Partial<Omit<LabelHTMLAttributes, "class"> & TailwindClassProp>, RealProps {
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
+    id: string;
+    disabled: boolean;
+    readonly: boolean;
+    border: boolean;
+    unstyle: boolean;
+    valid: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/LibMultiValues/LibMultiValues.d.vue.ts

@@ -0,0 +1,29 @@
+import { type HTMLAttributes } from "vue";
+import type { BaseInteractiveProps, LabelProps, TailwindClassProp, WrapperProps } from "../shared/props.js.js";
+type WrapperTypes = Partial<WrapperProps<"item", HTMLAttributes>>;
+type RealProps = LabelProps & BaseInteractiveProps & {
+    border?: boolean;
+};
+interface Props extends 
+/** @vue-ignore */
+Partial<Omit<HTMLAttributes, "class"> & TailwindClassProp>, 
+/** @vue-ignore */
+WrapperTypes, RealProps {
+}
+declare const _default: <T extends string | number>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value: T[]) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onUpdate:modelValue"> & (Props & {
+        modelValue?: T[];
+    }) & {}> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: (evt: "update:modelValue", value: T[]) => void;
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T as K]: T[K];
+} & {};

package/dist/runtime/components/LibNotifications/LibNotification.d.vue.ts

@@ -0,0 +1,17 @@
+import { type HTMLAttributes } from "vue";
+import { type NotificationEntry, NotificationHandler } from "../../helpers/NotificationHandler.js.js";
+import type { TailwindClassProp } from "../shared/props.js.js";
+type RealProps = {
+    notification: NotificationEntry;
+    handler?: NotificationHandler;
+};
+interface Props extends 
+/** @vue-ignore */
+Partial<Omit<HTMLAttributes, "class"> & TailwindClassProp>, RealProps {
+}
+declare const _default: import("vue").DefineComponent<Props, {
+    focus: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
+    handler: NotificationHandler;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/components/LibNotifications/LibNotifications.d.vue.ts

@@ -0,0 +1,13 @@
+import { NotificationHandler } from "../../helpers/NotificationHandler.js.js";
+import type { LinkableByIdProps, TailwindClassProp } from "../shared/props.js.js";
+import type { HTMLAttributes } from "vue";
+type RealProps = LinkableByIdProps & {
+    /** If not provided, uses the global handler (this requires useNotificationHandler be called and configured). */
+    handler?: NotificationHandler;
+};
+interface Props extends 
+/** @vue-ignore */
+Partial<Omit<HTMLAttributes, "class"> & TailwindClassProp>, RealProps {
+}
+declare const _default: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/components/LibPagination/LibPagination.d.vue.ts

@@ -0,0 +1,104 @@
+import { type HTMLAttributes } from "vue";
+import type { TailwindClassProp } from "../shared/props.js.js";
+/**
+ * Pagination component.
+ *
+ * Can be passed a slot like so to use a custom link element (like NuxtLink):
+ * ```vue
+ * <template #link="{ href, i, text, ariaLabel, ariaCurrent}">
+ * 	<NuxtLink :to="href" :aria-label="ariaLabel" :aria-current="ariaCurrent ?? false">{{ text ?? i }}</NuxtLink>
+ * </template>
+ * ```
+ */
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
+    customRoute: (route: string, i: number) => {
+        i: number;
+        href: string;
+    };
+    extraPages: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    link?: (props: {
+        class: string;
+        i: any;
+        href: any;
+        text: any;
+        ariaLabel: any;
+    }) => any;
+} & {
+    link?: (props: {
+        class: string;
+        i: number;
+        href: any;
+        text: any;
+        ariaLabel: any;
+    }) => any;
+} & {
+    link?: (props: {
+        i: any;
+        href: any;
+        ariaLabel: any;
+        class: string;
+    }) => any;
+} & {
+    current?: (props: {
+        tabindex: string;
+        i: any;
+        ariaLabel: any;
+        aria_current: boolean;
+        class: string;
+    }) => any;
+} & {
+    link?: (props: {
+        i: any;
+        href: any;
+        ariaLabel: any;
+        class: string;
+    }) => any;
+} & {
+    link?: (props: {
+        i: any;
+        href: any;
+        text: any;
+        ariaLabel: any;
+        class: string;
+    }) => any;
+} & {
+    link?: (props: {
+        i: any;
+        href: any;
+        text: any;
+        ariaLabel: any;
+        class: string;
+    }) => any;
+}>;
+export default _default;
+type RealProps = {
+    /** The total number of pages. */
+    total: number;
+    /** The number of the current page. It must be valid, between 0 - total or the component will throw an error. */
+    current: number;
+    /** The base route/link path for the page. Should end with a forward slash `/`. */
+    route: string;
+    /**
+     * A function to customize the output href and page link number. By default, page 0 is page 1, page 1 is 1, then everything else is normal.
+     *
+     * This is because usually we have routes like: `/page/1`, `/page/2`, not `/page/0`.
+     *
+     * You can use this function to customize things further. For example, make `/page/1` just `/`
+     */
+    customRoute?: (route: string, i: number) => {
+        i: number;
+        href: string;
+    };
+    /** How many extra pages to show to each side of the current page. */
+    extraPages?: number;
+};
+interface Props extends 
+/** @vue-ignore */
+Partial<Omit<HTMLAttributes, "class"> & TailwindClassProp>, RealProps {
+}
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/LibPalette/LibPalette.d.vue.ts

@@ -0,0 +1,14 @@
+import type { Theme } from "metamorphosis";
+import type { BaseInteractiveProps, LinkableByIdProps } from "../shared/props.js.js";
+declare const _default: import("vue").DefineComponent<LinkableByIdProps & BaseInteractiveProps & {
+    theme?: Theme;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LinkableByIdProps & BaseInteractiveProps & {
+    theme?: Theme;
+}> & Readonly<{}>, {
+    theme: Theme;
+    disabled: boolean;
+    readonly: boolean;
+    border: boolean;
+    unstyle: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/components/LibPopup/LibPopup.d.vue.ts

@@ -0,0 +1,46 @@
+import { type HTMLAttributes } from "vue";
+import { type LinkableByIdProps, type TailwindClassProp, type PopupProps } from "../shared/props.js.js";
+import type { IPopupReference } from "../../types/index.js.js";
+type RealProps = LinkableByIdProps & PopupProps;
+interface Props extends 
+/** @vue-ignore */
+Partial<Omit<HTMLAttributes, "class"> & TailwindClassProp>, RealProps {
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<Props & {
+    modelValue?: boolean;
+}, {
+    recompute: (force?: boolean) => void;
+    setReference: (el: IPopupReference | null) => void;
+    setBackground: (el: IPopupReference | null) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+} & {
+    close: () => any;
+}, string, import("vue").PublicProps, Readonly<Props & {
+    modelValue?: boolean;
+}> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onClose?: (() => any) | undefined;
+}>, {
+    canClose: boolean;
+    useDialogForBackdrop: false;
+    useBackdrop: boolean;
+    preferredHorizontal: ("center" | "right" | "left" | "either" | "center-screen" | "right-most" | "left-most" | "center-most")[] | import("../../main.lib.js.js").PopupPositioner;
+    preferredVertical: ("top" | "bottom" | "center" | "either" | "center-screen" | "top-most" | "bottom-most" | "center-most")[] | import("../../main.lib.js.js").PopupPositioner;
+    avoidRepositioning: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    button?: (props: {
+        extractEl: (_: any) => any;
+    }) => any;
+} & {
+    popup?: (props: {
+        position: any;
+        extractEl: (_: any) => any;
+    }) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/LibProgressBar/LibProgressBar.d.vue.ts

@@ -0,0 +1,41 @@
+import { type BaseInteractiveProps, type LabelProps, type LinkableByIdProps, type TailwindClassProp } from "../shared/props.js.js";
+import type { HTMLAttributes } from "vue";
+type RealProps = LinkableByIdProps & BaseInteractiveProps & LabelProps & {
+    progress: number;
+    /** Will auto hide after this given time if progress is 100% or more or less than 0% until progress is set to something else. Disabled (-1) by default. */
+    autohideOnComplete?: number;
+    /**
+     * Do not actually hide the element, just leave an unstyled div,
+     * so the whole layout doesn't change on completion when autohideOnComplete is set.
+     */
+    keepSpaceWhenHidden?: boolean;
+    /**
+     * By default the progress bar is visually clamped to 0-100, even if the value might be something else.
+     * You can change what it's clamped to here, to for example,
+     * show at least a small sliver of the progress bar when it's still 0.
+     */
+    clamp?: [start: number, end: number];
+};
+interface Props extends 
+/** @vue-ignore */
+Partial<Omit<HTMLAttributes, "class"> & TailwindClassProp>, RealProps {
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {
+    disabled: boolean;
+    readonly: boolean;
+    border: boolean;
+    unstyle: boolean;
+    autohideOnComplete: number;
+    keepSpaceWhenHidden: boolean;
+    clamp: [start: number, end: number];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+} & {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/LibRecorder/LibRecorder.d.vue.ts

@@ -0,0 +1,77 @@
+import { type HTMLAttributes } from "vue";
+import { type BaseInteractiveProps, type LabelProps, type LinkableByIdProps, type TailwindClassProp } from "../shared/props.js.js";
+type RealProps = LinkableByIdProps & BaseInteractiveProps & LabelProps & {
+    border?: boolean;
+    /** A value to display while recording, if none given the i18n `recorder.recording` key is used. */
+    recordingValue?: string;
+    /** A title to display on the input div while recording. Is also used as the aria-description. */
+    recordingTitle?: string;
+    /**
+     * The recorder object is a series of event listeners to attach to the input div while recording is started. If you need to bind directly to the element, see the `binders` prop.
+     *
+     * The listeners are then unbound when recording is set to false again.
+     *
+     * Note that the component does not handle the setting of `recording` (unless the component is disabled), `modelValue`,  or `recordingValue` at all and has no mechanism for cancelling a recording. It is left to the recorder listeners and any `recorder:*` handlers to determine what to do.
+     */
+    recorder?: undefined | Record<string, any>;
+    /** This provides a way to manually attach/remove event listeners to/from the element. It is an alternative to the `recorder` prop, see it for more details. Both cannot be specified at the same time. */
+    binders?: undefined | {
+        bind: (el: HTMLElement) => void;
+        unbind: (el: HTMLElement) => void;
+    };
+    /** The id of the element. If not provided, the id will be generated automatically. */
+    id?: string;
+};
+interface Props extends 
+/** @vue-ignore */
+Partial<Omit<HTMLAttributes, "class"> & TailwindClassProp>, RealProps {
+}
+declare const _default: import("vue").DefineComponent<Props & {
+    /**
+     * Puts the element into recording mode if true. See {@link props.recorder}.
+     */
+    recording?: boolean;
+    /** The final value of the recorder. For intermediate values while recording, pass a recorder and set an appropriate recording value. */
+    modelValue: string;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+    "update:recording": (value: boolean) => any;
+} & {
+    "recorder:blur": ($event: FocusEvent) => any;
+    "recorder:click": (args_0: {
+        event: MouseEvent | KeyboardEvent;
+        indicator: HTMLElement;
+        input: HTMLInputElement;
+    }) => any;
+    "focus:parent": () => any;
+}, string, import("vue").PublicProps, Readonly<Props & {
+    /**
+     * Puts the element into recording mode if true. See {@link props.recorder}.
+     */
+    recording?: boolean;
+    /** The final value of the recorder. For intermediate values while recording, pass a recorder and set an appropriate recording value. */
+    modelValue: string;
+}> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    "onUpdate:recording"?: ((value: boolean) => any) | undefined;
+    "onRecorder:blur"?: (($event: FocusEvent) => any) | undefined;
+    "onRecorder:click"?: ((args_0: {
+        event: MouseEvent | KeyboardEvent;
+        indicator: HTMLElement;
+        input: HTMLInputElement;
+    }) => any) | undefined;
+    "onFocus:parent"?: (() => any) | undefined;
+}>, {
+    id: string;
+    disabled: boolean;
+    readonly: boolean;
+    border: boolean;
+    unstyle: boolean;
+    recordingTitle: string;
+    recorder: Record<string, any>;
+    binders: {
+        bind: (el: HTMLElement) => void;
+        unbind: (el: HTMLElement) => void;
+    };
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/components/LibRoot/LibRoot.d.vue.ts

@@ -0,0 +1,41 @@
+import type { Theme } from "metamorphosis";
+import { NotificationHandler } from "../../helpers/NotificationHandler.js.js";
+type __VLS_Props = {
+    theme?: Theme;
+    outline?: boolean;
+    forceOutline?: boolean;
+    testWrapperMode?: boolean;
+    id?: string;
+    /** You can set a ref to the root element by passing :getRef="_ => el = _" */
+    getRef?: (el: HTMLElement | null) => void;
+    /** True by default, should be passed import.meta.client if using nuxt, or false when running server side. */
+    isClientSide?: boolean;
+    useBuiltinTranslations?: boolean;
+    useNotifications?: boolean;
+    notificationHandler?: NotificationHandler;
+};
+declare var __VLS_9: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_9) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {
+    darkMode: import("../../composables/useDarkMode.js.js").DarkModeState & import("../../composables/useDarkMode.js.js").DarkModeCommands;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    theme: Theme;
+    id: string;
+    useBuiltinTranslations: boolean;
+    isClientSide: boolean;
+    outline: boolean;
+    forceOutline: boolean;
+    testWrapperMode: boolean;
+    getRef: (el: HTMLElement | null) => void;
+    useNotifications: boolean;
+    notificationHandler: NotificationHandler;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/LibSimpleInput/LibSimpleInput.d.vue.ts

@@ -0,0 +1,35 @@
+import { type InputHTMLAttributes } from "vue";
+import { type BaseInteractiveProps, type LabelProps, type LinkableByIdProps, type TailwindClassProp } from "../shared/props.js.js";
+type RealProps = LinkableByIdProps & LabelProps & BaseInteractiveProps & {
+    placeholder?: InputHTMLAttributes["placeholder"];
+    disabled?: InputHTMLAttributes["disabled"];
+    id?: InputHTMLAttributes["id"];
+    type?: InputHTMLAttributes["type"];
+    valid?: boolean;
+};
+interface Props extends 
+/** @vue-ignore */
+Partial<Omit<InputHTMLAttributes, "class" | "readonly" | "disabled" | "onSubmit" | "onInput"> & TailwindClassProp>, RealProps {
+}
+declare const _default: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onInput?: ((val: InputEvent) => any) | undefined;
+        readonly onSubmit?: ((val: T) => any) | undefined;
+        readonly "onUpdate:modelValue"?: ((value: T) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onInput" | "onSubmit" | "onUpdate:modelValue"> & (Props & {
+        modelValue: T;
+    }) & {}> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: {
+        (e: "submit", val: T): void;
+        (e: "input", val: InputEvent): void;
+    } & ((evt: "update:modelValue", value: T) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T as K]: T[K];
+} & {};