reka-ui 0.0.0 → 0.0.2

package/dist/Dialog/DialogPortal.d.ts

@@ -0,0 +1,22 @@
+import { TeleportProps } from '../Teleport';
+
+export interface DialogPortalProps extends TeleportProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<DialogPortalProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<DialogPortalProps>>>, {}, {}>, {
+    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/Dialog/DialogRoot.d.ts

@@ -0,0 +1,80 @@
+import { Ref } from 'vue';
+
+export interface DialogRootProps {
+    /** The controlled open state of the dialog. Can be binded as `v-model:open`. */
+    open?: boolean;
+    /** The open state of the dialog when it is initially rendered. Use when you do not need to control its open state. */
+    defaultOpen?: boolean;
+    /**
+     * The modality of the dialog When set to `true`, <br>
+     * interaction with outside elements will be disabled and only dialog content will be visible to screen readers.
+     */
+    modal?: boolean;
+}
+export type DialogRootEmits = {
+    /** Event handler called when the open state of the dialog changes. */
+    'update:open': [value: boolean];
+};
+export interface DialogRootContext {
+    open: Readonly<Ref<boolean>>;
+    modal: Ref<boolean>;
+    openModal: () => void;
+    onOpenChange: (value: boolean) => void;
+    onOpenToggle: () => void;
+    triggerElement: Ref<HTMLElement | undefined>;
+    contentElement: Ref<HTMLElement | undefined>;
+    contentId: string;
+    titleId: string;
+    descriptionId: string;
+}
+export declare const injectDialogRootContext: <T extends DialogRootContext | null | undefined = DialogRootContext>(fallback?: T | undefined) => T extends null ? DialogRootContext | null : DialogRootContext, provideDialogRootContext: (contextValue: DialogRootContext) => DialogRootContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<DialogRootProps>, {
+    open: undefined;
+    defaultOpen: boolean;
+    modal: boolean;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (value: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<DialogRootProps>, {
+    open: undefined;
+    defaultOpen: boolean;
+    modal: boolean;
+}>>> & {
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}, {
+    defaultOpen: boolean;
+    open: boolean;
+    modal: boolean;
+}, {}>, 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_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/Dialog/DialogTitle.d.ts

@@ -0,0 +1,36 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface DialogTitleProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<DialogTitleProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<DialogTitleProps>, {
+    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/Dialog/DialogTrigger.d.ts

@@ -0,0 +1,36 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface DialogTriggerProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<DialogTriggerProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<DialogTriggerProps>, {
+    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/Dialog/index.d.ts

@@ -0,0 +1,8 @@
+export { default as DialogRoot, type DialogRootProps, type DialogRootEmits, } from './DialogRoot';
+export { default as DialogTrigger, type DialogTriggerProps, } from './DialogTrigger';
+export { default as DialogPortal, type DialogPortalProps, } from './DialogPortal';
+export { default as DialogContent, type DialogContentProps, type DialogContentEmits, } from './DialogContent';
+export { default as DialogOverlay, type DialogOverlayProps, } from './DialogOverlay';
+export { default as DialogClose, type DialogCloseProps, } from './DialogClose';
+export { default as DialogTitle, type DialogTitleProps, } from './DialogTitle';
+export { default as DialogDescription, type DialogDescriptionProps, } from './DialogDescription';

package/dist/Dialog/utils.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'vue';
+
+export type WarningProps = {
+    titleName?: string;
+    contentName?: string;
+    componentLink?: string;
+    titleId: string;
+    descriptionId: string;
+    contentElement: Ref<HTMLElement | undefined>;
+};
+export declare function useWarning({ titleName, contentName, componentLink, titleId, descriptionId, contentElement, }: WarningProps): void;

package/dist/DismissableLayer/DismissableLayer.d.ts

@@ -0,0 +1,89 @@
+import { PrimitiveProps } from '../Primitive';
+import { FocusOutsideEvent, PointerDownOutsideEvent } from './utils';
+
+export interface DismissableLayerProps extends PrimitiveProps {
+    /**
+     * When `true`, hover/focus/click interactions will be disabled on elements outside
+     * the `DismissableLayer`. Users will need to click twice on outside elements to
+     * interact with them: once to close the `DismissableLayer`, and again to trigger the element.
+     */
+    disableOutsidePointerEvents?: boolean;
+}
+export type DismissableLayerEmits = {
+    /**
+     * Event handler called when the escape key is down.
+     * Can be prevented.
+     */
+    escapeKeyDown: [event: KeyboardEvent];
+    /**
+     * Event handler called when the a `pointerdown` event happens outside of the `DismissableLayer`.
+     * Can be prevented.
+     */
+    pointerDownOutside: [event: PointerDownOutsideEvent];
+    /**
+     * Event handler called when the focus moves outside of the `DismissableLayer`.
+     * Can be prevented.
+     */
+    focusOutside: [event: FocusOutsideEvent];
+    /**
+     * Event handler called when an interaction happens outside the `DismissableLayer`.
+     * Specifically, when a `pointerdown` event happens outside or focus moves outside of it.
+     * Can be prevented.
+     */
+    interactOutside: [event: PointerDownOutsideEvent | FocusOutsideEvent];
+};
+export type DismissableLayerPrivateEmits = DismissableLayerEmits & {
+    /**
+     * Handler called when the `DismissableLayer` should be dismissed
+     */
+    dismiss: [];
+};
+export declare const context: {
+    layersRoot: Set<HTMLElement> & Omit<Set<HTMLElement>, keyof Set<any>>;
+    layersWithOutsidePointerEventsDisabled: Set<HTMLElement> & Omit<Set<HTMLElement>, keyof Set<any>>;
+    branches: Set<HTMLElement> & Omit<Set<HTMLElement>, keyof Set<any>>;
+};
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<DismissableLayerProps>, {
+    disableOutsidePointerEvents: boolean;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => void;
+    pointerDownOutside: (event: PointerDownOutsideEvent) => void;
+    focusOutside: (event: FocusOutsideEvent) => void;
+    interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => void;
+    dismiss: () => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<DismissableLayerProps>, {
+    disableOutsidePointerEvents: boolean;
+}>>> & {
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
+    onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
+    onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
+    onDismiss?: (() => any) | undefined;
+}, {
+    disableOutsidePointerEvents: boolean;
+}, {}>, {
+    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/DismissableLayer/DismissableLayerBranch.d.ts

@@ -0,0 +1,22 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface DismissableLayerBranchProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<DismissableLayerBranchProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<DismissableLayerBranchProps>>>, {}, {}>, {
+    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/DismissableLayer/index.d.ts

@@ -0,0 +1,3 @@
+export { default as DismissableLayer, type DismissableLayerEmits, type DismissableLayerProps, } from './DismissableLayer';
+export { default as DismissableLayerBranch } from './DismissableLayerBranch';
+export { useFocusOutside, usePointerDownOutside, type PointerDownOutsideEvent, type FocusOutsideEvent } from './utils';

package/dist/DismissableLayer/utils.d.ts

@@ -0,0 +1,29 @@
+import { Ref } from 'vue';
+
+export type PointerDownOutsideEvent = CustomEvent<{
+    originalEvent: PointerEvent;
+}>;
+export type FocusOutsideEvent = CustomEvent<{
+    originalEvent: FocusEvent;
+}>;
+export declare const DISMISSABLE_LAYER_NAME = "DismissableLayer";
+export declare const CONTEXT_UPDATE = "dismissableLayer.update";
+export declare const POINTER_DOWN_OUTSIDE = "dismissableLayer.pointerDownOutside";
+export declare const FOCUS_OUTSIDE = "dismissableLayer.focusOutside";
+/**
+ * Listens for `pointerdown` outside a DOM subtree. We use `pointerdown` rather than `pointerup`
+ * to mimic layer dismissing behaviour present in OS.
+ * Returns props to pass to the node we want to check for outside events.
+ */
+export declare function usePointerDownOutside(onPointerDownOutside?: (event: PointerDownOutsideEvent) => void, element?: Ref<HTMLElement | undefined>): {
+    onPointerDownCapture: () => boolean;
+};
+/**
+ * Listens for when focus happens outside a DOM subtree.
+ * Returns props to pass to the root (node) of the subtree we want to check.
+ */
+export declare function useFocusOutside(onFocusOutside?: (event: FocusOutsideEvent) => void, element?: Ref<HTMLElement | undefined>): {
+    onFocusCapture: () => boolean;
+    onBlurCapture: () => boolean;
+};
+export declare function dispatchUpdate(): void;

package/dist/DropdownMenu/DropdownMenuArrow.d.ts

@@ -0,0 +1,42 @@
+import { MenuArrowProps } from '../Menu';
+
+export interface DropdownMenuArrowProps extends MenuArrowProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<DropdownMenuArrowProps>, {
+    width: number;
+    height: number;
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<DropdownMenuArrowProps>, {
+    width: number;
+    height: number;
+    as: string;
+}>>>, {
+    width: number;
+    height: number;
+    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/DropdownMenu/DropdownMenuCheckboxItem.d.ts

@@ -0,0 +1,29 @@
+import { MenuCheckboxItemEmits, MenuCheckboxItemProps } from '../Menu';
+
+export type DropdownMenuCheckboxItemEmits = MenuCheckboxItemEmits;
+export interface DropdownMenuCheckboxItemProps extends MenuCheckboxItemProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<DropdownMenuCheckboxItemProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (event: Event) => void;
+    "update:modelValue": (payload: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<DropdownMenuCheckboxItemProps>>> & {
+    onSelect?: ((event: Event) => any) | undefined;
+    "onUpdate:modelValue"?: ((payload: 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/DropdownMenu/DropdownMenuContent.d.ts

@@ -0,0 +1,35 @@
+import { MenuContentEmits, MenuContentProps } from '../Menu';
+
+export type DropdownMenuContentEmits = MenuContentEmits;
+export interface DropdownMenuContentProps extends MenuContentProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<DropdownMenuContentProps>, {}, 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_TypePropsToRuntimeProps<DropdownMenuContentProps>>> & {
+    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;
+}, {}, {}>, {
+    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/DropdownMenu/DropdownMenuGroup.d.ts

@@ -0,0 +1,22 @@
+import { MenuGroupProps } from '../Menu';
+
+export interface DropdownMenuGroupProps extends MenuGroupProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<DropdownMenuGroupProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<DropdownMenuGroupProps>>>, {}, {}>, {
+    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/DropdownMenu/DropdownMenuItem.d.ts

@@ -0,0 +1,27 @@
+import { MenuItemEmits, MenuItemProps } from '../Menu';
+
+export type DropdownMenuItemEmits = MenuItemEmits;
+export interface DropdownMenuItemProps extends MenuItemProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<DropdownMenuItemProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (event: Event) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<DropdownMenuItemProps>>> & {
+    onSelect?: ((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/DropdownMenu/DropdownMenuItemIndicator.d.ts

@@ -0,0 +1,22 @@
+import { MenuItemIndicatorProps } from '../Menu';
+
+export interface DropdownMenuItemIndicatorProps extends MenuItemIndicatorProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<DropdownMenuItemIndicatorProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<DropdownMenuItemIndicatorProps>>>, {}, {}>, {
+    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/DropdownMenu/DropdownMenuLabel.d.ts

@@ -0,0 +1,22 @@
+import { MenuLabelProps } from '../Menu';
+
+export interface DropdownMenuLabelProps extends MenuLabelProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<DropdownMenuLabelProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<DropdownMenuLabelProps>>>, {}, {}>, {
+    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/DropdownMenu/DropdownMenuPortal.d.ts

@@ -0,0 +1,22 @@
+import { MenuPortalProps } from '../Menu';
+
+export interface DropdownMenuPortalProps extends MenuPortalProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<DropdownMenuPortalProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<DropdownMenuPortalProps>>>, {}, {}>, {
+    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/DropdownMenu/DropdownMenuRadioGroup.d.ts

@@ -0,0 +1,27 @@
+import { MenuRadioGroupEmits, MenuRadioGroupProps } from '../Menu';
+
+export type DropdownMenuRadioGroupEmits = MenuRadioGroupEmits;
+export interface DropdownMenuRadioGroupProps extends MenuRadioGroupProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<MenuRadioGroupProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (payload: string) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<MenuRadioGroupProps>>> & {
+    "onUpdate:modelValue"?: ((payload: string) => 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/DropdownMenu/DropdownMenuRadioItem.d.ts

@@ -0,0 +1,27 @@
+import { MenuRadioItemEmits, MenuRadioItemProps } from '../Menu';
+
+export type DropdownMenuRadioItemEmits = MenuRadioItemEmits;
+export interface DropdownMenuRadioItemProps extends MenuRadioItemProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<DropdownMenuRadioItemProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (event: Event) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<DropdownMenuRadioItemProps>>> & {
+    onSelect?: ((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;
+    };
+};