import { AcceptableInputValue } from 'reka-ui';
import { AcceptableValue } from 'reka-ui';
import { AccordionContentProps } from 'reka-ui';
import { AccordionItemProps as AccordionItemProps_2 } from 'reka-ui';
import { AccordionRootProps as AccordionRootProps_2 } from 'reka-ui';
import { AlertDialogAction } from 'reka-ui';
import { AlertDialogActionProps } from 'reka-ui';
import { AlertDialogCancel } from 'reka-ui';
import { AlertDialogCancelProps } from 'reka-ui';
import { AlertDialogContentProps } from 'reka-ui';
import { AlertDialogProps } from 'reka-ui';
import { AlertDialogRoot } from 'reka-ui';
import { AlertDialogTrigger } from 'reka-ui';
import { AlertDialogTriggerProps } from 'reka-ui';
import { AsTag } from 'reka-ui';
import { CheckboxGroupRoot as CheckboxGroup } from 'reka-ui';
import { CheckboxGroupRootProps as CheckboxGroupProps } from 'reka-ui';
import { CheckboxRootProps } from 'reka-ui';
import { CollapsibleContentProps } from 'reka-ui';
import { CollapsibleRootProps as CollapsibleRootProps_2 } from 'reka-ui';
import { CollapsibleTriggerProps as CollapsibleTriggerProps_2 } from 'reka-ui';
import { ComboboxContentProps as ComboboxContentProps_2 } from 'reka-ui';
import { ComboboxGroup } from 'reka-ui';
import { ComboboxInputProps as ComboboxInputProps_2 } from 'reka-ui';
import { ComboboxItemProps } from 'reka-ui';
import { ComboboxLabelProps } from 'reka-ui';
import { ComboboxRootProps as ComboboxRootProps_2 } from 'reka-ui';
import { Component } from 'vue';
import { ComponentOptionsMixin } from 'vue';
import { ComponentProvideOptions } from 'vue';
import { ComputedRef } from 'vue';
import { DefineComponent } from 'vue';
import { DialogClose } from 'reka-ui';
import { DialogCloseProps } from 'reka-ui';
import { DialogContentProps } from 'reka-ui';
import { DialogRoot } from 'reka-ui';
import { DialogRootProps } from 'reka-ui';
import { DialogTrigger } from 'reka-ui';
import { DialogTriggerProps } from 'reka-ui';
import { DropdownMenuContentProps as DropdownMenuContentProps_2 } from 'reka-ui';
import { DropdownMenuItemProps as DropdownMenuItemProps_2 } from 'reka-ui';
import { DropdownMenuRoot } from 'reka-ui';
import { DropdownMenuTrigger } from 'reka-ui';
import { EditableRootProps } from 'reka-ui';
import { FocusOutsideEvent } from 'reka-ui';
import { MaybeRefOrGetter } from 'vue';
import { NavigationMenuContentProps } from 'reka-ui';
import { NavigationMenuItem } from 'reka-ui';
import { NavigationMenuLinkProps as NavigationMenuLinkProps_2 } from 'reka-ui';
import { NavigationMenuListProps as NavigationMenuListProps_2 } from 'reka-ui';
import { NavigationMenuRootProps } from 'reka-ui';
import { NavigationMenuTriggerProps as NavigationMenuTriggerProps_2 } from 'reka-ui';
import { PaginationRootProps } from 'reka-ui';
import { PointerDownOutsideEvent } from 'reka-ui';
import { PopoverClose } from 'reka-ui';
import { PopoverContentProps } from 'reka-ui';
import { PopoverRoot } from 'reka-ui';
import { PopoverTrigger } from 'reka-ui';
import { PrimitiveProps } from 'reka-ui';
import { PublicProps } from 'vue';
import { RadioGroupItemProps as RadioGroupItemProps_2 } from 'reka-ui';
import { RadioGroupRootProps as RadioGroupRootProps_2 } from 'reka-ui';
import { Ref } from 'vue';
import { ScrollAreaRootProps } from 'reka-ui';
import { SelectContentProps as SelectContentProps_2 } from 'reka-ui';
import { SelectGroup } from 'reka-ui';
import { SelectItemProps } from 'reka-ui';
import { SelectLabelProps } from 'reka-ui';
import { SelectRootProps as SelectRootProps_2 } from 'reka-ui';
import { SelectTriggerProps as SelectTriggerProps_2 } from 'reka-ui';
import { SwitchRootProps } from 'reka-ui';
import { TabsContent } from 'reka-ui';
import { TabsRoot } from 'reka-ui';
import { TabsTriggerProps } from 'reka-ui';
import { ToastProviderProps as ToastProviderProps_2 } from 'reka-ui';
import { ToggleGroupItemProps } from 'reka-ui';
import { ToggleGroupRootProps as ToggleGroupRootProps_2 } from 'reka-ui';
import { ToggleProps as ToggleProps_2 } from 'reka-ui';
import { TooltipContentProps } from 'reka-ui';
import { TooltipRootProps } from 'reka-ui';

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

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

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

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

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

declare type __VLS_Props = ComboboxItemProps;

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

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

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

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

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

declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;

declare type __VLS_TemplateResult_2 = ReturnType<typeof __VLS_template_2>;

declare type __VLS_TemplateResult_3 = ReturnType<typeof __VLS_template_3>;

declare type __VLS_TemplateResult_4 = ReturnType<typeof __VLS_template_4>;

declare type __VLS_TemplateResult_5 = ReturnType<typeof __VLS_template_5>;

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

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

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

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

export declare const AccordionContent: __VLS_WithTemplateSlots_45<DefineComponent<AccordionContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AccordionContentProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export { AccordionContentProps }

export declare const AccordionIndicator: DefineComponent<AccordionIndicatorProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AccordionIndicatorProps> & Readonly<{}>, {
variant: "chevron" | "plus";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

export declare interface AccordionIndicatorProps {
    /**
     * The indicator icon for the accordion trigger.
     * @default "chevron"
     */
    variant?: 'chevron' | 'plus';
}

export declare const AccordionItem: __VLS_WithTemplateSlots_44<DefineComponent<AccordionItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AccordionItemProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare interface AccordionItemProps extends Omit<AccordionItemProps_2, 'value'> {
    /**
     * A string identifier for the accordion item. If omitted, a unique value will be generated automatically.
     */
    value?: string;
}

export declare const AccordionRoot: __VLS_WithTemplateSlots_43<DefineComponent<AccordionRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: string | string[] | undefined) => any;
}, string, PublicProps, Readonly<AccordionRootProps> & Readonly<{
"onUpdate:modelValue"?: ((value: string | string[] | undefined) => any) | undefined;
}>, {
size: "1" | "2" | "3";
indicatorSide: "left" | "right";
indicatorIcon: "none" | "chevron" | "plus";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare interface AccordionRootProps extends AccordionRootProps_2 {
    /**
     * Control the size of the accordion.
     *
     * @default "1"
     */
    size?: '1' | '2' | '3';
    /**
     * The indicator icon's poistion, left or right.
     *
     * @default "right"
     */
    indicatorSide?: 'left' | 'right';
    /**
     * An indicator icon on the left or right of the trigger.
     *
     * @default "chevron"
     */
    indicatorIcon?: 'none' | 'chevron' | 'plus';
    /**
     * The orientation of the accordion.
     *
     * @default "vertical"
     */
    orientation?: 'vertical' | 'horizontal';
}

export declare const AccordionTrigger: __VLS_WithTemplateSlots_46<DefineComponent<AccordionTriggerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AccordionTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare interface AccordionTriggerProps extends PrimitiveProps {
    /**
     * The indicator icon's poistion, left or right.
     *
     * @default "right"
     */
    indicatorSide?: 'left' | 'right';
    /**
     * An indicator icon on the left or right of the trigger.
     *
     * @default "chevron"
     */
    indicatorIcon?: 'none' | 'chevron' | 'plus';
}

export { AlertDialogAction }

export { AlertDialogActionProps }

export { AlertDialogCancel }

export { AlertDialogCancelProps }

export declare const AlertDialogPopup: __VLS_WithTemplateSlots_10<DefineComponent<AlertDialogContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
escapeKeyDown: (event: KeyboardEvent) => any;
pointerDownOutside: (event: PointerDownOutsideEvent) => any;
focusOutside: (event: FocusOutsideEvent) => any;
interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
openAutoFocus: (event: Event) => any;
closeAutoFocus: (event: Event) => any;
}, string, PublicProps, Readonly<AlertDialogContentProps> & Readonly<{
onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
onOpenAutoFocus?: ((event: Event) => any) | undefined;
onCloseAutoFocus?: ((event: Event) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare type AlertDialogPopupProps = AlertDialogContentProps;

export { AlertDialogProps }

export { AlertDialogRoot }

export { AlertDialogTrigger }

export { AlertDialogTriggerProps }

export declare const Avatar: DefineComponent<AvatarProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AvatarProps> & Readonly<{}>, {
radius: RadiusType;
size: "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
variant: "solid" | "soft" | "outline" | "surface" | "ring";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare interface AvatarProps {
    /** Alt text of the avatar, usually the person's name. */
    alt?: string;
    /** Avatar's image source URL. */
    src?: string;
    /** Using fallback characters for the avatar. */
    fallback?: string;
    /**
     * Overrides the radius inherited from the theme.
     * @default "small"
     */
    radius?: RadiusType;
    /**
     * The visual variant to apply.
     * @default "solid"
     */
    variant?: 'solid' | 'soft' | 'outline' | 'surface' | 'ring';
    /**
     * Control the size of the avatar.
     * @default "2"
     */
    size?: '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
    /** Overrides the accent color inherited from the Theme. */
    color?: ColorType;
}

export declare const Badge: __VLS_WithTemplateSlots_2<DefineComponent<BadgeProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<BadgeProps> & Readonly<{}>, {
radius: RadiusType;
as: AsTag;
size: "1" | "2" | "3";
variant: "solid" | "soft" | "surface" | "outline";
highContrast: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare interface BadgeProps {
    /**
     * The visual variant to apply.
     * @default "soft"
     */
    variant?: 'solid' | 'soft' | 'surface' | 'outline';
    /** Overrides the accent color inherited from the theme. */
    color?: ColorType;
    /**
     * Overrides the radius inherited from the theme.
     * @default "small"
     */
    radius?: RadiusType;
    /**
     * Control the size of the badge.
     * @default "1"
     */
    size?: '1' | '2' | '3';
    /** Uses a higher contrast color for the component. */
    highContrast?: boolean;
    /**
     * The element or component this component should render as.
     * @default "span"
     */
    as?: AsTag;
    asChild?: boolean;
}

export declare const buildPropsClass: (props: Record<string, any>, keys: string[]) => ComputedRef<string[]>;

export declare const Button: __VLS_WithTemplateSlots_4<DefineComponent<ButtonProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ButtonProps> & Readonly<{}>, {
as: AsTag | Component;
size: "1" | "2" | "3" | "4";
variant: "classic" | "solid" | "soft" | "surface" | "outline" | "ghost";
highContrast: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare interface ButtonProps {
    /**
     * The visual variant to apply.
     * @default "solid"
     */
    variant?: 'classic' | 'solid' | 'soft' | 'surface' | 'outline' | 'ghost';
    /** Overrides the accent color inherited from the ThemeProvider. */
    color?: ColorType;
    /** Overrides the radius inherited from the ThemeProvider. */
    radius?: RadiusType;
    /**
     * Control the size of the button.
     * @default "2"
     */
    size?: '1' | '2' | '3' | '4';
    /** Uses a higher contrast color for the component. */
    highContrast?: boolean;
    /** Mark the button as disabled. */
    disabled?: boolean;
    /**
     * The element or component this component should render as.
     * @default "button"
     */
    as?: AsTag | Component;
    asChild?: boolean;
}

export declare const Card: __VLS_WithTemplateSlots_3<DefineComponent<CardProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<CardProps> & Readonly<{}>, {
as: AsTag | Component;
size: "1" | "2" | "3" | "4" | "5";
variant: "surface" | "soft";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare interface CardProps extends PrimitiveProps {
    variant?: 'surface' | 'soft';
    radius?: RadiusType;
    size?: '1' | '2' | '3' | '4' | '5';
}

export declare const Checkbox: DefineComponent<CheckboxProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: boolean | "indeterminate") => any;
}, string, PublicProps, Readonly<CheckboxProps> & Readonly<{
"onUpdate:modelValue"?: ((value: boolean | "indeterminate") => any) | undefined;
}>, {
size: "1" | "2" | "3";
variant: "surface" | "soft";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export { CheckboxGroup }

export { CheckboxGroupProps }

export declare interface CheckboxProps extends CheckboxRootProps {
    color?: ColorType;
    variant?: 'surface' | 'soft';
    size?: '1' | '2' | '3';
    highContrast?: boolean;
}

export declare const CloseButton: DefineComponent<ButtonProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ButtonProps> & Readonly<{}>, {
as: AsTag | Component;
size: "1" | "2" | "3" | "4";
variant: "classic" | "solid" | "soft" | "surface" | "outline" | "ghost";
color: ColorType;
highContrast: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare const CollapsibleContent: __VLS_WithTemplateSlots_49<typeof __VLS_component_5, __VLS_TemplateResult_5["slots"]>;

export { CollapsibleContentProps }

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

export declare const CollapsibleRoot: __VLS_WithTemplateSlots_47<DefineComponent<CollapsibleRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (value: boolean) => any;
}, string, PublicProps, Readonly<CollapsibleRootProps> & Readonly<{
"onUpdate:open"?: ((value: boolean) => any) | undefined;
}>, {
size: "1" | "2" | "3" | "4";
variant: "ghost" | "soft" | "surface";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare interface CollapsibleRootProps extends CollapsibleRootProps_2 {
    color?: ColorType;
    radius?: RadiusType;
    variant?: 'ghost' | 'soft' | 'surface';
    size?: '1' | '2' | '3' | '4';
}

export declare const CollapsibleTrigger: __VLS_WithTemplateSlots_48<DefineComponent<CollapsibleTriggerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<CollapsibleTriggerProps> & Readonly<{}>, {
indicator: "none" | "left" | "right";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare interface CollapsibleTriggerProps extends CollapsibleTriggerProps_2 {
    indicator?: 'none' | 'left' | 'right';
}

export declare const ColorField: DefineComponent<    {
modelValue?: string;
} & ColorFieldProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: string) => any;
}, string, PublicProps, Readonly<{
modelValue?: string;
} & ColorFieldProps> & Readonly<{
"onUpdate:modelValue"?: ((value: string) => any) | undefined;
}>, {
as: AsTag | Component;
size: "1" | "2" | "3";
variant: "solid" | "ring";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare interface ColorFieldProps extends Omit<PrimitiveProps, 'asChild'> {
    id?: string;
    variant?: 'solid' | 'ring';
    size?: '1' | '2' | '3';
    radius?: RadiusType;
    defaultValue?: string;
}

export declare type ColorType = 'gray' | 'gold' | 'bronze' | 'brown' | 'yellow' | 'amber' | 'orange' | 'tomato' | 'red' | 'ruby' | 'crimson' | 'pink' | 'plum' | 'purple' | 'violet' | 'iris' | 'indigo' | 'blue' | 'cyan' | 'teal' | 'jade' | 'green' | 'grass' | 'lime' | 'mint' | 'sky';

export declare const ComboboxContent: __VLS_WithTemplateSlots_31<DefineComponent<ComboboxContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
escapeKeyDown: (event: KeyboardEvent) => any;
pointerDownOutside: (event: PointerDownOutsideEvent) => any;
focusOutside: (event: FocusOutsideEvent) => any;
interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
}, string, PublicProps, Readonly<ComboboxContentProps> & Readonly<{
onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
}>, {
variant: "solid" | "soft";
sideOffset: number;
position: "inline" | "popper";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

declare interface ComboboxContentProps extends ComboboxContentProps_2 {
    variant?: 'solid' | 'soft';
}

export declare const ComboboxEmpty: __VLS_WithTemplateSlots_34<typeof __VLS_component_3, __VLS_TemplateResult_3["slots"]>;

export { ComboboxGroup }

export declare const ComboboxInput: __VLS_WithTemplateSlots_30<DefineComponent<ComboboxInputProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (args_0: string) => any;
}, string, PublicProps, Readonly<ComboboxInputProps> & Readonly<{
"onUpdate:modelValue"?: ((args_0: string) => any) | undefined;
}>, {
variant: "surface" | "soft";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    item?(_: {
        value: AcceptableInputValue;
    }): any;
}>;

declare interface ComboboxInputProps extends ComboboxInputProps_2 {
    variant?: 'surface' | 'soft';
    radius?: RadiusType;
    placeholder?: string;
}

export declare const ComboboxItem: __VLS_WithTemplateSlots_32<typeof __VLS_component_2, __VLS_TemplateResult_2["slots"]>;

export declare const ComboboxLabel: __VLS_WithTemplateSlots_33<DefineComponent<ComboboxLabelProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ComboboxLabelProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare const ComboboxRoot: __VLS_WithTemplateSlots_29<DefineComponent<ComboboxRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (value: boolean) => any;
"update:modelValue": (value: AcceptableValue) => any;
highlight: (payload: {
ref: HTMLElement;
value: AcceptableValue;
} | undefined) => any;
}, string, PublicProps, Readonly<ComboboxRootProps> & Readonly<{
"onUpdate:open"?: ((value: boolean) => any) | undefined;
"onUpdate:modelValue"?: ((value: AcceptableValue) => any) | undefined;
onHighlight?: ((payload: {
ref: HTMLElement;
value: AcceptableValue;
} | undefined) => any) | undefined;
}>, {
size: "1" | "2" | "3";
multiple: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare interface ComboboxRootProps extends ComboboxRootProps_2 {
    size?: '1' | '2' | '3';
    color?: ColorType;
    highContrast?: boolean;
}

declare const _default: DefineComponent<DialogCloseButtonProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<DialogCloseButtonProps> & Readonly<{}>, {
as: AsTag | Component;
size: "1" | "2" | "3" | "4";
variant: "classic" | "solid" | "soft" | "surface" | "outline" | "ghost";
color: ColorType;
highContrast: boolean;
tooltip: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
export { _default as AlertDialogCancelButton }
export { _default as DialogCloseButton }

declare const _default_2: __VLS_WithTemplateSlots_7<DefineComponent<PrimitiveProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PrimitiveProps> & Readonly<{}>, {
as: AsTag | Component;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;
export { _default_2 as AlertDialogTitle }
export { _default_2 as DialogTitle }

declare const _default_3: __VLS_WithTemplateSlots_8<DefineComponent<PrimitiveProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PrimitiveProps> & Readonly<{}>, {
as: AsTag | Component;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;
export { _default_3 as AlertDialogDescription }
export { _default_3 as DialogDescription }

export { DialogClose }

declare interface DialogCloseButtonProps extends ButtonProps {
    tooltip?: string;
}
export { DialogCloseButtonProps as AlertDialogCloseButtonProps }
export { DialogCloseButtonProps }

export { DialogCloseProps }

export declare const DialogPopup: __VLS_WithTemplateSlots_9<DefineComponent<DialogPopupProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
escapeKeyDown: (event: KeyboardEvent) => any;
pointerDownOutside: (event: PointerDownOutsideEvent) => any;
focusOutside: (event: FocusOutsideEvent) => any;
interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
openAutoFocus: (event: Event) => any;
closeAutoFocus: (event: Event) => any;
}, string, PublicProps, Readonly<DialogPopupProps> & Readonly<{
onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
onOpenAutoFocus?: ((event: Event) => any) | undefined;
onCloseAutoFocus?: ((event: Event) => any) | undefined;
}>, {
size: "1" | "2" | "3" | "4" | "5";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare interface DialogPopupProps extends DialogContentProps {
    /**
     * Control size of the dialog. It will affect the padding and border-radius.
     * @default "1"
     */
    size?: '1' | '2' | '3' | '4' | '5';
}

export { DialogRoot }

export { DialogRootProps }

export { DialogTrigger }

export { DialogTriggerProps }

export declare const DropdownMenuContent: __VLS_WithTemplateSlots_11<DefineComponent<DropdownMenuContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
escapeKeyDown: (event: KeyboardEvent) => any;
pointerDownOutside: (event: PointerDownOutsideEvent) => any;
focusOutside: (event: FocusOutsideEvent) => any;
interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
openAutoFocus: (event: Event) => any;
closeAutoFocus: (event: Event) => any;
}, string, PublicProps, Readonly<DropdownMenuContentProps> & Readonly<{
onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
onOpenAutoFocus?: ((event: Event) => any) | undefined;
onCloseAutoFocus?: ((event: Event) => any) | undefined;
}>, {
size: "1" | "2";
variant: "solid" | "soft";
sideOffset: number;
align: "start" | "center" | "end";
collisionPadding: number | Partial<Record<"top" | "right" | "bottom" | "left", number>>;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare interface DropdownMenuContentProps extends DropdownMenuContentProps_2 {
    size?: '1' | '2';
    variant?: 'solid' | 'soft';
    color?: ColorType;
    highContrast?: boolean;
}

export declare const DropdownMenuItem: __VLS_WithTemplateSlots_12<DefineComponent<DropdownMenuItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
select: (event: Event) => any;
}, string, PublicProps, Readonly<DropdownMenuItemProps> & Readonly<{
onSelect?: ((event: Event) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare interface DropdownMenuItemProps extends DropdownMenuItemProps_2 {
    color?: ColorType;
    shortcut?: string;
}

export { DropdownMenuRoot }

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

export { DropdownMenuTrigger }

export declare const Editable: DefineComponent<EditableProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
submit: (value: string | null | undefined) => any;
"update:modelValue": (value: string) => any;
"update:state": (state: "cancel" | "submit" | "edit") => any;
}, string, PublicProps, Readonly<EditableProps> & Readonly<{
onSubmit?: ((value: string | null | undefined) => any) | undefined;
"onUpdate:modelValue"?: ((value: string) => any) | undefined;
"onUpdate:state"?: ((state: "cancel" | "submit" | "edit") => any) | undefined;
}>, {
radius: RadiusType;
size: "1" | "2" | "3";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare interface EditableProps extends EditableRootProps {
    /**
     * Overrides the radius inherited from the theme.
     * @default "small"
     */
    radius?: RadiusType;
    /** Overrides the accent color inherited from the theme. */
    color?: ColorType;
    /**
     * Control the size of the padding and radius.
     * @default "1"
     */
    size?: '1' | '2' | '3';
}

declare type GrayColorType = 'auto' | 'mauve' | 'olive' | 'sage' | 'sand' | 'slate';

export declare const IconButton: __VLS_WithTemplateSlots_5<DefineComponent<ButtonProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ButtonProps> & Readonly<{}>, {
as: AsTag | Component;
size: "1" | "2" | "3" | "4";
variant: "classic" | "solid" | "soft" | "surface" | "outline" | "ghost";
highContrast: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare type IconButtonProps = ButtonProps;

export declare const injectThemeContext: <T extends ThemeProviderContext | null | undefined = ThemeProviderContext>(fallback?: T | undefined) => T extends null ? ThemeProviderContext | null : ThemeProviderContext;

export declare type Message = string | {
    title: string;
    duration?: number;
    type?: 'foreground' | 'background';
    description?: string;
    action?: MessageAction;
};

declare interface MessageAction {
    label: string;
    altText?: string;
    variant?: 'solid' | 'soft' | 'surface' | 'outline' | 'ghost';
    color?: ColorType;
    radius?: RadiusType;
    size?: '1' | '2' | '3' | '4';
    onClick: () => void;
}

declare type MessageCategory = 'success' | 'info' | 'warning' | 'error' | 'loading';

export declare const NavigationMenuContent: __VLS_WithTemplateSlots_18<DefineComponent<NavigationMenuContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
escapeKeyDown: (event: KeyboardEvent) => any;
pointerDownOutside: (event: PointerDownOutsideEvent) => any;
focusOutside: (event: FocusOutsideEvent) => any;
interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
}, string, PublicProps, Readonly<NavigationMenuContentProps> & Readonly<{
onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export { NavigationMenuItem }

export declare const NavigationMenuLink: __VLS_WithTemplateSlots_15<DefineComponent<NavigationMenuLinkProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
select: (payload: CustomEvent<{
originalEvent: Event;
}>) => any;
}, string, PublicProps, Readonly<NavigationMenuLinkProps> & Readonly<{
onSelect?: ((payload: CustomEvent<{
originalEvent: Event;
}>) => any) | undefined;
}>, {
size: "1" | "2" | "3";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare interface NavigationMenuLinkProps extends NavigationMenuLinkProps_2 {
    /** Overrides the accent color inherited from the ThemeProvider. */
    color?: ColorType;
    /** Control the size of the component. */
    size?: '1' | '2' | '3';
    /** Overrides the radius inherited from the ThemeProvider. */
    radius?: RadiusType;
}

export declare const NavigationMenuList: __VLS_WithTemplateSlots_17<DefineComponent<NavigationMenuListProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<NavigationMenuListProps> & Readonly<{}>, {
size: "1" | "2" | "3";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare interface NavigationMenuListProps extends NavigationMenuListProps_2 {
    /** Overrides the accent color inherited from the ThemeProvider. */
    color?: ColorType;
    /**
     * Control the size of the button.
     * @default "2"
     */
    size?: '1' | '2' | '3';
    /** Overrides the radius inherited from the ThemeProvider. */
    radius?: RadiusType;
}

export declare const NavigationMenuRoot: __VLS_WithTemplateSlots_14<DefineComponent<NavigationMenuRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: string) => any;
}, string, PublicProps, Readonly<NavigationMenuRootProps> & Readonly<{
"onUpdate:modelValue"?: ((value: string) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare const NavigationMenuTrigger: __VLS_WithTemplateSlots_16<DefineComponent<NavigationMenuTriggerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<NavigationMenuTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare interface NavigationMenuTriggerProps extends NavigationMenuTriggerProps_2 {
    /** Overrides the accent color inherited from the ThemeProvider. */
    color?: ColorType;
    /** Control the size of the component. */
    size?: '1' | '2' | '3';
    /** Overrides the radius inherited from the ThemeProvider. */
    radius?: RadiusType;
}

export declare const Pagination: DefineComponent<PaginationProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:page": (value: number) => any;
}, string, PublicProps, Readonly<PaginationProps> & Readonly<{
"onUpdate:page"?: ((value: number) => any) | undefined;
}>, {
size: "1" | "2" | "3" | "4";
variant: "soft" | "surface" | "outline" | "ghost";
color: ColorType;
navigation: "none" | "prev-next" | "first-last" | "all";
itemsPerPage: number;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare interface PaginationProps extends PaginationRootProps {
    color?: ColorType;
    size?: '1' | '2' | '3' | '4';
    variant?: 'soft' | 'surface' | 'outline' | 'ghost';
    navigation?: 'none' | 'prev-next' | 'first-last' | 'all';
}

export { PopoverClose }

export declare const PopoverPopup: __VLS_WithTemplateSlots_13<DefineComponent<PopoverPopupProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
escapeKeyDown: (event: KeyboardEvent) => any;
pointerDownOutside: (event: PointerDownOutsideEvent) => any;
focusOutside: (event: FocusOutsideEvent) => any;
interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
openAutoFocus: (event: Event) => any;
closeAutoFocus: (event: Event) => any;
}, string, PublicProps, Readonly<PopoverPopupProps> & Readonly<{
onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
onOpenAutoFocus?: ((event: Event) => any) | undefined;
onCloseAutoFocus?: ((event: Event) => any) | undefined;
}>, {
size: "1" | "2";
side: "top" | "right" | "bottom" | "left";
sideOffset: number;
align: "start" | "center" | "end";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare interface PopoverPopupProps extends PopoverContentProps {
    size?: '1' | '2';
}

export { PopoverRoot }

export { PopoverTrigger }

declare interface PromiseMessageOption<T> {
    loading: string;
    success: (data: T) => Message;
    error?: (err: Error) => Message;
}

export declare const provideThemeContext: (contextValue: ThemeProviderContext) => ThemeProviderContext;

export declare const Quota: DefineComponent<QuotaProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<QuotaProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare interface QuotaProps {
    percent: number;
    color?: ColorType;
}

export declare const Radio: DefineComponent<    {
modelValue?: any;
} & RadioProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: any) => any;
}, string, PublicProps, Readonly<{
modelValue?: any;
} & RadioProps> & Readonly<{
"onUpdate:modelValue"?: ((value: any) => any) | undefined;
}>, {
size: "1" | "2" | "3";
variant: "surface" | "soft";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLInputElement>;

export declare const RadioCardsItem: __VLS_WithTemplateSlots_38<DefineComponent<RadioGroupItemProps_2, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<RadioGroupItemProps_2> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare const RadioCardsRoot: __VLS_WithTemplateSlots_37<DefineComponent<RadioCardsRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (payload: string) => any;
}, string, PublicProps, Readonly<RadioCardsRootProps> & Readonly<{
"onUpdate:modelValue"?: ((payload: string) => any) | undefined;
}>, {
size: "1" | "2" | "3";
variant: "surface" | "classic";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare interface RadioCardsRootProps extends RadioGroupRootProps_2 {
    /**
     * The visual variant of the radio group.
     * @default "surface"
     */
    variant?: 'surface' | 'classic';
    /**
     * Control the size of the radio group.
     * @default "2"
     */
    size?: '1' | '2' | '3';
    /** Overrides the accent color inherited from the ThemeProvider. */
    color?: ColorType;
    /** Uses a higher contrast color for the component. */
    highContrast?: boolean;
}

export declare const RadioGroupItem: __VLS_WithTemplateSlots_36<DefineComponent<RadioGroupItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<RadioGroupItemProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLLabelElement>, {
    default?(_: {}): any;
}>;

export declare interface RadioGroupItemProps extends RadioGroupItemProps_2 {
    /** Overrides the accent color inherited from the RadioGroupRoot. */
    color?: ColorType;
    /** Overrides the size inherited from the RadioGroupRoot. */
    size?: '1' | '2' | '3';
    /** Overrides the variant inherited from the RadioGroupRoot. */
    variant?: 'surface' | 'soft';
    /** Overrides the highContrast prop inherited from the RadioGroupRoot. */
    highContrast?: boolean;
}

export declare const RadioGroupRoot: __VLS_WithTemplateSlots_35<DefineComponent<RadioGroupRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (payload: string) => any;
}, string, PublicProps, Readonly<RadioGroupRootProps> & Readonly<{
"onUpdate:modelValue"?: ((payload: string) => any) | undefined;
}>, {
size: "1" | "2" | "3";
variant: "surface" | "soft";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare interface RadioGroupRootProps extends RadioGroupRootProps_2 {
    /**
     * The visual variant of the radio group.
     * @default "surface"
     */
    variant?: 'surface' | 'soft';
    /**
     * Control the size of the radio group.
     * @default "2"
     */
    size?: '1' | '2' | '3';
    /** Overrides the accent color inherited from the ThemeProvider. */
    color?: ColorType;
    /** Uses a higher contrast color for the component. */
    highContrast?: boolean;
}

export declare interface RadioProps {
    /**
     * The visual variant to apply.
     * @default "surface"
     */
    variant?: 'surface' | 'soft';
    /** Overrides the accent color inherited from the Theme. */
    color?: ColorType;
    /**
     * Control the size of the radio.
     * @default "2"
     */
    size?: '1' | '2' | '3';
    /** Uses a higher contrast color for the component. */
    highContrast?: boolean;
}

export declare const RadioTabsItem: __VLS_WithTemplateSlots_40<DefineComponent<RadioGroupItemProps_2, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<RadioGroupItemProps_2> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare type RadioTabsItemProps = RadioGroupItemProps_2;

export declare const RadioTabsRoot: __VLS_WithTemplateSlots_39<DefineComponent<RadioTabsRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (payload: string) => any;
}, string, PublicProps, Readonly<RadioTabsRootProps> & Readonly<{
"onUpdate:modelValue"?: ((payload: string) => any) | undefined;
}>, {
size: "1" | "2";
variant: "classic" | "surface" | "soft";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare interface RadioTabsRootProps extends RadioGroupRootProps_2 {
    /**
     * The visual variant of the radio tabs.
     * @default "classic"
     */
    variant?: 'classic' | 'surface' | 'soft';
    /**
     * Control the size of the radio tabs.
     * @default "2"
     */
    size?: '1' | '2';
    /** Overrides the accent color inherited from the ThemeProvider. */
    color?: ColorType;
    /** Overrides the radius inherited from the ThemeProvider. */
    radius?: RadiusType;
}

export declare type RadiusType = 'none' | 'small' | 'medium' | 'large' | 'full';

export declare const SavingIndicator: __VLS_WithTemplateSlots_53<DefineComponent<SavingIndicatorProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SavingIndicatorProps> & Readonly<{}>, {
as: AsTag | Component;
size: "1" | "2" | "3";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {
        status: SavingStatus;
    }): any;
}>;

export declare interface SavingIndicatorProps extends Omit<PrimitiveProps, 'asChild'> {
    status: SavingStatus;
    size?: '1' | '2' | '3';
}

export declare type SavingStatus = 'idle' | 'saving' | 'saved';

declare type ScalingType = '90%' | '95%' | '100%' | '105%' | '110%' | '115%' | '120%';

export declare const ScrollArea: __VLS_WithTemplateSlots_6<DefineComponent<ScrollAreaProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ScrollAreaProps> & Readonly<{}>, {
type: "auto" | "scroll" | "always" | "hover";
size: "1" | "2" | "3";
scrollbars: "vertical" | "horizontal" | "both";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare interface ScrollAreaProps extends ScrollAreaRootProps {
    size?: '1' | '2' | '3';
    radius?: RadiusType;
    scrollbars?: 'vertical' | 'horizontal' | 'both';
}

export declare const SelectContent: __VLS_WithTemplateSlots_25<DefineComponent<SelectContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SelectContentProps> & Readonly<{}>, {
variant: "solid" | "soft";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare interface SelectContentProps extends SelectContentProps_2 {
    variant?: 'solid' | 'soft';
}

export { SelectGroup }

export declare const SelectItem: __VLS_WithTemplateSlots_27<DefineComponent<SelectItemProps<AcceptableValue>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SelectItemProps<AcceptableValue>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export { SelectItemProps }

export declare const SelectLabel: __VLS_WithTemplateSlots_28<DefineComponent<SelectLabelProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SelectLabelProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export { SelectLabelProps }

export declare const SelectRoot: __VLS_WithTemplateSlots_24<DefineComponent<SelectRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (value: boolean) => any;
"update:modelValue": (value: AcceptableValue) => any;
}, string, PublicProps, Readonly<SelectRootProps> & Readonly<{
"onUpdate:open"?: ((value: boolean) => any) | undefined;
"onUpdate:modelValue"?: ((value: AcceptableValue) => any) | undefined;
}>, {
size: "1" | "2" | "3";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare interface SelectRootProps extends SelectRootProps_2 {
    size?: '1' | '2' | '3';
    color?: ColorType;
    highContrast?: boolean;
}

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

export declare const SelectTrigger: __VLS_WithTemplateSlots_26<DefineComponent<SelectTriggerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SelectTriggerProps> & Readonly<{}>, {
variant: "surface" | "soft" | "ghost";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {
        selectedLabel: string[];
        modelValue: AcceptableValue | AcceptableValue[] | undefined;
    }): any;
}>;

export declare interface SelectTriggerProps extends SelectTriggerProps_2 {
    variant?: 'surface' | 'soft' | 'ghost';
    radius?: RadiusType;
    placeholder?: string;
}

export declare const Separator: DefineComponent<SeparatorProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SeparatorProps> & Readonly<{}>, {
as: "span" | "div";
size: "1" | "2" | "3" | "4";
color: ColorType;
orientation: "horizontal" | "vertical";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare interface SeparatorProps {
    /**
     * The element this separator should render as.
     * @default "span"
     */
    as?: 'span' | 'div';
    /**
     * Control the orientation of the separator.
     * @default "horizontal"
     */
    orientation?: 'horizontal' | 'vertical';
    /**
     * Control the size of the separator.
     * @default "1"
     */
    size?: '1' | '2' | '3' | '4';
    /**
     * Overrides the color of the separator.
     * @default "gray"
     */
    color?: ColorType;
}

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

export declare const Switch: __VLS_WithTemplateSlots_19<DefineComponent<SwitchProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (payload: boolean) => any;
}, string, PublicProps, Readonly<SwitchProps> & Readonly<{
"onUpdate:modelValue"?: ((payload: boolean) => any) | undefined;
}>, {
size: "1" | "2" | "3";
variant: "surface" | "soft";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare interface SwitchProps extends SwitchRootProps {
    color?: ColorType;
    variant?: 'surface' | 'soft';
    size?: '1' | '2' | '3';
    highContrast?: boolean;
    radius?: RadiusType;
}

export declare const Table: __VLS_WithTemplateSlots_51<DefineComponent<TableProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<TableProps> & Readonly<{}>, {
size: "1" | "2" | "3";
variant: "surface" | "ghost";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>, {
    default?(_: {}): any;
}>;

export declare interface TableProps {
    size?: '1' | '2' | '3';
    variant?: 'surface' | 'ghost';
    layout?: 'auto' | 'fixed';
}

export { TabsContent }

export declare const TabsList: __VLS_WithTemplateSlots_41<DefineComponent<TabsListProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<TabsListProps> & Readonly<{}>, {
size: "1" | "2";
variant: "classic" | "outline" | "surface" | "soft";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare interface TabsListProps {
    size?: '1' | '2';
    radius?: RadiusType;
    color?: ColorType;
    variant?: 'classic' | 'outline' | 'surface' | 'soft';
    highContrast?: boolean;
}

export { TabsRoot }

export declare const TabsTrigger: __VLS_WithTemplateSlots_42<typeof __VLS_component_4, __VLS_TemplateResult_4["slots"]>;

export declare const TextArea: DefineComponent<    {
modelValue?: string;
} & TextAreaProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: string) => any;
}, string, PublicProps, Readonly<{
modelValue?: string;
} & TextAreaProps> & Readonly<{
"onUpdate:modelValue"?: ((value: string) => any) | undefined;
}>, {
size: "1" | "2" | "3";
variant: "surface" | "soft";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare interface TextAreaProps {
    class?: string;
    size?: '1' | '2' | '3';
    variant?: 'surface' | 'soft';
    resize?: 'none' | 'vertical' | 'horizontal' | 'both';
    color?: ColorType;
    radius?: RadiusType;
}

export declare const TextField: __VLS_WithTemplateSlots_23<DefineComponent<    {
modelValue?: any;
} & TextFieldProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: any) => any;
}, string, PublicProps, Readonly<{
modelValue?: any;
} & TextFieldProps> & Readonly<{
"onUpdate:modelValue"?: ((value: any) => any) | undefined;
}>, {
type: "date" | "datetime-local" | "email" | "hidden" | "month" | "number" | "password" | "search" | "tel" | "text" | "time" | "url" | "week" | "file";
size: "1" | "2" | "3";
variant: "surface" | "soft";
}, {}, {}, {}, string, ComponentProvideOptions, false, {
input: HTMLInputElement;
}, any>, {
    left?(_: {}): any;
    right?(_: {}): any;
}>;

export declare interface TextFieldProps {
    id?: string;
    class?: string;
    size?: '1' | '2' | '3';
    variant?: 'surface' | 'soft';
    color?: ColorType;
    radius?: RadiusType;
    type?: 'date' | 'datetime-local' | 'email' | 'hidden' | 'month' | 'number' | 'password' | 'search' | 'tel' | 'text' | 'time' | 'url' | 'week' | 'file';
}

export declare const ThemeProvider: __VLS_WithTemplateSlots<DefineComponent<ThemeProviderProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ThemeProviderProps> & Readonly<{}>, {
accentColor: ColorType;
radius: RadiusType;
grayColor: GrayColorType;
scaling: ScalingType;
panelBackground: "solid" | "translucent";
hasBackground: boolean;
as: AsTag | Component;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

declare interface ThemeProviderContext {
    accentColor: Ref<ColorType>;
    radius: Ref<RadiusType>;
    grayColor: Ref<GrayColorType>;
    scaling: Ref<ScalingType>;
    panelBackground: Ref<'solid' | 'translucent'>;
    hasBackground: Ref<boolean>;
}

export declare interface ThemeProviderProps extends PrimitiveProps {
    accentColor?: ColorType;
    radius?: RadiusType;
    grayColor?: GrayColorType;
    scaling?: ScalingType;
    panelBackground?: 'solid' | 'translucent';
    hasBackground?: boolean;
}

export declare const toast: ToastFunction;

declare type ToastFunction = {
    (message: Message): number;
    info: (message: Message) => number;
    success: (message: Message) => number;
    warning: (message: Message) => number;
    error: (message: Message) => number;
    promise: <T>(fn: () => Promise<T>, options: PromiseMessageOption<T>) => number;
};

export declare interface ToastMessage {
    id: number;
    category?: MessageCategory;
    title: string;
    height?: number;
    type?: 'foreground' | 'background';
    duration?: number;
    description?: string;
    action?: MessageAction;
}

export declare const ToastProvider: __VLS_WithTemplateSlots_50<DefineComponent<ToastProviderProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ToastProviderProps> & Readonly<{}>, {
size: "1" | "2" | "3";
position: "top-left" | "top-right" | "top-center" | "bottom-left" | "bottom-right" | "bottom-center";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
    item?(_: {
        key: number;
        message: {
            id: number;
            category?: MessageCategory | undefined;
            title: string;
            height?: number | undefined;
            type?: "foreground" | "background" | undefined;
            duration?: number | undefined;
            description?: string | undefined;
            action?: {
                label: string;
                altText?: string | undefined;
                variant?: "solid" | "soft" | "surface" | "outline" | "ghost" | undefined;
                color?: ColorType | undefined;
                radius?: RadiusType | undefined;
                size?: "1" | "2" | "3" | "4" | undefined;
                onClick: () => void;
            } | undefined;
        };
        index: number;
    }): any;
}>;

export declare interface ToastProviderProps extends ToastProviderProps_2 {
    size?: '1' | '2' | '3';
    position?: 'top-left' | 'top-right' | 'top-center' | 'bottom-left' | 'bottom-right' | 'bottom-center';
}

export declare const Toggle: __VLS_WithTemplateSlots_20<DefineComponent<ToggleProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: boolean) => any;
}, string, PublicProps, Readonly<ToggleProps> & Readonly<{
"onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
}>, {
size: "1" | "2" | "3";
variant: "solid" | "soft" | "ghost";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare const ToggleGroupItem: __VLS_WithTemplateSlots_22<typeof __VLS_component, __VLS_TemplateResult["slots"]>;

export declare const ToggleGroupRoot: __VLS_WithTemplateSlots_21<DefineComponent<ToggleGroupRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (payload: AcceptableValue | AcceptableValue[]) => any;
}, string, PublicProps, Readonly<ToggleGroupRootProps> & Readonly<{
"onUpdate:modelValue"?: ((payload: AcceptableValue | AcceptableValue[]) => any) | undefined;
}>, {
size: "1" | "2" | "3";
variant: "solid" | "soft" | "surface" | "outline" | "ghost";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
}>;

export declare interface ToggleGroupRootProps extends ToggleGroupRootProps_2 {
    /**
     * The visual variant to apply.
     * @default "solid"
     */
    variant?: 'solid' | 'soft' | 'surface' | 'outline' | 'ghost';
    /** Overrides the accent color inherited from the Theme. */
    color?: ColorType;
    /**
     * Control the size of the toggle.
     * @default "2"
     */
    size?: '1' | '2' | '3';
    /** Uses a higher contrast color for the component. */
    highContrast?: boolean;
    /** Overrides the radius inherited from the theme. */
    radius?: RadiusType;
}

export declare interface ToggleProps extends ToggleProps_2 {
    /**
     * The visual variant to apply.
     * @default "soft"
     */
    variant?: 'solid' | 'soft' | 'ghost';
    /** Overrides the accent color inherited from the Theme. */
    color?: ColorType;
    /** Overrides the radius inherited from the theme. */
    radius?: RadiusType;
    /**
     * Control the size of the toggle.
     * @default "2"
     */
    size?: '1' | '2' | '3';
    /** Uses a higher contrast color for the component. */
    highContrast?: boolean;
}

export declare const Tooltip: __VLS_WithTemplateSlots_52<DefineComponent<TooltipProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:open": (value: boolean) => any;
}, string, PublicProps, Readonly<TooltipProps> & Readonly<{
"onUpdate:open"?: ((value: boolean) => any) | undefined;
}>, {
color: ColorType;
side: "top" | "right" | "bottom" | "left";
sideOffset: number;
avoidCollisions: boolean;
collisionPadding: number | Partial<Record<"top" | "right" | "bottom" | "left", number>>;
maxWidth: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
    default?(_: {}): any;
    content?(_: {}): any;
}>;

export declare interface TooltipProps extends TooltipRootProps, TooltipContentProps {
    /** The content associated with the tooltip. */
    content?: string;
    /**
     * The max width of the tooltip popup.
     * @default "360px"
     */
    maxWidth?: string;
    /** Background color of the tooltip popup.
     * @default "gray"
     */
    color?: ColorType;
}

export declare function useForwardPropsEmitsWithout<T extends Record<string, any>, Name extends string>(props: MaybeRefOrGetter<T>, emit: (name: Name, ...args: any[]) => void, exclude: string[]): ComputedRef<T & Record<string, any>>;

export declare function useForwardPropsWithout<T extends Record<string, any>>(props: MaybeRefOrGetter<T>, exclude: string[]): ComputedRef<T>;

export { }