hys-ui 0.1.1 → 0.2.0

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

@@ -0,0 +1,22 @@
+type __VLS_Props = {
+    id: string;
+    anchor?: HTMLElement;
+    container?: HTMLElement;
+    placement: "top" | "bottom" | "left" | "right";
+    position: number;
+};
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        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<{}>, {}, {}, {}, {}, 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;
+    };
+};

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

@@ -26,8 +26,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     modelValue: number;
     max: number;
     min: number;
-    step: number;
     vertical: boolean;
+    step: 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/HysSteps/HysSteps.vue.d.ts

@@ -1,21 +1,76 @@
+export type HysStepStatus = 'process' | 'error' | 'finish' | 'wait';
+export interface HysStepItem {
+    title: string;
+    description?: string;
+    subtitle?: string;
+    disabled?: boolean;
+    status?: HysStepStatus;
+}
 type __VLS_Props = {
-    items: (string | {
-        title: string;
-        description?: string;
-        disabled?: boolean;
-    })[];
-    current: number;
+    items: (string | HysStepItem)[];
+    current?: number;
     vertical?: boolean;
     clickable?: boolean;
     disabled?: boolean;
-    status?: 'process' | 'error' | 'finish' | 'wait';
+    status?: HysStepStatus;
+    size?: 'sm' | 'md';
+    labelPlacement?: 'right' | 'bottom';
+    progressDot?: boolean;
+    simple?: boolean;
+    responsive?: boolean;
+    ariaLabel?: string;
+};
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        icon?: (props: {
+            item: HysStepItem;
+            index: number;
+            status: HysStepStatus;
+        }) => any;
+    } & {
+        title?: (props: {
+            item: HysStepItem;
+            index: number;
+            status: HysStepStatus;
+        }) => any;
+    } & {
+        title?: (props: {
+            item: HysStepItem;
+            index: number;
+            status: HysStepStatus;
+        }) => any;
+    } & {
+        subtitle?: (props: {
+            item: HysStepItem;
+            index: number;
+        }) => any;
+    } & {
+        description?: (props: {
+            item: HysStepItem;
+            index: number;
+            status: HysStepStatus;
+        }) => any;
+    };
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     change: (index: number) => any;
     "update:current": (index: number) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onChange?: ((index: number) => any) | undefined;
     "onUpdate:current"?: ((index: number) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+}>, {
+    size: "sm" | "md";
+    status: HysStepStatus;
+    current: number;
+    labelPlacement: "right" | "bottom";
+    responsive: 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;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -1,20 +1,79 @@
-type __VLS_Props = {
-    modelValue: boolean;
-    disabled?: boolean;
-    loading?: boolean;
-    activeText?: string;
-    inactiveText?: string;
-    ariaLabel?: string;
-    beforeChange?: (next: boolean) => boolean | void | Promise<boolean | void>;
+import { type Component } from "vue";
+import { type HysChoiceValue, type HysSwitchGuardContext } from "../../composables/choice";
+declare const __VLS_export: <T extends HysChoiceValue = boolean>(__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;
+        activeValue?: T;
+        inactiveValue?: T;
+        disabled?: boolean;
+        readonly?: boolean;
+        loading?: boolean;
+        size?: "sm" | "md" | "lg";
+        width?: number | string;
+        round?: boolean;
+        activeColor?: string;
+        inactiveColor?: string;
+        activeText?: string;
+        inactiveText?: string;
+        inlinePrompt?: boolean;
+        activeIcon?: Component;
+        inactiveIcon?: Component;
+        activeActionIcon?: Component;
+        inactiveActionIcon?: Component;
+        ariaLabel?: string;
+        name?: string;
+        form?: string;
+        tabindex?: number;
+        autofocus?: boolean;
+        focusable?: boolean;
+        error?: string;
+        status?: "error" | "warning" | "success";
+        beforeChange?: (next: T, current: T, context: HysSwitchGuardContext) => boolean | void | Promise<boolean | void>;
+    } & {
+        onChange?: ((value: T) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: T) => any) | undefined;
+        onClick?: ((value: T, event: MouseEvent) => any) | undefined;
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onError?: ((error: unknown) => 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<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+        checked: import("vue").ComputedRef<boolean>;
+        pending: import("vue").Ref<boolean, boolean>;
+        focus: (options?: FocusOptions) => void;
+        blur: () => void | undefined;
+        toggle: () => Promise<boolean>;
+    }>) => void;
+    attrs: any;
+    slots: {
+        active?: (props: {}) => any;
+    } & {
+        inactive?: (props: {}) => any;
+    } & {
+        thumb?: (props: {
+            checked: boolean;
+            loading: boolean;
+            focused: boolean;
+        }) => any;
+    } & {
+        loading?: (props: {}) => any;
+    } & {
+        active?: (props: {}) => any;
+    } & {
+        inactive?: (props: {}) => any;
+    };
+    emit: ((evt: "change", value: T) => void) & ((evt: "update:modelValue", value: T) => void) & ((evt: "click", value: T, event: MouseEvent) => void) & ((evt: "blur", event: FocusEvent) => void) & ((evt: "error", error: unknown) => void) & ((evt: "focus", event: FocusEvent) => void);
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: boolean) => any;
-    change: (value: boolean) => any;
-    error: (error: unknown) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
-    onChange?: ((value: boolean) => any) | undefined;
-    onError?: ((error: unknown) => any) | undefined;
-}>, {}, {}, {}, {}, 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/HysTable/HysTable.vue.d.ts

@@ -1,53 +1,227 @@
-export interface HysTableColumn {
-    key: string;
-    label: string;
-    width?: string | number;
-    align?: 'left' | 'center' | 'right';
-    sortable?: boolean;
-}
-declare const __VLS_export: <T extends Record<string, unknown>>(__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<{
-        columns: HysTableColumn[];
-        rows: T[];
-        rowKey?: string;
-        emptyText?: string;
-        loading?: boolean;
-        striped?: boolean;
-        bordered?: boolean;
-        size?: "sm" | "md" | "lg";
-        caption?: string;
-        rowClassName?: (row: T, index: number) => string;
-    } & {
-        onRowClick?: ((row: T) => any) | undefined;
-        onSortChange?: ((sort: {
-            key: string;
-            direction: "asc" | "desc";
-        } | null) => any) | undefined;
+import { type HysTableProps, type HysTableColumn, type HysTableKey, type HysTableSort, type HysTableFilters, type HysTableFilterValue, type HysTableQuery, type HysTableCellContext, type HysTableFilterConfirmOptions, type HysTableFilterResetOptions, type HysTableScrollRowOptions } from "../../composables/table";
+export type { HysTableColumn } from "../../composables/table";
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: <T extends object = Record<string, unknown>>(__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<HysTableProps<T> & {
+        onChange?: ((query: HysTableQuery<T>) => any) | undefined;
+        onSelect?: ((rows: T[], row: T, checked: boolean) => any) | undefined;
+        onLoad?: ((row: T, children: readonly T[]) => any) | undefined;
+        onScroll?: ((position: {
+            scrollLeft: number;
+            scrollTop: number;
+        }, event: Event) => any) | undefined;
+        onLoadError?: ((row: T, error: unknown) => any) | undefined;
+        onExpandChange?: ((row: T, expanded: boolean, keys: HysTableKey[]) => any) | undefined;
+        "onUpdate:page"?: ((page: number) => any) | undefined;
+        onPageSizeChange?: ((size: number) => any) | undefined;
+        "onUpdate:pageSize"?: ((size: number) => any) | undefined;
+        onRowClick?: ((row: T, index: number, event: MouseEvent) => any) | undefined;
+        onSelectionChange?: ((rows: T[], keys: HysTableKey[]) => any) | undefined;
+        onSortChange?: ((sort: HysTableSort | null, sorts: HysTableSort[]) => any) | undefined;
+        onPageChange?: ((page: number) => any) | undefined;
+        onQueryChange?: ((query: HysTableQuery<T>) => any) | undefined;
+        "onUpdate:sort"?: ((sort: HysTableSort | null) => any) | undefined;
+        "onUpdate:sorts"?: ((sorts: HysTableSort[]) => any) | undefined;
+        "onUpdate:filters"?: ((filters: HysTableFilters) => any) | undefined;
+        onFilterChange?: ((filters: HysTableFilters) => any) | undefined;
+        "onUpdate:selectedRowKeys"?: ((keys: HysTableKey[]) => any) | undefined;
+        onSelectRange?: ((rows: T[], rangeRows: T[], checked: boolean) => any) | undefined;
+        onSelectAll?: ((rows: T[], checked: boolean) => any) | undefined;
+        onSelectInvert?: ((rows: T[], keys: HysTableKey[]) => any) | undefined;
+        "onUpdate:currentRowKey"?: ((key: HysTableKey | null) => any) | undefined;
+        onCurrentChange?: ((row: T | undefined, previous: T | undefined) => any) | undefined;
+        onChildrenChange?: ((row: T, children: readonly T[]) => any) | undefined;
+        "onUpdate:expandedRowKeys"?: ((keys: HysTableKey[]) => any) | undefined;
+        onRowDblclick?: ((row: T, index: number, event: MouseEvent) => any) | undefined;
+        onRowContextmenu?: ((row: T, index: number, event: MouseEvent) => any) | undefined;
+        onCellClick?: ((context: HysTableCellContext<T>, event: MouseEvent) => any) | undefined;
+        onCellDblclick?: ((context: HysTableCellContext<T>, event: MouseEvent) => any) | undefined;
+        onCellContextmenu?: ((context: HysTableCellContext<T>, event: MouseEvent) => any) | undefined;
+        onCellMouseEnter?: ((context: HysTableCellContext<T>, event: MouseEvent) => any) | undefined;
+        onCellMouseLeave?: ((context: HysTableCellContext<T>, event: MouseEvent) => any) | undefined;
+        onHeaderClick?: ((column: HysTableColumn<T>, event: MouseEvent) => any) | undefined;
+        onHeaderContextmenu?: ((column: HysTableColumn<T>, event: MouseEvent) => any) | undefined;
+        "onUpdate:filterColumnKey"?: ((key: string | null) => any) | undefined;
+        onFilterOpenChange?: ((key: string | null) => any) | undefined;
+        "onUpdate:columnWidths"?: ((widths: Record<string, number>) => any) | undefined;
+        onColumnResize?: ((column: HysTableColumn<T>, width: number, previous: number) => 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>;
+        viewport: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        selectedKeys: import("vue").ComputedRef<HysTableKey[]>;
+        currentRow: import("vue").ComputedRef<T | undefined>;
+        expandedKeys: import("vue").ComputedRef<HysTableKey[]>;
+        query: import("vue").ComputedRef<HysTableQuery<T>>;
+        columns: import("vue").ComputedRef<HysTableColumn<T>[]>;
+        clearSelection: () => Promise<boolean>;
+        getSelectionRows: () => T[];
+        getHalfSelectionRows: () => T[];
+        toggleRowSelection: (value: HysTableKey | T, checked?: boolean, range?: boolean) => Promise<boolean>;
+        toggleAllSelection: (checked?: boolean) => Promise<boolean>;
+        invertSelection: () => Promise<boolean>;
+        setCurrentRow: (value?: HysTableKey | T | null | undefined) => Promise<boolean>;
+        toggleRowExpansion: (value: HysTableKey | T, expanded?: boolean) => Promise<boolean>;
+        loadRow: (value: HysTableKey | T, force?: boolean) => Promise<boolean>;
+        updateKeyChildren: (value: HysTableKey | T, children: readonly T[]) => Promise<boolean>;
+        clearSort: () => void;
+        setSort: (value: HysTableSort | readonly HysTableSort[] | null) => void;
+        clearFilter: (keys?: readonly string[]) => void;
+        setFilter: (key: string, values: readonly HysTableFilterValue[]) => void;
+        showFilter: (key: string) => Promise<boolean>;
+        hideFilter: () => Promise<boolean>;
+        setPage: (n: number, action?: "page" | "pageSize") => void;
+        resizeColumn: (key: string, width: number) => void;
+        resetColumnWidths: () => void;
+        doLayout: () => Promise<void>;
+        scrollTo: (options: ScrollToOptions) => void;
+        setScrollTop: (top: number) => void;
+        setScrollLeft: (left: number) => void;
+        scrollToRow: (value: T | HysTableKey, options?: HysTableScrollRowOptions) => Promise<boolean>;
+    }>) => void;
     attrs: any;
     slots: {
+        [x: string]: ((props: {
+            column: HysTableColumn<T>;
+            sorts: HysTableSort[];
+        }) => any) | undefined;
+    } & {
+        [x: string]: ((props: {
+            column: HysTableColumn<T>;
+            sorts: HysTableSort[];
+        }) => any) | undefined;
+    } & {
         [x: string]: ((props: {
             row: T;
             value: unknown;
             index: number;
+            column: HysTableColumn<T>;
         }) => any) | undefined;
+    } & {
+        title?: (props: {
+            rows: T[];
+            query: HysTableQuery<T>;
+        }) => any;
+    } & {
+        selection?: (props: {
+            rows: T[];
+            keys: HysTableKey[];
+            selectAll: () => Promise<boolean>;
+            invert: () => Promise<boolean>;
+            clear: () => Promise<boolean>;
+        }) => any;
+    } & {
+        'selection-header'?: (props: {
+            column: HysTableColumn<T>;
+            checked: boolean;
+            indeterminate: boolean;
+            disabled: boolean;
+            toggle: (checked?: boolean) => Promise<boolean>;
+        }) => any;
+    } & {
+        'header-cell'?: (props: {
+            column: HysTableColumn<T>;
+            sorts: HysTableSort[];
+        }) => any;
+    } & {
+        'header-cell'?: (props: {
+            column: HysTableColumn<T>;
+            sorts: HysTableSort[];
+        }) => any;
+    } & {
+        'filter-icon'?: (props: {
+            column: HysTableColumn<T>;
+            filtered: boolean;
+            open: boolean;
+        }) => any;
     } & {
         loading?: (props: {}) => any;
+    } & {
+        'selection-cell'?: (props: {
+            row: T;
+            index: number;
+            column: HysTableColumn<T>;
+            checked: boolean;
+            indeterminate: boolean;
+            disabled: boolean;
+            toggle: (selected?: boolean) => Promise<boolean>;
+        }) => any;
+    } & {
+        'expand-icon'?: (props: {
+            row: T;
+            index: number;
+            expanded: boolean;
+            loading: boolean;
+            depth: number;
+        }) => any;
+    } & {
+        'expand-icon'?: (props: {
+            row: T;
+            index: number;
+            expanded: boolean;
+            loading: boolean;
+            depth: number;
+        }) => any;
+    } & {
+        'body-cell'?: (props: {
+            row: T;
+            column: HysTableColumn<T>;
+            value: unknown;
+            index: number;
+        }) => any;
+    } & {
+        expand?: (props: {
+            row: T;
+            index: number;
+            expanded: boolean;
+        }) => any;
     } & {
         empty?: (props: {}) => any;
+    } & {
+        append?: (props: {
+            rows: T[];
+        }) => any;
+    } & {
+        'summary-cell'?: (props: {
+            column: HysTableColumn<T>;
+            index: number;
+            value: any;
+            rows: T[];
+        }) => any;
+    } & {
+        footer?: (props: {
+            rows: T[];
+            query: HysTableQuery<T>;
+        }) => any;
+    } & {
+        'filter-dropdown'?: (props: {
+            column: HysTableColumn<T>;
+            open: true;
+            values: HysTableFilterValue[];
+            setValues: (values: readonly HysTableFilterValue[]) => void;
+            confirm: (options?: HysTableFilterConfirmOptions | Event) => void;
+            clear: (options?: HysTableFilterResetOptions | Event) => void;
+            close: () => void;
+        }) => any;
+    } & {
+        tooltip?: (props: {
+            row: T;
+            column: HysTableColumn<T>;
+            value: unknown;
+            rowIndex: number;
+            columnIndex: number;
+        }) => any;
     };
-    emit: ((evt: "rowClick", row: T) => void) & ((evt: "sortChange", sort: {
-        key: string;
-        direction: "asc" | "desc";
-    } | null) => void);
+    emit: ((evt: "change", query: HysTableQuery<T>) => void) & ((evt: "select", rows: T[], row: T, checked: boolean) => void) & ((evt: "load", row: T, children: readonly T[]) => void) & ((evt: "scroll", position: {
+        scrollLeft: number;
+        scrollTop: number;
+    }, event: Event) => void) & ((evt: "loadError", row: T, error: unknown) => void) & ((evt: "expandChange", row: T, expanded: boolean, keys: HysTableKey[]) => void) & ((evt: "update:page", page: number) => void) & ((evt: "pageSizeChange", size: number) => void) & ((evt: "update:pageSize", size: number) => void) & ((evt: "rowClick", row: T, index: number, event: MouseEvent) => void) & ((evt: "selectionChange", rows: T[], keys: HysTableKey[]) => void) & ((evt: "sortChange", sort: HysTableSort | null, sorts: HysTableSort[]) => void) & ((evt: "pageChange", page: number) => void) & ((evt: "queryChange", query: HysTableQuery<T>) => void) & ((evt: "update:sort", sort: HysTableSort | null) => void) & ((evt: "update:sorts", sorts: HysTableSort[]) => void) & ((evt: "update:filters", filters: HysTableFilters) => void) & ((evt: "filterChange", filters: HysTableFilters) => void) & ((evt: "update:selectedRowKeys", keys: HysTableKey[]) => void) & ((evt: "selectRange", rows: T[], rangeRows: T[], checked: boolean) => void) & ((evt: "selectAll", rows: T[], checked: boolean) => void) & ((evt: "selectInvert", rows: T[], keys: HysTableKey[]) => void) & ((evt: "update:currentRowKey", key: HysTableKey | null) => void) & ((evt: "currentChange", row: T | undefined, previous: T | undefined) => void) & ((evt: "childrenChange", row: T, children: readonly T[]) => void) & ((evt: "update:expandedRowKeys", keys: HysTableKey[]) => void) & ((evt: "rowDblclick", row: T, index: number, event: MouseEvent) => void) & ((evt: "rowContextmenu", row: T, index: number, event: MouseEvent) => void) & ((evt: "cellClick", context: HysTableCellContext<T>, event: MouseEvent) => void) & ((evt: "cellDblclick", context: HysTableCellContext<T>, event: MouseEvent) => void) & ((evt: "cellContextmenu", context: HysTableCellContext<T>, event: MouseEvent) => void) & ((evt: "cellMouseEnter", context: HysTableCellContext<T>, event: MouseEvent) => void) & ((evt: "cellMouseLeave", context: HysTableCellContext<T>, event: MouseEvent) => void) & ((evt: "headerClick", column: HysTableColumn<T>, event: MouseEvent) => void) & ((evt: "headerContextmenu", column: HysTableColumn<T>, event: MouseEvent) => void) & ((evt: "update:filterColumnKey", key: string | null) => void) & ((evt: "filterOpenChange", key: string | null) => void) & ((evt: "update:columnWidths", widths: Record<string, number>) => void) & ((evt: "columnResize", column: HysTableColumn<T>, width: number, previous: number) => 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];
 } : {

package/dist/types/components/HysTable/HysTableFilterOptions.vue.d.ts

@@ -0,0 +1,18 @@
+import { type HysTableFilter, type HysTableFilterValue } from "../../composables/table";
+type __VLS_Props = {
+    options: readonly HysTableFilter[];
+    values: readonly HysTableFilterValue[];
+    multiple: boolean;
+    mode?: "menu" | "tree";
+    search?: boolean | ((query: string, option: HysTableFilter) => boolean);
+    disabled?: boolean;
+    searchLabel: string;
+    emptyText: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:values": (values: HysTableFilterValue[]) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:values"?: ((values: HysTableFilterValue[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -1,43 +1,96 @@
+export type HysTabValue = string | number;
+export interface HysTabItem {
+    label: string;
+    value: HysTabValue;
+    disabled?: boolean;
+    closable?: boolean;
+    content?: string;
+    forceRender?: boolean;
+}
 type __VLS_Props = {
-    modelValue: string;
-    items: {
-        label: string;
-        value: string;
-        disabled?: boolean;
-        closable?: boolean;
-    }[];
+    modelValue?: HysTabValue;
+    defaultValue?: HysTabValue;
+    items: HysTabItem[];
     disabled?: boolean;
-    type?: 'line' | 'card';
+    type?: 'line' | 'card' | 'border-card' | 'segment';
     vertical?: boolean;
+    placement?: 'top' | 'right' | 'bottom' | 'left';
+    size?: 'sm' | 'md' | 'lg';
+    stretch?: boolean;
+    centered?: boolean;
     closable?: boolean;
+    addable?: boolean;
+    editable?: boolean;
+    trigger?: 'click' | 'hover';
+    activation?: 'auto' | 'manual';
+    /** 首次访问时才挂载面板；用于 panel 插槽。 */
+    lazy?: boolean;
+    /** 离开时销毁面板；默认保留已访问面板的局部状态。 */
+    destroyOnHide?: boolean;
+    animated?: boolean;
+    showScrollButtons?: boolean;
     ariaLabel?: string;
+    beforeLeave?: (next: HysTabValue, current: HysTabValue) => boolean | void | Promise<boolean | void>;
+    beforeClose?: (value: HysTabValue) => boolean | void | Promise<boolean | void>;
 };
+declare function scrollToActiveTab(): void;
 declare const __VLS_template: () => {
     __VLS_Slots: {
+        prefix?: (props: {}) => any;
+    } & {
         label?: (props: {
-            item: {
-                label: string;
-                value: string;
-                disabled?: boolean;
-                closable?: boolean;
-            };
+            item: HysTabItem;
+            active: boolean;
+        }) => any;
+    } & {
+        'close-icon'?: (props: {
+            item: HysTabItem;
+        }) => any;
+    } & {
+        'add-icon'?: (props: {}) => any;
+    } & {
+        suffix?: (props: {}) => any;
+    } & {
+        panel?: (props: {
+            item: HysTabItem;
+            active: boolean;
         }) => any;
     } & {
         default?: (props: {
-            active: string;
+            active: HysTabValue;
         }) => 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: string) => any;
-    change: (value: string) => any;
-    close: (value: string) => any;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    scrollToActiveTab: typeof scrollToActiveTab;
+    focus: (value?: HysTabValue) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (value: HysTabValue) => any;
+    "update:modelValue": (value: HysTabValue) => any;
+    guardError: (error: unknown) => any;
+    add: () => any;
+    close: (value: HysTabValue) => any;
+    tabClick: (value: HysTabValue, event: MouseEvent) => any;
+    edit: (value: HysTabValue | undefined, action: "add" | "remove") => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-    onChange?: ((value: string) => any) | undefined;
-    onClose?: ((value: string) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+    onChange?: ((value: HysTabValue) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: HysTabValue) => any) | undefined;
+    onGuardError?: ((error: unknown) => any) | undefined;
+    onAdd?: (() => any) | undefined;
+    onClose?: ((value: HysTabValue) => any) | undefined;
+    onTabClick?: ((value: HysTabValue, event: MouseEvent) => any) | undefined;
+    onEdit?: ((value: HysTabValue | undefined, action: "add" | "remove") => any) | undefined;
+}>, {
+    size: "sm" | "md" | "lg";
+    trigger: "click" | "hover";
+    lazy: boolean;
+    destroyOnHide: boolean;
+    type: "line" | "card" | "border-card" | "segment";
+    activation: "auto" | "manual";
+    animated: boolean;
+    showScrollButtons: 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/HysTagInput/HysTagInput.vue.d.ts

@@ -18,20 +18,20 @@ declare const __VLS_template: () => {
 };
 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;
+    "update:modelValue": (value: string[]) => any;
     add: (value: string) => any;
-    remove: (value: string) => any;
     reject: (value: string) => any;
+    remove: (value: string) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
     onChange?: ((value: string[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
     onAdd?: ((value: string) => any) | undefined;
-    onRemove?: ((value: string) => any) | undefined;
     onReject?: ((value: string) => any) | undefined;
+    onRemove?: ((value: string) => any) | undefined;
 }>, {
-    placeholder: string;
     max: number;
+    placeholder: string;
     addOnBlur: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;