hys-ui 0.1.1 → 0.3.0

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

@@ -1,57 +1,80 @@
-type __VLS_Props = {
-    modelValue?: string;
-    placeholder?: string;
-    type?: string;
-    disabled?: boolean;
-    readonly?: boolean;
-    ariaLabel?: string;
-    error?: string;
-    clearable?: boolean;
-    showPassword?: boolean;
-    showCount?: boolean;
-    maxlength?: number;
-    minlength?: number;
-    autocomplete?: string;
-    name?: string;
-    size?: 'sm' | 'md' | 'lg';
-};
+import { type HysInputProps } from "../../composables/textInput";
+declare function clear(): void;
 declare const __VLS_template: () => {
     __VLS_Slots: {
         prepend?: (props: {}) => any;
     } & {
         prefix?: (props: {}) => any;
+    } & {
+        'clear-icon'?: (props: {}) => any;
+    } & {
+        'password-icon'?: (props: {
+            visible: boolean;
+        }) => any;
     } & {
         suffix?: (props: {}) => any;
+    } & {
+        count?: (props: {
+            value: string;
+            count: number;
+            maxLength: number | undefined;
+        }) => any;
     } & {
         append?: (props: {}) => any;
+    } & {
+        count?: (props: {
+            value: string;
+            count: number;
+            maxLength: number | undefined;
+        }) => any;
     };
 };
 type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
-    input: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
-    focus: () => void | undefined;
+declare const __VLS_base: import("vue").DefineComponent<HysInputProps, {
+    input: import("vue").Ref<HTMLInputElement | HTMLTextAreaElement | undefined, HTMLInputElement | HTMLTextAreaElement | undefined>;
+    textarea: import("vue").ComputedRef<HTMLTextAreaElement | undefined>;
+    isComposing: import("vue").Ref<boolean, boolean>;
+    focus: (options?: FocusOptions) => void;
     blur: () => void | undefined;
     select: () => void | undefined;
+    clear: typeof clear;
+    resize: () => Promise<void>;
+    setSelectionRange: (start: number, end: number, direction?: "forward" | "backward" | "none") => void;
+    scrollTo: (options: ScrollToOptions) => void | undefined;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: string) => any;
     change: (value: string) => any;
-    input: (value: string) => any;
+    "update:modelValue": (value: string) => any;
     clear: () => any;
-    focus: (event: FocusEvent) => any;
+    input: (value: string) => any;
     blur: (event: FocusEvent) => any;
+    compositionend: (event: CompositionEvent) => any;
+    compositionstart: (event: CompositionEvent) => any;
+    compositionupdate: (event: CompositionEvent) => any;
+    focus: (event: FocusEvent) => any;
     pressEnter: (event: KeyboardEvent) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    "update:passwordVisible": (value: boolean) => any;
+    passwordVisibleChange: (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<HysInputProps> & Readonly<{
     onChange?: ((value: string) => any) | undefined;
-    onInput?: ((value: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
     onClear?: (() => any) | undefined;
-    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onInput?: ((value: string) => any) | undefined;
     onBlur?: ((event: FocusEvent) => any) | undefined;
+    onCompositionend?: ((event: CompositionEvent) => any) | undefined;
+    onCompositionstart?: ((event: CompositionEvent) => any) | undefined;
+    onCompositionupdate?: ((event: CompositionEvent) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
     onPressEnter?: ((event: KeyboardEvent) => any) | undefined;
+    "onUpdate:passwordVisible"?: ((value: boolean) => any) | undefined;
+    onPasswordVisibleChange?: ((value: boolean) => any) | undefined;
 }>, {
-    modelValue: string;
+    bordered: boolean;
     type: string;
-    size: "sm" | "md" | "lg";
+    resize: "none" | "both" | "horizontal" | "vertical";
+    showPasswordOn: "click" | "mousedown";
+    passwordVisible: boolean;
+    countPosition: "inside" | "outside";
+    rows: 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/HysMention/HysMention.vue.d.ts

@@ -1,4 +1,5 @@
-type __VLS_Props = {
+import type { HysPopupMotionProps } from '../../motion/popup';
+type __VLS_Props = HysPopupMotionProps & {
     users: {
         id: string;
         name: string;
@@ -30,15 +31,15 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
     focus: () => void | undefined;
     blur: () => void | undefined;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: string) => any;
     change: (value: string) => any;
+    "update:modelValue": (value: string) => any;
     select: (user: {
         id: string;
         name: string;
     }) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
-    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
     onChange?: ((value: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
     onSelect?: ((user: {
         id: string;
         name: string;

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

@@ -1,45 +1,122 @@
-type __VLS_Props = {
-    open: boolean;
-    title: string;
-    width?: string;
-    closeOnMask?: boolean;
-    closeOnEscape?: boolean;
-    showClose?: boolean;
-    destroyOnClose?: boolean;
-    fullscreen?: boolean;
-    placement?: 'left' | 'right' | 'top' | 'bottom';
-    beforeClose?: (reason: 'mask' | 'escape' | 'button') => boolean | void | Promise<boolean | void>;
-};
-declare function requestClose(reason?: 'mask' | 'escape' | 'button'): Promise<void>;
-declare const __VLS_template: () => {
-    __VLS_Slots: {
-        header?: (props: {}) => any;
-    } & {
-        default?: (props: {}) => any;
-    } & {
-        footer?: (props: {
-            close: typeof requestClose;
-            closing: boolean;
-        }) => any;
-    };
-};
-type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
-    close: typeof requestClose;
+import { type TransitionProps } from "vue";
+import { type HysModalProps, type HysModalSlots } from "../../composables/modal";
+type __VLS_Slots = HysModalSlots;
+declare const __VLS_base: import("vue").DefineComponent<HysModalProps, {
     element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    open: import("vue").Ref<boolean, boolean>;
+    closing: import("vue").ComputedRef<boolean>;
+    confirming: import("vue").ComputedRef<boolean>;
+    fullscreen: import("vue").ComputedRef<boolean>;
+    readonly position: import("../../index.js").HysModalPosition;
+    readonly dimensions: import("../../index.js").HysModalSize | undefined;
+    show: () => Promise<boolean>;
+    hide: () => Promise<boolean>;
+    close: (reasonOrEvent?: import("../../index.js").HysModalCloseReason | Event, event?: Event) => Promise<boolean>;
+    handleOpen: () => Promise<boolean>;
+    handleClose: () => Promise<boolean>;
+    confirm: (event?: Event) => Promise<boolean>;
+    cancel: (event?: Event) => Promise<boolean>;
+    focus: () => void;
+    toggleFullscreen: () => Promise<boolean>;
+    setFullscreen: (value: boolean) => Promise<boolean>;
+    resetPosition: () => void;
+    resetSize: () => void;
+    setPosition: (next: import("../../index.js").HysModalPosition) => void;
+    setSize: (next: import("../../index.js").HysModalSize) => void;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
     close: () => any;
-    closeError: (error: unknown) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    closeError: (error: unknown, context: import("../../index.js").HysModalActionContext) => any;
+    afterClose: () => any;
+    visibleChange: (value: boolean) => any;
+    cancel: (context: import("../../index.js").HysModalActionContext) => any;
+    drag: (position: import("../../index.js").HysModalPosition) => any;
+    resize: (size: import("../../index.js").HysModalSize) => any;
+    open: () => any;
+    "update:open": (value: boolean) => any;
+    opened: () => any;
+    closed: () => any;
+    ok: (context: import("../../index.js").HysModalActionContext) => any;
+    dragEnd: (position: import("../../index.js").HysModalPosition, info: {
+        cancelled: boolean;
+    }) => any;
+    resizeEnd: (size: import("../../index.js").HysModalSize, info: {
+        cancelled: boolean;
+    }) => any;
+    dragStart: (position: import("../../index.js").HysModalPosition) => any;
+    resizeStart: (size: import("../../index.js").HysModalSize) => any;
+    openAutoFocus: (event: Event) => any;
+    closeAutoFocus: (event: Event) => any;
+    confirmError: (error: unknown, context: import("../../index.js").HysModalActionContext) => any;
+    "update:fullscreen": (value: boolean) => any;
+    fullscreenChange: (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<HysModalProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
     onClose?: (() => any) | undefined;
-    onCloseError?: ((error: unknown) => any) | undefined;
+    onCloseError?: ((error: unknown, context: import("../../index.js").HysModalActionContext) => any) | undefined;
+    onAfterClose?: (() => any) | undefined;
+    onVisibleChange?: ((value: boolean) => any) | undefined;
+    onCancel?: ((context: import("../../index.js").HysModalActionContext) => any) | undefined;
+    onDrag?: ((position: import("../../index.js").HysModalPosition) => any) | undefined;
+    onResize?: ((size: import("../../index.js").HysModalSize) => any) | undefined;
+    onOpen?: (() => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    onOpened?: (() => any) | undefined;
+    onClosed?: (() => any) | undefined;
+    onOk?: ((context: import("../../index.js").HysModalActionContext) => any) | undefined;
+    onDragEnd?: ((position: import("../../index.js").HysModalPosition, info: {
+        cancelled: boolean;
+    }) => any) | undefined;
+    onResizeEnd?: ((size: import("../../index.js").HysModalSize, info: {
+        cancelled: boolean;
+    }) => any) | undefined;
+    onDragStart?: ((position: import("../../index.js").HysModalPosition) => any) | undefined;
+    onResizeStart?: ((size: import("../../index.js").HysModalSize) => any) | undefined;
+    onOpenAutoFocus?: ((event: Event) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+    onConfirmError?: ((error: unknown, context: import("../../index.js").HysModalActionContext) => any) | undefined;
+    "onUpdate:fullscreen"?: ((value: boolean) => any) | undefined;
+    onFullscreenChange?: ((value: boolean) => any) | undefined;
 }>, {
-    width: string;
-    placement: "left" | "right" | "top" | "bottom";
-    closeOnMask: boolean;
+    modelValue: boolean;
+    size: import("../../index.js").HysModalSizeName;
+    footer: boolean;
+    title: string;
+    type: import("../../index.js").HysModalType;
+    transition: string | false | TransitionProps;
+    showIcon: boolean;
+    closeText: string;
+    open: boolean;
+    appendTo: string | false | HTMLElement;
+    loadingText: string;
+    fullscreen: boolean;
     closeOnEscape: boolean;
+    cancelText: string;
+    initialFocus: import("../../index.js").HysModalInitialFocus;
+    closeOnMask: boolean;
     showClose: boolean;
     destroyOnClose: boolean;
+    modal: boolean;
+    lockScroll: boolean;
+    trapFocus: boolean;
+    restoreFocus: boolean;
+    headerSize: import("../../index.js").HysModalSectionSize;
+    footerSize: import("../../index.js").HysModalSectionSize;
+    headerAriaLevel: number;
+    fullscreenText: string;
+    restoreText: string;
+    showCancel: boolean;
+    okText: string;
+    showError: boolean;
+    closeOnConfirm: boolean;
+    resetSizeOnClose: boolean;
+    centered: boolean;
+    dragHandlePosition: "left" | "right" | "center" | "both";
+    dragMode: "preview" | "live";
+    dragThreshold: number;
+    dragEffect: import("../../index.js").HysModalDragEffect;
+    keepHandleVisible: boolean;
+    resetPositionOnClose: boolean;
 }, {}, {}, {}, 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/HysNumberInput/HysNumberInput.vue.d.ts

@@ -1,38 +1,96 @@
-type __VLS_Props = {
-    modelValue: number;
-    min?: number;
-    max?: number;
-    step?: number;
-    precision?: number;
-    stepStrictly?: boolean;
-    disabled?: boolean;
-    readonly?: boolean;
-    ariaLabel?: string;
-    showControls?: boolean;
-    selectOnFocus?: boolean;
-    size?: 'sm' | 'md' | 'lg';
+import { type HysNumberInputValue, type HysNumberInputFormatInfo, type HysNumberInputInvalidInfo, type HysNumberInputStepInfo } from "../../composables/numberInput";
+declare const __VLS_export: <T extends HysNumberInputValue = number | null>(__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;
+        defaultValue?: T;
+        min?: number | string;
+        max?: number | string;
+        step?: number | string;
+        stepBase?: number | string;
+        precision?: number;
+        stepStrictly?: boolean;
+        stringMode?: boolean;
+        valueOnClear?: number | string | null;
+        clearable?: boolean;
+        updateOnInput?: boolean;
+        formatter?: (value: HysNumberInputValue, info: HysNumberInputFormatInfo) => string;
+        parser?: (input: string) => number | string | null | undefined;
+        decimalSeparator?: string;
+        validator?: (value: HysNumberInputValue) => boolean;
+        allowInput?: (input: string) => boolean;
+        disabled?: boolean;
+        readonly?: boolean;
+        loading?: boolean;
+        ariaLabel?: string;
+        placeholder?: string;
+        name?: string;
+        error?: string;
+        status?: "error" | "warning" | "success";
+        showControls?: boolean;
+        controlsPosition?: "both" | "right";
+        selectOnFocus?: boolean;
+        keyboard?: boolean | Partial<Record<"ArrowUp" | "ArrowDown" | "Home" | "End" | "PageUp" | "PageDown", boolean>>;
+        wheel?: boolean;
+        repeat?: boolean;
+        repeatDelay?: number;
+        repeatInterval?: number;
+        size?: "sm" | "md" | "lg";
+        bordered?: boolean;
+        round?: boolean;
+        block?: boolean;
+        autofocus?: boolean;
+        align?: "left" | "center" | "right";
+    } & {
+        onChange?: ((value: T) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: T) => any) | undefined;
+        onClear?: (() => any) | undefined;
+        onInput?: ((value: T | null) => any) | undefined;
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+        onInvalid?: ((info: HysNumberInputInvalidInfo) => any) | undefined;
+        onPressEnter?: ((event: KeyboardEvent) => any) | undefined;
+        onStep?: ((value: T, info: HysNumberInputStepInfo) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        input: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+        focus: (options?: FocusOptions) => void;
+        blur: () => void | undefined;
+        select: () => void | undefined;
+        clear: () => void;
+        commit: (text?: string) => boolean;
+        increase: (multiplier?: number) => boolean;
+        decrease: (multiplier?: number) => boolean;
+    }>) => void;
+    attrs: any;
+    slots: {
+        prepend?: (props: {}) => any;
+    } & {
+        prefix?: (props: {}) => any;
+    } & {
+        suffix?: (props: {}) => any;
+    } & {
+        'clear-icon'?: (props: {}) => any;
+    } & {
+        'decrease-icon'?: (props: {}) => any;
+    } & {
+        'increase-icon'?: (props: {}) => any;
+    } & {
+        'increase-icon'?: (props: {}) => any;
+    } & {
+        'decrease-icon'?: (props: {}) => any;
+    } & {
+        append?: (props: {}) => any;
+    };
+    emit: ((evt: "change", value: T) => void) & ((evt: "update:modelValue", value: T) => void) & ((evt: "clear") => void) & ((evt: "input", value: T | null) => void) & ((evt: "blur", event: FocusEvent) => void) & ((evt: "focus", event: FocusEvent) => void) & ((evt: "invalid", info: HysNumberInputInvalidInfo) => void) & ((evt: "pressEnter", event: KeyboardEvent) => void) & ((evt: "step", value: T, info: HysNumberInputStepInfo) => void);
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
-    focus: () => void | undefined;
-    blur: () => void | undefined;
-    select: () => void | undefined;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: number) => any;
-    change: (value: number) => any;
-    input: (value: number | null) => any;
-    focus: (event: FocusEvent) => any;
-    blur: (event: FocusEvent) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((value: number) => any) | undefined;
-    onChange?: ((value: number) => any) | undefined;
-    onInput?: ((value: number | null) => any) | undefined;
-    onFocus?: ((event: FocusEvent) => any) | undefined;
-    onBlur?: ((event: FocusEvent) => any) | undefined;
-}>, {
-    size: "sm" | "md" | "lg";
-    step: number;
-    showControls: boolean;
-    selectOnFocus: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;
+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/HysOrgTree/HysOrgTree.vue.d.ts

@@ -10,6 +10,7 @@ type __VLS_Props = {
     searchable?: boolean;
     checkable?: boolean;
     checkedKeys?: string[];
+    disabled?: boolean;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (id: string) => any;

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

@@ -33,13 +33,13 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     "onUpdate:pageSize"?: ((size: number) => any) | undefined;
 }>, {
     disabled: boolean;
+    compact: boolean;
     loading: boolean;
     pageSize: number;
     siblingCount: number;
     showSizeChanger: boolean;
     showQuickJumper: boolean;
     showTotal: boolean;
-    compact: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -7,11 +7,11 @@ type __VLS_Props = {
     showSelectAll?: boolean;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: Record<string, boolean>) => any;
     change: (value: Record<string, boolean>) => any;
+    "update:modelValue": (value: Record<string, boolean>) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((value: Record<string, boolean>) => any) | undefined;
     onChange?: ((value: Record<string, boolean>) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: Record<string, boolean>) => any) | undefined;
 }>, {
     showSelectAll: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

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

@@ -1,35 +1,47 @@
-import { type Placement } from '../../composables/useFloating';
-type __VLS_Props = {
-    placement?: Placement;
-    trigger?: 'click' | 'hover' | 'focus';
-    disabled?: boolean;
-    open?: boolean;
-    width?: string;
-    title?: string;
-};
-declare const __VLS_template: () => {
-    __VLS_Slots: {
-        trigger?: (props: {}) => any;
-    } & {
-        default?: (props: {
-            close: () => void;
-        }) => any;
-    };
-};
-type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
-    show: () => void;
-    hide: () => void;
+import type { HysPopoverProps, HysPopoverSlots } from "../../composables/popupSurface";
+type __VLS_Slots = HysPopoverSlots;
+declare const __VLS_base: import("vue").DefineComponent<HysPopoverProps, {
+    element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    referenceElement: import("vue").ComputedRef<HTMLElement | undefined>;
+    open: import("vue").Ref<boolean, boolean>;
+    placement: import("vue").Ref<import("../..").Placement, import("../..").Placement>;
+    show: () => Promise<boolean>;
+    hide: () => Promise<boolean>;
+    close: () => Promise<boolean>;
+    toggle: () => Promise<boolean>;
+    updatePosition: () => void;
+    focus: () => void | undefined;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    visibleChange: (value: boolean) => any;
-    "update:open": (value: boolean) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onVisibleChange?: ((value: boolean) => any) | undefined;
-    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    "update:modelValue": (open: boolean) => any;
+    visibleChange: (open: boolean) => any;
+    show: () => any;
+    hide: () => any;
+    "update:open": (open: boolean) => any;
+    opened: () => any;
+    closed: () => any;
+    openChange: (open: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<HysPopoverProps> & Readonly<{
+    "onUpdate:modelValue"?: ((open: boolean) => any) | undefined;
+    onVisibleChange?: ((open: boolean) => any) | undefined;
+    onShow?: (() => any) | undefined;
+    onHide?: (() => any) | undefined;
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+    onOpened?: (() => any) | undefined;
+    onClosed?: (() => any) | undefined;
+    onOpenChange?: ((open: boolean) => any) | undefined;
 }>, {
+    modelValue: boolean;
+    destroyOnHide: boolean;
+    effect: "dark" | "light";
+    placement: import("../..").Placement;
     open: boolean;
-    trigger: "click" | "focus" | "hover";
-    placement: Placement;
+    appendTo: string | false | HTMLElement;
+    showDelay: number;
+    hideDelay: number;
+    autoAdjustOverflow: boolean;
+    enterable: boolean;
+    closeOnEscape: boolean;
+    closeOnOutside: boolean;
 }, {}, {}, {}, 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/HysProgress/HysProgress.vue.d.ts

@@ -1,28 +1,22 @@
-type __VLS_Props = {
-    value: number;
-    showLabel?: boolean;
-    color?: string;
-    status?: 'normal' | 'success' | 'warning' | 'error';
-    strokeWidth?: number;
-    type?: 'line' | 'circle';
-    width?: number;
-    format?: (value: number) => string;
-    indeterminate?: boolean;
-};
-declare const __VLS_template: () => {
-    __VLS_Slots: {
-        default?: (props: {
-            value: number;
-        }) => 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<{}>, {
-    type: "circle" | "line";
-    width: number;
-    status: "success" | "warning" | "normal" | "error";
+import { type HysProgressProps, type HysProgressSlots } from "../../composables/progress";
+type __VLS_Slots = HysProgressSlots;
+declare const __VLS_base: import("vue").DefineComponent<HysProgressProps, {
+    element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    value: import("vue").ComputedRef<number>;
+    successValue: import("vue").ComputedRef<number>;
+    status: import("vue").ComputedRef<import("../..").HysProgressStatus>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<HysProgressProps> & Readonly<{}>, {
+    size: import("../..").HysProgressSize;
+    type: import("../..").HysProgressType;
+    duration: number;
+    status: import("../..").HysProgressStatus;
+    strokeLinecap: import("../..").HysProgressLinecap;
     showLabel: boolean;
-    strokeWidth: number;
+    showStatusIcon: boolean;
+    stepGap: number;
+    gapPosition: import("../..").HysProgressGapPosition;
+    animated: boolean;
+    flowDuration: 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/HysRadio/HysRadio.vue.d.ts

@@ -0,0 +1,56 @@
+import { type HysChoiceValue } from "../../composables/choice";
+declare const __VLS_export: <T extends HysChoiceValue = HysChoiceValue>(__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;
+        value?: T;
+        label?: string;
+        disabled?: boolean;
+        readonly?: boolean;
+        size?: "sm" | "md" | "lg";
+        button?: boolean;
+        border?: boolean;
+        buttonStyle?: "outline" | "solid";
+        name?: string;
+        form?: string;
+        required?: boolean;
+        ariaLabel?: string;
+        tabindex?: number;
+        focusable?: boolean;
+        autofocus?: boolean;
+        error?: string;
+        status?: "error" | "warning" | "success";
+    } & {
+        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<{
+        input: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+        checked: import("vue").ComputedRef<boolean>;
+        focus: (options?: FocusOptions) => void;
+        blur: () => void | undefined;
+        select: () => Promise<boolean>;
+    }>) => void;
+    attrs: any;
+    slots: {
+        icon?: (props: {
+            checked: boolean;
+        }) => any;
+    } & {
+        default?: (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>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};