hys-ui 0.1.1 → 0.3.0

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

@@ -1,25 +1,76 @@
-type __VLS_Props = {
+import { type Component, type VNodeChild } from "vue";
+import type { HysPopupMotionProps } from "../../motion/popup";
+export interface HysBreadcrumbItem {
+    label: string;
+    href?: string;
+    disabled?: boolean;
+    target?: string;
+    rel?: string;
     separator?: string;
-    items: {
-        label: string;
-        href?: string;
-    }[];
-};
-declare const __VLS_template: () => {
-    __VLS_Slots: {
-        separator?: (props: {}) => any;
-    } & {
-        link?: (props: {
-            item: {
-                label: string;
-                href?: string;
-            };
-            index: number;
-        }) => any;
-    };
+    showSeparator?: boolean;
+    icon?: Component;
+    title?: string;
+    children?: readonly HysBreadcrumbItem[];
+    to?: unknown;
+    replace?: boolean;
+}
+export interface HysBreadcrumbSelectInfo {
+    index: number;
+    parent?: HysBreadcrumbItem;
+    path: readonly HysBreadcrumbItem[];
+    source: "dropdown" | "overflow";
+    event?: MouseEvent | KeyboardEvent;
+}
+export interface HysBreadcrumbProps extends HysPopupMotionProps {
+    items: readonly HysBreadcrumbItem[];
+    separator?: string;
+    separatorIcon?: Component;
+    ariaLabel?: string;
+    size?: "sm" | "md" | "lg";
+    disabled?: boolean;
+    maxItems?: number;
+    itemsBeforeCollapse?: number;
+    itemsAfterCollapse?: number;
+    maxItemWidth?: number | string;
+    ellipsisLabel?: string;
+    dropdownLabel?: string;
+}
+type __VLS_Slots = {
+    item?: (scope: {
+        item: HysBreadcrumbItem;
+        index: number;
+        current: boolean;
+    }) => VNodeChild;
+    link?: (scope: {
+        item: HysBreadcrumbItem;
+        index: number;
+        current: boolean;
+        attrs: Record<string, unknown>;
+    }) => VNodeChild;
+    separator?: (scope: {
+        item: HysBreadcrumbItem;
+        index: number;
+    }) => VNodeChild;
+    overflow?: (scope: {
+        items: readonly HysBreadcrumbItem[];
+    }) => VNodeChild;
 };
-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<HysBreadcrumbProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (item: HysBreadcrumbItem, index: number, event: MouseEvent) => any;
+    dropdownSelect: (item: HysBreadcrumbItem, info: HysBreadcrumbSelectInfo) => any;
+}, string, import("vue").PublicProps, Readonly<HysBreadcrumbProps> & Readonly<{
+    onSelect?: ((item: HysBreadcrumbItem, index: number, event: MouseEvent) => any) | undefined;
+    onDropdownSelect?: ((item: HysBreadcrumbItem, info: HysBreadcrumbSelectInfo) => any) | undefined;
+}>, {
+    size: "sm" | "md" | "lg";
+    ariaLabel: string;
+    separator: string;
+    maxItems: number;
+    itemsBeforeCollapse: number;
+    itemsAfterCollapse: number;
+    ellipsisLabel: string;
+    dropdownLabel: string;
+}, {}, {}, {}, 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/HysButton/HysButton.vue.d.ts

@@ -47,7 +47,6 @@ declare const __VLS_base: import("vue").DefineComponent<HysButtonProps, {
 }>, {
     type: "button" | "submit" | "reset";
     focusable: boolean;
-    size: "sm" | "md" | "lg";
     variant: HysButtonVariant;
     iconPosition: "left" | "right";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

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

@@ -1,38 +1,127 @@
-export interface CalendarEvent {
-    id: string;
-    date: string;
-    title: string;
-}
-type __VLS_Props = {
-    modelValue?: string;
-    events?: CalendarEvent[];
-    disabled?: boolean;
-    readonly?: boolean;
-    disabledDate?: (date: string) => boolean;
-};
-declare const __VLS_template: () => {
-    __VLS_Slots: {
+import type { HysPopupMotionProps } from '../../motion/popup';
+import { type HysCalendarValue, type HysCalendarMode, type HysCalendarTransition, type HysCalendarAction, type HysCalendarSelectInfo, type HysCalendarCell, type HysCalendarMonthCell, type CalendarEvent } from "../../composables/calendar";
+declare const __VLS_export: <T extends HysCalendarValue = 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<(HysPopupMotionProps & {
+        modelValue?: T;
+        defaultValue?: T;
+        valueType?: "string" | "date";
+        valueFormat?: string;
+        mode?: HysCalendarMode;
+        defaultMode?: HysCalendarMode;
+        fullscreen?: boolean;
+        transition?: HysCalendarTransition;
+        transitionDuration?: number;
+        controllerType?: "button" | "select";
+        formatter?: (value: number, type: "year" | "month") => string;
+        showModeSwitch?: boolean;
+        showHeader?: boolean;
+        showToday?: boolean;
+        firstDayOfWeek?: number;
+        locale?: string;
+        range?: readonly [HysCalendarValue, HysCalendarValue];
+        validRange?: readonly [HysCalendarValue, HysCalendarValue];
+        disabled?: boolean;
+        readonly?: boolean;
+        disabledDate?: (date: string) => boolean;
+        showAdjacentDays?: boolean;
+        fixedWeeks?: boolean;
+        showWeekNumbers?: boolean;
+        keyboard?: boolean;
+        loading?: boolean;
+        events?: readonly CalendarEvent[];
+        maxEvents?: number;
+        ariaLabel?: string;
+    }) & {
+        onChange?: ((date: T) => any) | undefined;
+        "onUpdate:modelValue"?: ((date: T) => any) | undefined;
+        onSelect?: ((date: T, info: HysCalendarSelectInfo) => any) | undefined;
+        "onUpdate:mode"?: ((mode: HysCalendarMode) => any) | undefined;
+        onPanelChange?: ((date: T, mode: HysCalendarMode) => any) | undefined;
+        onEvent?: ((id: string, event: CalendarEvent, date: string) => any) | undefined;
+        onMore?: ((date: string, events: CalendarEvent[]) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        selectedDay: import("vue").ComputedRef<T | undefined>;
+        panelValue: import("vue").ComputedRef<T>;
+        currentMode: import("vue").ComputedRef<HysCalendarMode>;
+        visibleRange: import("vue").ComputedRef<readonly [string, string]>;
+        pickDay: (value: HysCalendarValue) => Promise<boolean>;
+        selectDate: (action: HysCalendarAction) => boolean;
+        showMonth: (value: HysCalendarValue) => boolean;
+        setMode: (mode: HysCalendarMode) => boolean;
+        focus: () => Promise<void>;
+    }>) => void;
+    attrs: any;
+    slots: {
+        header?: (props: {
+            date: string;
+            value: T;
+            mode: HysCalendarMode;
+            selectDate: (action: HysCalendarAction) => boolean;
+            showMonth: (value: HysCalendarValue) => boolean;
+            setMode: (mode: HysCalendarMode) => boolean;
+        }) => any;
+    } & {
+        loading?: (props: {}) => any;
+    } & {
+        'date-full-cell'?: (props: {
+            date: Date;
+            data: HysCalendarCell;
+        }) => any;
+    } & {
         date?: (props: {
             date: string;
-            day: any;
+            day: number;
+        }) => any;
+    } & {
+        'date-cell'?: (props: {
+            date: Date;
+            data: HysCalendarCell;
+        }) => any;
+    } & {
+        event?: (props: {
+            event: CalendarEvent;
+            date: string;
+        }) => any;
+    } & {
+        more?: (props: {
+            date: string;
+            count: number;
+        }) => any;
+    } & {
+        'month-full-cell'?: (props: {
+            date: Date;
+            data: HysCalendarMonthCell;
+        }) => any;
+    } & {
+        'month-cell'?: (props: {
+            date: Date;
+            data: HysCalendarMonthCell;
+        }) => any;
+    } & {
+        footer?: (props: {
+            selected: T | undefined;
+            value: T;
+            mode: HysCalendarMode;
+            visibleRange: readonly [string, string];
+        }) => any;
+    } & {
+        event?: (props: {
+            event: CalendarEvent;
+            date: string;
         }) => any;
     };
+    emit: ((evt: "change", date: T) => void) & ((evt: "update:modelValue", date: T) => void) & ((evt: "select", date: T, info: HysCalendarSelectInfo) => void) & ((evt: "update:mode", mode: HysCalendarMode) => void) & ((evt: "panelChange", date: T, mode: HysCalendarMode) => void) & ((evt: "event", id: string, event: CalendarEvent, date: string) => void) & ((evt: "more", date: string, events: CalendarEvent[]) => void);
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };
-type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (date: string) => any;
-    select: (date: string) => any;
-    event: (id: string) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((date: string) => any) | undefined;
-    onSelect?: ((date: string) => any) | undefined;
-    onEvent?: ((id: string) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;
-type __VLS_WithSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

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

@@ -1,28 +1,76 @@
+import { type CSSProperties } from "vue";
+export interface HysCardTab {
+    label: string;
+    value: string | number;
+    disabled?: boolean;
+}
 type __VLS_Props = {
     title?: string;
     subtitle?: string;
+    footer?: string;
     loading?: boolean;
+    loadingText?: string;
     bordered?: boolean;
-    shadow?: 'always' | 'hover' | 'never';
-    bodyStyle?: Record<string, string>;
-    size?: 'sm' | 'md' | 'lg';
+    shadow?: "always" | "hover" | "never";
+    bodyStyle?: CSSProperties;
+    headerStyle?: CSSProperties;
+    footerStyle?: CSSProperties;
+    bodyClass?: string;
+    headerClass?: string;
+    footerClass?: string;
+    size?: "sm" | "md" | "lg";
+    hoverable?: boolean;
+    type?: "default" | "inner";
+    tabs?: readonly HysCardTab[];
+    activeTab?: string | number;
+    defaultActiveTab?: string | number;
+    tabsLabel?: string;
 };
 declare const __VLS_template: () => {
     __VLS_Slots: {
+        cover?: (props: {}) => any;
+    } & {
         header?: (props: {}) => any;
+    } & {
+        title?: (props: {}) => any;
     } & {
         action?: (props: {}) => any;
     } & {
-        default?: (props: {}) => any;
+        tab?: (props: {
+            tab: HysCardTab;
+            active: boolean;
+        }) => any;
+    } & {
+        'tab-extra'?: (props: {}) => any;
+    } & {
+        loading?: (props: {}) => any;
+    } & {
+        default?: (props: {
+            activeTab: string | number | undefined;
+        }) => any;
+    } & {
+        actions?: (props: {}) => any;
     } & {
         footer?: (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<{}>, {
-    size: "sm" | "md" | "lg";
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    activeTab: import("vue").ComputedRef<string | number | undefined>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:activeTab": (value: string | number) => any;
+    tabChange: (value: string | number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:activeTab"?: ((value: string | number) => any) | undefined;
+    onTabChange?: ((value: string | number) => any) | undefined;
+}>, {
     bordered: boolean;
-    shadow: "always" | "hover" | "never";
+    size: "sm" | "md" | "lg";
+    type: "default" | "inner";
+    loadingText: string;
+    shadow: "always" | "never" | "hover";
+    tabsLabel: string;
 }, {}, {}, {}, 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/HysCascader/HysCascader.vue.d.ts

@@ -1,46 +1,134 @@
-export interface HysCascaderNode {
-    label: string;
-    value: string;
-    children?: HysCascaderNode[];
-    disabled?: boolean;
-}
-type __VLS_Props = {
-    modelValue: string[];
-    options: HysCascaderNode[];
-    disabled?: boolean;
-    clearable?: boolean;
-    filterable?: boolean;
-    changeOnSelect?: boolean;
-    showAllLevels?: boolean;
-    separator?: string;
-    placeholder?: string;
-};
-declare const __VLS_template: () => {
-    __VLS_Slots: {
-        option?: (props: {
-            node: HysCascaderNode;
+import { type HysCascaderProps, type HysCascaderValue, type HysCascaderNode, type HysCascaderKey, type HysCascaderPath, type HysCascaderItem, type HysCascaderOptionContext, type HysCascaderChange } from "../../composables/cascader";
+export type { HysCascaderNode } from "../../composables/cascader";
+declare const __VLS_export: <V extends HysCascaderValue = string[], N extends object = HysCascaderNode>(__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<HysCascaderProps<N, V> & {
+        onChange?: ((value: V, info: HysCascaderChange<N>) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: V) => any) | undefined;
+        onSearch?: ((value: string) => any) | undefined;
+        onClear?: (() => any) | undefined;
+        onSelect?: ((path: import("../..").HysTreeKey[], nodes: N[], event?: Event | undefined) => any) | undefined;
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+        onLoad?: ((info: {
+            node: N;
+            path: HysCascaderKey[];
+            children: N[];
+        }) => any) | undefined;
+        onScroll?: ((info: {
+            level: number;
+            event: Event;
+        }) => any) | undefined;
+        "onUpdate:open"?: ((value: boolean) => any) | undefined;
+        "onUpdate:searchValue"?: ((value: string) => any) | undefined;
+        onLimit?: ((limit: number) => any) | undefined;
+        "onNode-expand"?: ((node: N, context: {
+            path: HysCascaderKey[];
+        }) => any) | undefined;
+        "onNode-collapse"?: ((node: N, context: {
+            path: HysCascaderKey[];
+        }) => any) | undefined;
+        "onChildren-loaded"?: ((info: {
+            node: N;
+            path: HysCascaderKey[];
+            children: N[];
+        }) => any) | undefined;
+        "onLoad-error"?: ((info: {
+            node: N;
+            path: HysCascaderKey[];
+            error: unknown;
+        }) => any) | undefined;
+        "onValue-change"?: ((value: V, info: HysCascaderChange<N>) => any) | undefined;
+        "onRemove-tag"?: ((path: import("../..").HysTreeKey[], node?: N | undefined) => any) | undefined;
+        "onSearch-error"?: ((error: unknown, query: string) => any) | undefined;
+        "onUpdate:expandedPath"?: ((path: import("../..").HysTreeKey[]) => any) | undefined;
+        onExpandChange?: ((path: import("../..").HysTreeKey[], nodes: N[]) => any) | undefined;
+        "onRoot-load"?: ((nodes: readonly N[]) => any) | undefined;
+        "onRoot-load-error"?: ((error: unknown) => any) | undefined;
+        "onVisible-change"?: ((value: boolean) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        open: import("vue").ComputedRef<boolean>;
+        focus: () => void;
+        blur: () => void;
+        show: () => Promise<boolean>;
+        hide: (restore?: boolean) => void;
+        clear: () => Promise<boolean>;
+        clearCheckedNodes: () => Promise<boolean>;
+        removeTag: (value: HysCascaderPath | HysCascaderKey) => Promise<boolean>;
+        setValue: (value: HysCascaderValue) => Promise<boolean>;
+        filter: (text: string) => void;
+        getSelectedItems: () => HysCascaderItem<N>[];
+        getCheckedNodes: (leafOnly?: boolean) => N[];
+        getExpandedPath: () => import("../..").HysTreeKey[];
+        setExpandedPath: (path: HysCascaderPath) => Promise<boolean>;
+        reloadNode: (path: HysCascaderPath) => Promise<boolean>;
+        reloadRoot: (force?: boolean) => Promise<boolean>;
+        scrollTo: (path: HysCascaderPath) => Promise<void>;
+    }>) => void;
+    attrs: any;
+    slots: {
+        option?: (scope: HysCascaderOptionContext<N>) => any;
+        suggestion?: (scope: HysCascaderOptionContext<N>) => any;
+        display?: (scope: {
+            item: HysCascaderItem<N>;
+        }) => any;
+        tag?: (scope: {
+            item: HysCascaderItem<N>;
+            remove: () => Promise<boolean>;
+        }) => any;
+        "max-tag-placeholder"?: (scope: {
+            items: HysCascaderItem<N>[];
+            count: number;
+        }) => any;
+        prefix?: () => any;
+        suffix?: () => any;
+        "clear-icon"?: () => any;
+        "remove-icon"?: () => any;
+        "expand-icon"?: (scope: HysCascaderOptionContext<N>) => any;
+        header?: () => any;
+        footer?: (scope: {
+            items: HysCascaderItem<N>[];
+            clear: () => Promise<boolean>;
+            close: () => void;
+        }) => any;
+        empty?: (scope: {
+            query: string;
+            level: number;
+        }) => any;
+        loading?: (scope: {
+            level: number;
         }) => any;
     };
+    emit: ((evt: "change", value: V, info: HysCascaderChange<N>) => void) & ((evt: "update:modelValue", value: V) => void) & ((evt: "search", value: string) => void) & ((evt: "clear") => void) & ((evt: "select", path: import("../..").HysTreeKey[], nodes: N[], event?: Event | undefined) => void) & ((evt: "blur", event: FocusEvent) => void) & ((evt: "focus", event: FocusEvent) => void) & ((evt: "load", info: {
+        node: N;
+        path: HysCascaderKey[];
+        children: N[];
+    }) => void) & ((evt: "scroll", info: {
+        level: number;
+        event: Event;
+    }) => void) & ((evt: "update:open", value: boolean) => void) & ((evt: "update:searchValue", value: string) => void) & ((evt: "limit", limit: number) => void) & ((evt: "node-expand", node: N, context: {
+        path: HysCascaderKey[];
+    }) => void) & ((evt: "node-collapse", node: N, context: {
+        path: HysCascaderKey[];
+    }) => void) & ((evt: "children-loaded", info: {
+        node: N;
+        path: HysCascaderKey[];
+        children: N[];
+    }) => void) & ((evt: "load-error", info: {
+        node: N;
+        path: HysCascaderKey[];
+        error: unknown;
+    }) => void) & ((evt: "value-change", value: V, info: HysCascaderChange<N>) => void) & ((evt: "remove-tag", path: import("../..").HysTreeKey[], node?: N | undefined) => void) & ((evt: "search-error", error: unknown, query: string) => void) & ((evt: "update:expandedPath", path: import("../..").HysTreeKey[]) => void) & ((evt: "expandChange", path: import("../..").HysTreeKey[], nodes: N[]) => void) & ((evt: "root-load", nodes: readonly N[]) => void) & ((evt: "root-load-error", error: unknown) => void) & ((evt: "visible-change", value: boolean) => void);
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };
-type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: string[]) => any;
-    change: (value: string[]) => any;
-    clear: () => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
-    onChange?: ((value: string[]) => any) | undefined;
-    onClear?: (() => any) | undefined;
-}>, {
-    placeholder: string;
-    separator: string;
-    showAllLevels: 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;
-    };
-};
+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/HysCascader/HysCascaderColumn.vue.d.ts

@@ -0,0 +1,55 @@
+import type { CascaderEntry, HysCascaderOptionContext } from "../../composables/cascader";
+declare const __VLS_export: <N extends object>(__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<{
+        rows: readonly CascaderEntry<N>[];
+        level: number;
+        label: string;
+        activeKey?: string;
+        multiple?: boolean;
+        strict?: boolean;
+        showPrefix?: boolean;
+        disabled?: boolean;
+        search?: boolean;
+        size?: "sm" | "md" | "lg";
+        virtual?: boolean;
+        itemHeight?: number;
+        listHeight?: number;
+        overscan?: number;
+        columnWidth?: number | string;
+        context: (entry: CascaderEntry<N>) => HysCascaderOptionContext<N>;
+        hasChildren: (entry: CascaderEntry<N>) => boolean;
+        error: (entry: CascaderEntry<N>) => unknown;
+        retryText: string;
+        expandLabel: (entry: CascaderEntry<N>) => string;
+    } & {
+        onScroll?: ((event: Event) => any) | undefined;
+        onRetry?: ((entry: CascaderEntry<N>) => any) | undefined;
+        onHover?: ((entry: CascaderEntry<N> | null) => any) | undefined;
+        onChoose?: ((entry: CascaderEntry<N>, event?: Event | undefined, checked?: boolean | undefined) => any) | undefined;
+        onKeyboard?: ((event: KeyboardEvent, entry: CascaderEntry<N>, level: number) => any) | undefined;
+        onExpand?: ((entry: CascaderEntry<N>) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        focus: (key?: string) => Promise<void>;
+        element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    }>) => void;
+    attrs: any;
+    slots: {
+        option?: (scope: HysCascaderOptionContext<N>) => any;
+        suggestion?: (scope: HysCascaderOptionContext<N>) => any;
+        "expand-icon"?: (scope: HysCascaderOptionContext<N>) => any;
+        loading?: (scope: HysCascaderOptionContext<N>) => any;
+    };
+    emit: ((evt: "scroll", event: Event) => void) & ((evt: "retry", entry: CascaderEntry<N>) => void) & ((evt: "hover", entry: CascaderEntry<N> | null) => void) & ((evt: "choose", entry: CascaderEntry<N>, event?: Event | undefined, checked?: boolean | undefined) => void) & ((evt: "keyboard", event: KeyboardEvent, entry: CascaderEntry<N>, level: number) => void) & ((evt: "expand", entry: CascaderEntry<N>) => 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];
+}) & {};