hys-ui 0.1.1 → 0.2.0

package/dist/types/components/HysRadioGroup/HysRadioGroup.vue.d.ts

@@ -1,37 +1,59 @@
-export interface HysRadioOption<V extends string | number = string> {
-    label: string;
-    value: V;
-    disabled?: boolean;
+import { type HysChoiceValue, type HysChoiceDataOption, type HysChoiceFieldNames, type HysChoiceOption } from "../../composables/choice";
+export interface HysRadioOption<V extends HysChoiceValue = string> extends HysChoiceOption<V> {
 }
-declare const __VLS_export: <T extends string | number = string>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+declare const __VLS_export: <T extends HysChoiceValue = string>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import("vue").PublicProps & __VLS_PrettifyLocal<{
-        modelValue?: T;
-        options: HysRadioOption<T>[];
+        modelValue?: T | null;
+        defaultValue?: T | null;
+        options?: readonly HysChoiceDataOption<T>[];
+        fieldNames?: HysChoiceFieldNames;
         name?: string;
+        form?: string;
         disabled?: boolean;
         readonly?: boolean;
         required?: boolean;
         vertical?: boolean;
         size?: "sm" | "md" | "lg";
         ariaLabel?: string;
+        type?: "radio" | "button";
+        buttonStyle?: "outline" | "solid";
+        border?: boolean;
+        block?: boolean;
+        loopNavigation?: boolean;
+        autofocus?: boolean;
+        error?: string;
+        status?: "error" | "warning" | "success";
+        emptyText?: string;
     } & {
-        "onUpdate:modelValue"?: ((value: T) => any) | undefined;
         onChange?: ((value: T) => any) | undefined;
-        onFocus?: ((event: FocusEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: T) => any) | undefined;
         onBlur?: ((event: FocusEvent) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
     }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
     } ? P : {});
     expose: (exposed: import("vue").ShallowUnwrapRef<{
-        focus: () => void;
+        value: import("vue").ComputedRef<HysChoiceValue | null>;
+        focus: (next?: HysChoiceValue) => void;
+        blur: () => void;
+        select: (next: HysChoiceValue) => Promise<boolean>;
     }>) => void;
     attrs: any;
     slots: {
         label?: (props: {
-            option: HysRadioOption<T>;
+            option: HysChoiceOption<T>;
+            checked: boolean;
         }) => any;
+    } & {
+        empty?: (props: {}) => any;
+    } & {
+        default?: (props: {
+            value: HysChoiceValue | null;
+        }) => any;
+    } & {
+        empty?: (props: {}) => any;
     };
-    emit: ((evt: "update:modelValue", value: T) => void) & ((evt: "change", value: T) => void) & ((evt: "focus", event: FocusEvent) => void) & ((evt: "blur", event: FocusEvent) => void);
+    emit: ((evt: "change", value: T) => void) & ((evt: "update:modelValue", value: T) => void) & ((evt: "blur", event: FocusEvent) => void) & ((evt: "focus", event: FocusEvent) => void);
 }>) => import("vue").VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };

package/dist/types/components/HysRating/HysRating.vue.d.ts

@@ -1,30 +1,110 @@
+import { type HysRatingIcon, type HysRatingLevels } from "../../composables/rating";
 type __VLS_Props = {
-    modelValue: number;
+    modelValue?: number | null;
+    defaultValue?: number;
     max?: number;
+    count?: number;
+    size?: "sm" | "md" | "lg";
+    iconSize?: number;
     readonly?: boolean;
     disabled?: boolean;
     allowClear?: boolean;
+    clearable?: boolean;
     allowHalf?: boolean;
     showScore?: boolean;
+    showText?: boolean;
+    texts?: readonly string[];
+    scoreTemplate?: string;
+    formatScore?: (value: number) => string;
+    textColor?: string;
+    color?: string;
+    colors?: HysRatingLevels<string>;
+    lowThreshold?: number;
+    highThreshold?: number;
+    voidColor?: string;
+    disabledVoidColor?: string;
+    icon?: HysRatingIcon;
+    icons?: HysRatingLevels<HysRatingIcon>;
+    voidIcon?: HysRatingIcon;
+    disabledVoidIcon?: HysRatingIcon;
+    character?: string;
+    tooltips?: readonly string[];
+    hoverValue?: number | null;
+    keyboard?: boolean;
+    autofocus?: boolean;
+    focusable?: boolean;
     ariaLabel?: string;
+    formatValueText?: (value: number, max: number) => string;
+    name?: string;
+    form?: string;
+    status?: "error" | "warning" | "success";
+    error?: string;
 };
+declare function resetPreview(): void;
+declare function setValue(value: number): Promise<boolean>;
+declare function clear(): Promise<boolean>;
+declare function focus(options?: FocusOptions): void;
+declare function blur(): void;
 declare const __VLS_template: () => {
     __VLS_Slots: {
         character?: (props: {
             value: number;
+            index: number;
+            fraction: number;
+            filled: boolean;
+        }) => any;
+    } & {
+        character?: (props: {
+            value: number;
+            index: number;
+            fraction: number;
+            filled: boolean;
+        }) => any;
+    } & {
+        text?: (props: {
+            value: number;
+            text: string;
         }) => any;
     };
 };
 type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: number) => any;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    value: import("vue").ComputedRef<number>;
+    hoverValue: import("vue").ComputedRef<number | null>;
+    focus: typeof focus;
+    blur: typeof blur;
+    setValue: typeof setValue;
+    clear: typeof clear;
+    setCurrentValue: (value: number) => void;
+    resetCurrentValue: typeof resetPreview;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     change: (value: number) => any;
+    "update:modelValue": (value: number) => any;
+    clear: () => any;
+    keydown: (event: KeyboardEvent) => any;
+    blur: (event: FocusEvent) => any;
+    focus: (event: FocusEvent) => any;
+    "update:hoverValue": (value: number | null) => any;
+    hoverChange: (value: number | null) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((value: number) => any) | undefined;
     onChange?: ((value: number) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    "onUpdate:hoverValue"?: ((value: number | null) => any) | undefined;
+    onHoverChange?: ((value: number | null) => any) | undefined;
 }>, {
-    max: number;
+    focusable: boolean;
+    defaultValue: number;
+    clearable: boolean;
+    keyboard: boolean;
     allowClear: boolean;
+    scoreTemplate: string;
+    lowThreshold: number;
+    highThreshold: number;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/types/components/HysRichTextEditor/HysRichTextEditor.vue.d.ts

@@ -13,15 +13,15 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {
     blur: () => void | undefined;
     getHTML: () => string;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: string) => any;
     change: (html: string) => any;
-    focus: (event: FocusEvent) => any;
+    "update:modelValue": (value: string) => any;
     blur: (event: FocusEvent) => any;
+    focus: (event: FocusEvent) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
-    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
     onChange?: ((html: string) => any) | undefined;
-    onFocus?: ((event: FocusEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
     onBlur?: ((event: FocusEvent) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/types/components/HysSearch/HysSearch.vue.d.ts

@@ -15,14 +15,14 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
     "update:modelValue": (value: string) => any;
     search: (value: string) => any;
     clear: () => any;
-    focus: (event: FocusEvent) => any;
     blur: (event: FocusEvent) => any;
+    focus: (event: FocusEvent) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
     onSearch?: ((value: string) => any) | undefined;
     onClear?: (() => any) | undefined;
-    onFocus?: ((event: FocusEvent) => any) | undefined;
     onBlur?: ((event: FocusEvent) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
 }>, {
     placeholder: string;
     clearable: boolean;

package/dist/types/components/HysSegmented/HysSegmented.vue.d.ts

@@ -1,39 +1,71 @@
-type __VLS_Props = {
-    modelValue: string;
-    options: {
-        label: string;
-        value: string;
+import { type HysChoiceValue, type HysChoiceDataOption, type HysChoiceFieldNames } from "../../composables/choice";
+import type { HysSegmentedOption } from "../../composables/segmented";
+declare const __VLS_export: <T extends HysChoiceValue = string>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
+        modelValue?: T | null;
+        defaultValue?: T | null;
+        options?: readonly HysChoiceDataOption<T>[];
+        fieldNames?: HysChoiceFieldNames;
         disabled?: boolean;
-    }[];
-    disabled?: boolean;
-    block?: boolean;
-    size?: 'sm' | 'md' | 'lg';
-    ariaLabel?: string;
-};
-declare const __VLS_template: () => {
-    __VLS_Slots: {
+        readonly?: boolean;
+        block?: boolean;
+        vertical?: boolean;
+        direction?: "horizontal" | "vertical";
+        size?: "sm" | "md" | "lg";
+        round?: boolean;
+        keyboard?: boolean;
+        loopNavigation?: boolean;
+        focusable?: boolean;
+        autofocus?: boolean;
+        ariaLabel?: string;
+        name?: string;
+        form?: string;
+        status?: "error" | "warning" | "success";
+        error?: string;
+        emptyText?: string;
+    } & {
+        onChange?: ((value: T) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: T) => any) | undefined;
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        value: import("vue").ComputedRef<HysChoiceValue | null>;
+        focus: (next?: HysChoiceValue) => void;
+        blur: () => void;
+        select: (next: HysChoiceValue) => Promise<boolean>;
+    }>) => void;
+    attrs: any;
+    slots: {
+        icon?: (props: {
+            option: HysSegmentedOption<T>;
+            checked: boolean;
+        }) => any;
+    } & {
         label?: (props: {
-            option: {
-                label: string;
-                value: string;
-                disabled?: boolean;
-            };
+            option: HysSegmentedOption<T>;
+            checked: boolean;
+        }) => any;
+    } & {
+        default?: (props: {
+            item: HysSegmentedOption<T>;
+            option: HysSegmentedOption<T>;
+            checked: boolean;
         }) => any;
+    } & {
+        empty?: (props: {}) => any;
     };
+    emit: ((evt: "change", value: T) => void) & ((evt: "update:modelValue", value: T) => void) & ((evt: "blur", event: FocusEvent) => void) & ((evt: "focus", event: FocusEvent) => void);
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };
-type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: string) => any;
-    change: (value: string) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-    onChange?: ((value: string) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;
-type __VLS_WithSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/types/components/HysSelect/HysSelect.vue.d.ts

@@ -1,60 +1,160 @@
-export interface HysSelectOption {
-    label: string;
-    value: string;
-    disabled?: boolean;
-}
-declare const __VLS_export: <T extends string | string[] = string>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+import { type CSSProperties } from "vue";
+import { type Placement } from "../../composables/useFloating";
+import { type HysSelectDataOption, type HysSelectFieldNames, type HysSelectModelValue, type HysSelectOption, type HysSelectSearchContext, type HysSelectValue } from "../../composables/selectOptions";
+declare const __VLS_export: <T extends HysSelectModelValue = string>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import("vue").PublicProps & __VLS_PrettifyLocal<{
-        modelValue: T;
-        options: HysSelectOption[];
+        modelValue?: T;
+        defaultValue?: T;
+        options?: HysSelectDataOption[];
+        fieldNames?: HysSelectFieldNames;
+        valueKey?: string;
         disabled?: boolean;
+        readonly?: boolean;
         ariaLabel?: string;
         placeholder?: string;
         multiple?: boolean;
         filterable?: boolean;
         clearable?: boolean;
+        emptyValues?: readonly unknown[];
+        clearValue?: HysSelectValue | null;
+        fallbackOption?: false | ((value: HysSelectValue) => HysSelectOption);
+        multipleLimit?: number;
+        maxTagCount?: number;
+        maxTagTextLength?: number;
+        removable?: boolean;
+        clearSearchAfterSelect?: boolean;
+        allowCreate?: boolean;
+        createOption?: (label: string) => HysSelectOption | false | null;
+        tokenSeparators?: string[];
+        clearCreatedOnClear?: boolean;
         loading?: boolean;
         remote?: boolean;
-        popupMatchWidth?: boolean;
+        remoteMethod?: (query: string, context: HysSelectSearchContext) => void | HysSelectDataOption[] | Promise<void | HysSelectDataOption[]>;
+        debounce?: number;
+        searchValue?: string;
         filterMethod?: (query: string, option: HysSelectOption) => boolean;
+        filterSort?: (a: HysSelectOption, b: HysSelectOption) => number;
+        open?: boolean;
+        defaultOpen?: boolean;
+        showOnFocus?: boolean;
+        retainSearch?: boolean;
+        defaultActiveFirst?: boolean;
+        keyboard?: boolean;
+        popupMatchWidth?: boolean;
+        popupWidth?: number | string;
+        placement?: Placement;
+        appendTo?: string | HTMLElement | false;
+        popupClass?: string;
+        popupStyle?: CSSProperties;
+        listHeight?: number;
+        virtual?: boolean;
+        itemHeight?: number;
+        overscan?: number;
         emptyText?: string;
+        noMatchText?: string;
+        loadingText?: string;
         size?: "sm" | "md" | "lg";
+        status?: "error" | "warning" | "success";
+        showArrow?: boolean;
+        showCheckmark?: boolean;
+        bordered?: boolean;
+        autofocus?: boolean;
+        name?: string;
     } & {
+        onChange?: ((value: T, options: HysSelectOption | HysSelectOption[] | undefined) => any) | undefined;
         "onUpdate:modelValue"?: ((value: T) => any) | undefined;
-        onChange?: ((value: T) => any) | undefined;
         onSearch?: ((query: string) => any) | undefined;
         onClear?: (() => any) | undefined;
+        onSelect?: ((value: HysSelectValue, option: HysSelectOption) => any) | undefined;
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+        "onUpdate:open"?: ((open: boolean) => any) | undefined;
         onVisibleChange?: ((open: boolean) => any) | undefined;
+        onSearchError?: ((error: unknown, query: string) => any) | undefined;
+        "onUpdate:searchValue"?: ((query: string) => any) | undefined;
+        onDeselect?: ((value: HysSelectValue, option: HysSelectOption) => any) | undefined;
+        onRemoveTag?: ((value: HysSelectValue, option: HysSelectOption) => any) | undefined;
+        onCreate?: ((option: HysSelectOption) => any) | undefined;
+        onReject?: ((value: HysSelectValue, reason: "create" | "limit") => any) | undefined;
+        onPopupScroll?: ((event: Event) => any) | undefined;
+        onReachEnd?: (() => any) | undefined;
     }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
     } ? P : {});
     expose: (exposed: import("vue").ShallowUnwrapRef<{
-        focus: () => void | undefined;
-        blur: () => void | undefined;
+        focus: () => void;
+        blur: () => void;
+        open: () => Promise<void>;
         close: () => void;
+        scrollTo: (value: HysSelectValue) => void;
+        retry: () => void;
+        selected: import("vue").ComputedRef<HysSelectOption[]>;
+        query: import("vue").ComputedRef<string>;
+        isOpen: import("vue").Ref<boolean, boolean>;
     }>) => void;
     attrs: any;
     slots: {
         label?: (props: {
-            selected: {
-                label: string;
-                value: string;
-                disabled?: boolean | undefined;
-            }[];
+            selected: HysSelectOption[];
+        }) => any;
+    } & {
+        tag?: (props: {
+            option: HysSelectOption;
+            remove: () => void;
+            disabled: boolean | undefined;
+        }) => any;
+    } & {
+        'remove-icon'?: (props: {}) => any;
+    } & {
+        'max-tag'?: (props: {
+            omitted: HysSelectOption[];
+        }) => any;
+    } & {
+        suffix?: (props: {
+            open: boolean;
+            loading: boolean;
+        }) => any;
+    } & {
+        'clear-icon'?: (props: {}) => any;
+    } & {
+        header?: (props: {
+            query: string;
+            selected: HysSelectOption[];
+            close: () => void;
         }) => any;
     } & {
         loading?: (props: {}) => any;
+    } & {
+        error?: (props: {
+            error: {};
+            retry: () => void;
+        }) => any;
+    } & {
+        group?: (props: {
+            label: string | undefined;
+        }) => any;
     } & {
         option?: (props: {
             option: HysSelectOption;
             selected: boolean;
+            created: boolean;
         }) => any;
     } & {
-        empty?: (props: {}) => any;
+        'selected-icon'?: (props: {
+            option: HysSelectOption;
+        }) => any;
     } & {
-        footer?: (props: {}) => any;
+        empty?: (props: {
+            query: string;
+        }) => any;
+    } & {
+        footer?: (props: {
+            query: string;
+            selected: HysSelectOption[];
+            close: () => void;
+        }) => any;
     };
-    emit: ((evt: "update:modelValue", value: T) => void) & ((evt: "change", value: T) => void) & ((evt: "search", query: string) => void) & ((evt: "clear") => void) & ((evt: "visibleChange", open: boolean) => void);
+    emit: ((evt: "change", value: T, options: HysSelectOption | HysSelectOption[] | undefined) => void) & ((evt: "update:modelValue", value: T) => void) & ((evt: "search", query: string) => void) & ((evt: "clear") => void) & ((evt: "select", value: HysSelectValue, option: HysSelectOption) => void) & ((evt: "blur", event: FocusEvent) => void) & ((evt: "focus", event: FocusEvent) => void) & ((evt: "update:open", open: boolean) => void) & ((evt: "visibleChange", open: boolean) => void) & ((evt: "searchError", error: unknown, query: string) => void) & ((evt: "update:searchValue", query: string) => void) & ((evt: "deselect", value: HysSelectValue, option: HysSelectOption) => void) & ((evt: "removeTag", value: HysSelectValue, option: HysSelectOption) => void) & ((evt: "create", option: HysSelectOption) => void) & ((evt: "reject", value: HysSelectValue, reason: "create" | "limit") => void) & ((evt: "popupScroll", event: Event) => void) & ((evt: "reachEnd") => void);
 }>) => import("vue").VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };

package/dist/types/components/HysSkeleton/HysSkeleton.vue.d.ts

@@ -1,23 +1,51 @@
+export type HysSkeletonVariant = "paragraph" | "text" | "circle" | "rect" | "image" | "button" | "input";
 type __VLS_Props = {
     lines?: number;
     loading?: boolean;
     active?: boolean;
     avatar?: boolean;
     avatarSize?: number;
+    avatarShape?: "circle" | "square";
     title?: boolean;
+    titleWidth?: number | string;
+    widths?: readonly (number | string)[];
+    round?: boolean;
+    count?: number;
+    variant?: HysSkeletonVariant;
+    width?: number | string;
+    height?: number | string;
+    delay?: number;
+    minDuration?: number;
+    loadingText?: string;
 };
 declare const __VLS_template: () => {
     __VLS_Slots: {
+        template?: (props: {
+            index: number;
+            active: boolean;
+        }) => any;
+    } & {
         default?: (props: {}) => any;
     };
 };
 type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    visibilityChange: (visible: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onVisibilityChange?: ((visible: boolean) => any) | undefined;
+}>, {
     title: boolean;
-    loading: boolean;
     active: boolean;
+    loading: boolean;
+    loadingText: string;
+    variant: HysSkeletonVariant;
     lines: number;
     avatarSize: number;
+    avatarShape: "circle" | "square";
+    titleWidth: string | number;
+    count: number;
+    delay: number;
+    minDuration: number;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/types/components/HysSlider/HysSlider.vue.d.ts

@@ -1,24 +1,81 @@
-declare const __VLS_export: <T extends number | [number, number] = number>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+import type { HysSliderValue, HysSliderStep, HysSliderMarks, HysSliderDragInfo } from "../../composables/slider";
+declare const __VLS_export: <T extends HysSliderValue = number>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import("vue").PublicProps & __VLS_PrettifyLocal<{
-        modelValue: T;
+        modelValue?: T;
+        defaultValue?: T;
+        range?: boolean;
         min?: number;
         max?: number;
-        step?: number;
+        step?: HysSliderStep;
         disabled?: boolean;
+        readonly?: boolean;
         label?: string;
+        ariaLabel?: string;
+        rangeStartLabel?: string;
+        rangeEndLabel?: string;
         showValue?: boolean;
-        marks?: Record<number, string>;
-        formatTooltip?: (value: number) => string;
+        marks?: HysSliderMarks;
+        formatTooltip?: (value: number) => string | number | null;
+        formatValueText?: (value: number) => string;
+        showTooltip?: boolean;
+        tooltipVisible?: boolean;
+        tooltipPlacement?: "top" | "bottom" | "left" | "right";
+        showStops?: boolean;
+        maxStops?: number;
+        included?: boolean;
+        reverse?: boolean;
+        vertical?: boolean;
+        height?: number | string;
+        size?: "sm" | "md" | "lg";
+        keyboard?: boolean;
+        draggableTrack?: boolean;
+        showInput?: boolean;
+        showInputControls?: boolean;
+        name?: string;
+        tabindex?: number;
+        autofocus?: boolean;
+        status?: "error" | "warning" | "success";
+        error?: string;
     } & {
-        "onUpdate:modelValue"?: ((value: T) => any) | undefined;
         onChange?: ((value: T) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: T) => any) | undefined;
+        onInput?: ((value: T) => any) | undefined;
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+        onDragStart?: ((value: T, info: HysSliderDragInfo) => any) | undefined;
+        onDragEnd?: ((value: T, info: HysSliderDragInfo) => any) | undefined;
     }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
     } ? P : {});
-    expose: (exposed: {}) => void;
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        dragging: import("vue").Ref<boolean, boolean>;
+        values: import("vue").ComputedRef<number[]>;
+        focus: (index?: number) => void;
+        blur: () => void;
+        setValue: (value: HysSliderValue) => void;
+        cancel: () => void;
+    }>) => void;
     attrs: any;
-    slots: {};
-    emit: ((evt: "update:modelValue", value: T) => void) & ((evt: "change", value: T) => void);
+    slots: {
+        thumb?: (props: {
+            value: number;
+            index: number;
+            dragging: boolean;
+        }) => any;
+    } & {
+        tooltip?: (props: {
+            value: number;
+            index: number;
+        }) => any;
+    } & {
+        mark?: (props: {
+            value: number;
+            label: string;
+            active: boolean;
+        }) => any;
+    };
+    emit: ((evt: "change", value: T) => void) & ((evt: "update:modelValue", value: T) => void) & ((evt: "input", value: T) => void) & ((evt: "blur", event: FocusEvent) => void) & ((evt: "focus", event: FocusEvent) => void) & ((evt: "dragStart", value: T, info: HysSliderDragInfo) => void) & ((evt: "dragEnd", value: T, info: HysSliderDragInfo) => void);
 }>) => import("vue").VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };