elenext/dist/index.d.ts

import { AllowedComponentProps } from 'vue';
import { Component } from 'vue';
import { ComponentCustomProps } from 'vue';
import { ComponentObjectPropsOptions } from 'vue';
import { ComponentOptionsMixin } from 'vue';
import { ComponentPropsOptions } from 'vue';
import { DefineComponent } from 'vue';
import { ExtractPropTypes } from 'vue';
import { Placement } from '@floating-ui/vue';
import { Plugin as Plugin_2 } from 'vue';
import { Prettify } from 'kotl';
import { PropType } from 'vue';
import { PublicProps } from 'vue';
import { Ref } from 'vue';
import { RendererElement } from 'vue';
import { RendererNode } from 'vue';
import { ResizeObserverEntry as ResizeObserverEntry_2 } from '@vueuse/core';
import { ShallowUnwrapRef } from 'vue';
import { VNode } from 'vue';
import { VNodeProps } from 'vue';

declare const __VLS_component: DefineComponent<    {
src: StringConstructor;
name: StringConstructor;
size: {
type: PropType<"sm" | "md" | "lg">;
default: string;
};
rounded: BooleanConstructor;
border: BooleanConstructor;
}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (args_0: any) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
src: StringConstructor;
name: StringConstructor;
size: {
type: PropType<"sm" | "md" | "lg">;
default: string;
};
rounded: BooleanConstructor;
border: BooleanConstructor;
}>> & {
onClick?: ((args_0: any) => any) | undefined;
}, {
size: "sm" | "md" | "lg";
border: boolean;
rounded: boolean;
}, {}>;

declare const __VLS_component_10: DefineComponent<    {
value: {
type: null;
required: true;
};
name: StringConstructor;
disabled: BooleanConstructor;
checked: {
type: BooleanConstructor;
default: undefined;
};
}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
change: (args_0: boolean) => void;
"update:checked": (args_0: boolean) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
value: {
type: null;
required: true;
};
name: StringConstructor;
disabled: BooleanConstructor;
checked: {
type: BooleanConstructor;
default: undefined;
};
}>> & {
onChange?: ((args_0: boolean) => any) | undefined;
"onUpdate:checked"?: ((args_0: boolean) => any) | undefined;
}, {
disabled: boolean;
checked: boolean;
}, {}>;

declare const __VLS_component_11: DefineComponent<    {
name: StringConstructor;
value: null;
disabled: BooleanConstructor;
size: {
type: PropType<"sm" | "md" | "lg">;
default: string;
};
}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:value": (args_0: unknown) => void;
change: (args_0: unknown) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
name: StringConstructor;
value: null;
disabled: BooleanConstructor;
size: {
type: PropType<"sm" | "md" | "lg">;
default: string;
};
}>> & {
onChange?: ((args_0: unknown) => any) | undefined;
"onUpdate:value"?: ((args_0: unknown) => any) | undefined;
}, {
size: "sm" | "md" | "lg";
disabled: boolean;
}, {}>;

declare const __VLS_component_12: DefineComponent<    {
direction: {
type: PropType<"vertical" | "horizontal" | "all">;
default: string;
};
}, {
viewportEl: Ref<HTMLElement | undefined>;
contentEl: Ref<HTMLElement | undefined>;
scrollTo(pos: "left" | "right" | "top" | "bottom" | [number, number]): void;
}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (args_0: any) => void;
resize: (entries: readonly ResizeObserverEntry_2[]) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
direction: {
type: PropType<"vertical" | "horizontal" | "all">;
default: string;
};
}>> & {
onClick?: ((args_0: any) => any) | undefined;
onResize?: ((entries: readonly ResizeObserverEntry_2[]) => any) | undefined;
}, {
direction: "vertical" | "horizontal" | "all";
}, {}>;

declare const __VLS_component_13: DefineComponent<    {
value: (StringConstructor | NumberConstructor)[];
options: {
type: PropType<SelectOption[]>;
default: () => never[];
};
size: PropType<"sm" | "md" | "lg">;
disabled: BooleanConstructor;
clearable: BooleanConstructor;
placeholder: StringConstructor;
}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
select: (...args: any[]) => void;
"update:value": (...args: any[]) => void;
change: (...args: any[]) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
value: (StringConstructor | NumberConstructor)[];
options: {
type: PropType<SelectOption[]>;
default: () => never[];
};
size: PropType<"sm" | "md" | "lg">;
disabled: BooleanConstructor;
clearable: BooleanConstructor;
placeholder: StringConstructor;
}>> & {
onChange?: ((...args: any[]) => any) | undefined;
onSelect?: ((...args: any[]) => any) | undefined;
"onUpdate:value"?: ((...args: any[]) => any) | undefined;
}, {
disabled: boolean;
options: {
value: string | number;
label: string;
disabled?: boolean | undefined;
}[];
clearable: boolean;
}, {}>;

declare const __VLS_component_14: DefineComponent<Readonly<ComponentPropsOptions<    {
[x: string]: unknown;
}>>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (args_0: any) => void;
}, string, PublicProps, Readonly<readonly string[] | ExtractPropTypes<Readonly<ComponentObjectPropsOptions<    {
[x: string]: unknown;
}>>>> & {
onClick?: ((args_0: any) => any) | undefined;
}, {
readonly [x: number]: string;
} | {}, {}>;

declare const __VLS_component_15: DefineComponent<    {
value: {
type: BooleanConstructor;
default: undefined;
};
name: StringConstructor;
disabled: BooleanConstructor;
}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:value": (args_0: boolean) => void;
change: (args_0: boolean) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
value: {
type: BooleanConstructor;
default: undefined;
};
name: StringConstructor;
disabled: BooleanConstructor;
}>> & {
onChange?: ((args_0: boolean) => any) | undefined;
"onUpdate:value"?: ((args_0: boolean) => any) | undefined;
}, {
disabled: boolean;
value: boolean;
}, {}>;

declare const __VLS_component_16: DefineComponent<    {
current: {
type: StringConstructor;
default: string;
};
items: {
type: PropType<{
key: string;
label: string;
}[]>;
default: () => never[];
};
type: {
type: PropType<"underline" | "card">;
default: string;
};
}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
change: (key: string) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
current: {
type: StringConstructor;
default: string;
};
items: {
type: PropType<{
key: string;
label: string;
}[]>;
default: () => never[];
};
type: {
type: PropType<"underline" | "card">;
default: string;
};
}>> & {
onChange?: ((key: string) => any) | undefined;
}, {
type: "underline" | "card";
items: {
key: string;
label: string;
}[];
current: string;
}, {}>;

declare const __VLS_component_17: DefineComponent<    {
value: StringConstructor;
status: {
type: PropType<"normal" | "success" | "warning" | "danger">;
default: string;
};
placeholder: StringConstructor;
readonly: BooleanConstructor;
disabled: BooleanConstructor;
noBorder: BooleanConstructor;
rows: {
type: NumberConstructor;
default: number;
};
resize: {
type: PropType<"none" | "both" | "horizontal" | "vertical">;
default: string;
};
autocomplete: {
type: PropType<"on" | "off">;
default: string;
};
}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
input: (args_0: Event) => void;
"update:value": (args_0: string) => void;
change: (args_0: string) => void;
focus: (args_0: FocusEvent) => void;
blur: (args_0: FocusEvent) => void;
contextmenu: (args_0: MouseEvent) => void;
keydown: (args_0: KeyboardEvent) => void;
keypress: (args_0: KeyboardEvent) => void;
keyup: (args_0: KeyboardEvent) => void;
paste: (args_0: ClipboardEvent) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
value: StringConstructor;
status: {
type: PropType<"normal" | "success" | "warning" | "danger">;
default: string;
};
placeholder: StringConstructor;
readonly: BooleanConstructor;
disabled: BooleanConstructor;
noBorder: BooleanConstructor;
rows: {
type: NumberConstructor;
default: number;
};
resize: {
type: PropType<"none" | "both" | "horizontal" | "vertical">;
default: string;
};
autocomplete: {
type: PropType<"on" | "off">;
default: string;
};
}>> & {
onPaste?: ((args_0: ClipboardEvent) => any) | undefined;
onFocus?: ((args_0: FocusEvent) => any) | undefined;
onBlur?: ((args_0: FocusEvent) => any) | undefined;
onChange?: ((args_0: string) => any) | undefined;
onInput?: ((args_0: Event) => any) | undefined;
onKeydown?: ((args_0: KeyboardEvent) => any) | undefined;
onKeypress?: ((args_0: KeyboardEvent) => any) | undefined;
onKeyup?: ((args_0: KeyboardEvent) => any) | undefined;
onContextmenu?: ((args_0: MouseEvent) => any) | undefined;
"onUpdate:value"?: ((args_0: string) => any) | undefined;
}, {
disabled: boolean;
readonly: boolean;
status: "success" | "warning" | "danger" | "normal";
autocomplete: "off" | "on";
resize: "none" | "vertical" | "horizontal" | "both";
noBorder: boolean;
rows: number;
}, {}>;

declare const __VLS_component_18: DefineComponent<    {
content: StringConstructor;
placement: {
type: PropType<PopperPlacement>;
default: string;
};
}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
content: StringConstructor;
placement: {
type: PropType<PopperPlacement>;
default: string;
};
}>>, {
placement: Placement;
}, {}>;

declare const __VLS_component_2: DefineComponent<    {
color: {
type: PropType<"default" | "primary" | "success" | "warning" | "danger">;
default: string;
};
size: {
type: PropType<"sm" | "md" | "lg">;
default: string;
};
placement: {
type: PropType<"top-right" | "top-left" | "bottom-right" | "bottom-left">;
default: string;
};
content: StringConstructor;
}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (args_0: any) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
color: {
type: PropType<"default" | "primary" | "success" | "warning" | "danger">;
default: string;
};
size: {
type: PropType<"sm" | "md" | "lg">;
default: string;
};
placement: {
type: PropType<"top-right" | "top-left" | "bottom-right" | "bottom-left">;
default: string;
};
content: StringConstructor;
}>> & {
onClick?: ((args_0: any) => any) | undefined;
}, {
color: "default" | "primary" | "success" | "warning" | "danger";
size: "sm" | "md" | "lg";
placement: "top-right" | "top-left" | "bottom-right" | "bottom-left";
}, {}>;

declare const __VLS_component_3: DefineComponent<    {
variant: {
type: PropType<"solid" | "soft" | "outline" | "text" | "pure" | "default">;
default: string;
};
color: {
type: PropType<"primary" | "success" | "warning" | "danger">;
default: string;
};
size: {
type: PropType<"sm" | "md" | "lg">;
default: string;
};
pill: BooleanConstructor;
square: BooleanConstructor;
block: BooleanConstructor;
loading: BooleanConstructor;
disabled: BooleanConstructor;
}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (args_0: Event) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
variant: {
type: PropType<"solid" | "soft" | "outline" | "text" | "pure" | "default">;
default: string;
};
color: {
type: PropType<"primary" | "success" | "warning" | "danger">;
default: string;
};
size: {
type: PropType<"sm" | "md" | "lg">;
default: string;
};
pill: BooleanConstructor;
square: BooleanConstructor;
block: BooleanConstructor;
loading: BooleanConstructor;
disabled: BooleanConstructor;
}>> & {
onClick?: ((args_0: Event) => any) | undefined;
}, {
variant: "default" | "text" | "solid" | "soft" | "outline" | "pure";
color: "primary" | "success" | "warning" | "danger";
size: "sm" | "md" | "lg";
pill: boolean;
square: boolean;
block: boolean;
loading: boolean;
disabled: boolean;
}, {}>;

declare const __VLS_component_4: DefineComponent<    {
value: {
type: null;
required: true;
};
name: StringConstructor;
disabled: BooleanConstructor;
checked: {
type: BooleanConstructor;
default: undefined;
};
}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
change: (args_0: boolean) => void;
"update:checked": (args_0: boolean) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
value: {
type: null;
required: true;
};
name: StringConstructor;
disabled: BooleanConstructor;
checked: {
type: BooleanConstructor;
default: undefined;
};
}>> & {
onChange?: ((args_0: boolean) => any) | undefined;
"onUpdate:checked"?: ((args_0: boolean) => any) | undefined;
}, {
disabled: boolean;
checked: boolean;
}, {}>;

declare const __VLS_component_5: DefineComponent<    {
name: StringConstructor;
value: PropType<unknown[]>;
disabled: BooleanConstructor;
}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:value": (args_0: unknown[]) => void;
change: (args_0: unknown[]) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
name: StringConstructor;
value: PropType<unknown[]>;
disabled: BooleanConstructor;
}>> & {
onChange?: ((args_0: unknown[]) => any) | undefined;
"onUpdate:value"?: ((args_0: unknown[]) => any) | undefined;
}, {
disabled: boolean;
}, {}>;

declare const __VLS_component_6: DefineComponent<    {
value: (StringConstructor | NumberConstructor)[];
status: {
type: PropType<"normal" | "success" | "warning" | "danger">;
default: string;
};
prefix: StringConstructor;
suffix: StringConstructor;
placeholder: StringConstructor;
readonly: BooleanConstructor;
disabled: BooleanConstructor;
allowClear: BooleanConstructor;
}, {
focus: () => void | undefined;
blur: () => void | undefined;
}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
input: (args_0: Event) => void;
"update:value": (args_0: string | number) => void;
change: (args_0: string | number) => void;
focus: (args_0: FocusEvent) => void;
blur: (args_0: FocusEvent) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
value: (StringConstructor | NumberConstructor)[];
status: {
type: PropType<"normal" | "success" | "warning" | "danger">;
default: string;
};
prefix: StringConstructor;
suffix: StringConstructor;
placeholder: StringConstructor;
readonly: BooleanConstructor;
disabled: BooleanConstructor;
allowClear: BooleanConstructor;
}>> & {
onFocus?: ((args_0: FocusEvent) => any) | undefined;
onBlur?: ((args_0: FocusEvent) => any) | undefined;
onChange?: ((args_0: string | number) => any) | undefined;
onInput?: ((args_0: Event) => any) | undefined;
"onUpdate:value"?: ((args_0: string | number) => any) | undefined;
}, {
disabled: boolean;
readonly: boolean;
status: "success" | "warning" | "danger" | "normal";
allowClear: boolean;
}, {}>;

declare const __VLS_component_7: DefineComponent<    {
title: StringConstructor;
current: StringConstructor;
items: {
type: PropType<MenuItemType[]>;
default: () => never[];
};
}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (args_0: any) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: StringConstructor;
current: StringConstructor;
items: {
type: PropType<MenuItemType[]>;
default: () => never[];
};
}>> & {
onClick?: ((args_0: any) => any) | undefined;
}, {
items: MenuItemType[];
}, {}>;

declare const __VLS_component_8: DefineComponent<    {
content: StringConstructor;
trigger: {
type: PropType<PopperTrigger>;
default: string;
};
placement: {
type: PropType<PopperPlacement>;
default: string;
};
sizeMode: PropType<PopperSizeMode>;
}, {
toggle: () => void | undefined;
}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
change: (open: boolean) => void;
"update:open": (open: boolean) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
content: StringConstructor;
trigger: {
type: PropType<PopperTrigger>;
default: string;
};
placement: {
type: PropType<PopperPlacement>;
default: string;
};
sizeMode: PropType<PopperSizeMode>;
}>> & {
onChange?: ((open: boolean) => any) | undefined;
"onUpdate:open"?: ((open: boolean) => any) | undefined;
}, {
placement: Placement;
trigger: PopperTrigger;
}, {}>;

declare const __VLS_component_9: DefineComponent<    {
value: {
type: null;
required: true;
};
name: StringConstructor;
disabled: BooleanConstructor;
checked: {
type: BooleanConstructor;
default: undefined;
};
}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
change: (args_0: boolean) => void;
"update:checked": (args_0: boolean) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
value: {
type: null;
required: true;
};
name: StringConstructor;
disabled: BooleanConstructor;
checked: {
type: BooleanConstructor;
default: undefined;
};
}>> & {
onChange?: ((args_0: boolean) => any) | undefined;
"onUpdate:checked"?: ((args_0: boolean) => any) | undefined;
}, {
disabled: boolean;
checked: boolean;
}, {}>;

declare type __VLS_Prettify<T> = {
    [K in keyof T]: T[K];
} & {};

declare function __VLS_template(): Readonly<{
    fallback?(_: {}): any;
}> & {
    fallback?(_: {}): any;
};

declare function __VLS_template_10(): {
    default?(_: {
        checked: boolean;
    }): any;
};

declare function __VLS_template_11(): {
    default?(_: {}): any;
};

declare function __VLS_template_12(): Readonly<{
    default?(_: {}): any;
}> & {
    default?(_: {}): any;
};

declare function __VLS_template_13(): Readonly<{
    label?: (props: {
        selected: boolean;
        item?: SelectOption;
        placeholder?: string;
    }) => any;
}> & {
    label?: (props: {
        selected: boolean;
        item?: SelectOption;
        placeholder?: string;
    }) => any;
};

declare function __VLS_template_14(): Readonly<{
    default?(_: {}): any;
}> & {
    default?(_: {}): any;
};

declare function __VLS_template_15(): Readonly<{
    default?(_: {}): any;
    open?(_: {}): any;
    close?(_: {}): any;
}> & {
    default?(_: {}): any;
    open?(_: {}): any;
    close?(_: {}): any;
};

declare function __VLS_template_16(): Readonly<{
    default?(props: {
        current: string;
    }): any;
}> & {
    default?(props: {
        current: string;
    }): any;
};

declare function __VLS_template_17(): Readonly<{
    toolbar?(props: {
        content: string;
    }): any;
}> & {
    toolbar?(props: {
        content: string;
    }): any;
};

declare function __VLS_template_18(): {
    default?(_: {}): any;
    content?(_: {}): any;
};

declare function __VLS_template_2(): Readonly<{
    default?(_: {}): any;
    icon?(_: {}): any;
}> & {
    default?(_: {}): any;
    icon?(_: {}): any;
};

declare function __VLS_template_3(): Readonly<{
    default?(_: {}): any;
    icon?(_: {}): any;
}> & {
    default?(_: {}): any;
    icon?(_: {}): any;
};

declare function __VLS_template_4(): {
    default?(_: {}): any;
};

declare function __VLS_template_5(): {
    default?(_: {}): any;
};

declare function __VLS_template_6(): Readonly<{
    prefix?: (_: {}) => any;
    suffix?: (_: {}) => any;
}> & {
    prefix?: (_: {}) => any;
    suffix?: (_: {}) => any;
};

declare function __VLS_template_7(): Readonly<{
    default?(_: {}): any;
}> & {
    default?(_: {}): any;
};

declare function __VLS_template_8(): {
    default?(_: {}): any;
    content?(_: {}): any;
};

declare function __VLS_template_9(): {
    default?(_: {}): any;
};

declare type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_10<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_11<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_12<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_13<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_14<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_15<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_16<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_17<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_18<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_2<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_3<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_4<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_5<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_6<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_7<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_8<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_9<T, S> = T & {
    new (): {
        $slots: S;
    };
};

export declare const Anchor: DefineComponent<    {
current: StringConstructor;
items: {
type: PropType<IAnchorItem[]>;
default: () => never[];
};
}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
change: (item: IAnchorItem, deep: number) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
current: StringConstructor;
items: {
type: PropType<IAnchorItem[]>;
default: () => never[];
};
}>> & {
onChange?: ((item: IAnchorItem, deep: number) => any) | undefined;
}, {
items: IAnchorItem[];
}, {}>;

export declare const Avatar: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;

export declare const Badge: __VLS_WithTemplateSlots_2<typeof __VLS_component_2, ReturnType<typeof __VLS_template_2>>;

export declare const Button: __VLS_WithTemplateSlots_3<typeof __VLS_component_3, ReturnType<typeof __VLS_template_3>>;

export declare const Checkbox: __VLS_WithTemplateSlots_4<typeof __VLS_component_4, ReturnType<typeof __VLS_template_4>>;

export declare const CheckboxGroup: __VLS_WithTemplateSlots_5<typeof __VLS_component_5, ReturnType<typeof __VLS_template_5>>;

export declare type IAnchorItem = {
    /**
     * 链接标题
     */
    title: string;
    /**
     * 链接对应的 id
     */
    id: string;
    /**
     * 锚点链接
     * 通常使用 `#${id}` 作为锚点
     */
    link: string;
    /**
     * 该属性指定在何处显示链接的资源
     */
    target?: string;
    /**
     * 子级
     */
    children?: IAnchorItem[];
};

declare type IListItem<T = any> = IListItemDivider | IListItemGroup<T> | T;

declare type IListItemDivider = {
    type: 'divider';
};

declare type IListItemGroup<T> = {
    type: 'group';
    label: string;
    children: T[];
};

declare type IListItemNormal = {
    label: string;
    key?: string;
    disabled?: boolean;
    children?: IListItem[];
};

export declare const Input: __VLS_WithTemplateSlots_6<typeof __VLS_component_6, ReturnType<typeof __VLS_template_6>>;

export declare const ListBox: <T extends IListItemNormal>(__VLS_props: Awaited<typeof __VLS_setup>["props"], __VLS_ctx?: __VLS_Prettify<Pick<Awaited<typeof __VLS_setup>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
    props: __VLS_Prettify<Pick<Partial<{
        size: "sm" | "md" | "lg";
        indexKey: string;
    }> & Omit<{
        readonly size: "sm" | "md" | "lg";
        readonly indexKey: string;
        readonly items?: IListItem<T>[] | undefined;
        onClick?: ((args_0: T) => any) | undefined;
    } & VNodeProps & AllowedComponentProps & ComponentCustomProps & Readonly<ExtractPropTypes<    {
    items: PropType<IListItem<T>[]>;
    size: {
    type: PropType<"sm" | "md" | "lg">;
    default: string;
    };
    indexKey: {
    type: StringConstructor;
    default: string;
    };
    }>> & {
        onClick?: ((args_0: T) => any) | undefined;
    }, "size" | "indexKey">, "onClick" | "items" | ("size" | "indexKey")> & {}> & __VLS_BuiltInPublicProps;
    expose(exposed: ShallowUnwrapRef<    {}>): void;
    attrs: any;
    slots: ReturnType<() => Readonly<{
        item?(props: {
            item: T;
        }): any;
        group?(props: {
            item: IListItemGroup<T>;
        }): any;
    }> & {
        item?(props: {
            item: T;
        }): any;
        group?(props: {
            item: IListItemGroup<T>;
        }): any;
    }>;
    emit: ((evt: "click", args_0: T) => void) & {};
}>) => VNode<RendererNode, RendererElement, {
[key: string]: any;
}> & {
    __ctx?: Awaited<typeof __VLS_setup>;
};

export declare const Menu: __VLS_WithTemplateSlots_7<typeof __VLS_component_7, ReturnType<typeof __VLS_template_7>>;

export declare type MenuItemDividerType = {
    type: 'divider';
};

export declare type MenuItemRawType = {
    key: string;
    label: string;
    link?: string;
    target?: string;
    disabled?: boolean;
    icon?: Component;
    children?: MenuItemType[];
};

export declare type MenuItemTitleType = {
    type: 'title';
    label: string;
};

export declare type MenuItemType = MenuItemDividerType | MenuItemTitleType | MenuItemRawType;

export declare const plugin: Plugin_2;

export declare const Popover: __VLS_WithTemplateSlots_8<typeof __VLS_component_8, ReturnType<typeof __VLS_template_8>>;

declare type PopperPlacement = Placement;

declare type PopperSizeMode = 'min-width';

declare type PopperTrigger = 'click' | 'hover' | 'focus' | 'manual';

export declare const Radio: __VLS_WithTemplateSlots_9<typeof __VLS_component_9, ReturnType<typeof __VLS_template_9>>;

export declare const RadioCard: __VLS_WithTemplateSlots_10<typeof __VLS_component_10, ReturnType<typeof __VLS_template_10>>;

export declare const RadioGroup: __VLS_WithTemplateSlots_11<typeof __VLS_component_11, ReturnType<typeof __VLS_template_11>>;

export declare const ScrollArea: __VLS_WithTemplateSlots_12<typeof __VLS_component_12, ReturnType<typeof __VLS_template_12>>;

export declare const Select: __VLS_WithTemplateSlots_13<typeof __VLS_component_13, ReturnType<typeof __VLS_template_13>>;

export declare type SelectOption = Prettify<{
    value: string | number;
} & Omit<IListItemNormal, 'children' | 'key'>>;

export declare const SpaceCompact: __VLS_WithTemplateSlots_14<typeof __VLS_component_14, ReturnType<typeof __VLS_template_14>>;

export declare const Switch: __VLS_WithTemplateSlots_15<typeof __VLS_component_15, ReturnType<typeof __VLS_template_15>>;

export declare const Tabs: __VLS_WithTemplateSlots_16<typeof __VLS_component_16, ReturnType<typeof __VLS_template_16>>;

export declare const Textarea: __VLS_WithTemplateSlots_17<typeof __VLS_component_17, ReturnType<typeof __VLS_template_17>>;

export declare const Tooltip: __VLS_WithTemplateSlots_18<typeof __VLS_component_18, ReturnType<typeof __VLS_template_18>>;

export declare function useAnchor(headers: Ref<IAnchorItem[]>, options?: {
    offset?: number;
    defaultValue?: string;
    container?: Ref<HTMLElement | undefined>;
}): {
    current: Ref<any>;
    headers: Ref<IAnchorItem[]>;
};

export { }


declare global {
    type __VLS_IntrinsicElements = __VLS_PickNotAny<import('vue/jsx-runtime').JSX.IntrinsicElements, __VLS_PickNotAny<globalThis.JSX.IntrinsicElements, Record<string, any>>>;
    type __VLS_Element = __VLS_PickNotAny<import('vue/jsx-runtime').JSX.Element, globalThis.JSX.Element>;
    type __VLS_GlobalComponents = __VLS_PickNotAny<import('vue').GlobalComponents, {}> & __VLS_PickNotAny<import('@vue/runtime-core').GlobalComponents, {}> & __VLS_PickNotAny<import('@vue/runtime-dom').GlobalComponents, {}> & Pick<typeof import('vue'), 'Transition' | 'TransitionGroup' | 'KeepAlive' | 'Suspense' | 'Teleport'>;
    type __VLS_BuiltInPublicProps = __VLS_PickNotAny<import('vue').VNodeProps, {}> & __VLS_PickNotAny<import('vue').AllowedComponentProps, {}> & __VLS_PickNotAny<import('vue').ComponentCustomProps, {}>;
    type __VLS_IsAny<T> = 0 extends 1 & T ? true : false;
    type __VLS_PickNotAny<A, B> = __VLS_IsAny<A> extends true ? B : A;
    const __VLS_intrinsicElements: __VLS_IntrinsicElements;
    function __VLS_getVForSourceType(source: number): [number, number, number][];
    function __VLS_getVForSourceType(source: string): [string, number, number][];
    function __VLS_getVForSourceType<T extends any[]>(source: T): [
        item: T[number],
        key: number,
        index: number
    ][];
    function __VLS_getVForSourceType<T extends {
        [Symbol.iterator](): Iterator<any>;
    }>(source: T): [
        item: T extends {
            [Symbol.iterator](): Iterator<infer T1>;
        } ? T1 : never,
        key: number,
        index: undefined
    ][];
    function __VLS_getVForSourceType<T extends number | {
        [Symbol.iterator](): Iterator<any>;
    }>(source: T): [
        item: number | (Exclude<T, number> extends {
            [Symbol.iterator](): Iterator<infer T1>;
        } ? T1 : never),
        key: number,
        index: undefined
    ][];
    function __VLS_getVForSourceType<T>(source: T): [
        item: T[keyof T],
        key: keyof T,
        index: number
    ][];
    function __VLS_getSlotParams<T>(slot: T): Parameters<__VLS_PickNotAny<NonNullable<T>, (...args: any[]) => any>>;
    function __VLS_getSlotParam<T>(slot: T): Parameters<__VLS_PickNotAny<NonNullable<T>, (...args: any[]) => any>>[0];
    function __VLS_directiveFunction<T>(dir: T): T extends import('vue').ObjectDirective<infer E, infer V> | import('vue').FunctionDirective<infer E, infer V> ? (value: V) => void : T;
    function __VLS_withScope<T, K>(ctx: T, scope: K): ctx is T & K;
    function __VLS_makeOptional<T>(t: T): {
        [K in keyof T]?: T[K];
    };
    type __VLS_SelfComponent<N, C> = string extends N ? {} : N extends string ? {
        [P in N]: C;
    } : {};
    type __VLS_WithComponent<N0 extends string, LocalComponents, N1 extends string, N2 extends string, N3 extends string> = N1 extends keyof LocalComponents ? N1 extends N0 ? Pick<LocalComponents, N0 extends keyof LocalComponents ? N0 : never> : {
        [K in N0]: LocalComponents[N1];
    } : N2 extends keyof LocalComponents ? N2 extends N0 ? Pick<LocalComponents, N0 extends keyof LocalComponents ? N0 : never> : {
        [K in N0]: LocalComponents[N2];
    } : N3 extends keyof LocalComponents ? N3 extends N0 ? Pick<LocalComponents, N0 extends keyof LocalComponents ? N0 : never> : {
        [K in N0]: LocalComponents[N3];
    } : N1 extends keyof __VLS_GlobalComponents ? N1 extends N0 ? Pick<__VLS_GlobalComponents, N0 extends keyof __VLS_GlobalComponents ? N0 : never> : {
        [K in N0]: __VLS_GlobalComponents[N1];
    } : N2 extends keyof __VLS_GlobalComponents ? N2 extends N0 ? Pick<__VLS_GlobalComponents, N0 extends keyof __VLS_GlobalComponents ? N0 : never> : {
        [K in N0]: __VLS_GlobalComponents[N2];
    } : N3 extends keyof __VLS_GlobalComponents ? N3 extends N0 ? Pick<__VLS_GlobalComponents, N0 extends keyof __VLS_GlobalComponents ? N0 : never> : {
        [K in N0]: __VLS_GlobalComponents[N3];
    } : {
        [K in N0]: unknown;
    };
    function __VLS_asFunctionalComponent<T, K = T extends new (...args: any) => any ? InstanceType<T> : unknown>(t: T, instance?: K): T extends new (...args: any) => any ? (props: (K extends {
        $props: infer Props;
    } ? Props : any) & Record<string, unknown>, ctx?: any) => __VLS_Element & {
        __ctx?: {
            attrs?: any;
            slots?: K extends {
                $slots: infer Slots;
            } ? Slots : any;
            emit?: K extends {
                $emit: infer Emit;
            } ? Emit : any;
        } & {
            props?: (K extends {
                $props: infer Props;
            } ? Props : any) & Record<string, unknown>;
            expose?(exposed: K): void;
        };
    } : T extends () => any ? (props: {}, ctx?: any) => ReturnType<T> : T extends (...args: any) => any ? T : (_: {} & Record<string, unknown>, ctx?: any) => {
        __ctx?: {
            attrs?: any;
            expose?: any;
            slots?: any;
            emit?: any;
            props?: {} & Record<string, unknown>;
        };
    };
    function __VLS_elementAsFunction<T>(tag: T, endTag?: T): (_: T & Record<string, unknown>) => void;
    function __VLS_functionalComponentArgsRest<T extends (...args: any) => any>(t: T): Parameters<T>['length'] extends 2 ? [any] : [];
    function __VLS_pickFunctionalComponentCtx<T, K>(comp: T, compInstance: K): __VLS_PickNotAny<'__ctx' extends keyof __VLS_PickNotAny<K, {}> ? K extends {
        __ctx?: infer Ctx;
    } ? Ctx : never : any, T extends (props: any, ctx: infer Ctx) => any ? Ctx : any>;
    type __VLS_FunctionalComponentProps<T, K> = '__ctx' extends keyof __VLS_PickNotAny<K, {}> ? K extends {
        __ctx?: {
            props?: infer P;
        };
    } ? NonNullable<P> : never : T extends (props: infer P, ...args: any) => any ? P : {};
    type __VLS_AsFunctionOrAny<F> = unknown extends F ? any : ((...args: any) => any) extends F ? F : any;
    function __VLS_normalizeSlot<S>(s: S): S extends () => infer R ? (props: {}) => R : S;
    /**
     * emit
     */
    type __VLS_UnionToIntersection<U> = (U extends unknown ? (arg: U) => unknown : never) extends ((arg: infer P) => unknown) ? P : never;
    type __VLS_OverloadUnionInner<T, U = unknown> = U & T extends (...args: infer A) => infer R ? U extends T ? never : __VLS_OverloadUnionInner<T, Pick<T, keyof T> & U & ((...args: A) => R)> | ((...args: A) => R) : never;
    type __VLS_OverloadUnion<T> = Exclude<__VLS_OverloadUnionInner<(() => never) & T>, T extends () => never ? never : () => never>;
    type __VLS_ConstructorOverloads<T> = __VLS_OverloadUnion<T> extends infer F ? F extends (event: infer E, ...args: infer A) => any ? {
        [K in E & string]: (...args: A) => void;
    } : never : never;
    type __VLS_NormalizeEmits<T> = __VLS_PrettifyGlobal<__VLS_UnionToIntersection<__VLS_ConstructorOverloads<T> & {
        [K in keyof T]: T[K] extends any[] ? {
            (...args: T[K]): void;
        } : never;
    }>>;
    type __VLS_PrettifyGlobal<T> = {
        [K in keyof T]: T[K];
    } & {};
}