hys-ui 0.1.0 → 0.2.0

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

@@ -1,22 +1,128 @@
+import { type HysFormCol, type HysFormGridValue } from "../../composables/formLayout";
+import { type HysFormPath, type HysFormRule, type HysFormStatus, type HysFormTrigger } from "../../composables/formContext";
 type __VLS_Props = {
     label?: string;
-    prop?: string;
+    prop?: HysFormPath;
+    rules?: HysFormRule | HysFormRule[];
+    dependencies?: HysFormPath[];
     error?: string;
+    warning?: string;
+    status?: HysFormStatus;
     required?: boolean;
+    showRequiredMark?: boolean;
+    requiredMarkPosition?: "left" | "right";
     hint?: string;
     for?: string;
+    disabled?: boolean;
+    size?: "sm" | "md" | "lg";
+    labelPosition?: "top" | "left" | "right";
+    labelWidth?: string | number;
+    labelAlign?: "left" | "right";
+    labelWrap?: boolean;
+    labelSuffix?: string;
+    colon?: boolean;
+    labelCol?: HysFormCol;
+    wrapperCol?: HysFormCol;
+    span?: HysFormGridValue;
+    optionalMark?: string;
+    tooltip?: string;
+    help?: string;
+    extra?: string;
+    showLabel?: boolean;
+    showFeedback?: boolean;
+    feedbackIcon?: boolean;
+    inlineFeedback?: boolean;
+    validateFirst?: boolean;
+    preserve?: boolean;
+    autoLink?: boolean;
+    group?: boolean;
+    noStyle?: boolean;
+    validateTrigger?: HysFormTrigger | HysFormTrigger[];
 };
+declare function validate(event?: HysFormTrigger): Promise<boolean>;
+declare function focus(): void;
 declare const __VLS_template: () => {
     __VLS_Slots: {
+        label?: (props: {
+            required: boolean;
+            status: HysFormStatus;
+        }) => any;
+    } & {
+        tooltip?: (props: {}) => any;
+    } & {
         default?: (props: {
             id: string;
             invalid: boolean;
             error: string | undefined;
+            warning: string | undefined;
+            errors: string[];
+            warnings: string[];
+            status: HysFormStatus;
+            disabled: boolean;
+            size: "sm" | "md" | "lg";
+        }) => any;
+    } & {
+        help?: (props: {
+            error: string | undefined;
+            warning: string | undefined;
+            errors: string[];
+            warnings: string[];
+            status: HysFormStatus;
+        }) => any;
+    } & {
+        feedback?: (props: {
+            error: string | undefined;
+            warning: string | undefined;
+            errors: string[];
+            warnings: string[];
+            status: HysFormStatus;
+        }) => any;
+    } & {
+        error?: (props: {
+            error: string;
+            errors: string[];
+        }) => any;
+    } & {
+        warning?: (props: {
+            warning: string;
+            warnings: string[];
+        }) => any;
+    } & {
+        hint?: (props: {}) => any;
+    } & {
+        extra?: (props: {
+            status: HysFormStatus;
         }) => 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<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    validate: typeof validate;
+    clearValidate: () => void;
+    resetField: () => void;
+    setInitialValue: ((value: unknown) => void) | undefined;
+    focus: typeof focus;
+    path: import("vue").ComputedRef<string>;
+    status: import("vue").ComputedRef<HysFormStatus>;
+    error: import("vue").ComputedRef<string | undefined>;
+    warning: import("vue").ComputedRef<string | undefined>;
+    size: import("vue").ComputedRef<"sm" | "md" | "lg">;
+    validateMessage: import("vue").ComputedRef<string | undefined>;
+    validateState: import("vue").ComputedRef<HysFormStatus>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    required: boolean;
+    preserve: boolean;
+    group: boolean;
+    labelWrap: boolean;
+    colon: boolean;
+    showLabel: boolean;
+    showFeedback: boolean;
+    showRequiredMark: boolean;
+    inlineFeedback: boolean;
+    feedbackIcon: boolean;
+    validateFirst: boolean;
+    autoLink: boolean;
+}, {}, {}, {}, 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;

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

@@ -1,3 +1,4 @@
+import type { HysGanttScrollOptions, HysGanttDependencyChange, HysGanttDependencyInvalid, HysGanttDependencyMove, HysGanttHistoryEntry, HysGanttHistoryState, HysGanttHistoryInvalid, HysGanttConflict } from "../../composables/gantt";
 export interface GanttItem {
     id: string | number;
     title: string;
@@ -10,7 +11,7 @@ export interface GanttItem {
     color?: string;
     disabled?: boolean;
 }
-type Scale = 'day' | 'week' | 'month';
+type Scale = "day" | "week" | "month";
 type __VLS_Props = {
     items: GanttItem[];
     modelValue?: string | number | null;
@@ -18,22 +19,105 @@ type __VLS_Props = {
     editable?: boolean;
     rowHeight?: number;
     labelWidth?: number;
+    labelResizable?: boolean;
+    minLabelWidth?: number;
+    maxLabelWidth?: number;
+    fitContainer?: boolean;
+    height?: number | string;
+    maxHeight?: number | string | false;
+    virtual?: boolean;
+    overscan?: number;
+    dependencyEditable?: boolean;
+    showDependencies?: boolean;
+    history?: boolean;
+    historyLimit?: number;
+    historyKeyboard?: boolean;
+    showHistoryControls?: boolean;
+    showConflicts?: boolean;
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (id: string | number | null) => any;
+declare function scrollToTask(id: string | number, options?: HysGanttScrollOptions): Promise<boolean>;
+declare function scrollToTop(options?: Pick<HysGanttScrollOptions, "behavior">): void;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
+    element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    viewport: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+    scrollToTask: typeof scrollToTask;
+    scrollToTop: typeof scrollToTop;
+    addDependency: (sourceId: string | number, targetId: string | number) => Promise<boolean>;
+    removeDependency: (sourceId: string | number, targetId: string | number) => Promise<boolean>;
+    moveDependency: (sourceId: string | number, previousTargetId: string | number, targetId: string | number) => Promise<boolean>;
+    cancelDependency: () => void;
+    undo: () => Promise<boolean>;
+    redo: () => Promise<boolean>;
+    clearHistory: () => void;
+    canUndo: import("vue").ComputedRef<boolean>;
+    canRedo: import("vue").ComputedRef<boolean>;
+    historyState: import("vue").ComputedRef<HysGanttHistoryState>;
+    conflicts: import("vue").ComputedRef<{
+        id: string;
+        type: import("../..").HysGanttConflictType;
+        taskId: string | number;
+        taskTitle: string;
+        sourceId?: string | number;
+        sourceTitle?: string;
+        message: string;
+        expectedStart?: string;
+        days?: number;
+    }[]>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     change: (item: GanttItem) => any;
+    "update:modelValue": (id: string | number | null) => any;
     open: (item: GanttItem) => any;
+    undo: (entry: HysGanttHistoryEntry) => any;
+    redo: (entry: HysGanttHistoryEntry) => any;
+    "update:scale": (value: Scale) => any;
+    scaleChange: (value: Scale) => any;
     "update:items": (items: GanttItem[]) => any;
+    dependencyAdd: (info: HysGanttDependencyChange, item: GanttItem) => any;
+    dependencyRemove: (info: HysGanttDependencyChange, item: GanttItem) => any;
+    dependencyInvalid: (info: HysGanttDependencyInvalid) => any;
+    dependencyMove: (info: HysGanttDependencyMove, item: GanttItem, previousItem: GanttItem) => any;
+    "update:labelWidth": (width: number) => any;
+    labelResize: (width: number) => any;
+    historyChange: (state: HysGanttHistoryState) => any;
+    historyInvalid: (info: HysGanttHistoryInvalid) => any;
+    conflictChange: (conflicts: HysGanttConflict[]) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((id: string | number | null) => any) | undefined;
     onChange?: ((item: GanttItem) => any) | undefined;
+    "onUpdate:modelValue"?: ((id: string | number | null) => any) | undefined;
     onOpen?: ((item: GanttItem) => any) | undefined;
+    onUndo?: ((entry: HysGanttHistoryEntry) => any) | undefined;
+    onRedo?: ((entry: HysGanttHistoryEntry) => any) | undefined;
+    "onUpdate:scale"?: ((value: Scale) => any) | undefined;
+    onScaleChange?: ((value: Scale) => any) | undefined;
     "onUpdate:items"?: ((items: GanttItem[]) => any) | undefined;
+    onDependencyAdd?: ((info: HysGanttDependencyChange, item: GanttItem) => any) | undefined;
+    onDependencyRemove?: ((info: HysGanttDependencyChange, item: GanttItem) => any) | undefined;
+    onDependencyInvalid?: ((info: HysGanttDependencyInvalid) => any) | undefined;
+    onDependencyMove?: ((info: HysGanttDependencyMove, item: GanttItem, previousItem: GanttItem) => any) | undefined;
+    "onUpdate:labelWidth"?: ((width: number) => any) | undefined;
+    onLabelResize?: ((width: number) => any) | undefined;
+    onHistoryChange?: ((state: HysGanttHistoryState) => any) | undefined;
+    onHistoryInvalid?: ((info: HysGanttHistoryInvalid) => any) | undefined;
+    onConflictChange?: ((conflicts: HysGanttConflict[]) => any) | undefined;
 }>, {
     scale: Scale;
+    maxHeight: string | number | false;
+    virtual: boolean;
+    overscan: number;
     editable: boolean;
     labelWidth: number;
     rowHeight: number;
+    labelResizable: boolean;
+    minLabelWidth: number;
+    maxLabelWidth: number;
+    fitContainer: boolean;
+    dependencyEditable: boolean;
+    showDependencies: boolean;
+    history: boolean;
+    historyLimit: number;
+    historyKeyboard: boolean;
+    showHistoryControls: boolean;
+    showConflicts: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -30,15 +30,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/HysNumberInput/HysNumberInput.vue.d.ts

@@ -1,36 +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;
-    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;
-    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;
@@ -17,6 +18,8 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:modelValue"?: ((id: string) => any) | undefined;
     "onUpdate:checkedKeys"?: ((keys: string[]) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}>, {
+    searchable: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -2,11 +2,18 @@ type __VLS_Props = {
     roles: string[];
     resources: string[];
     modelValue: Record<string, boolean>;
+    disabled?: boolean;
+    readonly?: boolean;
+    showSelectAll?: boolean;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (value: Record<string, boolean>) => any;
     "update:modelValue": (value: Record<string, boolean>) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((value: Record<string, boolean>) => any) | undefined;
     "onUpdate:modelValue"?: ((value: Record<string, boolean>) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}>, {
+    showSelectAll: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -21,14 +21,14 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
     show: () => void;
     hide: () => void;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    visibleChange: (value: boolean) => any;
     "update:open": (value: boolean) => any;
+    visibleChange: (value: boolean) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onVisibleChange?: ((value: boolean) => any) | undefined;
     "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    onVisibleChange?: ((value: boolean) => any) | undefined;
 }>, {
-    open: boolean;
     trigger: "click" | "focus" | "hover";
+    open: boolean;
     placement: Placement;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

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

@@ -21,8 +21,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     type: "circle" | "line";
     width: number;
     status: "success" | "warning" | "normal" | "error";
-    showLabel: boolean;
     strokeWidth: number;
+    showLabel: 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/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];
+}) & {};