hys-ui 0.1.1 → 0.3.0

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

@@ -1,18 +1,45 @@
-type __VLS_Props = {
-    modelValue: boolean;
-    label?: string;
-    disabled?: boolean;
-    ariaLabel?: string;
-    readonly?: boolean;
-    name?: string;
-    value?: string;
-    required?: boolean;
-    indeterminate?: boolean;
-    tabindex?: number;
-    size?: 'sm' | 'md' | 'lg';
-};
-declare const __VLS_template: () => {
-    __VLS_Slots: {
+import { type HysChoiceValue } from "../../composables/choice";
+declare const __VLS_export: <T extends HysChoiceValue | 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;
+        label?: string;
+        disabled?: boolean;
+        ariaLabel?: string;
+        readonly?: boolean;
+        name?: string;
+        form?: string;
+        value?: HysChoiceValue;
+        trueValue?: HysChoiceValue;
+        falseValue?: HysChoiceValue;
+        required?: boolean;
+        indeterminate?: boolean;
+        tabindex?: number;
+        size?: "sm" | "md" | "lg";
+        border?: boolean;
+        button?: boolean;
+        buttonStyle?: "outline" | "solid";
+        autofocus?: boolean;
+        focusable?: boolean;
+        status?: "error" | "warning" | "success";
+        error?: string;
+    } & {
+        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;
+        toggle: () => Promise<boolean>;
+    }>) => void;
+    attrs: any;
+    slots: {
         icon?: (props: {
             checked: boolean;
             indeterminate: boolean;
@@ -20,30 +47,14 @@ declare const __VLS_template: () => {
     } & {
         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>>;
 };
-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;
-    blur: () => void | undefined;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: boolean) => any;
-    change: (value: boolean) => any;
-    focus: (event: FocusEvent) => any;
-    blur: (event: FocusEvent) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
-    onChange?: ((value: boolean) => any) | undefined;
-    onFocus?: ((event: FocusEvent) => any) | undefined;
-    onBlur?: ((event: FocusEvent) => any) | undefined;
-}>, {
-    size: "sm" | "md" | "lg";
-}, {}, {}, {}, 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/HysCheckboxGroup/HysCheckboxGroup.vue.d.ts

@@ -0,0 +1,73 @@
+import { type HysChoiceValue, type HysChoiceDataOption, type HysChoiceFieldNames, type HysCheckboxChange, type HysCheckboxReject } 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[];
+        defaultValue?: T[];
+        options?: readonly HysChoiceDataOption<T>[];
+        fieldNames?: HysChoiceFieldNames;
+        disabled?: boolean;
+        readonly?: boolean;
+        size?: "sm" | "md" | "lg";
+        min?: number;
+        max?: number;
+        required?: boolean;
+        name?: string;
+        form?: string;
+        ariaLabel?: string;
+        vertical?: boolean;
+        type?: "checkbox" | "button";
+        buttonStyle?: "outline" | "solid";
+        border?: boolean;
+        error?: string;
+        status?: "error" | "warning" | "success";
+        autofocus?: boolean;
+        emptyText?: string;
+    } & {
+        onChange?: ((value: T[], info: HysCheckboxChange) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: T[]) => any) | undefined;
+        onBlur?: ((event: FocusEvent) => any) | undefined;
+        onFocus?: ((event: FocusEvent) => any) | undefined;
+        onReject?: ((info: HysCheckboxReject) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        values: import("vue").ComputedRef<HysChoiceValue[]>;
+        allChecked: import("vue").ComputedRef<boolean>;
+        indeterminate: import("vue").ComputedRef<boolean>;
+        focus: (value?: HysChoiceValue) => void;
+        blur: () => void;
+        checkAll: () => Promise<boolean>;
+        clear: () => Promise<boolean>;
+        toggle: (value: HysChoiceValue, checked?: boolean) => Promise<boolean>;
+    }>) => void;
+    attrs: any;
+    slots: {
+        option?: (props: {
+            option: import("../../index.js").HysChoiceOption<T>;
+            checked: boolean;
+        }) => any;
+    } & {
+        empty?: (props: {}) => any;
+    } & {
+        default?: (props: {
+            values: HysChoiceValue[];
+            allChecked: boolean;
+            indeterminate: boolean;
+            checkAll: () => Promise<boolean>;
+            clear: () => Promise<boolean>;
+        }) => any;
+    } & {
+        empty?: (props: {}) => any;
+    };
+    emit: ((evt: "change", value: T[], info: HysCheckboxChange) => void) & ((evt: "update:modelValue", value: T[]) => void) & ((evt: "blur", event: FocusEvent) => void) & ((evt: "focus", event: FocusEvent) => void) & ((evt: "reject", info: HysCheckboxReject) => 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/components/HysColorPicker/HysColorPanel.vue.d.ts

@@ -0,0 +1,58 @@
+import type { useColorPicker } from "../../composables/useColorPicker";
+import { type HysColorPickerProps } from "../../composables/color";
+type __VLS_Props = {
+    state: ReturnType<typeof useColorPicker>;
+    options: HysColorPickerProps;
+};
+declare const __VLS_template: () => {
+    __VLS_Slots: {
+        header?: (props: {
+            value: string;
+            draft: string;
+            color: Readonly<import("../../index.js").HysColor>;
+            disabled: boolean;
+            readonly: boolean;
+            valid: boolean;
+            dirty: boolean;
+            setColor: (value: string) => Promise<boolean>;
+            confirm: () => Promise<boolean>;
+            cancel: () => void;
+            clear: () => Promise<boolean>;
+            show: () => Promise<boolean>;
+            hide: () => Promise<boolean>;
+        }) => any;
+    } & {
+        preset?: (props: {
+            value: string;
+            color: string;
+            selected: boolean;
+            disabled: boolean;
+        }) => any;
+    } & {
+        footer?: (props: {
+            value: string;
+            draft: string;
+            color: Readonly<import("../../index.js").HysColor>;
+            disabled: boolean;
+            readonly: boolean;
+            valid: boolean;
+            dirty: boolean;
+            setColor: (value: string) => Promise<boolean>;
+            confirm: () => Promise<boolean>;
+            cancel: () => void;
+            clear: () => Promise<boolean>;
+            show: () => Promise<boolean>;
+            hide: () => Promise<boolean>;
+        }) => 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/HysColorPicker/HysColorPicker.vue.d.ts

@@ -1,14 +1,67 @@
-type __VLS_Props = {
-    modelValue: string;
-    disabled?: boolean;
-    label?: string;
-    presets?: string[];
-    clearable?: boolean;
-};
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+import { type HysColorPickerProps, type HysColorPickerSlots } from "../../composables/color";
+type __VLS_Slots = HysColorPickerSlots;
+declare const __VLS_base: import("vue").DefineComponent<HysColorPickerProps, {
+    element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    input: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+    panel: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    value: import("vue").ComputedRef<string>;
+    draft: import("vue").Ref<string, string>;
+    color: import("vue").ComputedRef<{
+        h: number;
+        s: number;
+        v: number;
+        a: number;
+    }>;
+    open: import("vue").ComputedRef<boolean>;
+    focus: (options?: FocusOptions) => void;
+    blur: () => void;
+    show: () => Promise<boolean>;
+    hide: (restore?: boolean) => Promise<boolean>;
+    confirm: () => Promise<boolean>;
+    cancel: () => void;
+    clear: () => Promise<boolean>;
+    setColor: (raw: string) => Promise<boolean>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (value: string) => any;
     "update:modelValue": (value: string) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    clear: () => any;
+    visibleChange: (open: boolean) => any;
+    blur: (event: FocusEvent) => any;
+    cancel: () => any;
+    focus: (event: FocusEvent) => any;
+    invalid: (value: string) => any;
+    "update:open": (open: boolean) => any;
+    activeChange: (value: string) => any;
+    confirm: (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<HysColorPickerProps> & Readonly<{
+    onChange?: ((value: string) => any) | undefined;
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+    onClear?: (() => any) | undefined;
+    onVisibleChange?: ((open: boolean) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onCancel?: (() => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onInvalid?: ((value: string) => any) | undefined;
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+    onActiveChange?: ((value: string) => any) | undefined;
+    onConfirm?: ((value: string) => any) | undefined;
+}>, {
+    modelValue: string;
+    immediate: boolean;
+    placement: import("../../index.js").Placement;
+    open: boolean;
+    popupWidth: string | number;
+    appendTo: string | false | HTMLElement;
+    showFooter: boolean;
+    validateEvent: boolean;
+    showInput: boolean;
+    showPresets: 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/HysCommandPalette/HysCommandPalette.vue.d.ts

@@ -1,9 +1,10 @@
+import type { HysPopupMotionProps } from '../../motion/popup';
 type Action = {
     id: string;
     label: string;
     description?: string;
 };
-type __VLS_Props = {
+type __VLS_Props = HysPopupMotionProps & {
     actions: Action[];
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {

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

@@ -1,37 +1,53 @@
-type __VLS_Props = {
-    items: {
-        label: string;
-        value: string;
-        disabled?: boolean;
-        type?: 'item' | 'divider';
-    }[];
-    disabled?: boolean;
+import type { HysContextMenuItem, HysContextMenuProps, HysContextMenuSlots, HysMenuKey, HysMenuSelectInfo } from "../../composables/menu";
+declare const __VLS_export: <N extends object = HysContextMenuItem>(__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<HysContextMenuProps<N> & {
+        onSelect?: ((value: N extends {
+            value: infer V extends HysMenuKey;
+        } ? V : HysMenuKey, info: HysMenuSelectInfo<N>) => any) | undefined;
+        onVisibleChange?: ((value: boolean) => any) | undefined;
+        "onUpdate:open"?: ((value: boolean) => any) | undefined;
+        "onUpdate:openPath"?: ((value: HysMenuKey[]) => any) | undefined;
+        onOpenPathChange?: ((value: HysMenuKey[]) => any) | undefined;
+        "onUpdate:checkedKeys"?: ((value: HysMenuKey[]) => any) | undefined;
+        onCheckedChange?: ((value: HysMenuKey[], info?: HysMenuSelectInfo<N> | undefined) => any) | undefined;
+        "onUpdate:selectedKeys"?: ((value: HysMenuKey[]) => any) | undefined;
+        onSelectionChange?: ((value: HysMenuKey[], info?: HysMenuSelectInfo<N> | undefined) => 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").Ref<boolean, boolean>;
+        checkedKeys: import("vue").ComputedRef<HysMenuKey[]>;
+        selectedKeys: import("vue").ComputedRef<HysMenuKey[]>;
+        openPath: import("vue").ComputedRef<HysMenuKey[]>;
+        focus: () => void;
+        blur: () => void;
+        show: (event?: MouseEvent | KeyboardEvent | import("../..").HysMenuShowOptions) => Promise<boolean>;
+        showAt: (x: number, y: number, focus?: boolean) => Promise<boolean>;
+        hide: (restore?: boolean) => Promise<boolean>;
+        handleOpen: () => Promise<boolean>;
+        handleClose: (restore?: boolean) => Promise<boolean>;
+        toggle: () => Promise<boolean>;
+        focusItem: (key: HysMenuKey) => Promise<boolean>;
+        openSubmenu: (key: HysMenuKey, focusChild?: boolean) => Promise<boolean>;
+        closeSubmenus: () => Promise<boolean>;
+        setCheckedKeys: (keys: readonly HysMenuKey[]) => Promise<boolean>;
+        setSelectedKeys: (keys: readonly HysMenuKey[]) => Promise<boolean>;
+        getItems: () => N[];
+    }>) => void;
+    attrs: any;
+    slots: HysContextMenuSlots<N>;
+    emit: ((evt: "select", value: N extends {
+        value: infer V extends HysMenuKey;
+    } ? V : HysMenuKey, info: HysMenuSelectInfo<N>) => void) & ((evt: "visibleChange", value: boolean) => void) & ((evt: "update:open", value: boolean) => void) & ((evt: "update:openPath", value: HysMenuKey[]) => void) & ((evt: "openPathChange", value: HysMenuKey[]) => void) & ((evt: "update:checkedKeys", value: HysMenuKey[]) => void) & ((evt: "checkedChange", value: HysMenuKey[], info?: HysMenuSelectInfo<N> | undefined) => void) & ((evt: "update:selectedKeys", value: HysMenuKey[]) => void) & ((evt: "selectionChange", value: HysMenuKey[], info?: HysMenuSelectInfo<N> | undefined) => void);
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };
-declare const __VLS_template: () => {
-    __VLS_Slots: {
-        default?: (props: {}) => any;
-    } & {
-        item?: (props: {
-            item: {
-                label: string;
-                value: string;
-                disabled?: boolean;
-                type?: "item" | "divider";
-            };
-        }) => 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, {
-    select: (value: string) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onSelect?: ((value: 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/HysContextMenu/HysMenuPanel.vue.d.ts

@@ -0,0 +1,79 @@
+import { type MenuRow, type HysMenuItemContext } from "../../composables/menu";
+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 MenuRow<N>[];
+        level: number;
+        id: string;
+        rootId: string;
+        label: string;
+        parentLabel?: string;
+        busy: boolean;
+        loading: boolean;
+        emptyText: string;
+        loadingText: string;
+        backText: string;
+        direction?: "ltr" | "rtl";
+        context: (row: MenuRow<N>) => HysMenuItemContext<N>;
+        tabbable: (row: MenuRow<N>) => number;
+    } & {
+        onScroll?: (() => any) | undefined;
+        onChoose?: ((row: MenuRow<N>, event: MouseEvent) => any) | undefined;
+        onFocusRow?: ((row: MenuRow<N>) => any) | undefined;
+        onHoverRow?: ((row: MenuRow<N>) => any) | undefined;
+        onKeyboard?: ((event: KeyboardEvent) => any) | undefined;
+        onBack?: (() => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    }>) => void;
+    attrs: any;
+    slots: {
+        header?: (props: {}) => any;
+    } & {
+        loading?: (props: {}) => any;
+    } & {
+        empty?: (props: {}) => any;
+    } & {
+        icon?: (props: {
+            item: N;
+            value: import("../..").HysMenuKey | undefined;
+            label: string;
+            path: readonly N[];
+            keys: readonly import("../..").HysMenuKey[];
+            level: number;
+            disabled: boolean;
+            checked: boolean;
+            selected: boolean;
+            expanded: boolean;
+            submenu: boolean;
+        }) => any;
+    } & {
+        item?: (props: {
+            item: N;
+            value: import("../..").HysMenuKey | undefined;
+            label: string;
+            path: readonly N[];
+            keys: readonly import("../..").HysMenuKey[];
+            level: number;
+            disabled: boolean;
+            checked: boolean;
+            selected: boolean;
+            expanded: boolean;
+            submenu: boolean;
+        }) => any;
+    } & {
+        footer?: (props: {}) => any;
+    };
+    emit: ((evt: "scroll") => void) & ((evt: "choose", row: MenuRow<N>, event: MouseEvent) => void) & ((evt: "focusRow", row: MenuRow<N>) => void) & ((evt: "hoverRow", row: MenuRow<N>) => void) & ((evt: "keyboard", event: KeyboardEvent) => void) & ((evt: "back") => 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/components/HysContextMenu/HysMenuSlot.d.ts

@@ -0,0 +1,8 @@
+import { type FunctionalComponent, type VNodeChild } from "vue";
+/** Keep a single interactive root so router/link slots receive menu semantics. */
+declare const HysMenuSlot: FunctionalComponent<{
+    content?: (scope: any) => VNodeChild;
+    scope: any;
+    nodeAttrs?: Record<string, unknown>;
+}>;
+export default HysMenuSlot;