Saving all progress

node_modules/radix-vue/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Radix Vue <https://github.com/unovue/radix-vue>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/radix-vue/README.md

@@ -0,0 +1,89 @@
+<br />
+<p align="center">
+  <a href="https://github.com/unovue/radix-vue">
+    <img src="https://www.radix-vue.com/logo.svg" alt="Logo" width="150" />
+  </a>
+
+<h1 align="center">
+Radix Vue
+</h1>
+<p align="center">
+An unofficial Vue port of Radix UI. <br>
+Radix is an unstyled, customisable UI Library with built in accessibility for building top quality design systems.
+
+<p>
+
+<p align="center">
+<a href='https://github.com/unovue/radix-vue/actions/workflows/test.yml'>
+</a>
+<a href="https://www.npmjs.com/package/radix-vue" target="__blank"><img src="https://img.shields.io/npm/v/radix-vue?style=flat&colorA=002438&colorB=41c399" alt="NPM version"></a>
+<a href="https://www.npmjs.com/package/radix-vue" target="__blank"><img alt="NPM Downloads" src="https://img.shields.io/npm/dm/radix-vue?flat&colorA=002438&colorB=41c399"></a>
+<a href="https://github.com/unovue/radix-vue" target="__blank"><img alt="GitHub stars" src="https://img.shields.io/github/stars/unovue/radix-vue?flat&colorA=002438&colorB=41c399"></a>
+</p>
+
+<p align="center">
+<a href="https://chat.radix-vue.com"><b>Get involved!</b></a>
+</p>
+<p align="center">
+ <a href="https://radix-vue.com">Documentation</a> | <a href="https://www.radix-vue.com/overview/getting-started.html">Getting Started</a> | <a href="https://www.radix-vue.com/">Examples</a> | <a href="https://www.radix-vue.com/overview/introduction.html">Why Radix Vue?</a>
+</p>
+
+![hero image](https://www.radix-vue.com/og.jpg)
+ <em>design by: [icarusgkx](https://twitter.com/icarusgkx), [melkam](https://github.com/MellKam)</em>
+
+## Installation
+
+```bash
+pnpm add radix-vue
+```
+```bash
+npm install radix-vue
+```
+```bash
+yarn add radix-vue
+```
+
+## Documentation
+
+For full documentation, visit [radix-vue.com](https://radix-vue.com).
+
+## Releases
+
+For changelog, visit [releases](https://github.com/unovue/radix-vue/releases).
+
+## Contributing
+
+We would love to have your contributions! All PRs all welcomed! We need help building the core components, docs, tests, stories! Join our discord and we will get you up and running!
+
+## Dev Setup
+
+### Docs
+
+1. Clone the repo
+2. Run `pnpm i`
+3. Run `pnpm docs:dev` to run vitepress
+4. Open `http://localhost:5173`
+
+### Package
+
+1. Clone the repo
+2. Run `pnpm i`
+3. Run `pnpm story:dev` to run histoire (storybook)
+4. Open `http://localhost:6006`
+
+## Authors
+
+- [Khairul Haaziq](https://github.com/khairulhaaziq)
+- [Mujahid Anuar](https://github.com/mujahidfa)
+- [Zernonia](https://github.com/zernonia)
+
+## Credits
+
+All credits go to these open-source works and resources
+
+- [Radix UI](https://radix-ui.com) for doing all the hard work to make sure components are accessible
+- [Floating UI](https://floating-ui.com) for creating powerful components that as the base of many Radix Vue components
+- [VueUse](https://vueuse.org) for providing many useful utilities.
+- [Ark UI](https://ark-ui.com) for the `<Primitive>` component
+- [Radix Svelte](https://radix-svelte.com)
+- [Headless UI](https://headlessui.com)

node_modules/radix-vue/dist/Accordion/AccordionContent.d.ts

@@ -0,0 +1,21 @@
+import { CollapsibleContentProps } from '../Collapsible';
+export interface AccordionContentProps extends CollapsibleContentProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<AccordionContentProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<AccordionContentProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/Accordion/AccordionHeader.d.ts

@@ -0,0 +1,35 @@
+import { PrimitiveProps } from '../Primitive';
+export interface AccordionHeaderProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<AccordionHeaderProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<AccordionHeaderProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Accordion/AccordionItem.d.ts

@@ -0,0 +1,59 @@
+import { ComputedRef, VNodeRef } from 'vue';
+import { CollapsibleRootProps } from '../Collapsible';
+declare enum AccordionItemState {
+    Open = "open",
+    Closed = "closed"
+}
+export interface AccordionItemProps extends Omit<CollapsibleRootProps, 'open' | 'defaultOpen' | 'onOpenChange'> {
+    /**
+     * Whether or not an accordion item is disabled from user interaction.
+     * When `true`, prevents the user from interacting with the item.
+     *
+     * @defaultValue false
+     */
+    disabled?: boolean;
+    /**
+     * A string value for the accordion item. All items within an accordion should use a unique value.
+     */
+    value: string;
+}
+interface AccordionItemContext {
+    open: ComputedRef<boolean>;
+    dataState: ComputedRef<AccordionItemState>;
+    disabled: ComputedRef<boolean>;
+    dataDisabled: ComputedRef<'' | undefined>;
+    triggerId: string;
+    currentRef: VNodeRef;
+    currentElement: ComputedRef<HTMLElement | undefined>;
+    value: ComputedRef<string>;
+}
+export declare const injectAccordionItemContext: <T extends AccordionItemContext | null | undefined = AccordionItemContext>(fallback?: T | undefined) => T extends null ? AccordionItemContext | null : AccordionItemContext, provideAccordionItemContext: (contextValue: AccordionItemContext) => AccordionItemContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<AccordionItemProps>, {
+    open: ComputedRef<boolean>;
+    dataDisabled: ComputedRef<"" | undefined>;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<AccordionItemProps>>>, {}, {}>, Readonly<{
+    default: (props: {
+        /** Current open state */
+        open: boolean;
+    }) => any;
+}> & {
+    default: (props: {
+        /** Current open state */
+        open: boolean;
+    }) => any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/Accordion/AccordionRoot.d.ts

@@ -0,0 +1,135 @@
+import { ComputedRef, Ref } from 'vue';
+import { PrimitiveProps } from '../Primitive';
+import { DataOrientation, Direction, SingleOrMultipleProps, SingleOrMultipleType } from '../shared/types';
+export interface AccordionRootProps<ValidValue = string | string[], ExplicitType = SingleOrMultipleType> extends PrimitiveProps, SingleOrMultipleProps<ValidValue, ExplicitType> {
+    /**
+     * When type is "single", allows closing content when clicking trigger for an open item.
+     * When type is "multiple", this prop has no effect.
+     *
+     * @defaultValue false
+     */
+    collapsible?: boolean;
+    /**
+     * When `true`, prevents the user from interacting with the accordion and all its items
+     *
+     * @defaultValue false
+     */
+    disabled?: boolean;
+    /**
+     * The reading direction of the accordion when applicable. If omitted, assumes LTR (left-to-right) reading mode.
+     *
+     * @defaultValue "ltr"
+     */
+    dir?: Direction;
+    /**
+     * The orientation of the accordion.
+     *
+     * @defaultValue "vertical"
+     */
+    orientation?: DataOrientation;
+}
+export type AccordionRootEmits<T extends SingleOrMultipleType = SingleOrMultipleType> = {
+    /**
+     * Event handler called when the expanded state of an item changes
+     */
+    'update:modelValue': [value: (T extends 'single' ? string : string[]) | undefined];
+};
+export type AccordionRootContext<P extends AccordionRootProps> = {
+    disabled: Ref<P['disabled']>;
+    direction: Ref<P['dir']>;
+    orientation: P['orientation'];
+    parentElement: Ref<HTMLElement | undefined>;
+    changeModelValue: (value: string) => void;
+    isSingle: ComputedRef<boolean>;
+    modelValue: Ref<string | undefined | string[]>;
+    collapsible: boolean;
+};
+export declare const injectAccordionRootContext: <T extends AccordionRootContext<AccordionRootProps<string | string[], SingleOrMultipleType>> | null | undefined = AccordionRootContext<AccordionRootProps<string | string[], SingleOrMultipleType>>>(fallback?: T | undefined) => T extends null ? AccordionRootContext<AccordionRootProps<string | string[], SingleOrMultipleType>> | null : AccordionRootContext<AccordionRootProps<string | string[], SingleOrMultipleType>>, provideAccordionRootContext: (contextValue: AccordionRootContext<AccordionRootProps<string | string[], SingleOrMultipleType>>) => AccordionRootContext<AccordionRootProps<string | string[], SingleOrMultipleType>>;
+declare const _default: <ValidValue extends string | string[], ExplicitType extends SingleOrMultipleType>(__VLS_props: {
+    "onUpdate:modelValue"?: ((value: (ExplicitType extends "single" ? string : string[]) | undefined) => any) | undefined;
+    collapsible?: boolean | undefined;
+    disabled?: boolean | undefined;
+    dir?: Direction | undefined;
+    orientation?: DataOrientation | undefined;
+    asChild?: boolean | undefined;
+    as?: import('../Primitive').AsTag | import('vue').Component | undefined;
+    type?: (ValidValue extends string ? "single" : ValidValue extends string[] ? "multiple" : ExplicitType extends "single" ? "single" : ExplicitType extends "multiple" ? "multiple" : never) | undefined;
+    modelValue?: ValidValue | undefined;
+    defaultValue?: ValidValue | undefined;
+} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, __VLS_ctx?: {
+    slots: Readonly<{
+        default: (props: {
+            /** Current active value */
+            modelValue: string | string[] | undefined;
+        }) => any;
+    }> & {
+        default: (props: {
+            /** Current active value */
+            modelValue: string | string[] | undefined;
+        }) => any;
+    };
+    attrs: any;
+    emit: (evt: "update:modelValue", value: (ExplicitType extends "single" ? string : string[]) | undefined) => void;
+} | undefined, __VLS_expose?: ((exposed: import('vue').ShallowUnwrapRef<{}>) => void) | undefined, __VLS_setup?: Promise<{
+    props: {
+        "onUpdate:modelValue"?: ((value: (ExplicitType extends "single" ? string : string[]) | undefined) => any) | undefined;
+        collapsible?: boolean | undefined;
+        disabled?: boolean | undefined;
+        dir?: Direction | undefined;
+        orientation?: DataOrientation | undefined;
+        asChild?: boolean | undefined;
+        as?: import('../Primitive').AsTag | import('vue').Component | undefined;
+        type?: (ValidValue extends string ? "single" : ValidValue extends string[] ? "multiple" : ExplicitType extends "single" ? "single" : ExplicitType extends "multiple" ? "multiple" : never) | undefined;
+        modelValue?: ValidValue | undefined;
+        defaultValue?: ValidValue | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Readonly<{
+        default: (props: {
+            /** Current active value */
+            modelValue: string | string[] | undefined;
+        }) => any;
+    }> & {
+        default: (props: {
+            /** Current active value */
+            modelValue: string | string[] | undefined;
+        }) => any;
+    };
+    emit: (evt: "update:modelValue", value: (ExplicitType extends "single" ? string : string[]) | undefined) => void;
+}>) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> & {
+    __ctx?: {
+        props: {
+            "onUpdate:modelValue"?: ((value: (ExplicitType extends "single" ? string : string[]) | undefined) => any) | undefined;
+            collapsible?: boolean | undefined;
+            disabled?: boolean | undefined;
+            dir?: Direction | undefined;
+            orientation?: DataOrientation | undefined;
+            asChild?: boolean | undefined;
+            as?: import('../Primitive').AsTag | import('vue').Component | undefined;
+            type?: (ValidValue extends string ? "single" : ValidValue extends string[] ? "multiple" : ExplicitType extends "single" ? "single" : ExplicitType extends "multiple" ? "multiple" : never) | undefined;
+            modelValue?: ValidValue | undefined;
+            defaultValue?: ValidValue | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: Readonly<{
+            default: (props: {
+                /** Current active value */
+                modelValue: string | string[] | undefined;
+            }) => any;
+        }> & {
+            default: (props: {
+                /** Current active value */
+                modelValue: string | string[] | undefined;
+            }) => any;
+        };
+        emit: (evt: "update:modelValue", value: (ExplicitType extends "single" ? string : string[]) | undefined) => void;
+    } | undefined;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Accordion/AccordionTrigger.d.ts

@@ -0,0 +1,21 @@
+import { PrimitiveProps } from '../Primitive';
+export interface AccordionTriggerProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<AccordionTriggerProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<AccordionTriggerProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/Accordion/index.d.ts

@@ -0,0 +1,5 @@
+export { default as AccordionContent, type AccordionContentProps, } from './AccordionContent';
+export { default as AccordionHeader, type AccordionHeaderProps, } from './AccordionHeader';
+export { default as AccordionItem, type AccordionItemProps, } from './AccordionItem';
+export { default as AccordionRoot, type AccordionRootProps, type AccordionRootEmits, } from './AccordionRoot';
+export { default as AccordionTrigger, type AccordionTriggerProps, } from './AccordionTrigger';

node_modules/radix-vue/dist/AlertDialog/AlertDialogAction.d.ts

@@ -0,0 +1,35 @@
+import { DialogCloseProps } from '../Dialog';
+export interface AlertDialogActionProps extends DialogCloseProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<AlertDialogActionProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<AlertDialogActionProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/AlertDialog/AlertDialogCancel.d.ts

@@ -0,0 +1,35 @@
+import { DialogCloseProps } from '../Dialog';
+export interface AlertDialogCancelProps extends DialogCloseProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<AlertDialogCancelProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<AlertDialogCancelProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/AlertDialog/AlertDialogContent.d.ts

@@ -0,0 +1,40 @@
+import { DialogContentEmits, DialogContentProps } from '../Dialog';
+interface AlertDialogContentContext {
+    onCancelElementChange: (el: HTMLElement | undefined) => void;
+}
+export declare const injectAlertDialogContentContext: <T extends AlertDialogContentContext | null | undefined = AlertDialogContentContext>(fallback?: T | undefined) => T extends null ? AlertDialogContentContext | null : AlertDialogContentContext, provideAlertDialogContentContext: (contextValue: AlertDialogContentContext) => AlertDialogContentContext;
+export type AlertDialogContentEmits = DialogContentEmits;
+export interface AlertDialogContentProps extends DialogContentProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<AlertDialogContentProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => void;
+    pointerDownOutside: (event: import('../DismissableLayer').PointerDownOutsideEvent) => void;
+    focusOutside: (event: import('../DismissableLayer').FocusOutsideEvent) => void;
+    interactOutside: (event: import('../DismissableLayer').PointerDownOutsideEvent | import('../DismissableLayer').FocusOutsideEvent) => void;
+    openAutoFocus: (event: Event) => void;
+    closeAutoFocus: (event: Event) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<AlertDialogContentProps>>> & {
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: import('../DismissableLayer').PointerDownOutsideEvent) => any) | undefined;
+    onFocusOutside?: ((event: import('../DismissableLayer').FocusOutsideEvent) => any) | undefined;
+    onInteractOutside?: ((event: import('../DismissableLayer').PointerDownOutsideEvent | import('../DismissableLayer').FocusOutsideEvent) => any) | undefined;
+    onOpenAutoFocus?: ((event: Event) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/AlertDialog/AlertDialogDescription.d.ts

@@ -0,0 +1,35 @@
+import { DialogDescriptionProps } from '../Dialog';
+export interface AlertDialogDescriptionProps extends DialogDescriptionProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<AlertDialogDescriptionProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<AlertDialogDescriptionProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/AlertDialog/AlertDialogOverlay.d.ts

@@ -0,0 +1,21 @@
+import { DialogOverlayProps } from '../Dialog';
+export interface AlertDialogOverlayProps extends DialogOverlayProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<AlertDialogOverlayProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<AlertDialogOverlayProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/AlertDialog/AlertDialogPortal.d.ts

@@ -0,0 +1,21 @@
+import { TeleportProps } from '../Teleport';
+export interface AlertDialogPortalProps extends TeleportProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<AlertDialogPortalProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<AlertDialogPortalProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/AlertDialog/AlertDialogRoot.d.ts

@@ -0,0 +1,26 @@
+import { DialogRootEmits, DialogRootProps } from '../Dialog';
+export type AlertDialogEmits = DialogRootEmits;
+export interface AlertDialogProps extends Omit<DialogRootProps, 'modal'> {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<AlertDialogProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (value: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<AlertDialogProps>>> & {
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/AlertDialog/AlertDialogTitle.d.ts

@@ -0,0 +1,35 @@
+import { DialogTitleProps } from '../Dialog';
+export interface AlertDialogTitleProps extends DialogTitleProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<AlertDialogTitleProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<AlertDialogTitleProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/AlertDialog/AlertDialogTrigger.d.ts

@@ -0,0 +1,35 @@
+import { DialogTriggerProps } from '../Dialog';
+export interface AlertDialogTriggerProps extends DialogTriggerProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<AlertDialogTriggerProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<AlertDialogTriggerProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/AlertDialog/index.d.ts

@@ -0,0 +1,9 @@
+export { default as AlertDialogRoot, type AlertDialogProps, type AlertDialogEmits, } from './AlertDialogRoot';
+export { default as AlertDialogTrigger, type AlertDialogTriggerProps, } from './AlertDialogTrigger';
+export { default as AlertDialogPortal, type AlertDialogPortalProps, } from './AlertDialogPortal';
+export { default as AlertDialogContent, type AlertDialogContentProps, type AlertDialogContentEmits, } from './AlertDialogContent';
+export { default as AlertDialogOverlay, type AlertDialogOverlayProps, } from './AlertDialogOverlay';
+export { default as AlertDialogCancel, type AlertDialogCancelProps, } from './AlertDialogCancel';
+export { default as AlertDialogTitle, type AlertDialogTitleProps, } from './AlertDialogTitle';
+export { default as AlertDialogDescription, type AlertDialogDescriptionProps, } from './AlertDialogDescription';
+export { default as AlertDialogAction, type AlertDialogActionProps, } from './AlertDialogAction';

node_modules/radix-vue/dist/AspectRatio/AspectRatio.d.ts

@@ -0,0 +1,48 @@
+import { PrimitiveProps } from '../Primitive';
+export interface AspectRatioProps extends PrimitiveProps {
+    /**
+     * The desired ratio. Eg: 16/9
+     * @defaultValue 1
+     */
+    ratio?: number;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<AspectRatioProps>, {
+    ratio: number;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<AspectRatioProps>, {
+    ratio: number;
+}>>>, {
+    ratio: number;
+}, {}>, Readonly<{
+    default: (props: {
+        /** Current aspect ratio (in %) */
+        aspect: number;
+    }) => any;
+}> & {
+    default: (props: {
+        /** Current aspect ratio (in %) */
+        aspect: number;
+    }) => any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/AspectRatio/index.d.ts

@@ -0,0 +1 @@
+export { default as AspectRatio, type AspectRatioProps, } from './AspectRatio';

node_modules/radix-vue/dist/Avatar/AvatarFallback.d.ts

@@ -0,0 +1,40 @@
+import { PrimitiveProps } from '../Primitive';
+export interface AvatarFallbackProps extends PrimitiveProps {
+    /** Useful for delaying rendering so it only appears for those with slower connections. */
+    delayMs?: number;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<AvatarFallbackProps>, {
+    delayMs: number;
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<AvatarFallbackProps>, {
+    delayMs: number;
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+    delayMs: number;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Avatar/AvatarImage.d.ts

@@ -0,0 +1,50 @@
+import { ImgHTMLAttributes } from 'vue';
+import { PrimitiveProps } from '../Primitive';
+import { ImageLoadingStatus } from './utils';
+export type AvatarImageEmits = {
+    /**
+     * A callback providing information about the loading status of the image. <br>
+     * This is useful in case you want to control more precisely what to render as the image is loading.
+     */
+    loadingStatusChange: [value: ImageLoadingStatus];
+};
+export interface AvatarImageProps extends PrimitiveProps {
+    src: string;
+    referrerPolicy?: ImgHTMLAttributes['referrerpolicy'];
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<AvatarImageProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    loadingStatusChange: (value: ImageLoadingStatus) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<AvatarImageProps>, {
+    as: string;
+}>>> & {
+    onLoadingStatusChange?: ((value: ImageLoadingStatus) => any) | undefined;
+}, {
+    as: import('../Primitive/Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Avatar/AvatarRoot.d.ts

@@ -0,0 +1,41 @@
+import { Ref } from 'vue';
+import { PrimitiveProps } from '../Primitive';
+import { ImageLoadingStatus } from './utils';
+export interface AvatarRootProps extends PrimitiveProps {
+}
+export type AvatarRootContext = {
+    imageLoadingStatus: Ref<ImageLoadingStatus>;
+};
+export declare const injectAvatarRootContext: <T extends AvatarRootContext | null | undefined = AvatarRootContext>(fallback?: T | undefined) => T extends null ? AvatarRootContext | null : AvatarRootContext, provideAvatarRootContext: (contextValue: AvatarRootContext) => AvatarRootContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<AvatarRootProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<AvatarRootProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Avatar/index.d.ts

@@ -0,0 +1,3 @@
+export { default as AvatarRoot, type AvatarRootProps } from './AvatarRoot';
+export { default as AvatarImage, type AvatarImageProps, type AvatarImageEmits, } from './AvatarImage';
+export { default as AvatarFallback, type AvatarFallbackProps, } from './AvatarFallback';

node_modules/radix-vue/dist/Avatar/utils.d.ts

@@ -0,0 +1,3 @@
+import { ImgHTMLAttributes, Ref } from 'vue';
+export type ImageLoadingStatus = 'idle' | 'loading' | 'loaded' | 'error';
+export declare function useImageLoadingStatus(src: Ref<string>, referrerPolicy?: Ref<ImgHTMLAttributes['referrerpolicy']>): Ref<ImageLoadingStatus>;

node_modules/radix-vue/dist/Calendar/CalendarCell.d.ts

@@ -0,0 +1,38 @@
+import { PrimitiveProps } from '../Primitive';
+import { DateValue } from '@internationalized/date';
+export interface CalendarCellProps extends PrimitiveProps {
+    /** The date value for the cell */
+    date: DateValue;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<CalendarCellProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<CalendarCellProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Calendar/CalendarCellTrigger.d.ts

@@ -0,0 +1,48 @@
+import { PrimitiveProps } from '../Primitive';
+import { DateValue } from '@internationalized/date';
+export interface CalendarCellTriggerProps extends PrimitiveProps {
+    /** The date value provided to the cell trigger */
+    day: DateValue;
+    /** The month in which the cell is rendered */
+    month: DateValue;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<CalendarCellTriggerProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<CalendarCellTriggerProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, Readonly<{
+    default: (props: {
+        /** Current day */
+        dayValue: string;
+    }) => any;
+}> & {
+    default: (props: {
+        /** Current day */
+        dayValue: string;
+    }) => any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Calendar/CalendarGrid.d.ts

@@ -0,0 +1,35 @@
+import { PrimitiveProps } from '../Primitive';
+export interface CalendarGridProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<CalendarGridProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<CalendarGridProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Calendar/CalendarGridBody.d.ts

@@ -0,0 +1,35 @@
+import { PrimitiveProps } from '../Primitive';
+export interface CalendarGridBodyProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<CalendarGridBodyProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<CalendarGridBodyProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Calendar/CalendarGridHead.d.ts

@@ -0,0 +1,35 @@
+import { PrimitiveProps } from '../Primitive';
+export interface CalendarGridHeadProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<CalendarGridHeadProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<CalendarGridHeadProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Calendar/CalendarGridRow.d.ts

@@ -0,0 +1,35 @@
+import { PrimitiveProps } from '../Primitive';
+export interface CalendarGridRowProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<CalendarGridRowProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<CalendarGridRowProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Calendar/CalendarHeadCell.d.ts

@@ -0,0 +1,35 @@
+import { PrimitiveProps } from '../Primitive';
+export interface CalendarHeadCellProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<CalendarHeadCellProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<CalendarHeadCellProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Calendar/CalendarHeader.d.ts

@@ -0,0 +1,35 @@
+import { PrimitiveProps } from '../Primitive';
+export interface CalendarHeaderProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<CalendarHeaderProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<CalendarHeaderProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Calendar/CalendarHeading.d.ts

@@ -0,0 +1,43 @@
+import { PrimitiveProps } from '../Primitive';
+export interface CalendarHeadingProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<CalendarHeadingProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<CalendarHeadingProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, Readonly<{
+    default: (props: {
+        /** Current month and year */
+        headingValue: string;
+    }) => any;
+}> & {
+    default: (props: {
+        /** Current month and year */
+        headingValue: string;
+    }) => any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Calendar/CalendarNext.d.ts

@@ -0,0 +1,47 @@
+import { PrimitiveProps } from '../Primitive';
+import { CalendarIncrement } from '../shared/date';
+import { DateValue } from '@internationalized/date';
+export interface CalendarNextProps extends PrimitiveProps {
+    /**
+     * The calendar unit to go forward
+     * @deprecated Use `nextPage` instead
+     */
+    step?: CalendarIncrement;
+    /** The function to be used for the next page. Overwrites the `nextPage` function set on the `CalendarRoot`. */
+    nextPage?: (placeholder: DateValue) => DateValue;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<CalendarNextProps>, {
+    as: string;
+    step: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<CalendarNextProps>, {
+    as: string;
+    step: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+    step: CalendarIncrement;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Calendar/CalendarPrev.d.ts

@@ -0,0 +1,47 @@
+import { PrimitiveProps } from '../Primitive';
+import { CalendarIncrement } from '../shared/date';
+import { DateValue } from '@internationalized/date';
+export interface CalendarPrevProps extends PrimitiveProps {
+    /**
+     * The calendar unit to go back
+     * @deprecated Use `prevPage` instead
+     */
+    step?: CalendarIncrement;
+    /** The function to be used for the prev page. Overwrites the `prevPage` function set on the `CalendarRoot`. */
+    prevPage?: (placeholder: DateValue) => DateValue;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<CalendarPrevProps>, {
+    as: string;
+    step: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<CalendarPrevProps>, {
+    as: string;
+    step: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+    step: CalendarIncrement;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Calendar/CalendarRoot.d.ts

@@ -0,0 +1,247 @@
+import { DateValue } from '@internationalized/date';
+import { Ref } from 'vue';
+import { PrimitiveProps } from '../Primitive';
+import { Formatter } from '../shared';
+import { CalendarIncrement } from '../shared/date';
+import { Grid, Matcher, WeekDayFormat } from '../date';
+import { Direction } from '../shared/types';
+type CalendarRootContext = {
+    locale: Ref<string>;
+    modelValue: Ref<DateValue | DateValue[] | undefined>;
+    placeholder: Ref<DateValue>;
+    pagedNavigation: Ref<boolean>;
+    preventDeselect: Ref<boolean>;
+    weekStartsOn: Ref<0 | 1 | 2 | 3 | 4 | 5 | 6>;
+    weekdayFormat: Ref<WeekDayFormat>;
+    fixedWeeks: Ref<boolean>;
+    multiple: Ref<boolean>;
+    numberOfMonths: Ref<number>;
+    disabled: Ref<boolean>;
+    readonly: Ref<boolean>;
+    initialFocus: Ref<boolean>;
+    onDateChange: (date: DateValue) => void;
+    onPlaceholderChange: (date: DateValue) => void;
+    fullCalendarLabel: Ref<string>;
+    parentElement: Ref<HTMLElement | undefined>;
+    headingValue: Ref<string>;
+    isInvalid: Ref<boolean>;
+    isDateDisabled: Matcher;
+    isDateSelected: Matcher;
+    isDateUnavailable?: Matcher;
+    isOutsideVisibleView: (date: DateValue) => boolean;
+    prevPage: (step?: CalendarIncrement, prevPageFunc?: (date: DateValue) => DateValue) => void;
+    nextPage: (step?: CalendarIncrement, nextPageFunc?: (date: DateValue) => DateValue) => void;
+    isNextButtonDisabled: (step?: CalendarIncrement, nextPageFunc?: (date: DateValue) => DateValue) => boolean;
+    isPrevButtonDisabled: (step?: CalendarIncrement, prevPageFunc?: (date: DateValue) => DateValue) => boolean;
+    formatter: Formatter;
+    dir: Ref<Direction>;
+};
+interface BaseCalendarRootProps extends PrimitiveProps {
+    /** The default value for the calendar */
+    defaultValue?: DateValue;
+    /** The default placeholder date */
+    defaultPlaceholder?: DateValue;
+    /** The placeholder date, which is used to determine what month to display when no date is selected. This updates as the user navigates the calendar and can be used to programmatically control the calendar view */
+    placeholder?: DateValue;
+    /** This property causes the previous and next buttons to navigate by the number of months displayed at once, rather than one month */
+    pagedNavigation?: boolean;
+    /** Whether or not to prevent the user from deselecting a date without selecting another date first */
+    preventDeselect?: boolean;
+    /** The day of the week to start the calendar on */
+    weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    /** The format to use for the weekday strings provided via the weekdays slot prop */
+    weekdayFormat?: WeekDayFormat;
+    /** The accessible label for the calendar */
+    calendarLabel?: string;
+    /** Whether or not to always display 6 weeks in the calendar */
+    fixedWeeks?: boolean;
+    /** The maximum date that can be selected */
+    maxValue?: DateValue;
+    /** The minimum date that can be selected */
+    minValue?: DateValue;
+    /** The locale to use for formatting dates */
+    locale?: string;
+    /** The number of months to display at once */
+    numberOfMonths?: number;
+    /** Whether or not the calendar is disabled */
+    disabled?: boolean;
+    /** Whether or not the calendar is readonly */
+    readonly?: boolean;
+    /** If true, the calendar will focus the selected day, today, or the first day of the month depending on what is visible when the calendar is mounted */
+    initialFocus?: boolean;
+    /** A function that returns whether or not a date is disabled */
+    isDateDisabled?: Matcher;
+    /** A function that returns whether or not a date is unavailable */
+    isDateUnavailable?: Matcher;
+    /** The reading direction of the calendar when applicable. <br> If omitted, inherits globally from `ConfigProvider` or assumes LTR (left-to-right) reading mode. */
+    dir?: Direction;
+    /** A function that returns the next page of the calendar. It receives the current placeholder as an argument inside the component. */
+    nextPage?: (placeholder: DateValue) => DateValue;
+    /** A function that returns the previous page of the calendar. It receives the current placeholder as an argument inside the component. */
+    prevPage?: (placeholder: DateValue) => DateValue;
+}
+export interface MultipleCalendarRootProps extends BaseCalendarRootProps {
+    /** The controlled checked state of the calendar. Can be bound as `v-model`. */
+    modelValue?: DateValue[] | undefined;
+    /** Whether or not multiple dates can be selected */
+    multiple: true;
+}
+export interface SingleCalendarRootProps extends BaseCalendarRootProps {
+    /** The controlled checked state of the calendar. Can be bound as `v-model`. */
+    modelValue?: DateValue | undefined;
+    /** Whether or not multiple dates can be selected */
+    multiple?: false;
+}
+export type CalendarRootProps = MultipleCalendarRootProps | SingleCalendarRootProps;
+export type CalendarRootEmits = {
+    /** Event handler called whenever the model value changes */
+    'update:modelValue': [date: DateValue | undefined];
+    /** Event handler called whenever the placeholder value changes */
+    'update:placeholder': [date: DateValue];
+};
+export declare const injectCalendarRootContext: <T extends CalendarRootContext | null | undefined = CalendarRootContext>(fallback?: T | undefined) => T extends null ? CalendarRootContext | null : CalendarRootContext, provideCalendarRootContext: (contextValue: CalendarRootContext) => CalendarRootContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<CalendarRootProps>, {
+    defaultValue: undefined;
+    as: string;
+    pagedNavigation: boolean;
+    preventDeselect: boolean;
+    weekStartsOn: number;
+    weekdayFormat: string;
+    fixedWeeks: boolean;
+    multiple: boolean;
+    numberOfMonths: number;
+    disabled: boolean;
+    readonly: boolean;
+    initialFocus: boolean;
+    placeholder: undefined;
+    locale: string;
+    isDateDisabled: undefined;
+    isDateUnavailable: undefined;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (date: DateValue | undefined) => void;
+    "update:placeholder": (date: DateValue) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<MultipleCalendarRootProps>, {
+    defaultValue: undefined;
+    as: string;
+    pagedNavigation: boolean;
+    preventDeselect: boolean;
+    weekStartsOn: number;
+    weekdayFormat: string;
+    fixedWeeks: boolean;
+    multiple: boolean;
+    numberOfMonths: number;
+    disabled: boolean;
+    readonly: boolean;
+    initialFocus: boolean;
+    placeholder: undefined;
+    locale: string;
+    isDateDisabled: undefined;
+    isDateUnavailable: undefined;
+}>> | import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<SingleCalendarRootProps>, {
+    defaultValue: undefined;
+    as: string;
+    pagedNavigation: boolean;
+    preventDeselect: boolean;
+    weekStartsOn: number;
+    weekdayFormat: string;
+    fixedWeeks: boolean;
+    multiple: boolean;
+    numberOfMonths: number;
+    disabled: boolean;
+    readonly: boolean;
+    initialFocus: boolean;
+    placeholder: undefined;
+    locale: string;
+    isDateDisabled: undefined;
+    isDateUnavailable: undefined;
+}>>> & {
+    "onUpdate:modelValue"?: ((date: DateValue | undefined) => any) | undefined;
+    "onUpdate:placeholder"?: ((date: DateValue) => any) | undefined;
+}, {
+    defaultValue: DateValue;
+    locale: string;
+    disabled: boolean;
+    multiple: true;
+    weekStartsOn: 0 | 2 | 1 | 3 | 4 | 5 | 6;
+    fixedWeeks: boolean;
+    numberOfMonths: number;
+    pagedNavigation: boolean;
+    as: import('../Primitive').AsTag | import('vue').Component;
+    placeholder: DateValue;
+    preventDeselect: boolean;
+    weekdayFormat: WeekDayFormat;
+    readonly: boolean;
+    initialFocus: boolean;
+    isDateDisabled: Matcher;
+    isDateUnavailable: Matcher;
+} | {
+    defaultValue: DateValue;
+    locale: string;
+    disabled: boolean;
+    multiple: false;
+    weekStartsOn: 0 | 2 | 1 | 3 | 4 | 5 | 6;
+    fixedWeeks: boolean;
+    numberOfMonths: number;
+    pagedNavigation: boolean;
+    as: import('../Primitive').AsTag | import('vue').Component;
+    placeholder: DateValue;
+    preventDeselect: boolean;
+    weekdayFormat: WeekDayFormat;
+    readonly: boolean;
+    initialFocus: boolean;
+    isDateDisabled: Matcher;
+    isDateUnavailable: Matcher;
+}, {}>, Readonly<{
+    default: (props: {
+        /** The current date of the placeholder */
+        date: DateValue;
+        /** The grid of dates */
+        grid: Grid<DateValue>[];
+        /** The days of the week */
+        weekDays: string[];
+        /** The start of the week */
+        weekStartsOn: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+        /** The calendar locale */
+        locale: string;
+        /** Whether or not to always display 6 weeks in the calendar */
+        fixedWeeks: boolean;
+    }) => any;
+}> & {
+    default: (props: {
+        /** The current date of the placeholder */
+        date: DateValue;
+        /** The grid of dates */
+        grid: Grid<DateValue>[];
+        /** The days of the week */
+        weekDays: string[];
+        /** The start of the week */
+        weekStartsOn: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+        /** The calendar locale */
+        locale: string;
+        /** Whether or not to always display 6 weeks in the calendar */
+        fixedWeeks: boolean;
+    }) => any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Calendar/index.d.ts

@@ -0,0 +1,12 @@
+export { default as CalendarRoot, type CalendarRootProps, type CalendarRootEmits, } from './CalendarRoot';
+export { default as CalendarHeader, type CalendarHeaderProps, } from './CalendarHeader';
+export { default as CalendarHeading, type CalendarHeadingProps, } from './CalendarHeading';
+export { default as CalendarGrid, type CalendarGridProps, } from './CalendarGrid';
+export { default as CalendarCell, type CalendarCellProps, } from './CalendarCell';
+export { default as CalendarHeadCell, type CalendarHeadCellProps, } from './CalendarHeadCell';
+export { default as CalendarNext, type CalendarNextProps, } from './CalendarNext';
+export { default as CalendarPrev, type CalendarPrevProps, } from './CalendarPrev';
+export { default as CalendarGridHead, type CalendarGridHeadProps, } from './CalendarGridHead';
+export { default as CalendarGridBody, type CalendarGridBodyProps, } from './CalendarGridBody';
+export { default as CalendarGridRow, type CalendarGridRowProps, } from './CalendarGridRow';
+export { default as CalendarCellTrigger, type CalendarCellTriggerProps, } from './CalendarCellTrigger';

node_modules/radix-vue/dist/Calendar/useCalendar.d.ts

@@ -0,0 +1,45 @@
+import { DateValue } from '@internationalized/date';
+import { Ref } from 'vue';
+import { Grid, Matcher, WeekDayFormat } from '../date';
+import { CalendarIncrement } from '../shared/date';
+export type UseCalendarProps = {
+    locale: Ref<string>;
+    placeholder: Ref<DateValue>;
+    weekStartsOn: Ref<0 | 1 | 2 | 3 | 4 | 5 | 6>;
+    fixedWeeks: Ref<boolean>;
+    numberOfMonths: Ref<number>;
+    minValue: Ref<DateValue | undefined>;
+    maxValue: Ref<DateValue | undefined>;
+    disabled: Ref<boolean>;
+    weekdayFormat: Ref<WeekDayFormat>;
+    pagedNavigation: Ref<boolean>;
+    isDateDisabled?: Matcher;
+    isDateUnavailable?: Matcher;
+    calendarLabel: Ref<string | undefined>;
+    nextPage: Ref<((placeholder: DateValue) => DateValue) | undefined>;
+    prevPage: Ref<((placeholder: DateValue) => DateValue) | undefined>;
+};
+export type UseCalendarStateProps = {
+    isDateDisabled: Matcher;
+    isDateUnavailable: Matcher;
+    date: Ref<DateValue | DateValue[] | undefined>;
+};
+export declare function useCalendarState(props: UseCalendarStateProps): {
+    isDateSelected: (dateObj: DateValue) => boolean;
+    isInvalid: import('vue').ComputedRef<boolean>;
+};
+export declare function useCalendar(props: UseCalendarProps): {
+    isDateDisabled: (dateObj: DateValue) => boolean;
+    isDateUnavailable: (date: DateValue) => boolean;
+    isNextButtonDisabled: (step?: CalendarIncrement, nextPageFunc?: ((date: DateValue) => DateValue) | undefined) => boolean;
+    isPrevButtonDisabled: (step?: CalendarIncrement, prevPageFunc?: ((date: DateValue) => DateValue) | undefined) => boolean;
+    grid: Ref<Grid<DateValue>[]>;
+    weekdays: import('vue').ComputedRef<string[]>;
+    visibleView: import('vue').ComputedRef<DateValue[]>;
+    isOutsideVisibleView: (date: DateValue) => boolean;
+    formatter: import('../shared').Formatter;
+    nextPage: (step?: CalendarIncrement, nextPageFunc?: ((date: DateValue) => DateValue) | undefined) => void;
+    prevPage: (step?: CalendarIncrement, prevPageFunc?: ((date: DateValue) => DateValue) | undefined) => void;
+    headingValue: import('vue').ComputedRef<string>;
+    fullCalendarLabel: import('vue').ComputedRef<string>;
+};

node_modules/radix-vue/dist/Checkbox/CheckboxIndicator.d.ts

@@ -0,0 +1,40 @@
+import { PrimitiveProps } from '../Primitive';
+export interface CheckboxIndicatorProps extends PrimitiveProps {
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with Vue animation libraries.
+     */
+    forceMount?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<CheckboxIndicatorProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<CheckboxIndicatorProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Checkbox/CheckboxRoot.d.ts

@@ -0,0 +1,81 @@
+import { PrimitiveProps } from '../Primitive';
+import { Ref } from 'vue';
+import { CheckedState } from './utils';
+export interface CheckboxRootProps extends PrimitiveProps {
+    /** The checked state of the checkbox when it is initially rendered. Use when you do not need to control its checked state. */
+    defaultChecked?: boolean;
+    /** The controlled checked state of the checkbox. Can be binded with v-model. */
+    checked?: boolean | 'indeterminate';
+    /** When `true`, prevents the user from interacting with the checkbox */
+    disabled?: boolean;
+    /** When `true`, indicates that the user must check the checkbox before the owning form can be submitted. */
+    required?: boolean;
+    /** The name of the checkbox. Submitted with its owning form as part of a name/value pair. */
+    name?: string;
+    /**
+     * The value given as data when submitted with a `name`.
+     *  @defaultValue "on"
+     */
+    value?: string;
+    /** Id of the element */
+    id?: string;
+}
+export type CheckboxRootEmits = {
+    /** Event handler called when the checked state of the checkbox changes. */
+    'update:checked': [value: boolean];
+};
+interface CheckboxRootContext {
+    disabled: Ref<boolean>;
+    state: Ref<CheckedState>;
+}
+export declare const injectCheckboxRootContext: <T extends CheckboxRootContext | null | undefined = CheckboxRootContext>(fallback?: T | undefined) => T extends null ? CheckboxRootContext | null : CheckboxRootContext, provideCheckboxRootContext: (contextValue: CheckboxRootContext) => CheckboxRootContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<CheckboxRootProps>, {
+    checked: undefined;
+    value: string;
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:checked": (value: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<CheckboxRootProps>, {
+    checked: undefined;
+    value: string;
+    as: string;
+}>>> & {
+    "onUpdate:checked"?: ((value: boolean) => any) | undefined;
+}, {
+    value: string;
+    as: import('../Primitive').AsTag | import('vue').Component;
+    checked: boolean | "indeterminate";
+}, {}>, Readonly<{
+    default: (props: {
+        /** Current checked state */
+        checked: CheckedState;
+    }) => any;
+}> & {
+    default: (props: {
+        /** Current checked state */
+        checked: CheckedState;
+    }) => any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Checkbox/index.d.ts

@@ -0,0 +1,3 @@
+export { default as CheckboxRoot, type CheckboxRootProps, type CheckboxRootEmits, } from './CheckboxRoot';
+export { default as CheckboxIndicator, type CheckboxIndicatorProps, } from './CheckboxIndicator';
+export type { CheckedState as CheckboxCheckedState, } from './utils';

node_modules/radix-vue/dist/Checkbox/utils.d.ts

@@ -0,0 +1,3 @@
+export type CheckedState = boolean | 'indeterminate';
+export declare function isIndeterminate(checked?: CheckedState): checked is 'indeterminate';
+export declare function getState(checked: CheckedState): "indeterminate" | "checked" | "unchecked";

node_modules/radix-vue/dist/Collapsible/CollapsibleContent.d.ts

@@ -0,0 +1,26 @@
+import { PrimitiveProps } from '../Primitive';
+export interface CollapsibleContentProps extends PrimitiveProps {
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with Vue animation libraries.
+     */
+    forceMount?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<CollapsibleContentProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<CollapsibleContentProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/Collapsible/CollapsibleRoot.d.ts

@@ -0,0 +1,70 @@
+import { PrimitiveProps } from '../Primitive';
+import { Ref } from 'vue';
+export interface CollapsibleRootProps extends PrimitiveProps {
+    /** The open state of the collapsible when it is initially rendered. <br> Use when you do not need to control its open state. */
+    defaultOpen?: boolean;
+    /** The controlled open state of the collapsible. Can be binded with `v-model`. */
+    open?: boolean;
+    /** When `true`, prevents the user from interacting with the collapsible. */
+    disabled?: boolean;
+}
+export type CollapsibleRootEmits = {
+    /** Event handler called when the open state of the collapsible changes. */
+    'update:open': [value: boolean];
+};
+interface CollapsibleRootContext {
+    contentId: string;
+    disabled?: Ref<boolean>;
+    open: Ref<boolean>;
+    onOpenToggle: () => void;
+}
+export declare const injectCollapsibleRootContext: <T extends CollapsibleRootContext | null | undefined = CollapsibleRootContext>(fallback?: T | undefined) => T extends null ? CollapsibleRootContext | null : CollapsibleRootContext, provideCollapsibleRootContext: (contextValue: CollapsibleRootContext) => CollapsibleRootContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<CollapsibleRootProps>, {
+    open: undefined;
+    defaultOpen: boolean;
+}>, {
+    open: Ref<boolean>;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (value: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<CollapsibleRootProps>, {
+    open: undefined;
+    defaultOpen: boolean;
+}>>> & {
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}, {
+    defaultOpen: boolean;
+    open: boolean;
+}, {}>, Readonly<{
+    default: (props: {
+        /** Current open state */
+        open: boolean;
+    }) => any;
+}> & {
+    default: (props: {
+        /** Current open state */
+        open: boolean;
+    }) => any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Collapsible/CollapsibleTrigger.d.ts

@@ -0,0 +1,35 @@
+import { PrimitiveProps } from '../Primitive';
+export interface CollapsibleTriggerProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<CollapsibleTriggerProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<CollapsibleTriggerProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Collapsible/index.d.ts

@@ -0,0 +1,3 @@
+export { default as CollapsibleRoot, type CollapsibleRootProps, type CollapsibleRootEmits, } from './CollapsibleRoot';
+export { default as CollapsibleTrigger, type CollapsibleTriggerProps, } from './CollapsibleTrigger';
+export { default as CollapsibleContent, type CollapsibleContentProps, } from './CollapsibleContent';

node_modules/radix-vue/dist/Collection/Collection.d.ts

@@ -0,0 +1,42 @@
+import { Ref } from 'vue';
+interface CollectionContext<ItemData = {}> {
+    collectionRef: Ref<HTMLElement | undefined>;
+    itemMap: Ref<Map<HTMLElement, {
+        ref: HTMLElement;
+        value?: any;
+    } & ItemData>>;
+    attrName: string;
+}
+export declare const injectCollectionContext: <T extends CollectionContext<{}> | null | undefined = CollectionContext<{}>>(fallback?: T | undefined) => T extends null ? CollectionContext<{}> | null : CollectionContext<{}>, provideCollectionContext: (contextValue: CollectionContext<{}>) => any;
+export declare function createCollection<ItemData = {}>(attrName?: string): {
+    getItems: () => ({
+        ref: HTMLElement;
+        value?: any;
+    } & ItemData)[];
+    reactiveItems: import('vue').ComputedRef<({
+        ref: HTMLElement;
+        value?: any;
+    } & ItemData)[]>;
+    itemMapSize: import('vue').ComputedRef<number>;
+};
+export declare const CollectionSlot: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{}>>, {}, {}>;
+export declare const CollectionItem: import('vue').DefineComponent<{
+    value: {
+        validator: () => boolean;
+    };
+}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    value: {
+        validator: () => boolean;
+    };
+}>>, {}, {}>;
+export declare function useCollection<ItemData = {}>(fallback?: CollectionContext<ItemData>): {
+    getItems: () => ({
+        ref: HTMLElement;
+        value?: any;
+    } & ItemData)[];
+};
+export {};

node_modules/radix-vue/dist/Collection/index.d.ts

@@ -0,0 +1 @@
+export * from './Collection';

node_modules/radix-vue/dist/Combobox/ComboboxAnchor.d.ts

@@ -0,0 +1,21 @@
+import { PrimitiveProps } from '../Primitive';
+export interface ComboboxAnchorProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<ComboboxAnchorProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<ComboboxAnchorProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/Combobox/ComboboxArrow.d.ts

@@ -0,0 +1,41 @@
+import { PopperArrowProps } from '../Popper';
+export interface ComboboxArrowProps extends PopperArrowProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<ComboboxArrowProps>, {
+    width: number;
+    height: number;
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<ComboboxArrowProps>, {
+    width: number;
+    height: number;
+    as: string;
+}>>>, {
+    width: number;
+    height: number;
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Combobox/ComboboxCancel.d.ts

@@ -0,0 +1,35 @@
+import { PrimitiveProps } from '../Primitive';
+export interface ComboboxCancelProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<ComboboxCancelProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<ComboboxCancelProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Combobox/ComboboxContent.d.ts

@@ -0,0 +1,37 @@
+import { ComboboxContentImplEmits, ComboboxContentImplProps } from './ComboboxContentImpl';
+export type ComboboxContentEmits = ComboboxContentImplEmits;
+export interface ComboboxContentProps extends ComboboxContentImplProps {
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with Vue animation libraries.
+     */
+    forceMount?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<ComboboxContentProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => void;
+    pointerDownOutside: (event: import('../DismissableLayer').PointerDownOutsideEvent) => void;
+    focusOutside: (event: import('../DismissableLayer').FocusOutsideEvent) => void;
+    interactOutside: (event: import('../DismissableLayer').PointerDownOutsideEvent | import('../DismissableLayer').FocusOutsideEvent) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<ComboboxContentProps>>> & {
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: import('../DismissableLayer').PointerDownOutsideEvent) => any) | undefined;
+    onFocusOutside?: ((event: import('../DismissableLayer').FocusOutsideEvent) => any) | undefined;
+    onInteractOutside?: ((event: import('../DismissableLayer').PointerDownOutsideEvent | import('../DismissableLayer').FocusOutsideEvent) => any) | undefined;
+}, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/Combobox/ComboboxContentImpl.d.ts

@@ -0,0 +1,78 @@
+import { Ref } from 'vue';
+import { DismissableLayerEmits, DismissableLayerProps } from '../DismissableLayer';
+import { PopperContentProps } from '../Popper';
+export type ComboboxContentImplEmits = DismissableLayerEmits;
+export interface ComboboxContentImplProps extends PopperContentProps, DismissableLayerProps {
+    /**
+     * The positioning mode to use, <br>
+     * `inline` is the default and you can control the position using CSS. <br>
+     * `popper` positions content in the same way as our other primitives, for example `Popover` or `DropdownMenu`.
+     */
+    position?: 'inline' | 'popper';
+    /** The document.body will be lock, and scrolling will be disabled. */
+    bodyLock?: boolean;
+    /**
+     * Allow component to be dismissableLayer.
+     * @deprecated (Will be removed in version 2.0, use `Listbox` instead)
+     */
+    dismissable?: boolean;
+}
+export declare const injectComboboxContentContext: <T extends {
+    position: Ref<'inline' | 'popper'>;
+} | null | undefined = {
+    position: Ref<'inline' | 'popper'>;
+}>(fallback?: T | undefined) => T extends null ? {
+    position: Ref<'inline' | 'popper'>;
+} | null : {
+    position: Ref<'inline' | 'popper'>;
+}, provideComboboxContentContext: (contextValue: {
+    position: Ref<'inline' | 'popper'>;
+}) => {
+    position: Ref<'inline' | 'popper'>;
+};
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<ComboboxContentImplProps>, {
+    position: string;
+    dismissable: boolean;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => void;
+    pointerDownOutside: (event: import('../DismissableLayer').PointerDownOutsideEvent) => void;
+    focusOutside: (event: import('../DismissableLayer').FocusOutsideEvent) => void;
+    interactOutside: (event: import('../DismissableLayer').PointerDownOutsideEvent | import('../DismissableLayer').FocusOutsideEvent) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<ComboboxContentImplProps>, {
+    position: string;
+    dismissable: boolean;
+}>>> & {
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: import('../DismissableLayer').PointerDownOutsideEvent) => any) | undefined;
+    onFocusOutside?: ((event: import('../DismissableLayer').FocusOutsideEvent) => any) | undefined;
+    onInteractOutside?: ((event: import('../DismissableLayer').PointerDownOutsideEvent | import('../DismissableLayer').FocusOutsideEvent) => any) | undefined;
+}, {
+    position: "inline" | "popper";
+    dismissable: boolean;
+}, {}>, {
+    default?(_: {}): any;
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Combobox/ComboboxEmpty.d.ts

@@ -0,0 +1,21 @@
+import { PrimitiveProps } from '../Primitive';
+export interface ComboboxEmptyProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<ComboboxEmptyProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<ComboboxEmptyProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/Combobox/ComboboxGroup.d.ts

@@ -0,0 +1,25 @@
+import { PrimitiveProps } from '../Primitive';
+export interface ComboboxGroupProps extends PrimitiveProps {
+}
+type ComboboxGroupContext = {
+    id: string;
+};
+export declare const injectComboboxGroupContext: <T extends ComboboxGroupContext | null | undefined = ComboboxGroupContext>(fallback?: T | undefined) => T extends null ? ComboboxGroupContext | null : ComboboxGroupContext, provideComboboxGroupContext: (contextValue: ComboboxGroupContext) => ComboboxGroupContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<ComboboxGroupProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<ComboboxGroupProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/Combobox/ComboboxInput.d.ts

@@ -0,0 +1,44 @@
+import { PrimitiveProps } from '../Primitive';
+export interface ComboboxInputProps extends PrimitiveProps {
+    /** Native input type */
+    type?: string;
+    /** When `true`, prevents the user from interacting with item */
+    disabled?: boolean;
+    /** Focus on element when mounted. */
+    autoFocus?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<ComboboxInputProps>, {
+    type: string;
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<ComboboxInputProps>, {
+    type: string;
+    as: string;
+}>>>, {
+    type: string;
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Combobox/ComboboxItem.d.ts

@@ -0,0 +1,70 @@
+import { Ref } from 'vue';
+import { PrimitiveProps } from '../Primitive';
+import { AcceptableValue } from './ComboboxRoot';
+export type SelectEvent<T> = CustomEvent<{
+    originalEvent: PointerEvent;
+    value?: T;
+}>;
+interface ComboboxItemContext {
+    isSelected: Ref<boolean>;
+}
+export declare const injectComboboxItemContext: <T extends ComboboxItemContext | null | undefined = ComboboxItemContext>(fallback?: T | undefined) => T extends null ? ComboboxItemContext | null : ComboboxItemContext, provideComboboxItemContext: (contextValue: ComboboxItemContext) => ComboboxItemContext;
+export type ComboboxItemEmits<T = AcceptableValue> = {
+    /** Event handler called when the selecting item. <br> It can be prevented by calling `event.preventDefault`. */
+    select: [event: SelectEvent<T>];
+};
+export interface ComboboxItemProps<T = AcceptableValue> extends PrimitiveProps {
+    /** The value given as data when submitted with a `name`. */
+    value: T;
+    /** When `true`, prevents the user from interacting with the item. */
+    disabled?: boolean;
+}
+declare const _default: <T extends AcceptableValue = AcceptableValue>(__VLS_props: {
+    onSelect?: ((event: SelectEvent<T>) => any) | undefined;
+    value: T;
+    disabled?: boolean | undefined;
+    asChild?: boolean | undefined;
+    as?: import('../Primitive').AsTag | import('vue').Component | undefined;
+} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, __VLS_ctx?: {
+    slots: {
+        default?(_: {}): any;
+    };
+    attrs: any;
+    emit: (evt: "select", event: SelectEvent<T>) => void;
+} | undefined, __VLS_expose?: ((exposed: import('vue').ShallowUnwrapRef<{}>) => void) | undefined, __VLS_setup?: Promise<{
+    props: {
+        onSelect?: ((event: SelectEvent<T>) => any) | undefined;
+        value: T;
+        disabled?: boolean | undefined;
+        asChild?: boolean | undefined;
+        as?: import('../Primitive').AsTag | import('vue').Component | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        default?(_: {}): any;
+    };
+    emit: (evt: "select", event: SelectEvent<T>) => void;
+}>) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> & {
+    __ctx?: {
+        props: {
+            onSelect?: ((event: SelectEvent<T>) => any) | undefined;
+            value: T;
+            disabled?: boolean | undefined;
+            asChild?: boolean | undefined;
+            as?: import('../Primitive').AsTag | import('vue').Component | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: {
+            default?(_: {}): any;
+        };
+        emit: (evt: "select", event: SelectEvent<T>) => void;
+    } | undefined;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Combobox/ComboboxItemIndicator.d.ts

@@ -0,0 +1,35 @@
+import { PrimitiveProps } from '../Primitive';
+export interface ComboboxItemIndicatorProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<ComboboxItemIndicatorProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<ComboboxItemIndicatorProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Combobox/ComboboxLabel.d.ts

@@ -0,0 +1,36 @@
+import { PrimitiveProps } from '../Primitive';
+export interface ComboboxLabelProps extends PrimitiveProps {
+    for?: string;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<ComboboxLabelProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<ComboboxLabelProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Combobox/ComboboxPortal.d.ts

@@ -0,0 +1,21 @@
+import { TeleportProps } from '../Teleport';
+export interface ComboboxPortalProps extends TeleportProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<ComboboxPortalProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<ComboboxPortalProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/Combobox/ComboboxRoot.d.ts

@@ -0,0 +1,206 @@
+import { ComputedRef, Ref } from 'vue';
+import { Direction } from '../shared/types';
+import { PrimitiveProps } from '../Primitive';
+export type AcceptableValue = string | number | boolean | Record<string, any>;
+type ArrayOrWrapped<T> = T extends any[] ? T : Array<T>;
+type ComboboxRootContext<T> = {
+    modelValue: Ref<T | Array<T>>;
+    onValueChange: (val: T) => void;
+    searchTerm: Ref<string>;
+    multiple: Ref<boolean>;
+    disabled: Ref<boolean>;
+    open: Ref<boolean>;
+    onOpenChange: (value: boolean) => void;
+    isUserInputted: Ref<boolean>;
+    filteredOptions: Ref<Array<T>>;
+    contentId: string;
+    contentElement: Ref<HTMLElement | undefined>;
+    onContentElementChange: (el: HTMLElement) => void;
+    inputElement: Ref<HTMLInputElement | undefined>;
+    onInputElementChange: (el: HTMLInputElement) => void;
+    onInputNavigation: (dir: 'up' | 'down' | 'home' | 'end') => void;
+    onInputEnter: (event: InputEvent) => void;
+    onCompositionStart: () => void;
+    onCompositionEnd: () => void;
+    selectedValue: Ref<T | undefined>;
+    selectedElement: ComputedRef<HTMLElement | undefined>;
+    onSelectedValueChange: (val: T) => void;
+    parentElement: Ref<HTMLElement | undefined>;
+};
+export declare const injectComboboxRootContext: <T extends ComboboxRootContext<AcceptableValue> | null | undefined = ComboboxRootContext<AcceptableValue>>(fallback?: T | undefined) => T extends null ? ComboboxRootContext<AcceptableValue> | null : ComboboxRootContext<AcceptableValue>, provideComboboxRootContext: (contextValue: ComboboxRootContext<AcceptableValue>) => ComboboxRootContext<AcceptableValue>;
+export type ComboboxRootEmits<T = AcceptableValue> = {
+    /** Event handler called when the value changes. */
+    'update:modelValue': [value: T];
+    /** Event handler called when the open state of the combobox changes. */
+    'update:open': [value: boolean];
+    /** Event handler called when the searchTerm of the combobox changes. */
+    'update:searchTerm': [value: string];
+    /** Event handler called when the highlighted value of the combobox changes */
+    'update:selectedValue': [value: T | undefined];
+};
+export interface ComboboxRootProps<T = AcceptableValue> extends PrimitiveProps {
+    /** The controlled value of the Combobox. Can be binded with with `v-model`. */
+    modelValue?: T | Array<T>;
+    /** The value of the combobox when initially rendered. Use when you do not need to control the state of the Combobox */
+    defaultValue?: T | Array<T>;
+    /** The controlled open state of the Combobox. Can be binded with with `v-model:open`. */
+    open?: boolean;
+    /** The open state of the combobox when it is initially rendered. <br> Use when you do not need to control its open state. */
+    defaultOpen?: boolean;
+    /** The controlled search term of the Combobox. Can be binded with with v-model:searchTerm. */
+    searchTerm?: string;
+    /** The current highlighted value of the COmbobox. Can be binded with `v-model:selectedValue`. */
+    selectedValue?: T;
+    /** Whether multiple options can be selected or not. */
+    multiple?: boolean;
+    /** When `true`, prevents the user from interacting with Combobox */
+    disabled?: boolean;
+    /** The name of the Combobox. Submitted with its owning form as part of a name/value pair. */
+    name?: string;
+    /** The reading direction of the combobox when applicable. <br> If omitted, inherits globally from `ConfigProvider` or assumes LTR (left-to-right) reading mode. */
+    dir?: Direction;
+    /** The custom filter function for filtering `ComboboxItem`. */
+    filterFunction?: (val: ArrayOrWrapped<T>, term: string) => ArrayOrWrapped<T>;
+    /** The display value of input for selected item. Does not work with `multiple`. */
+    displayValue?: (val: T) => string;
+    /**
+     * Whether to reset the searchTerm when the Combobox input blurred
+     * @defaultValue `true`
+     */
+    resetSearchTermOnBlur?: boolean;
+    /**
+     * Whether to reset the searchTerm when the Combobox value is selected
+     * @defaultValue `true`
+     */
+    resetSearchTermOnSelect?: boolean;
+}
+declare const _default: <T extends AcceptableValue = AcceptableValue>(__VLS_props: {
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: T) => any) | undefined;
+    "onUpdate:searchTerm"?: ((value: string) => any) | undefined;
+    "onUpdate:selectedValue"?: ((value: T | undefined) => any) | undefined;
+    modelValue?: T | T[] | undefined;
+    defaultValue?: T | T[] | undefined;
+    open?: boolean | undefined;
+    defaultOpen?: boolean | undefined;
+    searchTerm?: string | undefined;
+    selectedValue?: T | undefined;
+    multiple?: boolean | undefined;
+    disabled?: boolean | undefined;
+    name?: string | undefined;
+    dir?: Direction | undefined;
+    filterFunction?: ((val: ArrayOrWrapped<T>, term: string) => ArrayOrWrapped<T>) | undefined;
+    displayValue?: ((val: T) => string) | undefined;
+    resetSearchTermOnBlur?: boolean | undefined;
+    resetSearchTermOnSelect?: boolean | undefined;
+    asChild?: boolean | undefined;
+    as?: import('../Primitive').AsTag | import('vue').Component | undefined;
+} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, __VLS_ctx?: {
+    slots: Readonly<{
+        default: (props: {
+            /** Current open state */
+            open: boolean;
+            /** Current active value */
+            modelValue: T | T[];
+        }) => any;
+    }> & {
+        default: (props: {
+            /** Current open state */
+            open: boolean;
+            /** Current active value */
+            modelValue: T | T[];
+        }) => any;
+    };
+    attrs: any;
+    emit: ((evt: "update:open", value: boolean) => void) & ((evt: "update:modelValue", value: T) => void) & ((evt: "update:searchTerm", value: string) => void) & ((evt: "update:selectedValue", value: T | undefined) => void);
+} | undefined, __VLS_expose?: ((exposed: import('vue').ShallowUnwrapRef<{}>) => void) | undefined, __VLS_setup?: Promise<{
+    props: {
+        "onUpdate:open"?: ((value: boolean) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: T) => any) | undefined;
+        "onUpdate:searchTerm"?: ((value: string) => any) | undefined;
+        "onUpdate:selectedValue"?: ((value: T | undefined) => any) | undefined;
+        modelValue?: T | T[] | undefined;
+        defaultValue?: T | T[] | undefined;
+        open?: boolean | undefined;
+        defaultOpen?: boolean | undefined;
+        searchTerm?: string | undefined;
+        selectedValue?: T | undefined;
+        multiple?: boolean | undefined;
+        disabled?: boolean | undefined;
+        name?: string | undefined;
+        dir?: Direction | undefined;
+        filterFunction?: ((val: ArrayOrWrapped<T>, term: string) => ArrayOrWrapped<T>) | undefined;
+        displayValue?: ((val: T) => string) | undefined;
+        resetSearchTermOnBlur?: boolean | undefined;
+        resetSearchTermOnSelect?: boolean | undefined;
+        asChild?: boolean | undefined;
+        as?: import('../Primitive').AsTag | import('vue').Component | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Readonly<{
+        default: (props: {
+            /** Current open state */
+            open: boolean;
+            /** Current active value */
+            modelValue: T | T[];
+        }) => any;
+    }> & {
+        default: (props: {
+            /** Current open state */
+            open: boolean;
+            /** Current active value */
+            modelValue: T | T[];
+        }) => any;
+    };
+    emit: ((evt: "update:open", value: boolean) => void) & ((evt: "update:modelValue", value: T) => void) & ((evt: "update:searchTerm", value: string) => void) & ((evt: "update:selectedValue", value: T | undefined) => void);
+}>) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> & {
+    __ctx?: {
+        props: {
+            "onUpdate:open"?: ((value: boolean) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: T) => any) | undefined;
+            "onUpdate:searchTerm"?: ((value: string) => any) | undefined;
+            "onUpdate:selectedValue"?: ((value: T | undefined) => any) | undefined;
+            modelValue?: T | T[] | undefined;
+            defaultValue?: T | T[] | undefined;
+            open?: boolean | undefined;
+            defaultOpen?: boolean | undefined;
+            searchTerm?: string | undefined;
+            selectedValue?: T | undefined;
+            multiple?: boolean | undefined;
+            disabled?: boolean | undefined;
+            name?: string | undefined;
+            dir?: Direction | undefined;
+            filterFunction?: ((val: ArrayOrWrapped<T>, term: string) => ArrayOrWrapped<T>) | undefined;
+            displayValue?: ((val: T) => string) | undefined;
+            resetSearchTermOnBlur?: boolean | undefined;
+            resetSearchTermOnSelect?: boolean | undefined;
+            asChild?: boolean | undefined;
+            as?: import('../Primitive').AsTag | import('vue').Component | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: Readonly<{
+            default: (props: {
+                /** Current open state */
+                open: boolean;
+                /** Current active value */
+                modelValue: T | T[];
+            }) => any;
+        }> & {
+            default: (props: {
+                /** Current open state */
+                open: boolean;
+                /** Current active value */
+                modelValue: T | T[];
+            }) => any;
+        };
+        emit: ((evt: "update:open", value: boolean) => void) & ((evt: "update:modelValue", value: T) => void) & ((evt: "update:searchTerm", value: string) => void) & ((evt: "update:selectedValue", value: T | undefined) => void);
+    } | undefined;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Combobox/ComboboxSeparator.d.ts

@@ -0,0 +1,21 @@
+import { PrimitiveProps } from '../Primitive';
+export interface ComboboxSeparatorProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<ComboboxSeparatorProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<ComboboxSeparatorProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/Combobox/ComboboxTrigger.d.ts

@@ -0,0 +1,37 @@
+import { PrimitiveProps } from '../Primitive';
+export interface ComboboxTriggerProps extends PrimitiveProps {
+    /** When `true`, prevents the user from interacting with item */
+    disabled?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<ComboboxTriggerProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<ComboboxTriggerProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/Combobox/ComboboxViewport.d.ts

@@ -0,0 +1,25 @@
+import { PrimitiveProps } from '../Primitive';
+export interface ComboboxViewportProps extends PrimitiveProps {
+    /**
+     * Will add `nonce` attribute to the style tag which can be used by Content Security Policy. <br> If omitted, inherits globally from `ConfigProvider`.
+     */
+    nonce?: string;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<ComboboxViewportProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<ComboboxViewportProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/Combobox/index.d.ts

@@ -0,0 +1,15 @@
+export { default as ComboboxRoot, type ComboboxRootProps, type ComboboxRootEmits, } from './ComboboxRoot';
+export { default as ComboboxInput, type ComboboxInputProps, } from './ComboboxInput';
+export { default as ComboboxAnchor, type ComboboxAnchorProps, } from './ComboboxAnchor';
+export { default as ComboboxTrigger, type ComboboxTriggerProps, } from './ComboboxTrigger';
+export { default as ComboboxCancel, type ComboboxCancelProps, } from './ComboboxCancel';
+export { default as ComboboxGroup, type ComboboxGroupProps, } from './ComboboxGroup';
+export { default as ComboboxLabel, type ComboboxLabelProps, } from './ComboboxLabel';
+export { default as ComboboxContent, type ComboboxContentProps, type ComboboxContentEmits, } from './ComboboxContent';
+export { default as ComboboxEmpty, type ComboboxEmptyProps, } from './ComboboxEmpty';
+export { default as ComboboxViewport, type ComboboxViewportProps, } from './ComboboxViewport';
+export { default as ComboboxItem, type ComboboxItemProps, type ComboboxItemEmits, } from './ComboboxItem';
+export { default as ComboboxItemIndicator, type ComboboxItemIndicatorProps, } from './ComboboxItemIndicator';
+export { default as ComboboxSeparator, type ComboboxSeparatorProps, } from './ComboboxSeparator';
+export { default as ComboboxArrow, type ComboboxArrowProps, } from './ComboboxArrow';
+export { default as ComboboxPortal, type ComboboxPortalProps, } from './ComboboxPortal';

node_modules/radix-vue/dist/ConfigProvider/ConfigProvider.d.ts

@@ -0,0 +1,71 @@
+import { Direction, ScrollBodyOption } from '../shared/types';
+import { Ref } from 'vue';
+interface ConfigProviderContextValue {
+    dir?: Ref<Direction>;
+    scrollBody?: Ref<boolean | ScrollBodyOption>;
+    nonce?: Ref<string | undefined>;
+    useId?: () => string;
+}
+export declare const injectConfigProviderContext: <T extends ConfigProviderContextValue | null | undefined = ConfigProviderContextValue>(fallback?: T | undefined) => T extends null ? ConfigProviderContextValue | null : ConfigProviderContextValue, provideConfigProviderContext: (contextValue: ConfigProviderContextValue) => ConfigProviderContextValue;
+export interface ConfigProviderProps {
+    /**
+     * The global reading direction of your application. This will be inherited by all primitives.
+     * @defaultValue 'ltr'
+     */
+    dir?: Direction;
+    /**
+     * The global scroll body behavior of your application. This will be inherited by the related primitives.
+     * @type boolean | ScrollBodyOption
+     */
+    scrollBody?: boolean | ScrollBodyOption;
+    /**
+     * The global `nonce` value of your application. This will be inherited by the related primitives.
+     * @type string
+     */
+    nonce?: string;
+    /**
+     * The global `useId` injection as a workaround for preventing hydration issue.
+     */
+    useId?: () => string;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<ConfigProviderProps>, {
+    dir: string;
+    scrollBody: boolean;
+    nonce: undefined;
+    useId: undefined;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<ConfigProviderProps>, {
+    dir: string;
+    scrollBody: boolean;
+    nonce: undefined;
+    useId: undefined;
+}>>>, {
+    dir: Direction;
+    scrollBody: boolean | ScrollBodyOption;
+    nonce: string;
+    useId: () => string;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/ConfigProvider/index.d.ts

@@ -0,0 +1 @@
+export { default as ConfigProvider, type ConfigProviderProps } from './ConfigProvider';

node_modules/radix-vue/dist/ContextMenu/ContextMenuArrow.d.ts

@@ -0,0 +1,41 @@
+import { MenuArrowProps } from '../Menu';
+export interface ContextMenuArrowProps extends MenuArrowProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<ContextMenuArrowProps>, {
+    width: number;
+    height: number;
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<ContextMenuArrowProps>, {
+    width: number;
+    height: number;
+    as: string;
+}>>>, {
+    width: number;
+    height: number;
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/ContextMenu/ContextMenuCheckboxItem.d.ts

@@ -0,0 +1,28 @@
+import { MenuCheckboxItemEmits, MenuCheckboxItemProps } from '../Menu';
+export type ContextMenuCheckboxItemEmits = MenuCheckboxItemEmits;
+export interface ContextMenuCheckboxItemProps extends MenuCheckboxItemProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<ContextMenuCheckboxItemProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (event: Event) => void;
+    "update:checked": (payload: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<ContextMenuCheckboxItemProps>>> & {
+    onSelect?: ((event: Event) => any) | undefined;
+    "onUpdate:checked"?: ((payload: boolean) => any) | undefined;
+}, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/ContextMenu/ContextMenuContent.d.ts

@@ -0,0 +1,63 @@
+import { MenuContentEmits, MenuContentProps } from '../Menu';
+export type ContextMenuContentEmits = MenuContentEmits;
+export interface ContextMenuContentProps extends Omit<MenuContentProps, 'side' | 'sideOffset' | 'align' | 'arrowPadding' | 'updatePositionStrategy'> {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<ContextMenuContentProps>, {
+    alignOffset: number;
+    avoidCollisions: boolean;
+    collisionBoundary: () => never[];
+    collisionPadding: number;
+    sticky: string;
+    hideWhenDetached: boolean;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => void;
+    pointerDownOutside: (event: import('../DismissableLayer').PointerDownOutsideEvent) => void;
+    focusOutside: (event: import('../DismissableLayer').FocusOutsideEvent) => void;
+    interactOutside: (event: import('../DismissableLayer').PointerDownOutsideEvent | import('../DismissableLayer').FocusOutsideEvent) => void;
+    closeAutoFocus: (event: Event) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<ContextMenuContentProps>, {
+    alignOffset: number;
+    avoidCollisions: boolean;
+    collisionBoundary: () => never[];
+    collisionPadding: number;
+    sticky: string;
+    hideWhenDetached: boolean;
+}>>> & {
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: import('../DismissableLayer').PointerDownOutsideEvent) => any) | undefined;
+    onFocusOutside?: ((event: import('../DismissableLayer').FocusOutsideEvent) => any) | undefined;
+    onInteractOutside?: ((event: import('../DismissableLayer').PointerDownOutsideEvent | import('../DismissableLayer').FocusOutsideEvent) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}, {
+    sticky: "partial" | "always";
+    alignOffset: number;
+    avoidCollisions: boolean;
+    collisionBoundary: Element | (Element | null)[] | null;
+    collisionPadding: number | Partial<Record<"right" | "left" | "top" | "bottom", number>>;
+    hideWhenDetached: boolean;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/ContextMenu/ContextMenuGroup.d.ts

@@ -0,0 +1,21 @@
+import { MenuGroupProps } from '../Menu';
+export interface ContextMenuGroupProps extends MenuGroupProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<ContextMenuGroupProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<ContextMenuGroupProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/ContextMenu/ContextMenuItem.d.ts

@@ -0,0 +1,26 @@
+import { MenuItemEmits, MenuItemProps } from '../Menu';
+export type ContextMenuItemEmits = MenuItemEmits;
+export interface ContextMenuItemProps extends MenuItemProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<MenuItemProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (event: Event) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<MenuItemProps>>> & {
+    onSelect?: ((event: Event) => any) | undefined;
+}, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/ContextMenu/ContextMenuItemIndicator.d.ts

@@ -0,0 +1,21 @@
+import { MenuItemIndicatorProps } from '../Menu';
+export interface ContextMenuItemIndicatorProps extends MenuItemIndicatorProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<ContextMenuItemIndicatorProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<ContextMenuItemIndicatorProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/ContextMenu/ContextMenuLabel.d.ts

@@ -0,0 +1,21 @@
+import { MenuLabelProps } from '../Menu';
+export interface ContextMenuLabelProps extends MenuLabelProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<ContextMenuLabelProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<ContextMenuLabelProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/ContextMenu/ContextMenuPortal.d.ts

@@ -0,0 +1,21 @@
+import { MenuPortalProps } from '../Menu';
+export interface ContextMenuPortalProps extends MenuPortalProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<ContextMenuPortalProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<ContextMenuPortalProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/ContextMenu/ContextMenuRadioGroup.d.ts

@@ -0,0 +1,26 @@
+import { MenuRadioGroupEmits, MenuRadioGroupProps } from '../Menu';
+export type ContextMenuRadioGroupEmits = MenuRadioGroupEmits;
+export interface ContextMenuRadioGroupProps extends MenuRadioGroupProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<ContextMenuRadioGroupProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (payload: string) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<ContextMenuRadioGroupProps>>> & {
+    "onUpdate:modelValue"?: ((payload: string) => any) | undefined;
+}, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/ContextMenu/ContextMenuRadioItem.d.ts

@@ -0,0 +1,26 @@
+import { MenuItemEmits, MenuRadioItemProps } from '../Menu';
+export type ContextMenuRadioItemEmits = MenuItemEmits;
+export interface ContextMenuRadioItemProps extends MenuRadioItemProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<ContextMenuRadioItemProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (event: Event) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<ContextMenuRadioItemProps>>> & {
+    onSelect?: ((event: Event) => any) | undefined;
+}, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/ContextMenu/ContextMenuRoot.d.ts

@@ -0,0 +1,49 @@
+import { Ref } from 'vue';
+import { Direction } from '../shared/types';
+import { MenuEmits, MenuProps } from '../Menu';
+type ContextMenuRootContext = {
+    open: Ref<boolean>;
+    onOpenChange: (open: boolean) => void;
+    modal: Ref<boolean>;
+    dir: Ref<Direction>;
+};
+export interface ContextMenuRootProps extends Omit<MenuProps, 'open'> {
+}
+export type ContextMenuRootEmits = MenuEmits;
+export declare const injectContextMenuRootContext: <T extends ContextMenuRootContext | null | undefined = ContextMenuRootContext>(fallback?: T | undefined) => T extends null ? ContextMenuRootContext | null : ContextMenuRootContext, provideContextMenuRootContext: (contextValue: ContextMenuRootContext) => ContextMenuRootContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<ContextMenuRootProps>, {
+    modal: boolean;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (payload: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<ContextMenuRootProps>, {
+    modal: boolean;
+}>>> & {
+    "onUpdate:open"?: ((payload: boolean) => any) | undefined;
+}, {
+    modal: boolean;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/ContextMenu/ContextMenuSeparator.d.ts

@@ -0,0 +1,21 @@
+import { MenuSeparatorProps } from '../Menu';
+export interface ContextMenuSeparatorProps extends MenuSeparatorProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<ContextMenuSeparatorProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<ContextMenuSeparatorProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/ContextMenu/ContextMenuSub.d.ts

@@ -0,0 +1,50 @@
+import { MenuSubEmits, MenuSubProps } from '../Menu';
+export type ContextMenuSubEmits = MenuSubEmits;
+export interface ContextMenuSubProps extends MenuSubProps {
+    /** The open state of the submenu when it is initially rendered. Use when you do not need to control its open state. */
+    defaultOpen?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<ContextMenuSubProps>, {
+    open: undefined;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (payload: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<ContextMenuSubProps>, {
+    open: undefined;
+}>>> & {
+    "onUpdate:open"?: ((payload: boolean) => any) | undefined;
+}, {
+    open: boolean;
+}, {}>, Readonly<{
+    default: (props: {
+        /** Current open state */
+        open: boolean;
+    }) => any;
+}> & {
+    default: (props: {
+        /** Current open state */
+        open: boolean;
+    }) => any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/ContextMenu/ContextMenuSubContent.d.ts

@@ -0,0 +1,38 @@
+import { MenuSubContentEmits, MenuSubContentProps } from '../Menu';
+export type ContextMenuSubContentEmits = MenuSubContentEmits;
+export interface ContextMenuSubContentProps extends MenuSubContentProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<ContextMenuSubContentProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => void;
+    pointerDownOutside: (event: import('../DismissableLayer').PointerDownOutsideEvent) => void;
+    focusOutside: (event: import('../DismissableLayer').FocusOutsideEvent) => void;
+    interactOutside: (event: import('../DismissableLayer').PointerDownOutsideEvent | import('../DismissableLayer').FocusOutsideEvent) => void;
+    openAutoFocus: (event: Event) => void;
+    closeAutoFocus: (event: Event) => void;
+    entryFocus: (event: Event) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<ContextMenuSubContentProps>>> & {
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: import('../DismissableLayer').PointerDownOutsideEvent) => any) | undefined;
+    onFocusOutside?: ((event: import('../DismissableLayer').FocusOutsideEvent) => any) | undefined;
+    onInteractOutside?: ((event: import('../DismissableLayer').PointerDownOutsideEvent | import('../DismissableLayer').FocusOutsideEvent) => any) | undefined;
+    onOpenAutoFocus?: ((event: Event) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+    onEntryFocus?: ((event: Event) => any) | undefined;
+}, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/ContextMenu/ContextMenuSubTrigger.d.ts

@@ -0,0 +1,21 @@
+import { MenuSubTriggerProps } from '../Menu';
+export interface ContextMenuSubTriggerProps extends MenuSubTriggerProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<ContextMenuSubTriggerProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<ContextMenuSubTriggerProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/ContextMenu/ContextMenuTrigger.d.ts

@@ -0,0 +1,44 @@
+import { PrimitiveProps } from '../Primitive';
+export interface ContextMenuTriggerProps extends PrimitiveProps {
+    /**
+     * When `true`, the context menu would not open when right-clicking.
+     *
+     * Note that this will also restore the native context menu.
+     */
+    disabled?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<ContextMenuTriggerProps>, {
+    as: string;
+    disabled: boolean;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<ContextMenuTriggerProps>, {
+    as: string;
+    disabled: boolean;
+}>>>, {
+    disabled: boolean;
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/ContextMenu/index.d.ts

@@ -0,0 +1,16 @@
+export { default as ContextMenuRoot, type ContextMenuRootProps, type ContextMenuRootEmits, } from './ContextMenuRoot';
+export { default as ContextMenuTrigger, type ContextMenuTriggerProps, } from './ContextMenuTrigger';
+export { default as ContextMenuPortal, type ContextMenuPortalProps, } from './ContextMenuPortal';
+export { default as ContextMenuContent, type ContextMenuContentProps, type ContextMenuContentEmits, } from './ContextMenuContent';
+export { default as ContextMenuArrow, type ContextMenuArrowProps, } from './ContextMenuArrow';
+export { default as ContextMenuItem, type ContextMenuItemProps, type ContextMenuItemEmits, } from './ContextMenuItem';
+export { default as ContextMenuGroup, type ContextMenuGroupProps, } from './ContextMenuGroup';
+export { default as ContextMenuSeparator, type ContextMenuSeparatorProps, } from './ContextMenuSeparator';
+export { default as ContextMenuCheckboxItem, type ContextMenuCheckboxItemProps, type ContextMenuCheckboxItemEmits, } from './ContextMenuCheckboxItem';
+export { default as ContextMenuItemIndicator, type ContextMenuItemIndicatorProps, } from './ContextMenuItemIndicator';
+export { default as ContextMenuLabel, type ContextMenuLabelProps, } from './ContextMenuLabel';
+export { default as ContextMenuRadioGroup, type ContextMenuRadioGroupProps, type ContextMenuRadioGroupEmits, } from './ContextMenuRadioGroup';
+export { default as ContextMenuRadioItem, type ContextMenuRadioItemProps, type ContextMenuRadioItemEmits, } from './ContextMenuRadioItem';
+export { default as ContextMenuSub, type ContextMenuSubProps, type ContextMenuSubEmits, } from './ContextMenuSub';
+export { default as ContextMenuSubContent, type ContextMenuSubContentProps, type ContextMenuSubContentEmits, } from './ContextMenuSubContent';
+export { default as ContextMenuSubTrigger, type ContextMenuSubTriggerProps, } from './ContextMenuSubTrigger';

node_modules/radix-vue/dist/ContextMenu/utils.d.ts

@@ -0,0 +1 @@
+export declare function isTouchOrPen(event: PointerEvent): boolean;

node_modules/radix-vue/dist/DateField/DateFieldInput.d.ts

@@ -0,0 +1,24 @@
+import { PrimitiveProps } from '../Primitive';
+import { SegmentPart } from '../shared/date';
+export interface DateFieldInputProps extends PrimitiveProps {
+    /** The part of the date to render */
+    part: SegmentPart;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<DateFieldInputProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<DateFieldInputProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/DateField/DateFieldRoot.d.ts

@@ -0,0 +1,147 @@
+import { DateValue } from '@internationalized/date';
+import { Ref } from 'vue';
+import { PrimitiveProps } from '../Primitive';
+import { Formatter } from '../shared';
+import { Granularity, HourCycle, SegmentPart, SegmentValueObj } from '../shared/date';
+import { Matcher } from '../date';
+import { Direction } from '../shared/types';
+type DateFieldRootContext = {
+    locale: Ref<string>;
+    modelValue: Ref<DateValue | undefined>;
+    placeholder: Ref<DateValue>;
+    isDateUnavailable?: Matcher;
+    isInvalid: Ref<boolean>;
+    disabled: Ref<boolean>;
+    readonly: Ref<boolean>;
+    formatter: Formatter;
+    hourCycle: HourCycle;
+    segmentValues: Ref<SegmentValueObj>;
+    segmentContents: Ref<{
+        part: SegmentPart;
+        value: string;
+    }[]>;
+    elements: Ref<Set<HTMLElement>>;
+    focusNext: () => void;
+    setFocusedElement: (el: HTMLElement) => void;
+};
+export interface DateFieldRootProps extends PrimitiveProps {
+    /** The default value for the calendar */
+    defaultValue?: DateValue;
+    /** The default placeholder date */
+    defaultPlaceholder?: DateValue;
+    /** The placeholder date, which is used to determine what month to display when no date is selected. This updates as the user navigates the calendar and can be used to programmatically control the calendar view */
+    placeholder?: DateValue;
+    /** The controlled checked state of the calendar. Can be bound as `v-model`. */
+    modelValue?: DateValue | undefined;
+    /** The hour cycle used for formatting times. Defaults to the local preference */
+    hourCycle?: HourCycle;
+    /** The granularity to use for formatting times. Defaults to day if a CalendarDate is provided, otherwise defaults to minute. The field will render segments for each part of the date up to and including the specified granularity */
+    granularity?: Granularity;
+    /** Whether or not to hide the time zone segment of the field */
+    hideTimeZone?: boolean;
+    /** The maximum date that can be selected */
+    maxValue?: DateValue;
+    /** The minimum date that can be selected */
+    minValue?: DateValue;
+    /** The locale to use for formatting dates */
+    locale?: string;
+    /** Whether or not the date field is disabled */
+    disabled?: boolean;
+    /** Whether or not the date field is readonly */
+    readonly?: boolean;
+    /** A function that returns whether or not a date is unavailable */
+    isDateUnavailable?: Matcher;
+    /** The name of the date field. Submitted with its owning form as part of a name/value pair. */
+    name?: string;
+    /** When `true`, indicates that the user must check the date field before the owning form can be submitted. */
+    required?: boolean;
+    /** Id of the element */
+    id?: string;
+    /** The reading direction of the date field when applicable. <br> If omitted, inherits globally from `ConfigProvider` or assumes LTR (left-to-right) reading mode. */
+    dir?: Direction;
+}
+export type DateFieldRootEmits = {
+    /** Event handler called whenever the model value changes */
+    'update:modelValue': [date: DateValue | undefined];
+    /** Event handler called whenever the placeholder value changes */
+    'update:placeholder': [date: DateValue];
+};
+export declare const injectDateFieldRootContext: <T extends DateFieldRootContext | null | undefined = DateFieldRootContext>(fallback?: T | undefined) => T extends null ? DateFieldRootContext | null : DateFieldRootContext, provideDateFieldRootContext: (contextValue: DateFieldRootContext) => DateFieldRootContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<DateFieldRootProps>, {
+    defaultValue: undefined;
+    disabled: boolean;
+    readonly: boolean;
+    placeholder: undefined;
+    locale: string;
+    isDateUnavailable: undefined;
+}>, {
+    /** Helper to set the focused element inside the DateField */
+    setFocusedElement: (el: HTMLElement) => void;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (date: DateValue | undefined) => void;
+    "update:placeholder": (date: DateValue) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<DateFieldRootProps>, {
+    defaultValue: undefined;
+    disabled: boolean;
+    readonly: boolean;
+    placeholder: undefined;
+    locale: string;
+    isDateUnavailable: undefined;
+}>>> & {
+    "onUpdate:modelValue"?: ((date: DateValue | undefined) => any) | undefined;
+    "onUpdate:placeholder"?: ((date: DateValue) => any) | undefined;
+}, {
+    defaultValue: DateValue;
+    locale: string;
+    disabled: boolean;
+    placeholder: DateValue;
+    readonly: boolean;
+    isDateUnavailable: Matcher;
+}, {}>, Readonly<{
+    default: (props: {
+        /** The current date of the field */
+        modelValue: DateValue | undefined;
+        /** The date field segment contents */
+        segments: {
+            part: SegmentPart;
+            value: string;
+        }[];
+        /** Value if the input is invalid */
+        isInvalid: boolean;
+    }) => any;
+}> & {
+    default: (props: {
+        /** The current date of the field */
+        modelValue: DateValue | undefined;
+        /** The date field segment contents */
+        segments: {
+            part: SegmentPart;
+            value: string;
+        }[];
+        /** Value if the input is invalid */
+        isInvalid: boolean;
+    }) => any;
+}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

node_modules/radix-vue/dist/DateField/index.d.ts

@@ -0,0 +1,2 @@
+export { type DateFieldRootEmits, type DateFieldRootProps, default as DateFieldRoot, } from './DateFieldRoot';
+export { type DateFieldInputProps, default as DateFieldInput, } from './DateFieldInput';

node_modules/radix-vue/dist/DateField/useDateField.d.ts

@@ -0,0 +1,141 @@
+import { Formatter } from '../shared';
+import { HourCycle, SegmentPart, SegmentValueObj } from '../shared/date';
+import { DateValue } from '@internationalized/date';
+import { Ref } from 'vue';
+type SegmentAttrProps = {
+    disabled: boolean;
+    segmentValues: SegmentValueObj;
+    hourCycle: HourCycle;
+    placeholder: DateValue;
+    formatter: Formatter;
+};
+declare function daySegmentAttrs(props: SegmentAttrProps): {
+    'aria-label': string;
+    'aria-valuemin': number;
+    'aria-valuemax': number;
+    'aria-valuenow': number;
+    'aria-valuetext': string;
+    'data-placeholder': string | undefined;
+    role: string;
+    contenteditable: boolean;
+    tabindex: number | undefined;
+    spellcheck: boolean;
+    inputmode: string;
+    autocorrect: string;
+    enterkeyhint: string;
+    style: string;
+};
+declare function monthSegmentAttrs(props: SegmentAttrProps): {
+    'aria-label': string;
+    contenteditable: boolean;
+    'aria-valuemin': number;
+    'aria-valuemax': number;
+    'aria-valuenow': number;
+    'aria-valuetext': string;
+    'data-placeholder': string | undefined;
+    role: string;
+    tabindex: number | undefined;
+    spellcheck: boolean;
+    inputmode: string;
+    autocorrect: string;
+    enterkeyhint: string;
+    style: string;
+};
+declare function yearSegmentAttrs(props: SegmentAttrProps): {
+    'aria-label': string;
+    'aria-valuemin': number;
+    'aria-valuemax': number;
+    'aria-valuenow': number;
+    'aria-valuetext': string;
+    'data-placeholder': string | undefined;
+    role: string;
+    contenteditable: boolean;
+    tabindex: number | undefined;
+    spellcheck: boolean;
+    inputmode: string;
+    autocorrect: string;
+    enterkeyhint: string;
+    style: string;
+};
+declare function hourSegmentAttrs(props: SegmentAttrProps): {};
+declare function minuteSegmentAttrs(props: SegmentAttrProps): {};
+declare function secondSegmentAttrs(props: SegmentAttrProps): {};
+declare function dayPeriodSegmentAttrs(props: SegmentAttrProps): {};
+declare function literalSegmentAttrs(_props: SegmentAttrProps): {
+    'aria-hidden': boolean;
+    'data-segment': string;
+};
+declare function timeZoneSegmentAttrs(props: SegmentAttrProps): {
+    role: string;
+    'aria-label': string;
+    'data-readonly': boolean;
+    'data-segment': string;
+    tabindex: number | undefined;
+    style: string;
+};
+declare function eraSegmentAttrs(props: SegmentAttrProps): {
+    'aria-label': string;
+    'aria-valuemin': number;
+    'aria-valuemax': number;
+    'aria-valuenow': number;
+    'aria-valuetext': unknown;
+    role: string;
+    contenteditable: boolean;
+    tabindex: number | undefined;
+    spellcheck: boolean;
+    inputmode: string;
+    autocorrect: string;
+    enterkeyhint: string;
+    style: string;
+};
+export declare const segmentBuilders: {
+    day: {
+        attrs: typeof daySegmentAttrs;
+    };
+    month: {
+        attrs: typeof monthSegmentAttrs;
+    };
+    year: {
+        attrs: typeof yearSegmentAttrs;
+    };
+    hour: {
+        attrs: typeof hourSegmentAttrs;
+    };
+    minute: {
+        attrs: typeof minuteSegmentAttrs;
+    };
+    second: {
+        attrs: typeof secondSegmentAttrs;
+    };
+    dayPeriod: {
+        attrs: typeof dayPeriodSegmentAttrs;
+    };
+    literal: {
+        attrs: typeof literalSegmentAttrs;
+    };
+    timeZoneName: {
+        attrs: typeof timeZoneSegmentAttrs;
+    };
+    era: {
+        attrs: typeof eraSegmentAttrs;
+    };
+};
+export type UseDateFieldProps = {
+    hasLeftFocus: Ref<boolean>;
+    lastKeyZero: Ref<boolean>;
+    placeholder: Ref<DateValue>;
+    hourCycle: HourCycle;
+    formatter: Formatter;
+    segmentValues: Ref<SegmentValueObj>;
+    disabled: Ref<boolean>;
+    readonly: Ref<boolean>;
+    part: SegmentPart;
+    modelValue: Ref<DateValue | undefined>;
+    focusNext: () => void;
+};
+export declare function useDateField(props: UseDateFieldProps): {
+    handleSegmentClick: (e: MouseEvent) => void;
+    handleSegmentKeydown: (e: KeyboardEvent) => void;
+    attributes: import('vue').ComputedRef<{}>;
+};
+export {};

node_modules/radix-vue/dist/DateField/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './parser';
+export * from './segment';

node_modules/radix-vue/dist/DateField/utils/parser.d.ts

@@ -0,0 +1,30 @@
+import { Granularity, HourCycle, SegmentContentObj, SegmentPart, SegmentValueObj } from '../../shared/date';
+import { Formatter } from '../../shared';
+import { DateValue } from '@internationalized/date';
+import { Ref } from 'vue';
+type SyncSegmentValuesProps = {
+    value: DateValue;
+    formatter: Formatter;
+};
+export declare function syncSegmentValues(props: SyncSegmentValuesProps): SegmentValueObj;
+export declare function initializeSegmentValues(granularity: Granularity): SegmentValueObj;
+type SharedContentProps = {
+    granularity: Granularity;
+    dateRef: DateValue;
+    formatter: Formatter;
+    hideTimeZone: boolean;
+    hourCycle: HourCycle;
+};
+type CreateContentObjProps = SharedContentProps & {
+    segmentValues: SegmentValueObj;
+    locale: Ref<string>;
+};
+type CreateContentProps = CreateContentObjProps;
+export declare function createContent(props: CreateContentProps): {
+    obj: SegmentContentObj;
+    arr: {
+        part: SegmentPart;
+        value: string;
+    }[];
+};
+export {};

node_modules/radix-vue/dist/DateField/utils/segment.d.ts

@@ -0,0 +1,4 @@
+export declare function isSegmentNavigationKey(key: string): boolean;
+export declare function isNumberString(value: string): boolean;
+export declare function isAcceptableSegmentKey(key: string): boolean;
+export declare function getSegmentElements(parentElement: HTMLElement): Element[];

node_modules/radix-vue/dist/DatePicker/DatePickerAnchor.d.ts

@@ -0,0 +1,21 @@
+import { PopoverAnchorProps } from '..';
+export interface DatePickerAnchorProps extends PopoverAnchorProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<DatePickerAnchorProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<DatePickerAnchorProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/DatePicker/DatePickerArrow.d.ts

@@ -0,0 +1,21 @@
+import { PopoverArrowProps } from '..';
+export interface DatePickerArrowProps extends PopoverArrowProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<DatePickerArrowProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<DatePickerArrowProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/DatePicker/DatePickerCalendar.d.ts

@@ -0,0 +1,17 @@
+import { DateValue } from '@internationalized/date';
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{}>>, {}, {}>, {
+    default?(_: {
+        date: DateValue;
+        grid: import('../date').Grid<DateValue>[];
+        weekDays: string[];
+        weekStartsOn: 0 | 2 | 1 | 3 | 4 | 5 | 6;
+        locale: string;
+        fixedWeeks: boolean;
+    }): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/DatePicker/DatePickerCell.d.ts

@@ -0,0 +1,21 @@
+import { CalendarCellProps } from '..';
+export interface DatePickerCellProps extends CalendarCellProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<DatePickerCellProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<DatePickerCellProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/DatePicker/DatePickerCellTrigger.d.ts

@@ -0,0 +1,21 @@
+import { CalendarCellTriggerProps } from '..';
+export interface DatePickerCellTriggerProps extends CalendarCellTriggerProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<DatePickerCellTriggerProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<DatePickerCellTriggerProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/DatePicker/DatePickerClose.d.ts

@@ -0,0 +1,21 @@
+import { PopoverCloseProps } from '..';
+export interface DatePickerCloseProps extends PopoverCloseProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<DatePickerCloseProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<DatePickerCloseProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/radix-vue/dist/DatePicker/DatePickerContent.d.ts

@@ -0,0 +1,37 @@
+import { PopoverContentEmits, PopoverContentProps } from '..';
+export interface DatePickerContentProps extends PopoverContentProps {
+}
+export interface DatePickerContentEmits extends PopoverContentEmits {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToOption<DatePickerContentProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => void;
+    pointerDownOutside: (event: import('../DismissableLayer').PointerDownOutsideEvent) => void;
+    focusOutside: (event: import('../DismissableLayer').FocusOutsideEvent) => void;
+    interactOutside: (event: import('../DismissableLayer').PointerDownOutsideEvent | import('../DismissableLayer').FocusOutsideEvent) => void;
+    openAutoFocus: (event: Event) => void;
+    closeAutoFocus: (event: Event) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToOption<DatePickerContentProps>>> & {
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: import('../DismissableLayer').PointerDownOutsideEvent) => any) | undefined;
+    onFocusOutside?: ((event: import('../DismissableLayer').FocusOutsideEvent) => any) | undefined;
+    onInteractOutside?: ((event: import('../DismissableLayer').PointerDownOutsideEvent | import('../DismissableLayer').FocusOutsideEvent) => any) | undefined;
+    onOpenAutoFocus?: ((event: Event) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};