hys-ui 0.1.1 → 0.2.0

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

@@ -1,34 +1,113 @@
-export interface HysTreeSelectNode {
-    label: string;
-    value: string;
-    children?: HysTreeSelectNode[];
-    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<{
-    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
-        modelValue: T;
-        nodes: HysTreeSelectNode[];
-        placeholder?: string;
-        disabled?: boolean;
-        multiple?: boolean;
-        clearable?: boolean;
-        searchable?: boolean;
-        leafOnly?: boolean;
-    } & {
-        "onUpdate:modelValue"?: ((value: T) => any) | undefined;
-        onChange?: ((value: T) => any) | undefined;
+import type { HysTreeKey, HysTreeCheckInfo, HysTreeNodeContext } from "../../composables/tree";
+import type { HysTreeSelectProps, HysTreeSelectValue, HysTreeSelectNode, HysTreeSelectItem, HysTreeSelectChange } from "../../composables/treeSelect";
+export type { HysTreeSelectNode } from "../../composables/treeSelect";
+declare const __VLS_export: <V extends HysTreeSelectValue = string, N extends object = HysTreeSelectNode>(__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<HysTreeSelectProps<N, V> & {
+        onChange?: ((value: V, info: HysTreeSelectChange<N>) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: V) => any) | undefined;
+        onSearch?: ((query: string) => any) | undefined;
         onClear?: (() => any) | undefined;
+        onSelect?: ((key: HysTreeKey, node: N, info: unknown) => any) | undefined;
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+        onLoad?: ((info: {
+            node: N;
+            children: readonly N[];
+            loadedKeys: HysTreeKey[];
+        }) => any) | undefined;
+        onScroll?: ((event: Event) => any) | undefined;
+        "onUpdate:open"?: ((value: boolean) => any) | undefined;
+        "onUpdate:searchValue"?: ((value: string) => any) | undefined;
+        onDeselect?: ((key: HysTreeKey, node: N, info: unknown) => any) | undefined;
+        onLimit?: ((limit: number) => any) | undefined;
+        onCheck?: ((info: HysTreeCheckInfo<N>) => any) | undefined;
+        "onUpdate:expandedKeys"?: ((keys: HysTreeKey[]) => any) | undefined;
+        "onNode-expand"?: ((node: N, info: unknown) => any) | undefined;
+        "onNode-collapse"?: ((node: N, info: unknown) => any) | undefined;
+        "onUpdate:loadedKeys"?: ((keys: HysTreeKey[]) => any) | undefined;
+        "onChildren-loaded"?: ((info: {
+            node: N;
+            children: readonly N[];
+        }) => any) | undefined;
+        "onLoad-error"?: ((info: {
+            node: N;
+            error: unknown;
+        }) => any) | undefined;
+        "onValue-change"?: ((value: V, info: HysTreeSelectChange<N>) => any) | undefined;
+        "onRemove-tag"?: ((key: HysTreeKey, node: N | undefined) => any) | undefined;
+        "onSearch-complete"?: ((query: string) => any) | undefined;
+        "onSearch-error"?: ((error: unknown, query: string) => any) | undefined;
+        "onVisible-change"?: ((value: boolean) => 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>;
+        open: import("vue").Ref<boolean, boolean>;
+        focus: () => void;
+        blur: () => void;
+        show: () => Promise<boolean>;
+        hide: (restore?: boolean) => void;
+        clear: () => Promise<boolean>;
+        removeTag: (key: HysTreeKey) => Promise<boolean>;
+        setValue: (value: HysTreeSelectValue) => Promise<boolean>;
+        filter: (text: string) => void;
+        getSelectedKeys: () => HysTreeKey[];
+        getSelectedItems: () => HysTreeSelectItem<N>[];
+        getCheckedKeys: (leafOnly?: boolean) => HysTreeKey[];
+        getHalfCheckedKeys: () => HysTreeKey[];
+        getNode: (key: HysTreeKey) => N | undefined;
+        getExpandedKeys: () => HysTreeKey[];
+        setExpandedKeys: (keys: readonly HysTreeKey[]) => Promise<boolean>;
+        expandNode: (key: HysTreeKey, on?: boolean) => Promise<boolean>;
+        reloadNode: (key: HysTreeKey) => Promise<boolean>;
+        scrollTo: (options: {
+            key?: HysTreeKey;
+            top?: number;
+            align?: "top" | "bottom" | "auto";
+        }) => Promise<void>;
+    }>) => void;
     attrs: any;
     slots: {
-        option?: (props: {
-            node: HysTreeSelectNode;
+        option?: (scope: HysTreeNodeContext<N>) => any;
+        icon?: (scope: HysTreeNodeContext<N>) => any;
+        switcher?: (scope: HysTreeNodeContext<N>) => any;
+        tag?: (scope: {
+            item: HysTreeSelectItem<N>;
+            remove: () => Promise<boolean>;
+        }) => any;
+        "max-tag-placeholder"?: (scope: {
+            items: HysTreeSelectItem<N>[];
+            count: number;
+        }) => any;
+        prefix?: () => any;
+        suffix?: () => any;
+        header?: () => any;
+        footer?: (scope: {
+            items: HysTreeSelectItem<N>[];
+            clear: () => Promise<boolean>;
+            close: () => void;
+        }) => any;
+        empty?: (scope: {
+            query: string;
+        }) => any;
+        loading?: () => any;
+        error?: (scope: {
+            error: unknown;
+            retry: () => Promise<void>;
         }) => any;
     };
-    emit: ((evt: "update:modelValue", value: T) => void) & ((evt: "change", value: T) => void) & ((evt: "clear") => void);
+    emit: ((evt: "change", value: V, info: HysTreeSelectChange<N>) => void) & ((evt: "update:modelValue", value: V) => void) & ((evt: "search", query: string) => void) & ((evt: "clear") => void) & ((evt: "select", key: HysTreeKey, node: N, info: unknown) => void) & ((evt: "blur", event: FocusEvent) => void) & ((evt: "focus", event: FocusEvent) => void) & ((evt: "load", info: {
+        node: N;
+        children: readonly N[];
+        loadedKeys: HysTreeKey[];
+    }) => void) & ((evt: "scroll", event: Event) => void) & ((evt: "update:open", value: boolean) => void) & ((evt: "update:searchValue", value: string) => void) & ((evt: "deselect", key: HysTreeKey, node: N, info: unknown) => void) & ((evt: "limit", limit: number) => void) & ((evt: "check", info: HysTreeCheckInfo<N>) => void) & ((evt: "update:expandedKeys", keys: HysTreeKey[]) => void) & ((evt: "node-expand", node: N, info: unknown) => void) & ((evt: "node-collapse", node: N, info: unknown) => void) & ((evt: "update:loadedKeys", keys: HysTreeKey[]) => void) & ((evt: "children-loaded", info: {
+        node: N;
+        children: readonly N[];
+    }) => void) & ((evt: "load-error", info: {
+        node: N;
+        error: unknown;
+    }) => void) & ((evt: "value-change", value: V, info: HysTreeSelectChange<N>) => void) & ((evt: "remove-tag", key: HysTreeKey, node: N | undefined) => void) & ((evt: "search-complete", query: string) => void) & ((evt: "search-error", error: unknown, query: string) => void) & ((evt: "visible-change", value: boolean) => void);
 }>) => import("vue").VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };

package/dist/types/components/HysTreeSelect/HysTreeSelectPanel.vue.d.ts

@@ -0,0 +1,56 @@
+import type { HysTreeSelectStore } from "../../composables/useTreeSelect";
+import type { HysTreeSelectNode } from "../../composables/treeSelect";
+import type { HysTreeKey, HysTreeNodeContext } from "../../composables/tree";
+declare const __VLS_export: <N extends object = HysTreeSelectNode>(__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<{
+        store: HysTreeSelectStore<N>;
+        size?: "sm" | "md" | "lg";
+        treeId: string;
+        checkable?: boolean;
+        checkStrictly?: boolean;
+        leafOnly?: boolean;
+        expandOnClickNode?: boolean;
+        showLine?: boolean;
+        showIcon?: boolean;
+        indent?: number;
+        listHeight?: number;
+        virtual?: boolean;
+        itemHeight?: number;
+        overscan?: number;
+    } & {
+        onScroll?: ((event: Event) => any) | undefined;
+        onChoose?: ((key: HysTreeKey) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        focus: (key?: HysTreeKey) => Promise<void>;
+        scrollTo: (options: {
+            key?: HysTreeKey;
+            top?: number;
+            align?: "top" | "bottom" | "auto";
+        }) => Promise<void>;
+        searchKeys: (event: KeyboardEvent) => Promise<void>;
+        activeId: import("vue").ComputedRef<string | undefined>;
+        setActive: (key: HysTreeKey) => HysTreeKey;
+    }>) => void;
+    attrs: any;
+    slots: {
+        option?: (scope: HysTreeNodeContext<N>) => any;
+        icon?: (scope: HysTreeNodeContext<N>) => any;
+        switcher?: (scope: HysTreeNodeContext<N>) => any;
+        empty?: (scope: {
+            query: string;
+        }) => any;
+    };
+    emit: ((evt: "scroll", event: Event) => void) & ((evt: "choose", key: HysTreeKey) => 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];
+}) & {};

package/dist/types/composables/autocomplete.d.ts

@@ -0,0 +1,106 @@
+import type { Component, CSSProperties } from "vue";
+import type { Placement } from "./useFloating";
+import type { HysInputProps } from "./textInput";
+export interface HysAutocompleteOption {
+    value?: string;
+    label?: string;
+    disabled?: boolean;
+    [key: string]: unknown;
+}
+export type HysAutocompleteItem = string | HysAutocompleteOption;
+export interface HysAutocompleteGroup {
+    label: string;
+    options?: readonly HysAutocompleteDataOption[];
+    children?: readonly HysAutocompleteDataOption[];
+    disabled?: boolean;
+    key?: string | number;
+    type?: "group";
+}
+export type HysAutocompleteDataOption = HysAutocompleteItem | HysAutocompleteGroup;
+export interface HysAutocompleteContext {
+    signal: AbortSignal;
+}
+export type HysAutocompleteCallback = (options: readonly HysAutocompleteDataOption[]) => void;
+export type HysAutocompleteFetch = (query: string, callback: HysAutocompleteCallback, context: HysAutocompleteContext) => void | readonly HysAutocompleteDataOption[] | Promise<void | readonly HysAutocompleteDataOption[]>;
+export interface HysAutocompleteProps {
+    modelValue?: string;
+    defaultValue?: string;
+    options?: readonly HysAutocompleteDataOption[];
+    fetchSuggestions?: HysAutocompleteFetch | readonly HysAutocompleteDataOption[];
+    valueKey?: string;
+    labelKey?: string;
+    filterOption?: boolean | ((query: string, item: HysAutocompleteItem) => boolean);
+    caseSensitive?: boolean;
+    debounce?: number;
+    minQueryLength?: number;
+    triggerOnFocus?: boolean;
+    highlightFirst?: boolean;
+    loopNavigation?: boolean;
+    backfill?: boolean;
+    selectWhenUnmatched?: boolean;
+    selectOnTab?: boolean;
+    append?: boolean;
+    clearAfterSelect?: boolean;
+    blurAfterSelect?: boolean;
+    getShow?: (query: string) => boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    loading?: boolean;
+    hideLoading?: boolean;
+    clearable?: boolean;
+    clearIcon?: Component;
+    placeholder?: string;
+    label?: string;
+    ariaLabel?: string;
+    name?: string;
+    status?: "error" | "warning" | "success";
+    error?: string;
+    size?: "sm" | "md" | "lg";
+    bordered?: boolean;
+    autofocus?: boolean;
+    inputProps?: Omit<HysInputProps, "modelValue" | "defaultValue">;
+    open?: boolean;
+    defaultOpen?: boolean;
+    placement?: Placement;
+    popupMatchWidth?: boolean;
+    popupWidth?: number | string;
+    popupClass?: string;
+    popupStyle?: CSSProperties;
+    appendTo?: string | HTMLElement | false;
+    listHeight?: number;
+    emptyText?: string;
+    loadingText?: string;
+    errorText?: string;
+}
+export interface HysAutocompleteInstance {
+    input: HTMLInputElement | HTMLTextAreaElement | undefined;
+    isOpen: boolean;
+    loading: boolean;
+    highlightedIndex: number;
+    suggestions: readonly HysAutocompleteDataOption[];
+    focus: (options?: FocusOptions) => void;
+    blur: () => void;
+    open: () => Promise<void>;
+    close: () => void;
+    clear: () => void;
+    getData: () => Promise<void>;
+    retry: () => Promise<void>;
+    highlight: (index: number) => void;
+    select: (option: HysAutocompleteItem) => Promise<void>;
+}
+export interface HysAutocompleteRow {
+    key: string;
+    kind: "group" | "option";
+    label: string;
+    value: string;
+    disabled: boolean;
+    item: HysAutocompleteItem;
+    group?: HysAutocompleteGroup;
+}
+export declare function autocompleteValue(item: HysAutocompleteItem, key?: string, labelKey?: string): string;
+export declare function normalizeAutocomplete(data: readonly HysAutocompleteDataOption[], query: string, settings: {
+    valueKey: string;
+    labelKey: string;
+    filter: boolean | ((query: string, item: HysAutocompleteItem) => boolean);
+    caseSensitive: boolean;
+}): HysAutocompleteRow[];

package/dist/types/composables/avatar.d.ts

@@ -0,0 +1,70 @@
+import { type Component, type ComputedRef, type CSSProperties, type ImgHTMLAttributes, type InjectionKey } from "vue";
+import type { Placement } from "./useFloating";
+export type HysAvatarBreakpoint = "xs" | "sm" | "md" | "lg" | "xl" | "xxl";
+export type HysAvatarSize = number | "sm" | "md" | "lg" | "small" | "medium" | "default" | "large" | Partial<Record<HysAvatarBreakpoint, number>>;
+export type HysAvatarFit = "cover" | "contain" | "fill" | "none" | "scale-down";
+export interface HysAvatarProps {
+    name?: string;
+    src?: string;
+    srcset?: string;
+    srcSet?: string;
+    sizes?: string;
+    size?: HysAvatarSize;
+    shape?: "circle" | "square";
+    fit?: HysAvatarFit;
+    alt?: string;
+    icon?: Component;
+    gap?: number;
+    autoFit?: boolean;
+    color?: string;
+    textColor?: string;
+    bordered?: boolean;
+    radius?: number | string;
+    fallbackSrc?: string;
+    loadError?: (event: Event) => boolean | void;
+    draggable?: boolean;
+    crossOrigin?: "" | "anonymous" | "use-credentials";
+    lazy?: boolean;
+    imgProps?: ImgHTMLAttributes;
+}
+export interface HysAvatarLoadInfo {
+    src: string;
+    fallback: boolean;
+}
+export interface HysAvatarInstance {
+    element: HTMLElement | undefined;
+    image: HTMLImageElement | undefined;
+    loaded: boolean;
+    failed: boolean;
+    reload: () => void;
+}
+export interface HysAvatarOption extends HysAvatarProps {
+    key?: string | number;
+}
+export interface HysAvatarGroupInstance {
+    open: () => Promise<void>;
+    close: () => void;
+}
+export interface HysAvatarGroupProps {
+    options?: readonly HysAvatarOption[];
+    size?: HysAvatarSize;
+    shape?: "circle" | "square";
+    gap?: number;
+    maxCount?: number;
+    vertical?: boolean;
+    bordered?: boolean;
+    maxStyle?: CSSProperties;
+    maxClass?: string;
+    placement?: Placement;
+    trigger?: "hover" | "focus" | "click";
+    showOverflow?: boolean;
+    expandOnHover?: boolean;
+}
+export interface AvatarGroupContext {
+    size: ComputedRef<HysAvatarSize | undefined>;
+    shape: ComputedRef<"circle" | "square" | undefined>;
+    bordered: ComputedRef<boolean>;
+}
+export declare const avatarGroupKey: InjectionKey<AvatarGroupContext>;
+export declare function resolveAvatarSize(size: HysAvatarSize | undefined, viewport: number): number;
+export declare function useAvatarSize(size: ComputedRef<HysAvatarSize | undefined>): ComputedRef<number>;

package/dist/types/composables/calendar.d.ts

@@ -0,0 +1,66 @@
+export type HysCalendarValue = string | Date;
+export type HysCalendarMode = "month" | "year";
+export type HysCalendarTransition = "none" | "fade" | "slide" | "slide-up" | "zoom";
+export type HysCalendarAction = "prev-month" | "next-month" | "prev-year" | "next-year" | "today";
+export interface CalendarEvent {
+    id: string;
+    date: string;
+    title: string;
+    end?: string;
+    time?: string;
+    color?: string;
+    disabled?: boolean;
+    description?: string;
+}
+export interface HysCalendarSelectInfo {
+    source: "date" | "month" | "keyboard" | "customize";
+}
+export interface HysCalendarCell {
+    day: string;
+    date: Date;
+    type: "prev-month" | "current-month" | "next-month";
+    isSelected: boolean;
+    isToday: boolean;
+    disabled: boolean;
+    events: CalendarEvent[];
+}
+export interface HysCalendarMonthCell {
+    month: number;
+    date: Date;
+    day: string;
+    isSelected: boolean;
+    isToday: boolean;
+    disabled: boolean;
+    events: CalendarEvent[];
+}
+export interface HysCalendarInstance<T extends HysCalendarValue = string> {
+    readonly element: HTMLElement | undefined;
+    readonly selectedDay: T | undefined;
+    readonly panelValue: T;
+    readonly currentMode: HysCalendarMode;
+    readonly visibleRange: readonly [string, string];
+    pickDay: (value: HysCalendarValue) => Promise<boolean>;
+    selectDate: (action: HysCalendarAction) => boolean;
+    showMonth: (value: HysCalendarValue) => boolean;
+    setMode: (mode: HysCalendarMode) => boolean;
+    focus: () => Promise<void>;
+}
+export declare function calendarDay(value: HysCalendarValue | undefined, format?: string): number | undefined;
+export declare function civilDay(y: number, m: number, d: number): number;
+export declare function calendarParts(day: number): {
+    year: number;
+    month: number;
+    day: number;
+    weekday: number;
+};
+export declare function calendarISO(day: number): string;
+export declare function calendarDate(day: number): Date;
+export declare function calendarFormat(day: number, format: string): string;
+export declare function calendarShift(day: number, months: number): number;
+export declare function calendarWeeks(start: number, end: number, first: number): [number, number];
+export declare function calendarWeek(day: number): number;
+/** Index only the bounded visible window, including intersecting multi-day events. */
+export declare function calendarEvents(events: readonly CalendarEvent[], start: number, end: number): {
+    dates: Map<number, CalendarEvent[]>;
+    months: Map<number, CalendarEvent[]>;
+};

package/dist/types/composables/cascader.d.ts

@@ -0,0 +1,192 @@
+import type { CSSProperties, VNodeChild } from "vue";
+import { type HysTreeKey } from "./tree";
+import type { Placement } from "./useFloating";
+export type HysCascaderKey = HysTreeKey;
+export type HysCascaderPath = readonly HysCascaderKey[];
+export type HysCascaderValue = HysCascaderKey | HysCascaderPath | readonly HysCascaderPath[] | null;
+export interface HysCascaderDataNode<K extends HysCascaderKey = HysCascaderKey> {
+    label: string;
+    value: K;
+    children?: HysCascaderDataNode<K>[];
+    disabled?: boolean;
+    isLeaf?: boolean;
+    hasChildren?: boolean;
+}
+/** Original string-valued data shape remains available. */
+export type HysCascaderNode = HysCascaderDataNode<string>;
+export interface HysCascaderFieldNames {
+    value: string;
+    label: string;
+    children: string;
+    disabled: string;
+    leaf: string;
+    hasChildren: string;
+}
+export interface HysCascaderItem<N extends object = HysCascaderNode> {
+    path: HysCascaderKey[];
+    labels: string[];
+    nodes: N[];
+    node?: N;
+    value: HysCascaderKey;
+    label: string;
+    disabled: boolean;
+    missing: boolean;
+}
+export interface HysCascaderOptionContext<N extends object = HysCascaderNode> extends HysCascaderItem<N> {
+    node: N;
+    level: number;
+    leaf: boolean;
+    expanded: boolean;
+    checked: boolean;
+    indeterminate: boolean;
+    loading: boolean;
+}
+export interface HysCascaderLoadContext<N extends object = HysCascaderNode> {
+    signal: AbortSignal;
+    path: HysCascaderKey[];
+    nodes: N[];
+    level: number;
+}
+export interface HysCascaderChange<N extends object = HysCascaderNode> {
+    reason: "select" | "check" | "remove" | "clear" | "api";
+    node?: N;
+    items: HysCascaderItem<N>[];
+    paths: HysCascaderKey[][];
+    halfCheckedPaths: HysCascaderKey[][];
+    event?: Event;
+}
+export interface HysCascaderLocale {
+    panel: string;
+    search: string;
+    empty: string;
+    noMatch: string;
+    loading: string;
+    loadError: string;
+    retry: string;
+    clear: string;
+    close: string;
+    level: string;
+    expand: string;
+    remove: string;
+    more: string;
+    limit: string;
+}
+export interface HysCascaderProps<N extends object = HysCascaderNode, V extends HysCascaderValue = HysCascaderValue> {
+    options: readonly N[];
+    modelValue?: V;
+    defaultValue?: V;
+    cacheData?: readonly N[];
+    fieldNames?: Partial<HysCascaderFieldNames>;
+    valueKey?: string | ((node: N) => HysCascaderKey);
+    disabledMethod?: (node: N, path: readonly N[]) => boolean;
+    leafMethod?: (node: N, path: readonly N[]) => boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    loading?: boolean;
+    size?: "sm" | "md" | "lg";
+    status?: "error" | "warning" | "success";
+    placeholder?: string;
+    ariaLabel?: string;
+    name?: string;
+    form?: string;
+    autofocus?: boolean;
+    multiple?: boolean;
+    emitPath?: boolean;
+    checkStrictly?: boolean;
+    changeOnSelect?: boolean;
+    showCheckedStrategy?: "child" | "parent" | "all";
+    checkOnClickNode?: boolean;
+    checkOnClickLeaf?: boolean;
+    showPrefix?: boolean;
+    showAllLevels?: boolean;
+    separator?: string;
+    displayRender?: (item: HysCascaderItem<N>) => VNodeChild;
+    clearable?: boolean;
+    clearValue?: HysCascaderValue;
+    removable?: boolean;
+    multipleLimit?: number;
+    maxTagCount?: number;
+    maxTagTextLength?: number;
+    filterable?: boolean;
+    searchValue?: string;
+    defaultSearchValue?: string;
+    searchPlaceholder?: string;
+    filterMethod?: (query: string, path: readonly N[]) => boolean;
+    searchSort?: (a: HysCascaderItem<N>, b: HysCascaderItem<N>, query: string) => number;
+    searchLimit?: number | false;
+    debounce?: number;
+    beforeFilter?: (query: string, context: {
+        signal: AbortSignal;
+    }) => boolean | Promise<boolean>;
+    retainSearch?: boolean;
+    clearSearchAfterSelect?: boolean;
+    expandTrigger?: "click" | "hover";
+    hoverDelay?: number;
+    expandedPath?: HysCascaderPath;
+    defaultExpandedPath?: HysCascaderPath;
+    loadChildren?: (node: N, context: HysCascaderLoadContext<N>) => Promise<readonly N[]>;
+    loadRoot?: (context: {
+        signal: AbortSignal;
+    }) => Promise<readonly N[]>;
+    inline?: boolean;
+    showFooter?: boolean;
+    open?: boolean;
+    defaultOpen?: boolean;
+    showOnFocus?: boolean;
+    popupMatchWidth?: boolean;
+    popupWidth?: number | string;
+    popupClass?: string;
+    popupStyle?: CSSProperties;
+    appendTo?: string | HTMLElement | false;
+    placement?: Placement;
+    columnWidth?: number | string;
+    listHeight?: number;
+    virtual?: boolean;
+    itemHeight?: number;
+    overscan?: number;
+    emptyText?: string;
+    noMatchText?: string;
+    loadingText?: string;
+    locale?: Partial<HysCascaderLocale>;
+    validateEvent?: boolean;
+}
+export interface HysCascaderInstance<N extends object = HysCascaderNode> {
+    readonly element: HTMLElement | undefined;
+    readonly open: boolean;
+    focus: () => void;
+    blur: () => void;
+    show: () => Promise<boolean>;
+    hide: (restoreFocus?: boolean) => void;
+    clear: () => Promise<boolean>;
+    clearCheckedNodes: () => Promise<boolean>;
+    removeTag: (path: HysCascaderPath | HysCascaderKey) => Promise<boolean>;
+    setValue: (value: HysCascaderValue) => Promise<boolean>;
+    filter: (query: string) => void;
+    getSelectedItems: () => HysCascaderItem<N>[];
+    getCheckedNodes: (leafOnly?: boolean) => N[];
+    getExpandedPath: () => HysCascaderKey[];
+    setExpandedPath: (path: HysCascaderPath) => Promise<boolean>;
+    reloadNode: (path: HysCascaderPath) => Promise<boolean>;
+    reloadRoot: () => Promise<boolean>;
+    scrollTo: (path: HysCascaderPath) => Promise<void>;
+}
+export interface CascaderEntry<N extends object> {
+    value: string;
+    label: string;
+    raw: N;
+    path: HysCascaderKey[];
+    labels: string[];
+    nodes: N[];
+    children?: CascaderEntry<N>[];
+    disabled: boolean;
+    isLeaf: boolean;
+    hasChildren: boolean;
+}
+export declare const cascaderToken: (path: HysCascaderPath) => string;
+export declare function cascaderPath(token: string): HysCascaderKey[];
+export declare const validCascaderPath: (path: unknown) => path is HysCascaderKey[];
+export declare const cascaderWords: HysCascaderLocale;
+export declare function cascaderEntries<N extends object>(options: readonly N[], props: HysCascaderProps<N>, parent?: CascaderEntry<N>): {
+    roots: CascaderEntry<N>[];
+    map: Map<string, CascaderEntry<N>>;
+};