reka-ui 0.0.0 → 0.0.2

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,22 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface AccordionContentProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<AccordionContentProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<AccordionContentProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<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;
+    };
+};

package/dist/Accordion/AccordionHeader.d.ts

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

package/dist/Accordion/AccordionItem.d.ts

@@ -0,0 +1,60 @@
+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_TypePropsToRuntimeProps<AccordionItemProps>, {
+    open: ComputedRef<boolean>;
+    dataDisabled: ComputedRef<"" | undefined>;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<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_TypePropsToRuntimeProps<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;
+    };
+};

package/dist/Accordion/AccordionRoot.d.ts

@@ -0,0 +1,146 @@
+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: {
+    defaultValue?: ValidValue | undefined;
+    dir?: Direction | undefined;
+    disabled?: boolean | undefined;
+    type?: (ValidValue extends string ? "single" : ValidValue extends string[] ? "multiple" : ExplicitType extends "single" ? "single" : ExplicitType extends "multiple" ? "multiple" : never) | undefined;
+    asChild?: boolean | undefined;
+    as?: import('../Primitive').AsTag | import('vue').Component | undefined;
+    unmountOnHide?: boolean | undefined;
+    modelValue?: ValidValue | undefined;
+    collapsible?: boolean | undefined;
+    orientation?: DataOrientation | undefined;
+    "onUpdate:modelValue"?: ((value: (ExplicitType extends "single" ? string : string[]) | undefined) => any) | 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: {
+        defaultValue?: ValidValue | undefined;
+        dir?: Direction | undefined;
+        disabled?: boolean | undefined;
+        type?: (ValidValue extends string ? "single" : ValidValue extends string[] ? "multiple" : ExplicitType extends "single" ? "single" : ExplicitType extends "multiple" ? "multiple" : never) | undefined;
+        asChild?: boolean | undefined;
+        as?: import('../Primitive').AsTag | import('vue').Component | undefined;
+        unmountOnHide?: boolean | undefined;
+        modelValue?: ValidValue | undefined;
+        collapsible?: boolean | undefined;
+        orientation?: DataOrientation | undefined;
+        "onUpdate:modelValue"?: ((value: (ExplicitType extends "single" ? string : string[]) | undefined) => any) | 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: {
+            defaultValue?: ValidValue | undefined;
+            dir?: Direction | undefined;
+            disabled?: boolean | undefined;
+            type?: (ValidValue extends string ? "single" : ValidValue extends string[] ? "multiple" : ExplicitType extends "single" ? "single" : ExplicitType extends "multiple" ? "multiple" : never) | undefined;
+            asChild?: boolean | undefined;
+            as?: import('../Primitive').AsTag | import('vue').Component | undefined;
+            unmountOnHide?: boolean | undefined;
+            modelValue?: ValidValue | undefined;
+            collapsible?: boolean | undefined;
+            orientation?: DataOrientation | undefined;
+            "onUpdate:modelValue"?: ((value: (ExplicitType extends "single" ? string : string[]) | undefined) => any) | 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_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/Accordion/AccordionTrigger.d.ts

@@ -0,0 +1,22 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface AccordionTriggerProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<AccordionTriggerProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<AccordionTriggerProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<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;
+    };
+};

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

package/dist/AlertDialog/AlertDialogAction.d.ts

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

package/dist/AlertDialog/AlertDialogCancel.d.ts

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

package/dist/AlertDialog/AlertDialogContent.d.ts

@@ -0,0 +1,41 @@
+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_TypePropsToRuntimeProps<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_TypePropsToRuntimeProps<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_TypePropsToRuntimeProps<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;
+    };
+};

package/dist/AlertDialog/AlertDialogDescription.d.ts

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

package/dist/AlertDialog/AlertDialogOverlay.d.ts

@@ -0,0 +1,22 @@
+import { DialogOverlayProps } from '../Dialog';
+
+export interface AlertDialogOverlayProps extends DialogOverlayProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<AlertDialogOverlayProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<AlertDialogOverlayProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<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;
+    };
+};

package/dist/AlertDialog/AlertDialogPortal.d.ts

@@ -0,0 +1,22 @@
+import { TeleportProps } from '../Teleport';
+
+export interface AlertDialogPortalProps extends TeleportProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<AlertDialogPortalProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<AlertDialogPortalProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<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;
+    };
+};

package/dist/AlertDialog/AlertDialogRoot.d.ts

@@ -0,0 +1,27 @@
+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_TypePropsToRuntimeProps<AlertDialogProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (value: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<AlertDialogProps>>> & {
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<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;
+    };
+};

package/dist/AlertDialog/AlertDialogTitle.d.ts

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

package/dist/AlertDialog/AlertDialogTrigger.d.ts

@@ -0,0 +1,36 @@
+import { DialogTriggerProps } from '../Dialog';
+
+export interface AlertDialogTriggerProps extends DialogTriggerProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<AlertDialogTriggerProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<AlertDialogTriggerProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<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_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+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';