reka-ui 0.0.0 → 1.0.0-alpha.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Radix Vue <https://github.com/radix-vue>
+Copyright (c) 2023 UnoVue <https://github.com/unovue>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,7 +1,7 @@
 <br />
 <p align="center">
   <a href="https://github.com/radix-vue/radix-vue">
-    <img src="https://www.radix-vue.com/logo.svg" alt="Logo" width="150" />
+    <img src="https://reka-ui.com/logo.svg" alt="Logo" width="150" />
   </a>
 
 <h1 align="center">
@@ -25,10 +25,10 @@ Radix is an unstyled, customisable UI Library with built in accessibility for bu
 <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>
+ <a href="https://radix-vue.com">Documentation</a> | <a href="https://reka-ui.com/overview/getting-started.html">Getting Started</a> | <a href="https://reka-ui.com/">Examples</a> | <a href="https://reka-ui.com/overview/introduction.html">Why Radix Vue?</a>
 </p>
 
-![hero image](https://www.radix-vue.com/og.jpg)
+![hero image](https://reka-ui.com/og.jpg)
  <em>design by: [icarusgkx](https://twitter.com/icarusgkx), [melkam](https://github.com/MellKam)</em>
 
 ## Installation

package/dist/Accordion/AccordionContent.d.ts

@@ -0,0 +1,12 @@
+import { PrimitiveProps } from '../Primitive';
+export interface AccordionContentProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<AccordionContentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AccordionContentProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Accordion/AccordionHeader.d.ts

@@ -0,0 +1,14 @@
+import { PrimitiveProps } from '../Primitive';
+export interface AccordionHeaderProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<AccordionHeaderProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AccordionHeaderProps> & Readonly<{}>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Accordion/AccordionItem.d.ts

@@ -0,0 +1,50 @@
+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<AccordionItemProps, {
+    open: ComputedRef<boolean>;
+    dataDisabled: ComputedRef<"" | undefined>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AccordionItemProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, Readonly<{
+    default: (props: {
+        /** Current open state */
+        open: boolean;
+    }) => any;
+}> & {
+    default: (props: {
+        /** Current open state */
+        open: boolean;
+    }) => any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Accordion/AccordionRoot.d.ts

@@ -0,0 +1,145 @@
+import { ComputedRef, Ref } from 'vue';
+import { PrimitiveProps } from '../Primitive';
+import { AcceptableValue, 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;
+    /**
+     * When `true`, the element will be unmounted on closed state.
+     *
+     * @defaultValue `true`
+     */
+    unmountOnHide?: boolean;
+}
+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<AcceptableValue | AcceptableValue[] | undefined>;
+    collapsible: boolean;
+    unmountOnHide: Ref<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 AcceptableValue | AcceptableValue[], ExplicitType extends SingleOrMultipleType>(__VLS_props: {
+    readonly "onUpdate:modelValue"?: ((value: (ExplicitType extends "single" ? string : string[]) | undefined) => any) | undefined;
+    collapsible?: boolean | undefined;
+    disabled?: boolean | undefined;
+    dir?: Direction | undefined;
+    orientation?: DataOrientation | undefined;
+    unmountOnHide?: boolean | 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: AcceptableValue | AcceptableValue[] | undefined;
+        }) => any;
+    }> & {
+        default: (props: {
+            /** Current active value */
+            modelValue: AcceptableValue | AcceptableValue[] | 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: {
+        readonly "onUpdate:modelValue"?: ((value: (ExplicitType extends "single" ? string : string[]) | undefined) => any) | undefined;
+        collapsible?: boolean | undefined;
+        disabled?: boolean | undefined;
+        dir?: Direction | undefined;
+        orientation?: DataOrientation | undefined;
+        unmountOnHide?: boolean | 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: AcceptableValue | AcceptableValue[] | undefined;
+        }) => any;
+    }> & {
+        default: (props: {
+            /** Current active value */
+            modelValue: AcceptableValue | AcceptableValue[] | 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: {
+            readonly "onUpdate:modelValue"?: ((value: (ExplicitType extends "single" ? string : string[]) | undefined) => any) | undefined;
+            collapsible?: boolean | undefined;
+            disabled?: boolean | undefined;
+            dir?: Direction | undefined;
+            orientation?: DataOrientation | undefined;
+            unmountOnHide?: boolean | 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: AcceptableValue | AcceptableValue[] | undefined;
+            }) => any;
+        }> & {
+            default: (props: {
+                /** Current active value */
+                modelValue: AcceptableValue | AcceptableValue[] | 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];
+} & {};

package/dist/Accordion/AccordionTrigger.d.ts

@@ -0,0 +1,12 @@
+import { PrimitiveProps } from '../Primitive';
+export interface AccordionTriggerProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<AccordionTriggerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AccordionTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/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, injectAccordionRootContext, type AccordionRootEmits, type AccordionRootProps, } from './AccordionRoot';
+export { default as AccordionTrigger, type AccordionTriggerProps, } from './AccordionTrigger';

package/dist/AlertDialog/AlertDialogAction.d.ts

@@ -0,0 +1,14 @@
+import { DialogCloseProps } from '../Dialog';
+export interface AlertDialogActionProps extends DialogCloseProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<AlertDialogActionProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AlertDialogActionProps> & Readonly<{}>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/AlertDialog/AlertDialogCancel.d.ts

@@ -0,0 +1,14 @@
+import { DialogCloseProps } from '../Dialog';
+export interface AlertDialogCancelProps extends DialogCloseProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<AlertDialogCancelProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AlertDialogCancelProps> & Readonly<{}>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/AlertDialog/AlertDialogContent.d.ts

@@ -0,0 +1,31 @@
+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<AlertDialogContentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => any;
+    pointerDownOutside: (event: import('../DismissableLayer').PointerDownOutsideEvent) => any;
+    focusOutside: (event: import('../DismissableLayer').FocusOutsideEvent) => any;
+    interactOutside: (event: import('../DismissableLayer').PointerDownOutsideEvent | import('../DismissableLayer').FocusOutsideEvent) => any;
+    openAutoFocus: (event: Event) => any;
+    closeAutoFocus: (event: Event) => any;
+}, string, import('vue').PublicProps, Readonly<AlertDialogContentProps> & Readonly<{
+    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;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/AlertDialog/AlertDialogDescription.d.ts

@@ -0,0 +1,14 @@
+import { DialogDescriptionProps } from '../Dialog';
+export interface AlertDialogDescriptionProps extends DialogDescriptionProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<AlertDialogDescriptionProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AlertDialogDescriptionProps> & Readonly<{}>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/AlertDialog/AlertDialogOverlay.d.ts

@@ -0,0 +1,12 @@
+import { DialogOverlayProps } from '../Dialog';
+export interface AlertDialogOverlayProps extends DialogOverlayProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<AlertDialogOverlayProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AlertDialogOverlayProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/AlertDialog/AlertDialogPortal.d.ts

@@ -0,0 +1,12 @@
+import { TeleportProps } from '../Teleport';
+export interface AlertDialogPortalProps extends TeleportProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<AlertDialogPortalProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AlertDialogPortalProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/AlertDialog/AlertDialogRoot.d.ts

@@ -0,0 +1,17 @@
+import { DialogRootEmits, DialogRootProps } from '../Dialog';
+export type AlertDialogEmits = DialogRootEmits;
+export interface AlertDialogProps extends Omit<DialogRootProps, 'modal'> {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<AlertDialogProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<AlertDialogProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/AlertDialog/AlertDialogTitle.d.ts

@@ -0,0 +1,14 @@
+import { DialogTitleProps } from '../Dialog';
+export interface AlertDialogTitleProps extends DialogTitleProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<AlertDialogTitleProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AlertDialogTitleProps> & Readonly<{}>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/AlertDialog/AlertDialogTrigger.d.ts

@@ -0,0 +1,14 @@
+import { DialogTriggerProps } from '../Dialog';
+export interface AlertDialogTriggerProps extends DialogTriggerProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<AlertDialogTriggerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AlertDialogTriggerProps> & Readonly<{}>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/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';

package/dist/AspectRatio/AspectRatio.d.ts

@@ -0,0 +1,27 @@
+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<AspectRatioProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AspectRatioProps> & Readonly<{}>, {
+    ratio: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, Readonly<{
+    default: (props: {
+        /** Current aspect ratio (in %) */
+        aspect: number;
+    }) => any;
+}> & {
+    default: (props: {
+        /** Current aspect ratio (in %) */
+        aspect: number;
+    }) => any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/AspectRatio/index.d.ts

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

package/dist/Avatar/AvatarFallback.d.ts

@@ -0,0 +1,17 @@
+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<AvatarFallbackProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AvatarFallbackProps> & Readonly<{}>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+    delayMs: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Avatar/AvatarImage.d.ts

@@ -0,0 +1,27 @@
+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;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<AvatarImageProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    loadingStatusChange: (value: ImageLoadingStatus) => any;
+}, string, import('vue').PublicProps, Readonly<AvatarImageProps> & Readonly<{
+    onLoadingStatusChange?: ((value: ImageLoadingStatus) => any) | undefined;
+}>, {
+    as: import('../Primitive/Primitive').AsTag | import('vue').Component;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Avatar/AvatarRoot.d.ts

@@ -0,0 +1,20 @@
+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<AvatarRootProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AvatarRootProps> & Readonly<{}>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Avatar/index.d.ts

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

package/dist/Avatar/utils.d.ts

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

package/dist/Calendar/CalendarCell.d.ts

@@ -0,0 +1,17 @@
+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<CalendarCellProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<CalendarCellProps> & Readonly<{}>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Calendar/CalendarCellTrigger.d.ts

@@ -0,0 +1,27 @@
+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<CalendarCellTriggerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<CalendarCellTriggerProps> & Readonly<{}>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, Readonly<{
+    default: (props: {
+        /** Current day */
+        dayValue: string;
+    }) => any;
+}> & {
+    default: (props: {
+        /** Current day */
+        dayValue: string;
+    }) => any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Calendar/CalendarGrid.d.ts

@@ -0,0 +1,14 @@
+import { PrimitiveProps } from '../Primitive';
+export interface CalendarGridProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<CalendarGridProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<CalendarGridProps> & Readonly<{}>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Calendar/CalendarGridBody.d.ts

@@ -0,0 +1,14 @@
+import { PrimitiveProps } from '../Primitive';
+export interface CalendarGridBodyProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<CalendarGridBodyProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<CalendarGridBodyProps> & Readonly<{}>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};