import { AllowedComponentProps } from 'vue';
import { AriaAttributes } from 'vue';
import { Component } from 'vue';
import { ComponentCustomProps } from 'vue';
import { ComponentOptionsMixin } from 'vue';
import { ComponentProvideOptions } from 'vue';
import { ComponentPublicInstance } from 'vue';
import { ComputedRef } from 'vue';
import { CSSProperties } from 'vue';
import { DefineComponent } from 'vue';
import { Events } from 'vue';
import { ExtractPropTypes } from 'vue';
import { HTMLAttributes } from 'vue';
import { IfAny } from '@vue/shared';
import { InjectionKey } from 'vue';
import { isFunction } from '@vue/shared';
import { LooseRequired } from '@vue/shared';
import { MaybeRef } from 'vue';
import { MaybeRefOrGetter } from 'vue';
import { Prettify } from '@vue/shared';
import { PropType } from 'vue';
import { PublicProps } from 'vue';
import { Ref } from 'vue';
import { RendererElement } from 'vue';
import { RendererNode } from 'vue';
import { ShallowRef } from 'vue';
import { ShallowUnwrapRef } from 'vue';
import { TeleportProps } from 'vue';
import { UnwrapRef } from 'vue';
import { VirtualElement } from '@floating-ui/utils';
import { VNode } from 'vue';
import { VNodeProps } from 'vue';

declare const __VLS_component: DefineComponent<CollapsibleContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<CollapsibleContentProps> & Readonly<{}>, {
forceMount: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_10: DefineComponent<PortalProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PortalProps> & Readonly<{}>, {
to: string | RendererElement | null;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_11: DefineComponent<AlertDialogCancelProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AlertDialogCancelProps> & Readonly<{}>, {
as: object | AsTag;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_12: DefineComponent<AlertDialogContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AlertDialogContentProps> & Readonly<{}>, {
forceMount: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_13: DefineComponent<AlertDialogRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (open: boolean) => any;
}, string, PublicProps, Readonly<AlertDialogRootProps> & Readonly<{
"onUpdate:open"?: ((open: boolean) => any) | undefined;
}>, {
open: boolean;
defaultOpen: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_14: DefineComponent<AspectRatioProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AspectRatioProps> & Readonly<{}>, {
ratio: number;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_15: DefineComponent<AvatarFallbackProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AvatarFallbackProps> & Readonly<{}>, {
as: object | AsTag;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_16: DefineComponent<AvatarImageProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
loadingStatusChange: (status: ImageLoadingStatus) => any;
}, string, PublicProps, Readonly<AvatarImageProps> & Readonly<{
onLoadingStatusChange?: ((status: ImageLoadingStatus) => any) | undefined;
}>, {
as: object | AsTag;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_17: DefineComponent<AvatarRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AvatarRootProps> & Readonly<{}>, {
as: object | AsTag;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_18: DefineComponent<CheckboxIndicatorProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<CheckboxIndicatorProps> & Readonly<{}>, {
as: object | AsTag;
forceMount: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_19: DefineComponent<CheckboxRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:checked": (value: CheckedState) => any;
}, string, PublicProps, Readonly<CheckboxRootProps> & Readonly<{
"onUpdate:checked"?: ((value: CheckedState) => any) | undefined;
}>, {
value: string;
as: object | AsTag;
disabled: boolean;
required: boolean;
checked: CheckedState;
defaultChecked: CheckedState;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_2: DefineComponent<AccordionHeaderProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AccordionHeaderProps> & Readonly<{}>, {
as: object | AsTag;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_20: DefineComponent<CollapsibleContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<CollapsibleContentProps> & Readonly<{}>, {
forceMount: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_21: DefineComponent<CollapsibleRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (value: boolean) => any;
}, string, PublicProps, Readonly<CollapsibleRootProps> & Readonly<{
"onUpdate:open"?: ((value: boolean) => any) | undefined;
}>, {
open: boolean;
disabled: boolean;
defaultOpen: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_22: DefineComponent<CollapsibleTriggerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<CollapsibleTriggerProps> & Readonly<{}>, {
as: object | AsTag;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_23: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const __VLS_component_24: DefineComponent<MenuItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
select: (event: Event) => any;
}, string, PublicProps, Readonly<MenuItemProps> & Readonly<{
onSelect?: ((event: Event) => any) | undefined;
}>, {
disabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_25: DefineComponent<MenuCheckboxItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
select: (event: Event) => any;
"update:checked": (event: boolean) => any;
}, string, PublicProps, Readonly<MenuCheckboxItemProps> & Readonly<{
onSelect?: ((event: Event) => any) | undefined;
"onUpdate:checked"?: ((event: boolean) => any) | undefined;
}>, {
disabled: boolean;
checked: CheckedState;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_26: DefineComponent<MenuRadioGroupProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:value": (payload: string) => any;
}, string, PublicProps, Readonly<MenuRadioGroupProps> & Readonly<{
"onUpdate:value"?: ((payload: string) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_27: DefineComponent<MenuRadioItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
select: (event: Event) => any;
}, string, PublicProps, Readonly<MenuRadioItemProps> & Readonly<{
onSelect?: ((event: Event) => any) | undefined;
}>, {
disabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_28: DefineComponent<MenuItemIndicatorProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<MenuItemIndicatorProps> & Readonly<{}>, {
as: object | AsTag;
forceMount: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_29: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const __VLS_component_3: DefineComponent<AccordionItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AccordionItemProps> & Readonly<{}>, {
disabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_30: DefineComponent<PopperArrowProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PopperArrowProps> & Readonly<{}>, {
width: number;
height: number;
as: AsTag | object;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_31: DefineComponent<MenuSubTriggerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<MenuSubTriggerProps> & Readonly<{}>, {
disabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_32: DefineComponent<ContextMenuContenttProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ContextMenuContenttProps> & Readonly<{}>, {
forceMount: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_33: DefineComponent<ContextMenuRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (open: boolean) => any;
}, string, PublicProps, Readonly<ContextMenuRootProps> & Readonly<{
"onUpdate:open"?: ((open: boolean) => any) | undefined;
}>, {
modal: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_34: DefineComponent<ContextMenuSubProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (isOpen: boolean) => any;
}, string, PublicProps, Readonly<ContextMenuSubProps> & Readonly<{
"onUpdate:open"?: ((isOpen: boolean) => any) | undefined;
}>, {
open: boolean;
defaultOpen: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_35: DefineComponent<ContextMenuSubContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ContextMenuSubContentProps> & Readonly<{}>, {
forceMount: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_36: DefineComponent<ContextMenuTriggerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ContextMenuTriggerProps> & Readonly<{}>, {
as: object | AsTag;
disabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_37: DefineComponent<DialogContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<DialogContentProps> & Readonly<{}>, {
forceMount: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_38: DefineComponent<DialogRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (open: boolean) => any;
}, string, PublicProps, Readonly<DialogRootProps> & Readonly<{
"onUpdate:open"?: ((open: boolean) => any) | undefined;
}>, {
open: boolean;
defaultOpen: boolean;
modal: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_39: DefineComponent<DropdownMenuContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<DropdownMenuContentProps> & Readonly<{}>, {
forceMount: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_4: DefineComponent<AccordionTriggerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AccordionTriggerProps> & Readonly<{}>, {
as: object | AsTag;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_40: DefineComponent<DropdownMenuRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (open: boolean) => any;
}, string, PublicProps, Readonly<DropdownMenuRootProps> & Readonly<{
"onUpdate:open"?: ((open: boolean) => any) | undefined;
}>, {
open: boolean;
defaultOpen: boolean;
modal: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_41: DefineComponent<DropdownMenuSubProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (open: boolean) => any;
}, string, PublicProps, Readonly<DropdownMenuSubProps> & Readonly<{
"onUpdate:open"?: ((open: boolean) => any) | undefined;
}>, {
open: boolean;
defaultOpen: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_42: DefineComponent<DropdownMenuSubContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<DropdownMenuSubContentProps> & Readonly<{}>, {
forceMount: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_43: DefineComponent<DropdownMenuTriggerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<DropdownMenuTriggerProps> & Readonly<{}>, {
as: object | AsTag;
disabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_44: DefineComponent<HoverCardContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<HoverCardContentProps> & Readonly<{}>, {
forceMount: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_45: DefineComponent<HoverCardRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (open: boolean) => any;
}, string, PublicProps, Readonly<HoverCardRootProps> & Readonly<{
"onUpdate:open"?: ((open: boolean) => any) | undefined;
}>, {
open: boolean;
defaultOpen: boolean;
openDelay: number;
closeDelay: number;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_46: DefineComponent<HoverCardTriggerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<HoverCardTriggerProps> & Readonly<{}>, {
as: object | AsTag;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_47: DefineComponent<LabelProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
mousedown: (event: MouseEvent) => any;
}, string, PublicProps, Readonly<LabelProps> & Readonly<{
onMousedown?: ((event: MouseEvent) => any) | undefined;
}>, {
as: object | AsTag;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_48: DefineComponent<MenubarContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<MenubarContentProps> & Readonly<{}>, {
forceMount: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_49: DefineComponent<MenubarContentImplProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
escapeKeydown: (event: KeyboardEvent) => any;
pointerdownOutside: (event: PointerdownOutsideEvent) => any;
focusOutside: (event: FocusOutsideEvent) => any;
interactOutside: (event: PointerdownOutsideEvent | FocusOutsideEvent) => any;
closeAutoFocus: (event: Event) => any;
}, string, PublicProps, Readonly<MenubarContentImplProps> & Readonly<{
onEscapeKeydown?: ((event: KeyboardEvent) => any) | undefined;
onPointerdownOutside?: ((event: PointerdownOutsideEvent) => any) | undefined;
onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
onInteractOutside?: ((event: PointerdownOutsideEvent | FocusOutsideEvent) => any) | undefined;
onCloseAutoFocus?: ((event: Event) => any) | undefined;
}>, {
loop: boolean;
avoidCollisions: boolean;
hideWhenDetached: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_5: DefineComponent<DialogTriggerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<DialogTriggerProps> & Readonly<{}>, {
as: object | AsTag;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_50: DefineComponent<MenubarMenuProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<MenubarMenuProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_51: DefineComponent<MenubarRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:value": (value: string) => any;
}, string, PublicProps, Readonly<MenubarRootProps> & Readonly<{
"onUpdate:value"?: ((value: string) => any) | undefined;
}>, {
value: string;
loop: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_52: DefineComponent<MenubarSubProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (open: boolean) => any;
}, string, PublicProps, Readonly<MenubarSubProps> & Readonly<{
"onUpdate:open"?: ((open: boolean) => any) | undefined;
}>, {
open: boolean;
defaultOpen: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_53: DefineComponent<MenubarSubContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<MenubarSubContentProps> & Readonly<{}>, {
forceMount: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_54: DefineComponent<MenubarSubTriggerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<MenubarSubTriggerProps> & Readonly<{}>, {
disabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_55: DefineComponent<MenubarTriggerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<MenubarTriggerProps> & Readonly<{}>, {
as: object | AsTag;
disabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_56: DefineComponent<PopoverAnchorProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PopoverAnchorProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_57: DefineComponent<PopoverCloseProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PopoverCloseProps> & Readonly<{}>, {
as: object | AsTag;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_58: DefineComponent<PopoverContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PopoverContentProps> & Readonly<{}>, {
forceMount: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_59: DefineComponent<PopoverRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (value: boolean) => any;
}, string, PublicProps, Readonly<PopoverRootProps> & Readonly<{
"onUpdate:open"?: ((value: boolean) => any) | undefined;
}>, {
open: boolean;
defaultOpen: boolean;
modal: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_6: DefineComponent<DialogTitleProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<DialogTitleProps> & Readonly<{}>, {
as: object | AsTag;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_60: DefineComponent<PopoverTriggerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PopoverTriggerProps> & Readonly<{}>, {
as: object | AsTag;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_61: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const __VLS_component_62: DefineComponent<ExtractPropTypes<    {
value: {
type: PropType<Required<ProgressRootProps>["value"]>;
required: false;
validator(value: unknown, props: {
[x: string]: unknown;
}): boolean;
default: undefined;
};
max: {
type: PropType<Required<ProgressRootProps>["max"]>;
required: false;
validator(value: unknown): value is number;
default: number;
};
getValueLabel: {
type: PropType<Required<ProgressRootProps>["getValueLabel"]>;
required: false;
default: typeof defaultGetValueLabel;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
value: {
type: PropType<Required<ProgressRootProps>["value"]>;
required: false;
validator(value: unknown, props: {
[x: string]: unknown;
}): boolean;
default: undefined;
};
max: {
type: PropType<Required<ProgressRootProps>["max"]>;
required: false;
validator(value: unknown): value is number;
default: number;
};
getValueLabel: {
type: PropType<Required<ProgressRootProps>["getValueLabel"]>;
required: false;
default: typeof defaultGetValueLabel;
};
}>> & Readonly<{}>, {
value: number;
max: number;
getValueLabel: (value: number, max: number) => string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const __VLS_component_63: DefineComponent<RadioGroupIndicatorProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<RadioGroupIndicatorProps> & Readonly<{}>, {
as: object | AsTag;
forceMount: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_64: DefineComponent<RadioGroupItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<RadioGroupItemProps> & Readonly<{}>, {
as: object | AsTag;
disabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_65: DefineComponent<RadioGroupRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:value": (value: string) => any;
}, string, PublicProps, Readonly<RadioGroupRootProps> & Readonly<{
"onUpdate:value"?: ((value: string) => any) | undefined;
}>, {
disabled: boolean;
required: boolean;
loop: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_66: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const __VLS_component_67: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const __VLS_component_68: DefineComponent<ScrollAreaRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ScrollAreaRootProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_69: DefineComponent<ScrollAreaScrollbarProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ScrollAreaScrollbarProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_7: DefineComponent<DialogDescriptionProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<DialogDescriptionProps> & Readonly<{}>, {
as: object | AsTag;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_70: DefineComponent<ScrollAreaThumbProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ScrollAreaThumbProps> & Readonly<{}>, {
forceMount: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_71: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const __VLS_component_72: DefineComponent<SeparatorProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SeparatorProps> & Readonly<{}>, {
decorative: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_73: DefineComponent<SliderRangeProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SliderRangeProps> & Readonly<{}>, {
as: object | AsTag;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_74: DefineComponent<SliderRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:value": (value: number[]) => any;
valueCommit: (value: number[]) => any;
}, string, PublicProps, Readonly<SliderRootProps> & Readonly<{
"onUpdate:value"?: ((value: number[]) => any) | undefined;
onValueCommit?: ((value: number[]) => any) | undefined;
}>, {
as: object | AsTag;
disabled: boolean;
defaultValue: number[];
step: number;
max: number;
min: number;
minStepsBetweenThumbs: number;
inverted: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_75: DefineComponent<SliderThumbProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SliderThumbProps> & Readonly<{}>, {
as: object | AsTag;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_76: DefineComponent<SliderTrackProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SliderTrackProps> & Readonly<{}>, {
as: object | AsTag;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_77: DefineComponent<SwitchRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:checked": (checked: boolean) => any;
}, string, PublicProps, Readonly<SwitchRootProps> & Readonly<{
"onUpdate:checked"?: ((checked: boolean) => any) | undefined;
}>, {
value: string;
as: object | AsTag;
disabled: boolean;
required: boolean;
checked: boolean;
defaultChecked: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_78: DefineComponent<SwitchThumbProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SwitchThumbProps> & Readonly<{}>, {
as: object | AsTag;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_79: DefineComponent<TabsContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<TabsContentProps> & Readonly<{}>, {
forceMount: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_8: DefineComponent<DialogCloseProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<DialogCloseProps> & Readonly<{}>, {
as: object | AsTag;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_80: DefineComponent<TabsListProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<TabsListProps> & Readonly<{}>, {
loop: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_81: DefineComponent<TabsRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:value": (value: string) => any;
}, string, PublicProps, Readonly<TabsRootProps> & Readonly<{
"onUpdate:value"?: ((value: string) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_82: DefineComponent<TabsTriggerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<TabsTriggerProps> & Readonly<{}>, {
as: object | AsTag;
disabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_83: DefineComponent<ToastCloseProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ToastCloseProps> & Readonly<{}>, {
as: object | AsTag;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_84: DefineComponent<ToastRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (open: boolean) => any;
}, string, PublicProps, Readonly<ToastRootProps> & Readonly<{
"onUpdate:open"?: ((open: boolean) => any) | undefined;
}>, {
open: boolean;
defaultOpen: boolean;
forceMount: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_85: DefineComponent<ToastViewportProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ToastViewportProps> & Readonly<{}>, {
as: object | AsTag;
label: string;
hotkey: string[];
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_86: DefineComponent<ToggleProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:pressed": (value: boolean) => any;
}, string, PublicProps, Readonly<ToggleProps> & Readonly<{
"onUpdate:pressed"?: ((value: boolean) => any) | undefined;
}>, {
as: object | AsTag;
disabled: boolean;
pressed: boolean;
defaultPressed: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_87: DefineComponent<ToggleGroupItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ToggleGroupItemProps> & Readonly<{}>, {
as: object | AsTag;
disabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_88: DefineComponent<ToolbarButtonProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ToolbarButtonProps> & Readonly<{}>, {
as: object | AsTag;
disabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_89: DefineComponent<ToolbarLinkProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ToolbarLinkProps> & Readonly<{}>, {
as: object | AsTag;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_9: DefineComponent<DialogOverlayProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<DialogOverlayProps> & Readonly<{}>, {
forceMount: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_90: DefineComponent<ToolbarRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ToolbarRootProps> & Readonly<{}>, {
loop: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_91: DefineComponent<ToolbarSeparatorProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ToolbarSeparatorProps> & Readonly<{}>, {
decorative: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_92: DefineComponent<ToolbarToggleItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ToolbarToggleItemProps> & Readonly<{}>, {
as: object | AsTag;
disabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_93: DefineComponent<TooltipContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<TooltipContentProps> & Readonly<{}>, {
forceMount: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_94: DefineComponent<TooltipProviderProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<TooltipProviderProps> & Readonly<{}>, {
disableHoverableContent: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_95: DefineComponent<TooltipRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (open: boolean) => any;
}, string, PublicProps, Readonly<TooltipRootProps> & Readonly<{
"onUpdate:open"?: ((open: boolean) => any) | undefined;
}>, {
open: boolean;
defaultOpen: boolean;
disableHoverableContent: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_96: DefineComponent<TooltipTriggerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<TooltipTriggerProps> & Readonly<{}>, {
as: object | AsTag;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_97: DefineComponent<VisuallyHiddenProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<VisuallyHiddenProps> & Readonly<{}>, {
as: object | AsTag;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

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

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

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

declare function __VLS_template(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_10(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_11(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_12(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_13(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_14(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_15(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_16(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_17(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_18(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_19(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_2(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_20(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_21(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_22(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_23(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_24(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_25(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_26(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_27(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_28(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_29(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_3(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_30(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_31(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_32(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_33(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_34(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_35(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_36(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_37(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_38(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_39(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_4(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_40(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_41(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_42(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_43(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_44(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_45(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_46(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_47(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_48(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_49(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_5(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_50(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_51(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_52(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_53(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_54(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_55(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_56(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_57(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_58(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_59(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_6(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_60(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_61(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_62(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_63(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_64(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_65(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_66(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_67(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_68(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_69(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_7(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_70(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_71(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_72(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_73(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_74(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_75(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_76(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_77(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_78(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_79(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_8(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_80(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_81(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_82(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_83(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_84(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_85(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_86(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_87(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_88(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_89(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_9(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_90(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_91(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_92(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_93(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_94(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_95(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_96(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare function __VLS_template_97(): {
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    attrs: Partial<{}>;
};

declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;

declare type __VLS_TemplateResult_10 = ReturnType<typeof __VLS_template_10>;

declare type __VLS_TemplateResult_11 = ReturnType<typeof __VLS_template_11>;

declare type __VLS_TemplateResult_12 = ReturnType<typeof __VLS_template_12>;

declare type __VLS_TemplateResult_13 = ReturnType<typeof __VLS_template_13>;

declare type __VLS_TemplateResult_14 = ReturnType<typeof __VLS_template_14>;

declare type __VLS_TemplateResult_15 = ReturnType<typeof __VLS_template_15>;

declare type __VLS_TemplateResult_16 = ReturnType<typeof __VLS_template_16>;

declare type __VLS_TemplateResult_17 = ReturnType<typeof __VLS_template_17>;

declare type __VLS_TemplateResult_18 = ReturnType<typeof __VLS_template_18>;

declare type __VLS_TemplateResult_19 = ReturnType<typeof __VLS_template_19>;

declare type __VLS_TemplateResult_2 = ReturnType<typeof __VLS_template_2>;

declare type __VLS_TemplateResult_20 = ReturnType<typeof __VLS_template_20>;

declare type __VLS_TemplateResult_21 = ReturnType<typeof __VLS_template_21>;

declare type __VLS_TemplateResult_22 = ReturnType<typeof __VLS_template_22>;

declare type __VLS_TemplateResult_23 = ReturnType<typeof __VLS_template_23>;

declare type __VLS_TemplateResult_24 = ReturnType<typeof __VLS_template_24>;

declare type __VLS_TemplateResult_25 = ReturnType<typeof __VLS_template_25>;

declare type __VLS_TemplateResult_26 = ReturnType<typeof __VLS_template_26>;

declare type __VLS_TemplateResult_27 = ReturnType<typeof __VLS_template_27>;

declare type __VLS_TemplateResult_28 = ReturnType<typeof __VLS_template_28>;

declare type __VLS_TemplateResult_29 = ReturnType<typeof __VLS_template_29>;

declare type __VLS_TemplateResult_3 = ReturnType<typeof __VLS_template_3>;

declare type __VLS_TemplateResult_30 = ReturnType<typeof __VLS_template_30>;

declare type __VLS_TemplateResult_31 = ReturnType<typeof __VLS_template_31>;

declare type __VLS_TemplateResult_32 = ReturnType<typeof __VLS_template_32>;

declare type __VLS_TemplateResult_33 = ReturnType<typeof __VLS_template_33>;

declare type __VLS_TemplateResult_34 = ReturnType<typeof __VLS_template_34>;

declare type __VLS_TemplateResult_35 = ReturnType<typeof __VLS_template_35>;

declare type __VLS_TemplateResult_36 = ReturnType<typeof __VLS_template_36>;

declare type __VLS_TemplateResult_37 = ReturnType<typeof __VLS_template_37>;

declare type __VLS_TemplateResult_38 = ReturnType<typeof __VLS_template_38>;

declare type __VLS_TemplateResult_39 = ReturnType<typeof __VLS_template_39>;

declare type __VLS_TemplateResult_4 = ReturnType<typeof __VLS_template_4>;

declare type __VLS_TemplateResult_40 = ReturnType<typeof __VLS_template_40>;

declare type __VLS_TemplateResult_41 = ReturnType<typeof __VLS_template_41>;

declare type __VLS_TemplateResult_42 = ReturnType<typeof __VLS_template_42>;

declare type __VLS_TemplateResult_43 = ReturnType<typeof __VLS_template_43>;

declare type __VLS_TemplateResult_44 = ReturnType<typeof __VLS_template_44>;

declare type __VLS_TemplateResult_45 = ReturnType<typeof __VLS_template_45>;

declare type __VLS_TemplateResult_46 = ReturnType<typeof __VLS_template_46>;

declare type __VLS_TemplateResult_47 = ReturnType<typeof __VLS_template_47>;

declare type __VLS_TemplateResult_48 = ReturnType<typeof __VLS_template_48>;

declare type __VLS_TemplateResult_49 = ReturnType<typeof __VLS_template_49>;

declare type __VLS_TemplateResult_5 = ReturnType<typeof __VLS_template_5>;

declare type __VLS_TemplateResult_50 = ReturnType<typeof __VLS_template_50>;

declare type __VLS_TemplateResult_51 = ReturnType<typeof __VLS_template_51>;

declare type __VLS_TemplateResult_52 = ReturnType<typeof __VLS_template_52>;

declare type __VLS_TemplateResult_53 = ReturnType<typeof __VLS_template_53>;

declare type __VLS_TemplateResult_54 = ReturnType<typeof __VLS_template_54>;

declare type __VLS_TemplateResult_55 = ReturnType<typeof __VLS_template_55>;

declare type __VLS_TemplateResult_56 = ReturnType<typeof __VLS_template_56>;

declare type __VLS_TemplateResult_57 = ReturnType<typeof __VLS_template_57>;

declare type __VLS_TemplateResult_58 = ReturnType<typeof __VLS_template_58>;

declare type __VLS_TemplateResult_59 = ReturnType<typeof __VLS_template_59>;

declare type __VLS_TemplateResult_6 = ReturnType<typeof __VLS_template_6>;

declare type __VLS_TemplateResult_60 = ReturnType<typeof __VLS_template_60>;

declare type __VLS_TemplateResult_61 = ReturnType<typeof __VLS_template_61>;

declare type __VLS_TemplateResult_62 = ReturnType<typeof __VLS_template_62>;

declare type __VLS_TemplateResult_63 = ReturnType<typeof __VLS_template_63>;

declare type __VLS_TemplateResult_64 = ReturnType<typeof __VLS_template_64>;

declare type __VLS_TemplateResult_65 = ReturnType<typeof __VLS_template_65>;

declare type __VLS_TemplateResult_66 = ReturnType<typeof __VLS_template_66>;

declare type __VLS_TemplateResult_67 = ReturnType<typeof __VLS_template_67>;

declare type __VLS_TemplateResult_68 = ReturnType<typeof __VLS_template_68>;

declare type __VLS_TemplateResult_69 = ReturnType<typeof __VLS_template_69>;

declare type __VLS_TemplateResult_7 = ReturnType<typeof __VLS_template_7>;

declare type __VLS_TemplateResult_70 = ReturnType<typeof __VLS_template_70>;

declare type __VLS_TemplateResult_71 = ReturnType<typeof __VLS_template_71>;

declare type __VLS_TemplateResult_72 = ReturnType<typeof __VLS_template_72>;

declare type __VLS_TemplateResult_73 = ReturnType<typeof __VLS_template_73>;

declare type __VLS_TemplateResult_74 = ReturnType<typeof __VLS_template_74>;

declare type __VLS_TemplateResult_75 = ReturnType<typeof __VLS_template_75>;

declare type __VLS_TemplateResult_76 = ReturnType<typeof __VLS_template_76>;

declare type __VLS_TemplateResult_77 = ReturnType<typeof __VLS_template_77>;

declare type __VLS_TemplateResult_78 = ReturnType<typeof __VLS_template_78>;

declare type __VLS_TemplateResult_79 = ReturnType<typeof __VLS_template_79>;

declare type __VLS_TemplateResult_8 = ReturnType<typeof __VLS_template_8>;

declare type __VLS_TemplateResult_80 = ReturnType<typeof __VLS_template_80>;

declare type __VLS_TemplateResult_81 = ReturnType<typeof __VLS_template_81>;

declare type __VLS_TemplateResult_82 = ReturnType<typeof __VLS_template_82>;

declare type __VLS_TemplateResult_83 = ReturnType<typeof __VLS_template_83>;

declare type __VLS_TemplateResult_84 = ReturnType<typeof __VLS_template_84>;

declare type __VLS_TemplateResult_85 = ReturnType<typeof __VLS_template_85>;

declare type __VLS_TemplateResult_86 = ReturnType<typeof __VLS_template_86>;

declare type __VLS_TemplateResult_87 = ReturnType<typeof __VLS_template_87>;

declare type __VLS_TemplateResult_88 = ReturnType<typeof __VLS_template_88>;

declare type __VLS_TemplateResult_89 = ReturnType<typeof __VLS_template_89>;

declare type __VLS_TemplateResult_9 = ReturnType<typeof __VLS_template_9>;

declare type __VLS_TemplateResult_90 = ReturnType<typeof __VLS_template_90>;

declare type __VLS_TemplateResult_91 = ReturnType<typeof __VLS_template_91>;

declare type __VLS_TemplateResult_92 = ReturnType<typeof __VLS_template_92>;

declare type __VLS_TemplateResult_93 = ReturnType<typeof __VLS_template_93>;

declare type __VLS_TemplateResult_94 = ReturnType<typeof __VLS_template_94>;

declare type __VLS_TemplateResult_95 = ReturnType<typeof __VLS_template_95>;

declare type __VLS_TemplateResult_96 = ReturnType<typeof __VLS_template_96>;

declare type __VLS_TemplateResult_97 = ReturnType<typeof __VLS_template_97>;

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_19<T, S> = T & {
    new (): {
        $slots: S;
    };
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

export declare const AccordionContent: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;

export declare type AccordionContentProps = CollapsibleContentProps;

export declare interface AccordionContext {
    id: string;
    collapsible?: boolean;
    disabled?: () => boolean | undefined;
    direction: Ref<Direction>;
    orientation: Exclude<AccordionImplProps['orientation'], undefined>;
    value: Ref<string[]>;
    onItemOpen: (value: string) => void;
    onItemClose: (value: string) => void;
}

export declare const AccordionHeader: __VLS_WithTemplateSlots_2<typeof __VLS_component_2, __VLS_TemplateResult_2["slots"]>;

export declare interface AccordionHeaderProps {
    as?: PrimitiveProps['as'];
}

declare interface AccordionImplProps {
    /**
     * Whether or not an accordion is disabled from user interaction.
     *
     * @defaultValue false
     */
    disabled?: boolean;
    /**
     * The layout in which the Accordion operates.
     * @default vertical
     */
    orientation?: AriaAttributes['aria-orientation'];
    /**
     * The language read direction.
     */
    dir?: Direction;
}

export declare const AccordionItem: __VLS_WithTemplateSlots_3<typeof __VLS_component_3, __VLS_TemplateResult_3["slots"]>;

export declare interface AccordionItemContext {
    open: Ref<boolean>;
    disabled: Ref<boolean | undefined>;
    triggerId: string;
}

export declare interface AccordionItemProps {
    /**
     * Whether or not an accordion item is disabled from user interaction.
     *
     * @defaultValue false
     */
    disabled?: boolean;
    /**
     * A string value for the accordion item. All items within an accordion should use a unique value.
     */
    value: string;
}

declare interface AccordionMultipleProps {
    /**
     * The controlled stateful value of the accordion items whose contents are expanded.
     */
    value?: string[];
    /**
     * The value of the items whose contents are expanded when the accordion is initially rendered. Use
     * `defaultValue` if you do not need to control the state of an accordion.
     */
    defaultValue?: string[];
}

export declare const AccordionRoot: <T extends AccordionType = undefined>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
        readonly "onUpdate:value"?: ((value: T extends "multiple" ? string[] : string) => any) | undefined;
    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onUpdate:value"> & AccordionRootProps<T>> & PublicProps;
    expose(exposed: ShallowUnwrapRef<    {}>): void;
    attrs: any;
    slots: {
        default?(_: {}): any;
    };
    emit: (evt: "update:value", value: T extends "multiple" ? string[] : string) => void;
}>) => VNode<RendererNode, RendererElement, {
[key: string]: any;
}> & {
    __ctx?: Awaited<typeof __VLS_setup>;
};

export declare type AccordionRootEmits<T extends AccordionType> = {
    /**
     * The callback that fires when the state of the toggle group changes.
     */
    'update:value': [value: EmitValue<T>];
};

export declare interface AccordionRootProps<T extends AccordionType> extends AccordionImplProps {
    type?: T;
    value?: T extends 'multiple' ? AccordionMultipleProps['value'] : AccordionSingleProps['value'];
    defaultValue?: T extends 'multiple' ? AccordionMultipleProps['defaultValue'] : AccordionSingleProps['defaultValue'];
    collapsible?: AccordionSingleProps['collapsible'];
}

declare interface AccordionSingleProps {
    /**
     * The controlled stateful value of the accordion item whose content is expanded.
     */
    value?: string;
    /**
     * The value of the item whose content is expanded when the accordion is initially rendered. Use
     * `defaultValue` if you do not need to control the state of an accordion.
     */
    defaultValue?: string;
    /**
     * Whether an accordion item can be collapsed after it has been opened.
     * @default false
     */
    collapsible?: boolean;
}

export declare const AccordionTrigger: __VLS_WithTemplateSlots_4<typeof __VLS_component_4, __VLS_TemplateResult_4["slots"]>;

declare interface AccordionTriggerProps {
    as?: PrimitiveProps['as'];
}

declare type AccordionType = 'single' | 'multiple' | undefined;

export declare const AlertDialogCancel: __VLS_WithTemplateSlots_11<typeof __VLS_component_11, __VLS_TemplateResult_11["slots"]>;

declare interface AlertDialogCancelProps extends DialogCloseProps {
}

export declare const AlertDialogContent: __VLS_WithTemplateSlots_12<typeof __VLS_component_12, __VLS_TemplateResult_12["slots"]>;

export declare interface AlertDialogContentProps extends DialogContentProps {
}

export declare const AlertDialogRoot: __VLS_WithTemplateSlots_13<typeof __VLS_component_13, __VLS_TemplateResult_13["slots"]>;

export declare type AlertDialogRootEmits = DialogRootEmits;

export declare interface AlertDialogRootProps extends Omit<DialogRootProps, 'modal'> {
}

declare type Align = (typeof ALIGN_OPTIONS)[number];

declare const ALIGN_OPTIONS: readonly ["start", "center", "end"];

declare type AllEventHandlers = {
    [K in keyof Events as K | `${K}${EventSuffixes}`]: EventHandlers<Events[K]>;
};

export declare function arrayify<T>(value: T | T[]): T[];

export declare const ARROW_KEYS: string[];

declare interface ArrowProps extends PrimitiveProps {
    /**
     * The width of the arrow in pixels.
     *
     * @defaultValue 10
     */
    width?: number;
    /**
     * The height of the arrow in pixels.
     *
     * @defaultValue 5
     */
    height?: number;
}

export declare const AspectRatio: __VLS_WithTemplateSlots_14<typeof __VLS_component_14, __VLS_TemplateResult_14["slots"]>;

export declare interface AspectRatioProps {
    ratio?: number;
}

declare type AsTag = 'a' | 'button' | 'div' | 'form' | 'h2' | 'h3' | 'img' | 'input' | 'label' | 'li' | 'nav' | 'ol' | 'p' | 'span' | 'svg' | 'ul' | 'template' | ({} & string);

export declare interface AvatarContext {
    imageLoadingStatus: Ref<ImageLoadingStatus>;
    onImageLoadingStatusChange: (status: ImageLoadingStatus) => void;
}

export declare const AvatarFallback: __VLS_WithTemplateSlots_15<typeof __VLS_component_15, __VLS_TemplateResult_15["slots"]>;

export declare interface AvatarFallbackProps {
    as?: PrimitiveProps['as'];
    delayMs?: number;
}

export declare const AvatarImage: __VLS_WithTemplateSlots_16<typeof __VLS_component_16, __VLS_TemplateResult_16["slots"]>;

export declare type AvatarImageEmits = {
    loadingStatusChange: [status: ImageLoadingStatus];
};

export declare interface AvatarImageProps {
    as?: PrimitiveProps['as'];
    src?: string;
}

export declare const AvatarRoot: __VLS_WithTemplateSlots_17<typeof __VLS_component_17, __VLS_TemplateResult_17["slots"]>;

export declare interface AvatarRootProps {
    as?: PrimitiveProps['as'];
}

export declare const BACK_KEYS: Record<SlideDirection, string[]>;

declare type BaseEventSuffixes = 'Capture' | 'Once' | 'Passive';

declare type BooleanKey<T, K extends keyof T = keyof T> = K extends any ? [T[K]] extends [boolean | undefined] ? K : never : never;

declare type Boundary = Element | undefined;

export declare const CheckboxBubbleInput: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare interface CheckboxContext {
    checked: Ref<CheckedState>;
    disabled: () => boolean | undefined;
    bubbleInput: {
        control: Ref<HTMLButtonElement | undefined>;
        bubbles: MutableRefObject<boolean>;
        isFormControl: MutableRefObject<boolean>;
        name: () => string | undefined;
        value: () => string;
        checked: Ref<CheckedState>;
        defaultChecked: boolean | undefined;
        required: () => boolean | undefined;
        disabled: () => boolean | undefined;
    };
}

export declare const CheckboxIndicator: __VLS_WithTemplateSlots_18<typeof __VLS_component_18, __VLS_TemplateResult_18["slots"]>;

export declare interface CheckboxIndicatorProps {
    as?: PrimitiveProps['as'];
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: boolean;
}

export declare const CheckboxRoot: __VLS_WithTemplateSlots_19<typeof __VLS_component_19, __VLS_TemplateResult_19["slots"]>;

export declare type CheckboxRootEmits = {
    'update:checked': [value: CheckedState];
};

export declare interface CheckboxRootProps {
    as?: PrimitiveProps['as'];
    checked?: CheckedState;
    defaultChecked?: CheckedState;
    disabled?: boolean;
    required?: boolean;
    value?: string;
    name?: string;
}

export declare type CheckedState = boolean | 'indeterminate';

export declare function clamp(value: number, min: number, max: number): number;

export declare const CollapsibleContent: __VLS_WithTemplateSlots_20<typeof __VLS_component_20, __VLS_TemplateResult_20["slots"]>;

export declare interface CollapsibleContentProps {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with Vue animation libraries.
     */
    forceMount?: boolean;
}

export declare interface CollapsibleContext {
    contentId: string;
    disabled: () => boolean | undefined;
    open: Ref<boolean>;
    onOpenToggle: () => void;
}

export declare const CollapsibleRoot: __VLS_WithTemplateSlots_21<typeof __VLS_component_21, __VLS_TemplateResult_21["slots"]>;

export declare type CollapsibleRootEmits = {
    'update:open': [value: boolean];
};

export declare interface CollapsibleRootProps {
    defaultOpen?: boolean;
    open?: boolean;
    disabled?: boolean;
}

export declare const CollapsibleTrigger: __VLS_WithTemplateSlots_22<typeof __VLS_component_22, __VLS_TemplateResult_22["slots"]>;

export declare interface CollapsibleTriggerProps {
    as?: PrimitiveProps['as'];
}

export declare const Collection: {
    readonly provideCollectionContext: (collectionRef: MutableRefObject<HTMLElement | undefined>, provide?: boolean) => {
        collectionRef: MutableRefObject<HTMLElement | undefined>;
    };
    readonly useCollectionContext: (consumerName: string) => CollectionContext;
    readonly useCollectionItem: <K extends string>(currentElement: HTMLElement | undefined, attrs: any, key: K) => void;
};

declare interface CollectionContext {
    collectionRef: MutableRefObject<HTMLElement | undefined>;
}

declare type CollectionItemWithData<E extends HTMLElement, D> = E & {
    $$rcid: D;
};

declare type CombineSuffixes<T extends string, U extends string = T> = T extends any ? T | `${T}${CombineSuffixes<Exclude<U, T>>}` : never;

export declare function composeEventHandlers<E extends Event>(originalEventHandler?: (event: E) => void, ourEventHandler?: (event: E) => void, { checkForDefaultPrevented }?: {
    checkForDefaultPrevented?: boolean | undefined;
}): (event: E) => void;

export declare const ContextMenuContent: __VLS_WithTemplateSlots_32<typeof __VLS_component_32, __VLS_TemplateResult_32["slots"]>;

export declare interface ContextMenuContenttProps {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: boolean;
}

export declare interface ContextMenuContextValue {
    open: Ref<boolean>;
    onOpenChange: (open: boolean) => void;
    modal: boolean;
}

export declare const ContextMenuRoot: __VLS_WithTemplateSlots_33<typeof __VLS_component_33, __VLS_TemplateResult_33["slots"]>;

export declare type ContextMenuRootEmits = {
    'update:open': [open: boolean];
};

export declare interface ContextMenuRootProps {
    dir?: Direction;
    modal?: boolean;
}

export declare const ContextMenuSub: __VLS_WithTemplateSlots_34<typeof __VLS_component_34, __VLS_TemplateResult_34["slots"]>;

export declare const ContextMenuSubContent: __VLS_WithTemplateSlots_35<typeof __VLS_component_35, __VLS_TemplateResult_35["slots"]>;

declare interface ContextMenuSubContentProps extends MenuSubContentProps {
}

export declare type ContextMenuSubEmits = {
    'update:open': [isOpen: boolean];
};

export declare interface ContextMenuSubProps {
    open?: boolean;
    defaultOpen?: boolean;
}

export declare const ContextMenuTrigger: __VLS_WithTemplateSlots_36<typeof __VLS_component_36, __VLS_TemplateResult_36["slots"]>;

declare interface ContextMenuTriggerProps {
    as?: PrimitiveProps['as'];
    disabled?: boolean;
}

export declare function convertPropsToHookProps<T extends Record<string, any>, K extends keyof T, EP extends Record<string, (...args: any[]) => any>>(props: T, reactiveProps: K[], emits: () => EP): Prettify<ReplaceProps<T, K> & EP>;

export declare function convertPropsToHookProps<T extends Record<string, any>, K extends keyof T>(props: T, reactiveProps: K[]): Prettify<ReplaceProps<T, K>>;

export declare function convertPropsToHookProps<T extends Record<string, any>>(props: T): Prettify<T>;

/**
 * Create global state that can be injected into components.
 *
 * @see https://vueuse.org/createInjectionState
 *
 */
export declare function createContext<T>(contextName: string, defaultValue: T): readonly [useProvidingState: (state: T) => void, useContext: (consumerName?: string) => T, key: InjectionKey<T>];

export declare function createContext<T>(contextName: string): readonly [useProvidingState: (state: T) => void, useContext: (consumerName: string) => T, key: InjectionKey<T>];

declare const _default: __VLS_WithTemplateSlots_5<typeof __VLS_component_5, __VLS_TemplateResult_5["slots"]>;
export { _default as AlertDialogTrigger }
export { _default as DialogTrigger }

declare const _default_10: __VLS_WithTemplateSlots_26<typeof __VLS_component_26, __VLS_TemplateResult_26["slots"]>;
export { _default_10 as ContextMenuRadioGroup }
export { _default_10 as DropdownMenuRadioGroup }
export { _default_10 as MenubarRadioGroup }

declare const _default_11: __VLS_WithTemplateSlots_27<typeof __VLS_component_27, __VLS_TemplateResult_27["slots"]>;
export { _default_11 as ContextMenuRadioItem }
export { _default_11 as DropdownMenuRadioItem }
export { _default_11 as MenubarRadioItem }

declare const _default_12: __VLS_WithTemplateSlots_28<typeof __VLS_component_28, __VLS_TemplateResult_28["slots"]>;
export { _default_12 as ContextMenuItemIndicator }
export { _default_12 as DropdownMenuItemIndicator }
export { _default_12 as MenubarItemIndicator }

declare const _default_13: __VLS_WithTemplateSlots_29<typeof __VLS_component_29, __VLS_TemplateResult_29["slots"]>;
export { _default_13 as ContextMenuSeparator }
export { _default_13 as DropdownMenuSeparator }
export { _default_13 as MenubarSeparator }

declare const _default_14: __VLS_WithTemplateSlots_30<typeof __VLS_component_30, __VLS_TemplateResult_30["slots"]>;
export { _default_14 as ContextMenuArrow }
export { _default_14 as DropdownMenuArrow }
export { _default_14 as HoverCardArrow }
export { _default_14 as MenubarArrow }
export { _default_14 as PopoverArrow }
export { _default_14 as TooltipArrow }

declare const _default_15: __VLS_WithTemplateSlots_31<typeof __VLS_component_31, __VLS_TemplateResult_31["slots"]>;
export { _default_15 as ContextMenuSubTrigger }
export { _default_15 as DropdownMenuSubTrigger }

declare const _default_16: __VLS_WithTemplateSlots_83<typeof __VLS_component_83, __VLS_TemplateResult_83["slots"]>;
export { _default_16 as ToastAction }
export { _default_16 as ToastClose }

declare const _default_2: __VLS_WithTemplateSlots_6<typeof __VLS_component_6, __VLS_TemplateResult_6["slots"]>;
export { _default_2 as AlertDialogTitle }
export { _default_2 as DialogTitle }

declare const _default_3: __VLS_WithTemplateSlots_7<typeof __VLS_component_7, __VLS_TemplateResult_7["slots"]>;
export { _default_3 as AlertDialogDescription }
export { _default_3 as DialogDescription }

declare const _default_4: __VLS_WithTemplateSlots_8<typeof __VLS_component_8, __VLS_TemplateResult_8["slots"]>;
export { _default_4 as AlertDialogAction }
export { _default_4 as DialogClose }

declare const _default_5: __VLS_WithTemplateSlots_9<typeof __VLS_component_9, __VLS_TemplateResult_9["slots"]>;
export { _default_5 as AlertDialogOverlay }
export { _default_5 as DialogOverlay }

declare const _default_6: __VLS_WithTemplateSlots_10<typeof __VLS_component_10, __VLS_TemplateResult_10["slots"]>;
export { _default_6 as AlertDialogPortal }
export { _default_6 as ContextMenuPortal }
export { _default_6 as DialogPortal }
export { _default_6 as DropdownMenuPortal }
export { _default_6 as HoverCardPortal }
export { _default_6 as MenubarPortal }
export { _default_6 as PopoverPortal }
export { _default_6 as TooltipPortal }

declare const _default_7: __VLS_WithTemplateSlots_23<typeof __VLS_component_23, __VLS_TemplateResult_23["slots"]>;
export { _default_7 as ContextMenuGroup }
export { _default_7 as DropdownMenuGroup }
export { _default_7 as MenubarGroup }

declare const _default_8: __VLS_WithTemplateSlots_24<typeof __VLS_component_24, __VLS_TemplateResult_24["slots"]>;
export { _default_8 as ContextMenuItem }
export { _default_8 as DropdownMenuItem }
export { _default_8 as MenubarItem }

declare const _default_9: __VLS_WithTemplateSlots_25<typeof __VLS_component_25, __VLS_TemplateResult_25["slots"]>;
export { _default_9 as ContextMenuCheckboxItem }
export { _default_9 as DropdownMenuCheckboxItem }
export { _default_9 as MenubarCheckboxItem }

export declare const DEFAULT_ACCORDION_CONTENT_PROPS: {
    forceMount: undefined;
};

export declare const DEFAULT_ACCORDION_ITEM_PROPS: {
    disabled: undefined;
};

export declare const DEFAULT_ACCORDION_ROOT_PROPS: {
    collapsible: undefined;
    disabled: undefined;
};

export declare const DEFAULT_ALERT_DIALOG_CONTENT_PROPS: {
    forceMount: undefined;
};

export declare const DEFAULT_ASPECT_RATIO_PROPS: {
    ratio: number;
};

export declare const DEFAULT_AVATAR_FALLBACK_PROPS: {
    as: "span";
};

export declare const DEFAULT_AVATAR_IMAGE_PROPS: {
    as: "img";
};

export declare const DEFAULT_AVATAR_ROOT_PROPS: {
    as: "span";
};

export declare const DEFAULT_CHECKBOX_INDICATOR_PROPS: {
    as: "span";
    forceMount: undefined;
};

export declare const DEFAULT_CHECKBOX_ROOT_PROPS: {
    as: "button";
    value: string;
    checked: undefined;
    defaultChecked: undefined;
    disabled: undefined;
    required: undefined;
};

export declare const DEFAULT_COLLAPSIBLE_CONTENT_PROPS: {
    forceMount: undefined;
};

export declare const DEFAULT_COLLAPSIBLE_ROOT_PROPS: {
    defaultOpen: undefined;
    open: undefined;
    disabled: undefined;
};

export declare const DEFAULT_CONTEXT_MENU_CONTENT_PROPS: {
    forceMount: undefined;
};

export declare const DEFAULT_CONTEXT_MENU_ROOT_PROPS: {
    modal: undefined;
};

export declare const DEFAULT_CONTEXT_MENU_SUB_PROPS: {
    open: undefined;
    defaultOpen: undefined;
};

export declare const DEFAULT_DIALOG_CLOSE_PROPS: {
    as: "button";
};

export declare const DEFAULT_DIALOG_CONTENT_PROPS: {
    forceMount: undefined;
};

export declare const DEFAULT_DIALOG_DESCRIPTION_PROPS: {
    as: "p";
};

export declare const DEFAULT_DIALOG_OVERLAY_PROPS: {
    forceMount: undefined;
};

export declare const DEFAULT_DIALOG_ROOT_PROPS: {
    open: undefined;
    defaultOpen: undefined;
    modal: undefined;
};

export declare const DEFAULT_DIALOG_TITLE_PROPS: {
    as: "h2";
};

export declare const DEFAULT_DIALOG_TRIGGER_PROPS: {
    as: "button";
};

export declare const DEFAULT_DROPDOWN_MENU_CONTENT_PROPS: {
    forceMount: undefined;
};

export declare const DEFAULT_DROPDOWN_MENU_ROOT_PROPS: {
    open: undefined;
    defaultOpen: undefined;
    modal: undefined;
};

export declare const DEFAULT_DROPDOWN_MENU_SUB_CONTENT_IMPL_PROPS: {
    avoidCollisions: undefined;
    hideWhenDetached: undefined;
    loop: undefined;
};

export declare const DEFAULT_DROPDOWN_MENU_SUB_CONTENT_PROPS: {
    forceMount: undefined;
};

export declare const DEFAULT_DROPDOWN_MENU_SUB_PROPS: {
    open: undefined;
    defaultOpen: undefined;
};

export declare const DEFAULT_DROPDOWN_MENU_TRIGGER_PROPS: {
    as: "button";
    disabled: undefined;
};

export declare const DEFAULT_HOVER_CARD_CONTENT_PROPS: {
    forceMount: undefined;
};

export declare const DEFAULT_HOVER_CARD_ROOT_PROPS: {
    open: undefined;
    defaultOpen: undefined;
};

export declare const DEFAULT_HOVER_CARD_TRIGGER_PROPS: {
    as: "a";
};

export declare const DEFAULT_MENUBAR_CONTENT_IMPL_PROPS: {
    avoidCollisions: undefined;
    hideWhenDetached: undefined;
    loop: undefined;
};

export declare const DEFAULT_MENUBAR_CONTENT_PROPS: {
    forceMount: undefined;
};

export declare const DEFAULT_MENUBAR_ROOT_PROPS: {
    value: undefined;
    loop: undefined;
};

export declare const DEFAULT_MENUBAR_SUB_CONTENT_PROPS: {
    forceMount: undefined;
};

export declare const DEFAULT_MENUBAR_SUB_TRIGGER_PROPS: {
    disabled: undefined;
};

export declare const DEFAULT_MENUBAR_TRIGGER_PROPS: {
    as: "button";
    disabled: undefined;
};

export declare const DEFAULT_POPOVER_CLOSE_PROPS: {
    as: "button";
};

export declare const DEFAULT_POPOVER_CONTENT_PROPS: {
    forceMount: undefined;
};

export declare const DEFAULT_POPOVER_ROOT_PROPS: {
    open: undefined;
    defaultOpen: undefined;
    modal: undefined;
};

export declare const DEFAULT_POPOVER_TRIGGER_PROPS: {
    as: "button";
};

export declare const DEFAULT_RADIO_GROUP_INDICATOR_PROPS: {
    as: "span";
    forceMount: undefined;
};

export declare const DEFAULT_RADIO_GROUP_ITEM_PROPS: {
    as: "button";
    disabled: undefined;
};

export declare const DEFAULT_RADIO_GROUP_ROOT_PROPS: {
    disabled: undefined;
    required: undefined;
    loop: undefined;
};

export declare const DEFAULT_SCROLL_AREA_PROPS: {};

export declare const DEFAULT_SCROLL_AREA_SCROLLBAR_VISIBLE_PROPS: {};

export declare const DEFAULT_SCROLL_AREA_THUMB_PROPS: {
    forceMount: undefined;
};

export declare const DEFAULT_SCROLLBAR_AUTO_PROPS: {
    forceMount: undefined;
};

export declare const DEFAULT_SCROLLBAR_HOVER_PROPS: {
    forceMount: undefined;
};

export declare const DEFAULT_SCROLLBAR_PROPS: {};

export declare const DEFAULT_SCROLLBAR_SCROLL_PROPS: {
    forceMount: undefined;
};

export declare const DEFAULT_SEPARATOR_PROPS: {
    decorative: undefined;
};

export declare const DEFAULT_SLIDER_RANGE_PROPS: {
    as: "span";
};

export declare const DEFAULT_SLIDER_ROOT_PROPS: {
    as: "span";
    disabled: undefined;
    inverted: undefined;
    min: number;
    max: number;
    step: number;
    minStepsBetweenThumbs: number;
    defaultValue: (v: LooseRequired<SliderRootProps>) => number[];
};

export declare const DEFAULT_SLIDER_THUMB_PROPS: {
    as: "span";
};

export declare const DEFAULT_SLIDER_TRACK_PROPS: {
    as: "span";
};

export declare const DEFAULT_SWITCH_ROOT_PROPS: {
    as: "button";
    checked: undefined;
    defaultChecked: undefined;
    value: string;
    required: undefined;
    disabled: undefined;
};

export declare const DEFAULT_SWITCH_THUMB_PROPS: {
    as: "span";
};

export declare const DEFAULT_TABS_CONTENT_PROPS: {
    forceMount: undefined;
};

export declare const DEFAULT_TABS_LIST_PROPS: {
    loop: undefined;
};

export declare const DEFAULT_TABS_ROOT_PROPS: {};

export declare const DEFAULT_TABS_TRIGGER_PROPS: {
    as: "button";
    disabled: undefined;
};

export declare const DEFAULT_TOGGLE_GROUP_ITEM_PROPS: {
    as: "button";
    disabled: undefined;
};

export declare const DEFAULT_TOGGLE_GROUP_PROPS: {
    disabled: undefined;
    rovingFocus: undefined;
    loop: undefined;
};

export declare const DEFAULT_TOGGLE_PROPS: {
    as: "button";
    pressed: undefined;
    defaultPressed: undefined;
    disabled: undefined;
};

export declare const DEFAULT_TOOLBAR_BUTTON_PROPS: {
    as: "button";
    disabled: undefined;
};

export declare const DEFAULT_TOOLBAR_LINK_PROPS: {
    as: "a";
};

export declare const DEFAULT_TOOLBAR_ROOT_PROPS: {
    loop: undefined;
};

export declare const DEFAULT_TOOLBAR_SEPARATOR_PROPS: {
    decorative: undefined;
};

export declare const DEFAULT_TOOLBAR_TOGGLE_GROUP_PROPS: {
    disabled: undefined;
    loop: undefined;
};

export declare const DEFAULT_TOOLBAR_TOGGLE_ITEM_PROPS: {
    as: "button";
    disabled: undefined;
};

export declare const DEFAULT_TOOLTIP_CONTENT_IMPL_PROPS: {
    avoidCollisions: undefined;
    hideWhenDetached: undefined;
};

export declare const DEFAULT_TOOLTIP_CONTENT_PROPS: {
    forceMount: undefined;
};

export declare const DEFAULT_TOOLTIP_PROVIDER_PROPS: {
    disableHoverableContent: undefined;
};

export declare const DEFAULT_TOOLTIP_ROOT_PROPS: {
    open: undefined;
    defaultOpen: undefined;
    disableHoverableContent: undefined;
};

export declare const DEFAULT_TOOLTIP_TRIGGER_PROPS: {
    as: "button";
};

declare function defaultGetValueLabel(value: number, max: number): string;

export declare interface DialogCloseProps {
    as?: PrimitiveProps['as'];
}

export declare const DialogContent: __VLS_WithTemplateSlots_37<typeof __VLS_component_37, __VLS_TemplateResult_37["slots"]>;

export declare type DialogContentImplEmits = {
    /**
     * Event handler called when auto-focusing on open.
     * Can be prevented.
     */
    openAutoFocus: [event: Event];
    /**
     * Event handler called when auto-focusing on close.
     * Can be prevented.
     */
    closeAutoFocus: [event: Event];
} & Omit<DismissableLayerEmits, 'dismiss'>;

export declare interface DialogContentProps {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling transntion with Vue native transition or other animation libraries.
     */
    forceMount?: boolean;
}

declare interface DialogContext {
    triggerRef: MutableRefObject<HTMLElement | undefined>;
    content: Ref<HTMLElement | undefined>;
    contentId: string;
    titleId: string;
    descriptionId: string;
    open: Ref<boolean>;
    onOpenChange: (open: boolean) => void;
    onOpenToggle: () => void;
    modal: boolean;
}
export { DialogContext as AlertDialogContext }
export { DialogContext }

export declare interface DialogDescriptionProps {
    as?: PrimitiveProps['as'];
}

export declare interface DialogOverlayProps {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: boolean;
}

export declare const DialogRoot: __VLS_WithTemplateSlots_38<typeof __VLS_component_38, __VLS_TemplateResult_38["slots"]>;

export declare type DialogRootEmits = {
    'update:open': [open: boolean];
};

export declare interface DialogRootProps {
    open?: boolean;
    defaultOpen?: boolean;
    modal?: boolean;
}

export declare interface DialogTitleProps {
    as?: PrimitiveProps['as'];
}

export declare interface DialogTriggerProps {
    as?: PrimitiveProps['as'];
}

declare type Direction = 'ltr' | 'rtl';

declare type DismissableLayerEmits = {
    /**
     * Event handler called when the escape key is down.
     * Can be prevented.
     */
    escapeKeydown: [event: KeyboardEvent];
    /**
     * Event handler called when the a `pointerdown` event happens outside of the `DismissableLayer`.
     * Can be prevented.
     */
    pointerdownOutside: [event: PointerdownOutsideEvent];
    /**
     * Event handler called when the focus moves outside of the `DismissableLayer`.
     * Can be prevented.
     */
    focusOutside: [event: FocusOutsideEvent];
    /**
     * Event handler called when an interaction happens outside the `DismissableLayer`.
     * Specifically, when a `pointerdown` event happens outside or focus moves outside of it.
     * Can be prevented.
     */
    interactOutside: [event: PointerdownOutsideEvent | FocusOutsideEvent];
    /**
     * Handler called when the `DismissableLayer` should be dismissed
     */
    dismiss: [];
};

declare interface DismissableLayerProps {
    /**
     * When `true`, hover/focus/click interactions will be disabled on elements outside
     * the `DismissableLayer`. Users will need to click twice on outside elements to
     * interact with them: once to close the `DismissableLayer`, and again to trigger the element.
     */
    disableOutsidePointerEvents?: boolean;
}

export declare const DropdownMenuContent: __VLS_WithTemplateSlots_39<typeof __VLS_component_39, __VLS_TemplateResult_39["slots"]>;

export declare interface DropdownMenuContentProps extends MenuContentProps {
}

export declare interface DropdownMenuContextValue {
    triggerId: string;
    triggerRef: MutableRefObject<HTMLElement | undefined>;
    contentId: string;
    open: () => boolean;
    onOpenChange: (open: boolean) => void;
    onOpenToggle: () => void;
    modal: boolean;
}

export declare const DropdownMenuRoot: __VLS_WithTemplateSlots_40<typeof __VLS_component_40, __VLS_TemplateResult_40["slots"]>;

export declare type DropdownMenuRootEmits = {
    'update:open': [open: boolean];
};

export declare interface DropdownMenuRootProps extends MenuRootProps {
    defaultOpen?: boolean;
}

export declare const DropdownMenuSub: __VLS_WithTemplateSlots_41<typeof __VLS_component_41, __VLS_TemplateResult_41["slots"]>;

export declare const DropdownMenuSubContent: __VLS_WithTemplateSlots_42<typeof __VLS_component_42, __VLS_TemplateResult_42["slots"]>;

export declare type DropdownMenuSubContentImplEmits = MenuSubContentImplEmits;

export declare interface DropdownMenuSubContentImplProps extends MenuSubContentImplProps {
}

export declare interface DropdownMenuSubContentProps extends MenuSubContentProps {
}

export declare type DropdownMenuSubEmits = {
    'update:open': [open: boolean];
};

export declare interface DropdownMenuSubProps {
    open?: boolean;
    defaultOpen?: boolean;
}

export declare const DropdownMenuTrigger: __VLS_WithTemplateSlots_43<typeof __VLS_component_43, __VLS_TemplateResult_43["slots"]>;

export declare interface DropdownMenuTriggerProps {
    as?: PrimitiveProps['as'];
    disabled?: boolean;
}

export declare type EmitsToHookProps<T extends Record<string, any[]>> = {
    [K in keyof T as K extends `update:${infer Rest}` ? `onUpdate${Capitalize<Rest>}` : `on${Capitalize<string & K>}`]?: (...args: T[K]) => void;
};

declare type EmitValue<T> = T extends 'multiple' ? Exclude<AccordionMultipleProps['value'], undefined> : Exclude<AccordionSingleProps['value'], undefined>;

declare type EmitValue_2<T> = T extends 'multiple' ? Exclude<ToggleGroupMultipleProps['value'], undefined> : Exclude<ToggleGroupSingleProps['value'], undefined>;

declare type EventHandlers<E> = (event: E) => void | Array<(event: E) => void>;

declare type EventSuffixes = CombineSuffixes<BaseEventSuffixes>;

export declare function focusFirst(candidates: HTMLElement[], preventScroll?: boolean): boolean;

declare type FocusOutsideEvent = CustomEvent<{
    originalEvent: FocusEvent;
}>;

declare interface FocusScopeProps {
    /**
     * When `true`, tabbing from last item will focus first tabbable
     * and shift+tab from first item will focus last tababble.
     * @defaultValue false
     */
    loop?: boolean;
    /**
     * When `true`, focus cannot escape the focus scope via keyboard,
     * pointer, or a programmatic focus.
     * @defaultValue false
     */
    trapped?: boolean;
}

export declare function getDecimalCount(value: number): number;

export declare function getElFromTemplateRef<T extends HTMLElement>(nodeRef: VNodeRef): T | undefined;

export declare function getRawChildren(children: VNode[]): VNode[];

declare type Hook<T = () => void> = T | T[];

export declare const HoverCardContent: __VLS_WithTemplateSlots_44<typeof __VLS_component_44, __VLS_TemplateResult_44["slots"]>;

export declare interface HoverCardContentProps {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: boolean;
}

export declare interface HoverCardContext {
    open: Ref<boolean>;
    onOpenChange: (open: boolean) => void;
    onOpen: () => void;
    onClose: () => void;
    onDismiss: () => void;
    hasSelectionRef: MutableRefObject<boolean>;
    isPointerDownOnContentRef: MutableRefObject<boolean>;
}

export declare const HoverCardRoot: __VLS_WithTemplateSlots_45<typeof __VLS_component_45, __VLS_TemplateResult_45["slots"]>;

export declare type HoverCardRootEmits = {
    'update:open': [open: boolean];
};

export declare interface HoverCardRootProps {
    open?: boolean;
    defaultOpen?: boolean;
    openDelay?: number;
    closeDelay?: number;
}

export declare const HoverCardTrigger: __VLS_WithTemplateSlots_46<typeof __VLS_component_46, __VLS_TemplateResult_46["slots"]>;

export declare interface HoverCardTriggerProps extends PopperAnchorProps {
    as?: PrimitiveProps['as'];
}

export declare type IAttrsData = Record<string, unknown> & VNodeProps;

export declare type ImageLoadingStatus = 'idle' | 'loading' | 'loaded' | 'error';

export declare const isDef: <T = any>(val?: T) => val is T;

export { isFunction }

export declare function isIndeterminate(checked?: CheckedState): checked is 'indeterminate';

export declare function isNumber(value: unknown): value is number;

export declare function isPointInPolygon(point: Point, polygon: Polygon): boolean;

export declare const isPropFalsy: <T = any>(val?: T) => val is T;

export declare interface ItemData {
    $menubar: {
        value: string;
        disabled: boolean;
    };
}

declare type KeysOfType<T, U> = {
    [K in keyof T]: T[K] extends U ? K : never;
}[keyof T];

export declare const Label: __VLS_WithTemplateSlots_47<typeof __VLS_component_47, __VLS_TemplateResult_47["slots"]>;

export declare type LabelEmits = {
    mousedown: [event: MouseEvent];
};

export declare interface LabelProps {
    as?: PrimitiveProps['as'];
}

export { LooseRequired }

declare interface Machine<S> {
    [k: string]: {
        [k: string]: S;
    };
}

declare type MachineEvent<T> = keyof UnionToIntersection<T[keyof T]>;

declare type MachineState<T> = keyof T;

declare type Measurable = HTMLElement | VirtualElement;

export declare const MenubarContent: __VLS_WithTemplateSlots_48<typeof __VLS_component_48, __VLS_TemplateResult_48["slots"]>;

export declare const MenubarContentImpl: __VLS_WithTemplateSlots_49<typeof __VLS_component_49, __VLS_TemplateResult_49["slots"]>;

export declare type MenubarContentImplEmits = Omit<MenuContentImplEmits, 'entryFocus'>;

export declare interface MenubarContentImplProps extends MenuContentImplProps {
}

export declare interface MenubarContentProps extends MenuContentProps {
}

export declare interface MenubarContextValue {
    value: Ref<string | undefined>;
    dir: Ref<Direction>;
    loop: boolean;
    onMenuOpen: (value: string) => void;
    onMenuClose: () => void;
    onMenuToggle: (value: string) => void;
}

export declare const MenubarMenu: __VLS_WithTemplateSlots_50<typeof __VLS_component_50, __VLS_TemplateResult_50["slots"]>;

export declare interface MenubarMenuContextValue {
    value: string;
    triggerId: string;
    triggerRef: MutableRefObject<HTMLElement | undefined>;
    contentId: string;
    wasKeyboardTriggerOpenRef: MutableRefObject<boolean>;
}

export declare interface MenubarMenuProps {
    value?: string;
}

export declare const MenubarRoot: __VLS_WithTemplateSlots_51<typeof __VLS_component_51, __VLS_TemplateResult_51["slots"]>;

export declare type MenubarRootEmits = {
    'update:value': [value: string];
};

export declare interface MenubarRootProps {
    value?: string;
    defaultValue?: string;
    loop?: RovingFocusGroupRootProps['loop'];
    dir?: RovingFocusGroupRootProps['dir'];
}

export declare const MenubarSub: __VLS_WithTemplateSlots_52<typeof __VLS_component_52, __VLS_TemplateResult_52["slots"]>;

export declare const MenubarSubContent: __VLS_WithTemplateSlots_53<typeof __VLS_component_53, __VLS_TemplateResult_53["slots"]>;

export declare interface MenubarSubContentProps extends MenuSubContentProps {
}

export declare type MenubarSubEmits = {
    'update:open': [open: boolean];
};

export declare interface MenubarSubProps {
    open?: boolean;
    defaultOpen?: boolean;
}

export declare const MenubarSubTrigger: __VLS_WithTemplateSlots_54<typeof __VLS_component_54, __VLS_TemplateResult_54["slots"]>;

export declare interface MenubarSubTriggerProps extends MenuSubTriggerProps {
}

export declare const MenubarTrigger: __VLS_WithTemplateSlots_55<typeof __VLS_component_55, __VLS_TemplateResult_55["slots"]>;

export declare interface MenubarTriggerProps {
    as?: PrimitiveProps['as'];
    disabled?: boolean;
}

declare interface MenuCheckboxItemProps extends MenuItemProps {
    checked?: CheckedState;
}

declare type MenuContentImplEmits = UseMenuContentImplSharedEmits;

declare interface MenuContentImplProps extends Omit<PopperContentProps, 'dir'> {
    /**
     * Whether keyboard navigation should loop around
     * @defaultValue false
     */
    loop?: boolean;
}

declare interface MenuContentProps {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: boolean;
}

declare interface MenuItemImplProps {
    disabled?: boolean;
    textValue?: string;
}

declare interface MenuItemIndicatorProps {
    as?: PrimitiveProps['as'];
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: boolean;
}

declare type MenuItemProps = {
    disabled?: boolean;
    textValue?: string;
};

declare interface MenuRadioGroupProps {
    value?: string;
}

declare interface MenuRadioItemProps extends MenuItemProps {
    value: string;
}

declare interface MenuRootProps {
    open?: boolean;
    dir?: Direction;
    modal?: boolean;
}

declare type MenuSubContentImplEmits = Omit<UseMenuContentImplSharedEmits, 'closeAutoFocus' | 'entryFocus'>;

declare interface MenuSubContentImplProps extends Omit<PopperContentProps, 'dir' | 'side' | 'align'> {
    /**
     * Whether keyboard navigation should loop around
     * @defaultValue false
     */
    loop?: boolean;
}

declare interface MenuSubContentProps {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: boolean;
}

declare interface MenuSubTriggerProps extends MenuItemImplProps {
}

export declare function mergePrimitiveAttrs(attrs: PrimitiveElAttrs, extraAttrsList: PrimitiveElAttrs[]): PrimitiveElAttrs;

export declare interface MutableRefObject<T> {
    value: T;
}

export declare function normalizeAttrs(attrs: PrimitiveElAttrs): IAttrsData;

export declare type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;

declare type Orientation = AriaAttributes['aria-orientation'];

export declare const PAGE_KEYS: string[];

export declare type PickOptionalRecord<T> = Pick<T, OptionalKeys<T>>;

export declare type Point = [number, number];

declare type PointerdownOutsideEvent = CustomEvent<{
    originalEvent: PointerEvent;
}>;

export declare type Polygon = Point[];

export declare const PopoverAnchor: __VLS_WithTemplateSlots_56<typeof __VLS_component_56, __VLS_TemplateResult_56["slots"]>;

export declare interface PopoverAnchorProps extends PopperAnchorProps {
}

export declare const PopoverClose: __VLS_WithTemplateSlots_57<typeof __VLS_component_57, __VLS_TemplateResult_57["slots"]>;

export declare interface PopoverCloseProps {
    as?: PrimitiveProps['as'];
}

export declare const PopoverContent: __VLS_WithTemplateSlots_58<typeof __VLS_component_58, __VLS_TemplateResult_58["slots"]>;

export declare interface PopoverContentProps {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: boolean;
}

export declare interface PopoverContext {
    triggerRef: MutableRefObject<HTMLElement | undefined>;
    contentId: string;
    open: Ref<boolean>;
    onOpenChange: (open: boolean) => void;
    onOpenToggle: () => void;
    modal: boolean;
}

export declare const PopoverRoot: __VLS_WithTemplateSlots_59<typeof __VLS_component_59, __VLS_TemplateResult_59["slots"]>;

export declare type PopoverRootEmits = {
    /**
     * Event handler called when the open state of the popover changes.
     */
    'update:open': [value: boolean];
};

export declare interface PopoverRootProps {
    open?: boolean;
    defaultOpen?: boolean;
    modal?: boolean;
}

export declare const PopoverTrigger: __VLS_WithTemplateSlots_60<typeof __VLS_component_60, __VLS_TemplateResult_60["slots"]>;

export declare interface PopoverTriggerProps {
    as?: PrimitiveProps['as'];
}

declare interface PopperAnchorProps {
    virtualRef?: MutableRefObject<Measurable>;
}

declare interface PopperArrowProps extends ArrowProps {
}

declare type PopperContentEmits = {
    placed: [];
};

declare interface PopperContentProps {
    side?: Side_2;
    sideOffset?: number;
    align?: Align;
    alignOffset?: number;
    arrowPadding?: number;
    avoidCollisions?: boolean;
    collisionBoundary?: Boundary | Boundary[];
    collisionPadding?: number | Partial<Record<Side_2, number>>;
    sticky?: 'partial' | 'always';
    hideWhenDetached?: boolean;
    updatePositionStrategy?: 'optimized' | 'always';
    dir?: Direction;
}

declare interface PortalProps {
    /**
     * Vue native teleport component prop `:to`
     *
     * {@link https://vuejs.org/guide/built-ins/teleport.html#basic-usage}
     */
    to?: TeleportProps['to'];
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with Vue animation libraries.
     */
    forceMount?: boolean;
}

declare const Primitive: DefineComponent<ExtractPropTypes<    {
as: {
type: PropType<AsTag | Component>;
default: string;
};
}>, () => VNode<RendererNode, RendererElement, {
[key: string]: any;
}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
as: {
type: PropType<AsTag | Component>;
default: string;
};
}>> & Readonly<{}>, {
as: AsTag | Component;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
export { Primitive as ContextMenuLabel }
export { Primitive as DropdownMenuLabel }
export { Primitive as MenubarLabel }
export { Primitive }
export { Primitive as ToastDescription }
export { Primitive as ToastTitle }

export declare type PrimitiveDefaultProps<T extends object, BK extends BooleanKey<PickOptionalRecord<T>> = never, UK extends BooleanKey<PickOptionalRecord<T>> = Exclude<BooleanKey<PickOptionalRecord<T>>, BK>, K extends keyof PickOptionalRecord<T> = Exclude<keyof PickOptionalRecord<T>, BK>> = Record<UK, undefined> & Record<BK, boolean> & PrimitiveProps_2<T> & Partial<Record<K, unknown>>;

export declare type PrimitiveElAttrs<E extends HTMLElement = HTMLElement> = Partial<AllEventHandlers & AriaAttributes & HTMLAttributes> & Partial<Record<string, unknown>> & {
    elRef?: Hook<(nodeRef: E | undefined) => void>;
};

export declare interface PrimitiveProps {
    as?: AsTag | object;
}

declare type PrimitiveProps_2<T> = (T extends {
    as?: any;
} ? Required<Pick<T, 'as'>> : unknown);

export declare interface ProgressContext {
    value?: () => number | undefined;
    max: (() => number) | number;
}

export declare const ProgressIndicator: __VLS_WithTemplateSlots_61<typeof __VLS_component_61, __VLS_TemplateResult_61["slots"]>;

export declare const ProgressRoot: __VLS_WithTemplateSlots_62<typeof __VLS_component_62, __VLS_TemplateResult_62["slots"]>;

export declare interface ProgressRootProps {
    value?: number | undefined;
    max?: number;
    getValueLabel?: (value: number, max: number) => string;
}

export declare const provideAccordionContext: (state: AccordionContext) => void;

export declare const provideAccordionItemContext: (state: AccordionItemContext) => void;

export declare const provideAvatarContext: (state: AvatarContext) => void;

export declare const provideCheckboxContext: (state: CheckboxContext) => void;

export declare const provideCollapsibleContext: (state: CollapsibleContext) => void;

export declare const provideContextMenuContext: (state: ContextMenuContextValue) => void;

declare const provideDialogContext: (state: DialogContext) => void;
export { provideDialogContext as provideAlertDialogContext }
export { provideDialogContext }

export declare const provideDropdownMenuContext: (state: DropdownMenuContextValue) => void;

export declare const provideHoverCardContext: (state: HoverCardContext) => void;

export declare const provideMenubarContext: (state: MenubarContextValue) => void;

export declare const provideMenubarMenuContext: (state: MenubarMenuContextValue) => void;

export declare const providePopoverContext: (state: PopoverContext) => void;

export declare const provideProgressContext: (state: ProgressContext) => void;

export declare const provideRadioContext: (state: RadioContext) => void;

export declare const provideRadioGroupContext: (state: RadioGroupContext) => void;

export declare const provideScrollAreaContext: (state: ScrollAreaContext) => void;

export declare const provideScrollbarContext: (state: ScrollbarContext) => void;

export declare const provideSliderContext: (state: SliderContext) => void;

export declare const provideSliderOrientationContext: (state: SliderOrientationContext) => void;

export declare const provideSwitchContext: (state: SwitchRootContext) => void;

export declare const provideTabsContext: (state: TabsContext) => void;

export declare const provideToastInteractiveContext: (state: ToastContext) => void;

export declare const provideToastProviderContext: (state: ToastProviderContext) => void;

export declare const provideToggleGroupContext: (state: ToggleGroupContext) => void;

export declare const provideToolbarContext: (state: ToolbarContext) => void;

export declare const provideTooltipContentContext: (state: TooltipContentContext) => void;

export declare const provideTooltipContext: (state: TooltipContext) => void;

export declare const provideTooltipProviderContext: (state: TooltipProviderContext) => void;

export declare interface RadioContext {
    checked: Ref<boolean>;
    disabled: Ref<boolean | undefined>;
    bubbleInput: {
        control: Ref<HTMLButtonElement | undefined>;
        bubbles: MutableRefObject<boolean>;
        isFormControl: MutableRefObject<boolean>;
        name: () => string | undefined;
        value: () => string;
        checked: Ref<boolean>;
        required: () => boolean | undefined;
        disabled: Ref<boolean | undefined>;
    };
}

export declare const RadioGroupBubbleInput: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare interface RadioGroupContext {
    name: () => string | undefined;
    required: () => boolean | undefined;
    disabled: () => boolean | undefined;
    value: Ref<string | undefined>;
    onValueChange: (value: string) => void;
}

export declare const RadioGroupIndicator: __VLS_WithTemplateSlots_63<typeof __VLS_component_63, __VLS_TemplateResult_63["slots"]>;

export declare interface RadioGroupIndicatorProps {
    as?: PrimitiveProps['as'];
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: boolean;
}

export declare const RadioGroupItem: __VLS_WithTemplateSlots_64<typeof __VLS_component_64, __VLS_TemplateResult_64["slots"]>;

export declare interface RadioGroupItemProps {
    as?: PrimitiveProps['as'];
    value: string;
    name?: string;
    disabled?: boolean;
}

export declare const RadioGroupRoot: __VLS_WithTemplateSlots_65<typeof __VLS_component_65, __VLS_TemplateResult_65["slots"]>;

export declare type RadioGroupRootEmits = {
    'update:value': [value: string];
};

export declare interface RadioGroupRootProps {
    name?: string;
    required?: boolean;
    disabled?: boolean;
    dir?: RovingFocusGroupRootProps['dir'];
    orientation?: RovingFocusGroupRootProps['orientation'];
    loop?: RovingFocusGroupRootProps['loop'];
    value?: string;
    defaultValue?: string;
}

export declare type RadixPrimitiveGetAttrs<E extends HTMLElement = HTMLElement> = (extraAttrs?: PrimitiveElAttrs<E>[]) => PrimitiveElAttrs<E>;

export declare type RadixPrimitiveReturns<T = {
    attrs: RadixPrimitiveGetAttrs;
}> = T;

export declare interface RefObject<T> {
    readonly value: T;
}

export declare type RefOrRefObject<T> = Ref<T> | MutableRefObject<T>;

declare type ReplaceProps<T, K extends keyof T> = Omit<T, K> & {
    [P in K]: () => T[P];
};

declare type RequiredKeys<T> = Exclude<KeysOfType<T, Exclude<T[keyof T], undefined>>, undefined>;

export declare function roundValue(value: number, decimalCount: number): number;

declare type RovingFocusGroupRootEmits = {
    'update:currentTabStopId': [tabStopId: string | undefined];
    'entryFocus': [event: Event];
};

declare interface RovingFocusGroupRootProps {
    /**
     * The orientation of the group.
     * Mainly so arrow navigation is done accordingly (left & right vs. up & down)
     */
    orientation?: Orientation;
    /**
     * The direction of navigation between items.
     */
    dir?: Direction;
    /**
     * Whether keyboard navigation should loop around
     * @defaultValue false
     */
    loop?: boolean;
    currentTabStopId?: string | undefined;
    defaultCurrentTabStopId?: string;
    preventScrollOnEntryFocus?: boolean;
}

export declare const ScrollAreaContent: __VLS_WithTemplateSlots_66<typeof __VLS_component_66, __VLS_TemplateResult_66["slots"]>;

export declare interface ScrollAreaContext {
    type: ScrollAreaType;
    dir: Ref<Direction>;
    scrollHideDelay: number;
    scrollArea: Ref<HTMLElement | undefined>;
    viewport: Ref<HTMLElement | undefined>;
    content: Ref<HTMLElement | undefined>;
    scrollbarX: Ref<HTMLElement | undefined>;
    scrollbarXEnabled: Ref<boolean>;
    onScrollbarXEnabledChange: (rendered: boolean) => void;
    scrollbarY: Ref<HTMLElement | undefined>;
    scrollbarYEnabled: Ref<boolean>;
    onScrollbarYEnabledChange: (rendered: boolean) => void;
    onCornerWidthChange: (width: number) => void;
    onCornerHeightChange: (height: number) => void;
}

export declare const ScrollAreaCorner: __VLS_WithTemplateSlots_67<typeof __VLS_component_67, __VLS_TemplateResult_67["slots"]>;

export declare const ScrollAreaRoot: __VLS_WithTemplateSlots_68<typeof __VLS_component_68, __VLS_TemplateResult_68["slots"]>;

export declare interface ScrollAreaRootProps {
    type?: ScrollAreaType;
    dir?: Direction;
    scrollHideDelay?: number;
}

export declare const ScrollAreaScrollbar: __VLS_WithTemplateSlots_69<typeof __VLS_component_69, __VLS_TemplateResult_69["slots"]>;

export declare interface ScrollAreaScrollbarHoverProps {
    orientation?: ScrollAreaScrollbarVisibleProps['orientation'];
    forceMount?: boolean;
}

export declare interface ScrollAreaScrollbarProps {
    orientation?: ScrollAreaScrollbarVisibleProps['orientation'];
}

export declare interface ScrollAreaScrollbarScrollProps {
    orientation?: ScrollAreaScrollbarVisibleProps['orientation'];
    forceMount?: boolean;
}

export declare interface ScrollAreaScrollbarVisibleProps {
    orientation?: 'horizontal' | 'vertical';
}

export declare const ScrollAreaThumb: __VLS_WithTemplateSlots_70<typeof __VLS_component_70, __VLS_TemplateResult_70["slots"]>;

export declare interface ScrollAreaThumbProps {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: boolean;
}

declare type ScrollAreaType = 'auto' | 'always' | 'scroll' | 'hover';

export declare const ScrollAreaViewport: __VLS_WithTemplateSlots_71<typeof __VLS_component_71, __VLS_TemplateResult_71["slots"]>;

export declare interface ScrollAreaViewportProps {
    el?: RefOrRefObject<HTMLElement | undefined>;
}

export declare interface ScrollbarContext {
    hasThumb: Ref<boolean>;
    thumb: Ref<HTMLElement | undefined>;
    onThumbPointerUp: () => void;
    onThumbPointerDown: (pointerPos: {
        x: number;
        y: number;
    }) => void;
    onThumbPositionChange: () => void;
}

export declare const Separator: __VLS_WithTemplateSlots_72<typeof __VLS_component_72, __VLS_TemplateResult_72["slots"]>;

export declare interface SeparatorProps {
    /**
     * Either `vertical` or `horizontal`. Defaults to `horizontal`.
     */
    orientation?: 'vertical' | 'horizontal';
    /**
     * Whether or not the component is purely decorative. When true, accessibility-related attributes
     * are updated so that that the rendered element is removed from the accessibility tree.
     */
    decorative?: boolean;
}

export declare type Side = 'top' | 'right' | 'bottom' | 'left';

declare type Side_2 = (typeof SIDE_OPTIONS)[number];

declare const SIDE_OPTIONS: readonly ["top", "right", "bottom", "left"];

declare interface Size {
    width: number;
    height: number;
}

export declare type SlideDirection = 'from-left' | 'from-right' | 'from-bottom' | 'from-top';

export declare interface SliderContext {
    name: () => string | undefined;
    disabled: () => boolean | undefined;
    min: () => number;
    max: () => number;
    values: Ref<number[]>;
    valueIndexToChangeRef: MutableRefObject<number>;
    thumbs: Set<HTMLElement>;
    orientation: NonNullable<SliderRootProps['orientation']>;
}

export declare type SliderOrientationContext = Ref<{
    startEdge: Side;
    endEdge: Side;
    size: keyof NonNullable<UnwrapRef<ReturnType<typeof useSize>>>;
    direction: number;
}>;

export declare const SliderRange: __VLS_WithTemplateSlots_73<typeof __VLS_component_73, __VLS_TemplateResult_73["slots"]>;

export declare interface SliderRangeProps {
    as?: PrimitiveProps['as'];
}

export declare const SliderRoot: __VLS_WithTemplateSlots_74<typeof __VLS_component_74, __VLS_TemplateResult_74["slots"]>;

export declare type SliderRootEmits = {
    'update:value': [value: number[]];
    'valueCommit': [value: number[]];
};

export declare interface SliderRootProps {
    as?: PrimitiveProps['as'];
    name?: string;
    disabled?: boolean;
    orientation?: HTMLAttributes['aria-orientation'];
    dir?: Direction;
    min?: number;
    max?: number;
    step?: number;
    minStepsBetweenThumbs?: number;
    value?: number[];
    defaultValue?: number[];
    inverted?: boolean;
}

export declare const SliderThumb: __VLS_WithTemplateSlots_75<typeof __VLS_component_75, __VLS_TemplateResult_75["slots"]>;

export declare interface SliderThumbProps {
    as?: PrimitiveProps['as'];
    name?: string;
}

export declare const SliderTrack: __VLS_WithTemplateSlots_76<typeof __VLS_component_76, __VLS_TemplateResult_76["slots"]>;

export declare interface SliderTrackProps {
    as?: PrimitiveProps['as'];
}

declare type SwipeDirection = 'up' | 'down' | 'left' | 'right';

export declare type SwipeEvent = {
    currentTarget: EventTarget & HTMLLIElement;
} & Omit<CustomEvent<{
    originalEvent: PointerEvent;
    delta: {
        x: number;
        y: number;
    };
}>, 'currentTarget'>;

export declare const SwitchBubbleInput: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const SwitchRoot: __VLS_WithTemplateSlots_77<typeof __VLS_component_77, __VLS_TemplateResult_77["slots"]>;

export declare interface SwitchRootContext {
    checked: Ref<boolean>;
    disabled: () => boolean | undefined;
    bubbleInput: {
        control: Ref<HTMLButtonElement | undefined>;
        bubbles: MutableRefObject<boolean>;
        isFormControl: MutableRefObject<boolean>;
        name: () => string | undefined;
        value: () => string;
        checked: Ref<boolean>;
        required: () => boolean | undefined;
        disabled: () => boolean | undefined;
    };
}

export declare type SwitchRootEmits = {
    'update:checked': [checked: boolean];
};

export declare interface SwitchRootProps {
    as?: PrimitiveProps['as'];
    checked?: boolean;
    defaultChecked?: boolean;
    required?: boolean;
    disabled?: boolean;
    value?: string;
    name?: string;
}

export declare const SwitchThumb: __VLS_WithTemplateSlots_78<typeof __VLS_component_78, __VLS_TemplateResult_78["slots"]>;

export declare interface SwitchThumbProps {
    as?: PrimitiveProps['as'];
}

export declare const TabsContent: __VLS_WithTemplateSlots_79<typeof __VLS_component_79, __VLS_TemplateResult_79["slots"]>;

export declare interface TabsContentProps {
    value: string;
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: boolean;
}

export declare interface TabsContext {
    baseId: string;
    value: Ref<string | undefined>;
    onValueChange: (value: string) => void;
    orientation: Exclude<TabsRootProps['orientation'], undefined>;
    dir: Ref<Direction>;
    activationMode: Exclude<TabsRootProps['activationMode'], undefined>;
}

export declare const TabsList: __VLS_WithTemplateSlots_80<typeof __VLS_component_80, __VLS_TemplateResult_80["slots"]>;

export declare interface TabsListProps {
    loop?: RovingFocusGroupRootProps['loop'];
}

export declare const TabsRoot: __VLS_WithTemplateSlots_81<typeof __VLS_component_81, __VLS_TemplateResult_81["slots"]>;

export declare type TabsRootEmits = {
    /** A function called when a new tab is selected */
    'update:value': [value: string];
};

export declare interface TabsRootProps {
    /** The value for the selected tab, if controlled */
    value?: string;
    /** The value of the tab to select by default, if uncontrolled */
    defaultValue?: string;
    /**
     * The orientation the tabs are layed out.
     * Mainly so arrow navigation is done accordingly (left & right vs. up & down)
     * @defaultValue horizontal
     */
    orientation?: RovingFocusGroupRootProps['orientation'];
    /**
     * The direction of navigation between toolbar items.
     */
    dir?: RovingFocusGroupRootProps['dir'];
    /**
     * Whether a tab is activated automatically or manually.
     * @defaultValue automatic
     */
    activationMode?: 'automatic' | 'manual';
}

export declare const TabsTrigger: __VLS_WithTemplateSlots_82<typeof __VLS_component_82, __VLS_TemplateResult_82["slots"]>;

export declare interface TabsTriggerProps {
    as?: PrimitiveProps['as'];
    value: string;
    disabled?: boolean;
}

declare interface ToastCloseProps {
    as?: PrimitiveProps['as'];
}
export { ToastCloseProps as ToastActionProps }
export { ToastCloseProps }

declare interface ToastContext {
    el: Ref<HTMLElement | undefined>;
    open: Ref<boolean>;
    onChangeOpen: (v: boolean) => void;
    onClose: () => void;
    setOnClose: (onClose: () => void) => void;
}

declare interface ToastProviderContext {
    label: string;
    duration: number;
    swipeDirection: Ref<SwipeDirection>;
    swipeThreshold: MaybeRefOrGetter<number>;
    toastCount: Ref<number>;
    viewport: Ref<HTMLElement | undefined>;
    onToastAdd: () => void;
    onToastRemove: () => void;
    isFocusedToastEscapeKeyDownRef: MutableRefObject<boolean>;
    isClosePausedRef: MutableRefObject<boolean>;
}

export declare interface ToastProviderProps {
    /**
     * An author-localized label for each toast. Used to help screen reader users
     * associate the interruption with a toast.
     * @defaultValue 'Notification'
     */
    label?: string;
    /**
     * Time in milliseconds that each toast should remain visible for.
     * @defaultValue 5000
     */
    duration?: number;
    /**
     * Direction of pointer swipe that should close the toast.
     * @defaultValue 'right'
     */
    swipeDirection?: MaybeRef<SwipeDirection>;
    /**
     * Distance in pixels that the swipe must pass before a close is triggered.
     * @defaultValue 50
     */
    swipeThreshold?: MaybeRefOrGetter<number>;
}

export declare const ToastRoot: __VLS_WithTemplateSlots_84<typeof __VLS_component_84, __VLS_TemplateResult_84["slots"]>;

export declare type ToastRootEmits = {
    'update:open': [open: boolean];
};

export declare interface ToastRootProps {
    open?: boolean;
    defaultOpen?: boolean;
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: boolean;
}

export declare const ToastViewport: __VLS_WithTemplateSlots_85<typeof __VLS_component_85, __VLS_TemplateResult_85["slots"]>;

export declare interface ToastViewportProps {
    as?: PrimitiveProps['as'];
    /**
     * The keys to use as the keyboard shortcut that will move focus to the toast viewport.
     * @defaultValue ['F8']
     */
    hotkey?: string[];
    /**
     * An author-localized label for the toast viewport to provide context for screen reader users
     * when navigating page landmarks. The available `{hotkey}` placeholder will be replaced for you.
     * @defaultValue 'Notifications ({hotkey})'
     */
    label?: string;
}

export declare const Toggle: __VLS_WithTemplateSlots_86<typeof __VLS_component_86, __VLS_TemplateResult_86["slots"]>;

export declare type ToggleEmits = {
    /**
     * The callback that fires when the state of the toggle changes.
     */
    'update:pressed': [value: boolean];
};

export declare interface ToggleGroupContext {
    rovingFocus: boolean;
    disabled: () => boolean | undefined;
    type: ToggleGroupType;
    value: Ref<string[]>;
    onItemActivate: (value: string) => void;
    onItemDeactivate: (value: string) => void;
}

export declare type ToggleGroupEmits<T extends ToggleGroupType> = {
    /**
     * The callback that fires when the state of the toggle group changes.
     */
    'update:value': [value: EmitValue_2<T>];
};

declare interface ToggleGroupImplProps {
    /**
     * Whether the group is disabled from user interaction.
     * @defaultValue false
     */
    disabled?: boolean;
    /**
     * Whether the group should maintain roving focus of its buttons.
     * @defaultValue true
     */
    rovingFocus?: boolean;
    loop?: RovingFocusGroupRootProps['loop'];
    orientation?: RovingFocusGroupRootProps['orientation'];
    dir?: RovingFocusGroupRootProps['dir'];
}

export declare const ToggleGroupItem: __VLS_WithTemplateSlots_87<typeof __VLS_component_87, __VLS_TemplateResult_87["slots"]>;

export declare interface ToggleGroupItemProps extends Omit<ToggleProps, 'pressed' | 'defaultPressed'> {
    /**
     * A string value for the toggle group item. All items within a toggle group should use a unique value.
     */
    value: string;
}

declare interface ToggleGroupMultipleProps {
    /**
     * The controlled stateful value of the items that are pressed.
     */
    value?: string[];
    /**
     * The value of the items that are pressed when initially rendered. Use
     * `defaultValue` if you do not need to control the state of a toggle group.
     */
    defaultValue?: string[];
}

export declare interface ToggleGroupProps<T extends ToggleGroupType> extends ToggleGroupImplProps {
    type?: T;
    value?: T extends 'multiple' ? ToggleGroupMultipleProps['value'] : ToggleGroupSingleProps['value'];
    defaultValue?: T extends 'multiple' ? ToggleGroupMultipleProps['defaultValue'] : ToggleGroupSingleProps['defaultValue'];
}

export declare const ToggleGroupRoot: <T extends ToggleGroupType = undefined>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal_2<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
    props: __VLS_PrettifyLocal_2<Pick<Partial<{}> & Omit<{
        readonly "onUpdate:value"?: ((value: T extends "multiple" ? string[] : string) => any) | undefined;
    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onUpdate:value"> & ToggleGroupProps<T>> & PublicProps;
    expose(exposed: ShallowUnwrapRef<    {}>): void;
    attrs: any;
    slots: {
        default?(_: {}): any;
    };
    emit: (evt: "update:value", value: T extends "multiple" ? string[] : string) => void;
}>) => VNode<RendererNode, RendererElement, {
[key: string]: any;
}> & {
    __ctx?: Awaited<typeof __VLS_setup>;
};

declare interface ToggleGroupSingleProps {
    /**
     * The controlled stateful value of the item that is pressed.
     */
    value?: string;
    /**
     * The value of the item that is pressed when initially rendered. Use
     * `defaultValue` if you do not need to control the state of a toggle group.
     */
    defaultValue?: string;
}

export declare type ToggleGroupType = 'single' | 'multiple' | undefined;

export declare interface ToggleProps {
    as?: PrimitiveProps['as'];
    /**
     * The controlled state of the toggle.
     */
    pressed?: boolean;
    /**
     * The state of the toggle when initially rendered. Use `defaultPressed`
     * if you do not need to control the state of the toggle.
     * @defaultValue false
     */
    defaultPressed?: boolean;
    disabled?: boolean;
}

export declare const ToolbarButton: __VLS_WithTemplateSlots_88<typeof __VLS_component_88, __VLS_TemplateResult_88["slots"]>;

export declare interface ToolbarButtonProps {
    as?: PrimitiveProps['as'];
    disabled?: boolean;
}

export declare interface ToolbarContext {
    orientation: RovingFocusGroupRootProps['orientation'];
    dir: Ref<Required<RovingFocusGroupRootProps>['dir']>;
}

export declare const ToolbarLink: __VLS_WithTemplateSlots_89<typeof __VLS_component_89, __VLS_TemplateResult_89["slots"]>;

export declare interface ToolbarLinkProps {
    as?: PrimitiveProps['as'];
}

export declare const ToolbarRoot: __VLS_WithTemplateSlots_90<typeof __VLS_component_90, __VLS_TemplateResult_90["slots"]>;

export declare interface ToolbarRootProps {
    orientation?: RovingFocusGroupRootProps['orientation'];
    loop?: RovingFocusGroupRootProps['loop'];
    dir?: RovingFocusGroupRootProps['dir'];
}

export declare const ToolbarSeparator: __VLS_WithTemplateSlots_91<typeof __VLS_component_91, __VLS_TemplateResult_91["slots"]>;

export declare interface ToolbarSeparatorProps extends Omit<SeparatorProps, 'orientation'> {
}

export declare const ToolbarToggleGroup: <T extends ToggleGroupType = undefined>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal_3<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
    props: __VLS_PrettifyLocal_3<Pick<Partial<{}> & Omit<{
        readonly "onUpdate:value"?: ((value: T extends "multiple" ? string[] : string) => any) | undefined;
    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onUpdate:value"> & ToolbarToggleGroupProps<T>> & PublicProps;
    expose(exposed: ShallowUnwrapRef<    {}>): void;
    attrs: any;
    slots: {
        default?(_: {}): any;
    };
    emit: (evt: "update:value", value: T extends "multiple" ? string[] : string) => void;
}>) => VNode<RendererNode, RendererElement, {
[key: string]: any;
}> & {
    __ctx?: Awaited<typeof __VLS_setup>;
};

export declare type ToolbarToggleGroupEmits<T extends ToggleGroupType> = ToggleGroupEmits<T>;

export declare interface ToolbarToggleGroupProps<T extends ToggleGroupType> extends Omit<ToggleGroupProps<T>, 'rovingFocus'> {
}

export declare const ToolbarToggleItem: __VLS_WithTemplateSlots_92<typeof __VLS_component_92, __VLS_TemplateResult_92["slots"]>;

export declare interface ToolbarToggleItemProps {
    as?: PrimitiveProps['as'];
    value: ToggleGroupItemProps['value'];
    disabled?: boolean;
}

export declare const TOOLTIP_OPEN = "tooltip.open";

export declare const TooltipContent: __VLS_WithTemplateSlots_93<typeof __VLS_component_93, __VLS_TemplateResult_93["slots"]>;

export declare const TooltipContentAriaLabel: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare interface TooltipContentContext {
    id: string;
    ariaLabel?: string | undefined;
}

export declare type TooltipContentImplEmits = {
    /** Event handler called when focus moves to the destructive action after opening. It can be prevented by calling `event.preventDefault` */
    escapeKeydown: DismissableLayerEmits['escapeKeydown'];
    /** Event handler called when a pointer event occurs outside the bounds of the component. It can be prevented by calling `event.preventDefault`. */
    pointerdownOutside: DismissableLayerEmits['pointerdownOutside'];
};

export declare interface TooltipContentImplProps extends PopperContentProps {
    /**
     * A more descriptive label for accessibility purpose
     */
    ariaLabel?: string;
}

export declare interface TooltipContentProps {
    /**
     * Used to force mounting when more control is needed. Useful when
     * controlling animation with React animation libraries.
     */
    forceMount?: boolean;
}

export declare interface TooltipContext {
    contentId: string;
    open: Ref<boolean>;
    stateAttribute: () => 'closed' | 'delayed-open' | 'instant-open';
    trigger: Ref<HTMLElement | undefined>;
    onTriggerEnter: () => void;
    onTriggerLeave: () => void;
    onOpen: () => void;
    onClose: () => void;
    disableHoverableContent: boolean;
}

export declare const TooltipProvider: __VLS_WithTemplateSlots_94<typeof __VLS_component_94, __VLS_TemplateResult_94["slots"]>;

export declare interface TooltipProviderContext {
    isOpenDelayed: Ref<boolean>;
    delayDuration: number;
    onOpen: () => void;
    onClose: () => void;
    onPointerInTransitChange: (inTransit: boolean) => void;
    isPointerInTransitRef: MutableRefObject<boolean>;
    disableHoverableContent: boolean;
}

export declare interface TooltipProviderProps {
    /**
     * The duration from when the pointer enters the trigger until the tooltip gets opened.
     * @defaultValue 700
     */
    delayDuration?: number;
    /**
     * How much time a user has to enter another trigger without incurring a delay again.
     * @defaultValue 300
     */
    skipDelayDuration?: number;
    /**
     * When `true`, trying to hover the content will result in the tooltip closing as the pointer leaves the trigger.
     * @defaultValue false
     */
    disableHoverableContent?: boolean;
}

export declare const TooltipRoot: __VLS_WithTemplateSlots_95<typeof __VLS_component_95, __VLS_TemplateResult_95["slots"]>;

export declare type TooltipRootEmits = {
    'update:open': [open: boolean];
};

export declare interface TooltipRootProps {
    open?: boolean;
    defaultOpen?: boolean;
    /**
     * The duration from when the pointer enters the trigger until the tooltip gets opened. This will
     * override the prop with the same name passed to Provider.
     * @defaultValue 700
     */
    delayDuration?: number;
    /**
     * When `true`, trying to hover the content will result in the tooltip closing as the pointer leaves the trigger.
     * @defaultValue false
     */
    disableHoverableContent?: boolean;
}

export declare const TooltipTrigger: __VLS_WithTemplateSlots_96<typeof __VLS_component_96, __VLS_TemplateResult_96["slots"]>;

export declare interface TooltipTriggerProps extends PopperAnchorProps {
    as?: PrimitiveProps['as'];
}

declare type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;

export declare function useAccordionContent(props: UseAccordionContentProps): RadixPrimitiveReturns<{
    isOpen: Ref<boolean>;
    attrs: RadixPrimitiveGetAttrs;
}>;

export declare interface UseAccordionContentProps extends UseCollapsibleContentProps {
}

export declare const useAccordionContext: (consumerName: string) => AccordionContext;

export declare const useAccordionItemContext: (consumerName: string) => AccordionItemContext;

export declare interface UseAlertDialogContent extends UseDialogContent {
}

export declare const useAlertDialogContent: typeof useDialogContent;

export declare const useAvatarContext: (consumerName: string) => AvatarContext;

export declare interface UseAvatarFallback {
    delayMs?: number;
}

export declare function useAvatarFallback(props?: UseAvatarFallback): RadixPrimitiveReturns<{
    isOpen: Ref<boolean>;
}>;

export declare function useAvatarImage(props?: UseAvatarImageProps): RadixPrimitiveReturns;

export declare interface UseAvatarImageProps extends EmitsToHookProps<AvatarImageEmits> {
    src?: () => string | undefined;
}

export declare function useAvatarRoot(): void;

export declare function useBodyScrollLock(): () => void;

export declare const useCheckboxContext: (consumerName: string) => CheckboxContext;

export declare function useCheckboxIndicator(props: UseCheckboxIndicatorProps): RadixPrimitiveReturns<{
    isPresent: Ref<boolean>;
    attrs: RadixPrimitiveGetAttrs;
}>;

export declare interface UseCheckboxIndicatorProps {
    el?: Ref<HTMLElement | undefined>;
    forceMount?: boolean;
}

export declare function useCheckboxRoot(props: UseCheckboxRootProps): RadixPrimitiveReturns;

export declare interface UseCheckboxRootProps extends EmitsToHookProps<CheckboxRootEmits> {
    control?: Ref<HTMLButtonElement | undefined>;
    checked?: () => CheckedState | undefined;
    defaultChecked?: CheckedState | undefined;
    disabled?: () => boolean | undefined;
    required?: () => boolean | undefined;
    value?: () => string;
    name?: () => string | undefined;
}

export declare function useCollapsibleContent(props: UseCollapsibleContentProps): RadixPrimitiveReturns<{
    isOpen: Ref<boolean>;
    attrs: RadixPrimitiveGetAttrs;
}>;

export declare interface UseCollapsibleContentProps {
    el?: Ref<HTMLElement | undefined>;
    forceMount?: boolean;
}

export declare const useCollapsibleContext: (consumerName: string) => CollapsibleContext;

export declare function useCollapsibleRoot(props: UseCollapsibleRootProps): RadixPrimitiveReturns;

export declare interface UseCollapsibleRootProps extends EmitsToHookProps<CollapsibleRootEmits> {
    open?: () => boolean | undefined;
    defaultOpen?: boolean;
    disabled?: () => boolean | undefined;
}

export declare function useCollapsibleTrigger(): RadixPrimitiveReturns;

export declare const useCollection: (thereContext?: CollectionContext) => () => CollectionItemWithData<HTMLElement, Record<string, any>>[];

export declare function useComposedElements<T extends HTMLElement = HTMLElement>(cb: (el: T | undefined) => void): (nodeRef: any) => void;

export declare function useContextMenuContent(props?: UseContextMenuContenttProps): RadixPrimitiveReturns<{
    isPresent: Ref<boolean>;
}>;

export declare interface UseContextMenuContenttProps {
    forceMount?: boolean;
}

export declare const useContextMenuContext: (consumerName: string) => ContextMenuContextValue;

export declare function useContextMenuSub(props?: UseContextMenuSubProps): void;

export declare interface UseContextMenuSubProps extends EmitsToHookProps<ContextMenuSubEmits> {
    open?: () => boolean | undefined;
    defaultOpen?: boolean;
}

/**
 * Shorthand for v-model binding, props + emit -> ref
 *
 * @see https://vueuse.org/useVModel
 * @param props
 * @param key
 * @param onChange
 * @param defaultValue
 */
export declare function useControllableState<P extends object, K extends keyof P, V = P[K]>(props: P, key: K, onChange: (value: V) => void, defaultValue?: V): Ref<V>;

export declare function useControllableStateV2<P, U = P, V = P>(prop: (() => P) | undefined, onChange: ((value: U) => void) | undefined, defaultValue: V | undefined): Ref<V>;

export declare function useControllableStateV3<P, U = P, V = P>(prop: (() => P) | undefined, onChange: ((value: U) => void) | undefined, defaultValue: () => V): Ref<V>;

export declare function useDialogClose(): RadixPrimitiveReturns;

export declare interface UseDialogContent {
    forceMount?: boolean;
}

export declare function useDialogContent(props: UseDialogContent): RadixPrimitiveReturns<{
    isPresent: Ref<boolean>;
}>;

export declare function useDialogContentImpl(props: UseDialogContentImplProps): RadixPrimitiveReturns;

export declare function useDialogContentImplModal(props: UseDialogContentImplProps): RadixPrimitiveReturns;

export declare function useDialogContentImplNonModal(props: UseDialogContentImplProps): RadixPrimitiveReturns;

export declare interface UseDialogContentImplProps extends Omit<UseDialogContentImplSharedProps, 'trapFocus' | 'disableOutsidePointerEvents'> {
}

export declare function useDialogContentImplShared(props: UseDialogContentImplSharedProps): RadixPrimitiveReturns;

export declare interface UseDialogContentImplSharedProps extends EmitsToHookProps<DialogContentImplEmits>, Omit<UseDismissableLayerProps, 'onDismiss'> {
    trapFocus?: () => boolean;
}

declare const useDialogContext: (consumerName: string) => DialogContext;
export { useDialogContext as useAlertDialogContext }
export { useDialogContext }

export declare function useDialogDescription(): RadixPrimitiveReturns;

export declare function useDialogOverlay(props?: UseDialogOverlayProps): RadixPrimitiveReturns<{
    isPresent: Ref<boolean>;
    attrs: RadixPrimitiveGetAttrs;
}>;

export declare interface UseDialogOverlayProps {
    forceMount?: boolean;
    el?: Ref<HTMLElement | undefined>;
}

export declare function useDialogRoot(props: UseDialogRootProps): void;

export declare interface UseDialogRootProps extends EmitsToHookProps<DialogRootEmits> {
    triggerRef?: MutableRefObject<HTMLElement | undefined>;
    content?: Ref<HTMLElement | undefined>;
    open?: () => boolean | undefined;
    defaultOpen?: boolean;
    modal?: boolean;
}

export declare function useDialogTitle(): RadixPrimitiveReturns;

export declare function useDialogTrigger(): RadixPrimitiveReturns;

declare interface UseDismissableLayerProps extends EmitsToHookProps<DismissableLayerEmits> {
    el?: Ref<HTMLElement | undefined>;
    disableOutsidePointerEvents?: () => boolean;
}

export declare const useDropdownMenuContent: typeof useMenuContent;

export declare interface UseDropdownMenuContentProps extends UseMenuContentProps {
}

export declare const useDropdownMenuContext: (consumerName: string) => DropdownMenuContextValue;

export declare function useDropdownMenuSub(props?: UseDropdownMenuSubProps): void;

export declare const useDropdownMenuSubContent: typeof useMenuSubContent;

export declare function useDropdownMenuSubContentImpl(props?: UseDropdownMenuSubContentImplProps): UseMenuContentImplSharedPeturns;

export declare interface UseDropdownMenuSubContentImplProps extends UseMenuSubContentImplProps {
}

export declare interface UseDropdownMenuSubContentProps extends UseMenuSubContentProps {
}

export declare interface UseDropdownMenuSubProps extends EmitsToHookProps<DropdownMenuSubEmits> {
    open?: () => boolean | undefined;
    defaultOpen?: boolean;
}

export declare function useDropdownMenuTrigger(props?: UseDropdownMenuTriggerProps): RadixPrimitiveReturns;

export declare interface UseDropdownMenuTriggerProps {
    disabled?: () => boolean | undefined;
}

export declare function useEscapeKeydown(handler: (e: KeyboardEvent) => void, ownerDocument?: MaybeRefOrGetter<Document | undefined>): void;

export declare function useForwardElement<T extends HTMLElement = HTMLElement>(elRef: Ref<T | undefined> | MutableRefObject<T | undefined>): (nodeRef: Element | ComponentPublicInstance | null | undefined) => void;

export declare const useHoverCardContext: (consumerName: string) => HoverCardContext;

export declare const useId: () => string;

export declare function useLabel(props?: UseLabelProps): RadixPrimitiveReturns;

export declare interface UseLabelProps extends EmitsToHookProps<LabelEmits> {
}

export declare const useMenubarContent: typeof useMenuContent;

export declare function useMenubarContentImpl(props?: UseMenubarContentImplProps): UseMenuContentImplSharedPeturns;

export declare interface UseMenubarContentImplProps extends Omit<UseMenuContentImplProps, 'onEntryFocus'> {
}

export declare interface UseMenubarContentProps extends UseMenuContentProps {
}

export declare const useMenubarContext: (consumerName: string) => MenubarContextValue;

export declare function useMenubarMenu(props: UseMenubarMenuProps): void;

export declare const useMenubarMenuContext: (consumerName: string) => MenubarMenuContextValue;

export declare interface UseMenubarMenuProps {
    value?: string;
}

export declare interface UseMenubarRootProps extends EmitsToHookProps<MenubarRootEmits> {
    value?: () => string | undefined;
    defaultValue?: string;
    loop?: boolean;
    dir?: MaybeRefOrGetter<Direction | undefined>;
}

export declare function useMenubarSub(props: UseMenubarSubProps): void;

export declare const useMenubarSubContent: typeof useMenuSubContent;

export declare interface UseMenubarSubContentProps extends UseMenuSubContentProps {
}

export declare interface UseMenubarSubProps extends EmitsToHookProps<MenubarSubEmits> {
    open?: () => boolean | undefined;
    defaultOpen?: boolean;
}

export declare function useMenubarSubTrigger(props?: UseMenubarSubTriggerProps): RadixPrimitiveReturns;

export declare interface UseMenubarSubTriggerProps extends UseMenuSubTriggerProps {
}

export declare function useMenubarTrigger(props?: UseMenubarTriggerProps): RadixPrimitiveReturns;

export declare interface UseMenubarTriggerProps {
    disabled?: () => boolean | undefined;
}

declare function useMenuContent(props?: UseMenuContentProps): RadixPrimitiveReturns<{
    isPresent: Ref<boolean>;
}>;

declare interface UseMenuContentImplProps extends Omit<UseMenuContentImplSharedProps, keyof UseMenuContentImplSharedPrivateProps> {
}

declare type UseMenuContentImplSharedEmits = {
    /**
     * Event handler called when auto-focusing on close.
     * Can be prevented.
     */
    closeAutoFocus: [event: Event];
    entryFocus: RovingFocusGroupRootEmits['entryFocus'];
    escapeKeydown: DismissableLayerEmits['escapeKeydown'];
    pointerdownOutside: DismissableLayerEmits['pointerdownOutside'];
    focusOutside: DismissableLayerEmits['focusOutside'];
    interactOutside: DismissableLayerEmits['interactOutside'];
};

declare interface UseMenuContentImplSharedPeturns {
    wrapperAttrs: () => IAttrsData;
    attrs: RadixPrimitiveGetAttrs;
}

declare type UseMenuContentImplSharedPrivateEmits = {
    openAutoFocus: [event: Event];
    dismiss: DismissableLayerEmits['dismiss'];
};

declare interface UseMenuContentImplSharedPrivateProps extends EmitsToHookProps<UseMenuContentImplSharedPrivateEmits> {
    disableOutsidePointerEvents?: DismissableLayerProps['disableOutsidePointerEvents'];
    disableOutsideScroll?: boolean;
    trapFocus?: FocusScopeProps['trapped'];
}

declare interface UseMenuContentImplSharedProps extends EmitsToHookProps<MenuContentImplEmits & UseMenuContentImplSharedPrivateEmits>, Omit<UsePopperContentProps, 'dir' | 'onPlaced'> {
    disableOutsidePointerEvents?: () => boolean;
    disableOutsideScroll?: boolean;
    trapFocus?: () => boolean;
    loop?: boolean;
}

declare interface UseMenuContentProps {
    forceMount?: boolean;
}

declare interface UseMenuItemImplProps {
    disabled?: () => boolean | undefined;
    textValue?: string;
}

declare function useMenuSubContent(props: UseMenuSubContentProps): RadixPrimitiveReturns<{
    isPresent: Ref<boolean>;
}>;

declare interface UseMenuSubContentImplProps extends Omit<UseMenuContentImplSharedProps, keyof UseMenuContentImplSharedPrivateProps | 'onCloseAutoFocus' | 'onEntryFocus' | 'side' | 'align'> {
}

declare interface UseMenuSubContentProps {
    forceMount?: boolean;
}

declare interface UseMenuSubTriggerProps extends UseMenuItemImplProps {
}

export declare function useMenuvarRoot(props?: UseMenubarRootProps): RadixPrimitiveReturns;

export declare function usePopoverAnchor(props?: UsePopoverAnchorProps): RadixPrimitiveReturns<{
    isShow: boolean;
    attrs: RadixPrimitiveGetAttrs;
}>;

export declare interface UsePopoverAnchorProps {
    virtualRef?: MutableRefObject<Measurable | undefined>;
}

export declare function usePopoverClose(): RadixPrimitiveReturns;

export declare function usePopoverContent(props?: UsePopoverContentProps): RadixPrimitiveReturns<{
    isPresent: Ref<boolean>;
}>;

export declare interface UsePopoverContentProps {
    forceMount?: boolean;
}

export declare const usePopoverContext: (consumerName: string) => PopoverContext;

export declare function usePopoverRoot(props?: UsePopoverRootProps): void;

export declare interface UsePopoverRootProps extends EmitsToHookProps<PopoverRootEmits> {
    triggerRef?: MutableRefObject<HTMLElement | undefined>;
    open?: () => boolean | undefined;
    defaultOpen?: boolean;
    modal?: boolean;
}

export declare function usePopoverTrigger(): RadixPrimitiveReturns;

declare function usePopperContent(props?: UsePopperContentProps): RadixPrimitiveReturns<{
    wrapperAttrs: () => IAttrsData;
    attrs: RadixPrimitiveGetAttrs;
}>;

declare interface UsePopperContentProps extends EmitsToHookProps<PopperContentEmits> {
    side?: Side_2;
    sideOffset?: number;
    align?: Align;
    alignOffset?: number;
    arrowPadding?: number;
    avoidCollisions?: boolean;
    collisionBoundary?: () => Boundary | Boundary[];
    collisionPadding?: number | Partial<Record<Side_2, number>>;
    sticky?: 'partial' | 'always';
    hideWhenDetached?: boolean;
    updatePositionStrategy?: 'optimized' | 'always';
    dir?: MaybeRefOrGetter<Direction | undefined>;
}

export declare const useProgressContext: (consumerName: string) => ProgressContext;

export declare function useProgressIndicator(): RadixPrimitiveReturns;

export declare function useProgressRoot(props: UseProgressRootProps): RadixPrimitiveReturns;

export declare interface UseProgressRootProps {
    value?: () => number | undefined;
    max?: (() => number) | number;
    getValueLabel?: (value: number, max: number) => string;
}

export declare const useRadioContext: (consumerName: string) => RadioContext;

export declare const useRadioGroupContext: (consumerName: string) => RadioGroupContext;

export declare function useRadioGroupIndicator(props?: UseRadioGroupIndicatorProps): RadixPrimitiveReturns<{
    isPresent: Ref<boolean>;
    attrs: RadixPrimitiveGetAttrs;
}>;

export declare interface UseRadioGroupIndicatorProps {
    el?: Ref<HTMLElement | undefined>;
    forceMount?: boolean;
}

export declare interface UseRadioGroupItem {
    control?: Ref<HTMLButtonElement | undefined>;
    value: () => string;
    name?: () => string | undefined;
    disabled?: () => boolean | undefined;
}

export declare function useRadioGroupItem(props: UseRadioGroupItem): RadixPrimitiveReturns;

export declare function useRadioGroupRoot(props: UseRadioGroupRootProps): RadixPrimitiveReturns;

export declare interface UseRadioGroupRootProps extends EmitsToHookProps<RadioGroupRootEmits> {
    elRef?: MutableRefObject<HTMLElement | undefined>;
    value?: () => string | undefined;
    defaultValue?: string;
    name?: () => string | undefined;
    required?: () => boolean | undefined;
    disabled?: () => boolean | undefined;
    orientation?: RovingFocusGroupRootProps['orientation'];
    loop?: boolean;
    dir?: MaybeRefOrGetter<Direction | undefined>;
}

export declare function useRef<T>(value: T): Ref extends T ? T extends Ref ? IfAny<T, MutableRefObject<T>, T> : MutableRefObject<T> : MutableRefObject<T>;

export declare function useRef<T = any>(): MutableRefObject<T | undefined>;

export declare function useScrollAreaContent(): RadixPrimitiveReturns;

export declare const useScrollAreaContext: (consumerName: string) => ScrollAreaContext;

export declare function useScrollAreaCorner(): RadixPrimitiveReturns<{
    hasCorner: Ref<boolean>;
}>;

export declare function useScrollAreaCornerImpl(): RadixPrimitiveReturns<{
    hasSize: Ref<boolean>;
    attrs: RadixPrimitiveGetAttrs;
}>;

export declare function useScrollAreaRoot(props: UseScrollAreaRootProps): RadixPrimitiveReturns;

declare interface UseScrollAreaRootProps {
    el?: Ref<HTMLElement | undefined>;
    type?: ScrollAreaType;
    dir?: MaybeRefOrGetter<Direction | undefined>;
    scrollHideDelay?: number;
}

export declare function useScrollAreaScrollbarAuto(props: UseScrollAreaScrollbarAutoProps): RadixPrimitiveReturns<{
    isPresent: Ref<boolean>;
    attrs: RadixPrimitiveGetAttrs;
}>;

export declare interface UseScrollAreaScrollbarAutoProps extends UseScrollAreaScrollbarVisibleProps {
    forceMount?: boolean;
}

export declare function useScrollAreaScrollbarHover(props: UseScrollAreaScrollbarHoverProps): RadixPrimitiveReturns<{
    isPresent: Ref<boolean>;
    attrs: RadixPrimitiveGetAttrs;
}>;

export declare interface UseScrollAreaScrollbarHoverProps extends UseScrollAreaScrollbarVisibleProps {
    forceMount?: boolean;
}

export declare function useScrollAreaScrollbarScroll(props: UseScrollAreaScrollbarScrollProps): RadixPrimitiveReturns<{
    isPresent: Ref<boolean>;
    attrs: RadixPrimitiveGetAttrs;
}>;

export declare interface UseScrollAreaScrollbarScrollProps extends UseScrollAreaScrollbarVisibleProps {
    forceMount?: boolean;
}

export declare function useScrollAreaScrollbarVisible(props: UseScrollAreaScrollbarVisibleProps): RadixPrimitiveReturns;

export declare interface UseScrollAreaScrollbarVisibleProps {
    orientation?: 'horizontal' | 'vertical';
}

export declare function useScrollAreaThumb(props: UseScrollAreaThumbProps): {
    isPresent: ShallowRef<boolean, boolean> | ComputedRef<boolean>;
};

export declare function useScrollAreaThumbImpl(): RadixPrimitiveReturns;

export declare interface UseScrollAreaThumbProps {
    forceMount?: boolean;
}

export declare function useScrollAreaViewport(props?: ScrollAreaViewportProps): RadixPrimitiveReturns;

export declare const useScrollbarContext: (consumerName: string) => ScrollbarContext;

export declare function useSeparator(props: UseSeparatorProps): RadixPrimitiveReturns;

export declare interface UseSeparatorProps {
    decorative?: SeparatorProps['decorative'];
    orientation?: SeparatorProps['orientation'];
}

export declare function useSize(elementRef: MaybeRefOrGetter<HTMLElement | undefined>): ShallowRef<Size | undefined, Size | undefined>;

export declare const useSliderContext: (consumerName: string) => SliderContext;

export declare const useSliderOrientationContext: (consumerName: string) => SliderOrientationContext;

export declare function useSliderRoot(props: UseSliderRootProps): RadixPrimitiveReturns;

export declare interface UseSliderRootProps extends EmitsToHookProps<SliderRootEmits> {
    el?: MutableRefObject<HTMLElement>;
    value?: () => number[] | undefined;
    defaultValue?: () => number[];
    name?: () => string | undefined;
    disabled?: () => boolean | undefined;
    orientation?: HTMLAttributes['aria-orientation'];
    dir?: MaybeRefOrGetter<Direction | undefined>;
    min?: () => number;
    max?: () => number;
    step?: () => number;
    minStepsBetweenThumbs?: () => number;
    inverted?: boolean;
}

export declare function useSliderThumb(props?: UseSliderThumbProps): RadixPrimitiveReturns<{
    bubbleInput: {
        name: () => string | undefined;
        value: Ref<number | undefined>;
        index: Ref<number>;
    };
    isFormControl: Ref<boolean>;
    wrapperAttrs: () => IAttrsData;
    attrs: RadixPrimitiveGetAttrs;
}>;

export declare interface UseSliderThumbProps {
    el?: Ref<HTMLElement>;
    name?: () => string | undefined;
}

export declare function useSliderTrack(): RadixPrimitiveReturns;

export declare function useStateMachine<M extends object>(initialState: MachineState<M>, machine: M & Machine<MachineState<M>>): readonly [Ref<keyof M, keyof M>, (event: MachineEvent<M>) => void];

export declare const useSwitchContext: (consumerName: string) => SwitchRootContext;

export declare function useSwitchRoot(props: UseSwitchRootProps): RadixPrimitiveReturns;

declare interface UseSwitchRootProps extends EmitsToHookProps<SwitchRootEmits> {
    control?: Ref<HTMLButtonElement | undefined>;
    checked?: () => boolean | undefined;
    defaultChecked?: boolean;
    disabled?: () => boolean | undefined;
    required?: () => boolean | undefined;
    value?: () => string;
    name?: () => string | undefined;
}

export declare function useSwitchThumb(): RadixPrimitiveReturns;

export declare function useTabsContent(props: UseTabsContentProps): RadixPrimitiveReturns<{
    isPresent: Ref<boolean>;
    attrs: RadixPrimitiveGetAttrs;
}>;

export declare interface UseTabsContentProps {
    el?: Ref<HTMLElement | undefined>;
    value: () => string;
    forceMount?: boolean;
}

export declare const useTabsContext: (consumerName: string) => TabsContext;

export declare function useTabsList(props: UseTabsListProps): RadixPrimitiveReturns;

export declare interface UseTabsListProps {
    elRef?: MutableRefObject<HTMLElement | undefined>;
    loop?: RovingFocusGroupRootProps['loop'];
}

export declare function useTabsRoot(props: UseTabsRootProps): RadixPrimitiveReturns;

export declare interface UseTabsRootProps extends EmitsToHookProps<TabsRootEmits> {
    value?: () => string | undefined;
    defaultValue?: string;
    orientation?: TabsRootProps['orientation'];
    dir?: MaybeRefOrGetter<Direction | undefined>;
    activationMode?: TabsRootProps['activationMode'];
}

export declare function useTabsTrigger(props: UseTabsTriggerProps): RadixPrimitiveReturns;

export declare interface UseTabsTriggerProps {
    value: () => string;
    disabled?: () => boolean | undefined;
}

export declare const useToastInteractiveContext: (consumerName: string) => ToastContext;

export declare function useToastProvider(props?: ToastProviderProps): void;

export declare const useToastProviderContext: (consumerName: string) => ToastProviderContext;

export declare function useToggle(props: UseToggleProps): RadixPrimitiveReturns;

export declare const useToggleGroupContext: (consumerName: string) => ToggleGroupContext;

export declare function useToggleGroupItem(props: UseToggleGroupItemProps): RadixPrimitiveReturns;

export declare interface UseToggleGroupItemProps extends Omit<UseToggleProps, 'pressed' | 'defaultPressed' | 'onUpdatePressed'> {
    value: MaybeRefOrGetter<string>;
}

declare interface UseToggleGroupProps<T extends ToggleGroupType> extends EmitsToHookProps<ToggleGroupEmits<T>> {
    type?: T;
    value?: () => T extends 'multiple' ? ToggleGroupMultipleProps['value'] : ToggleGroupSingleProps['value'];
    defaultValue?: T extends 'multiple' ? ToggleGroupMultipleProps['defaultValue'] : ToggleGroupSingleProps['defaultValue'];
    disabled?: () => boolean | undefined;
    rovingFocus?: boolean;
    loop?: RovingFocusGroupRootProps['loop'];
    orientation?: RovingFocusGroupRootProps['orientation'];
    dir?: MaybeRefOrGetter<Direction | undefined>;
}

export declare interface UseToggleProps extends EmitsToHookProps<ToggleEmits> {
    pressed?: () => boolean | undefined;
    defaultPressed?: boolean;
    disabled?: () => boolean | undefined;
}

export declare const useToolbarContext: (consumerName: string) => ToolbarContext;

export declare function useToolbarSeparator(props?: UseToolbarSeparatorProps): RadixPrimitiveReturns;

export declare interface UseToolbarSeparatorProps extends Omit<UseSeparatorProps, 'orientation'> {
}

export declare function useToolbarToggleGroup<T extends ToggleGroupType>(props: UseToolbarToggleGroupProps<T>): RadixPrimitiveReturns;

export declare interface UseToolbarToggleGroupProps<T extends ToggleGroupType> extends Omit<UseToggleGroupProps<T>, 'rovingFocus'> {
}

export declare interface UseToolbarToggleItem {
    value: () => ToggleGroupItemProps['value'];
    disabled?: () => boolean | undefined;
}

export declare function useToolbarToggleItem(props: UseToolbarToggleItem): RadixPrimitiveReturns;

export declare function useTooltipContent(props?: UseTooltipContentProps): RadixPrimitiveReturns<{
    isPresent: Ref<boolean>;
}>;

export declare const useTooltipContentContext: (consumerName: string) => TooltipContentContext;

export declare function useTooltipContentImpl(props: UseTooltipContentImplProps): ReturnType<typeof usePopperContent>;

export declare interface UseTooltipContentImplProps extends EmitsToHookProps<TooltipContentImplEmits>, Omit<UsePopperContentProps, 'onPlaced'> {
    ariaLabel?: string | undefined;
}

export declare interface UseTooltipContentProps {
    forceMount?: boolean;
}

export declare const useTooltipContext: (consumerName: string) => TooltipContext;

export declare function useTooltipProvider({ delayDuration, skipDelayDuration, disableHoverableContent, }?: TooltipProviderProps): void;

export declare const useTooltipProviderContext: (consumerName: string) => TooltipProviderContext;

export declare function useTooltipRoot(props: UseTooltipRootProps): void;

export declare interface UseTooltipRootProps extends EmitsToHookProps<TooltipRootEmits> {
    open?: () => boolean | undefined;
    defaultOpen?: boolean;
    delayDuration?: number;
    disableHoverableContent?: boolean;
}

export declare function useTooltipTrigger(): RadixPrimitiveReturns;

export declare const VISUALLY_HIDDEN_STYLE: CSSProperties;

export declare const VisuallyHidden: __VLS_WithTemplateSlots_97<typeof __VLS_component_97, __VLS_TemplateResult_97["slots"]>;

export declare interface VisuallyHiddenProps {
    as?: PrimitiveProps['as'];
}

export declare type VNodeRef = Element | ComponentPublicInstance | null | undefined;

/**
 * Wraps an array around itself at a given start index
 * Example: `wrapArray(['a', 'b', 'c', 'd'], 2) === ['c', 'd', 'a', 'b']`
 */
export declare function wrapArray<T>(array: T[], startIndex: number): T[];

export { }