@rupe/v-datepicker 1.0.0-alpha.0 → 1.0.0-alpha.1

package/dist/components/FocusScope/{FocusScope.d.ts → FocusScope.vue.d.ts}

@@ -1,4 +1,5 @@
-import { PrimitiveProps } from '../Primitive';
+import { PrimitiveProps, AsTag } from '../Primitive';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions, CreateComponentPublicInstanceWithMixins, ExtractPropTypes, PropType, Component, VNode, RendererNode, RendererElement, GlobalComponents, GlobalDirectives } from 'vue';
 export type FocusScopeEmits = {
     /**
      * Event handler called when auto-focusing on mount.
@@ -25,51 +26,51 @@ export interface FocusScopeProps extends PrimitiveProps {
      */
     trapped?: boolean;
 }
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<FocusScopeProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+declare const _default: __VLS_WithTemplateSlots< DefineComponent<FocusScopeProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
     mountAutoFocus: (event: Event) => any;
     unmountAutoFocus: (event: Event) => any;
-}, string, import('vue').PublicProps, Readonly<FocusScopeProps> & Readonly<{
+}, string, PublicProps, Readonly<FocusScopeProps> & Readonly<{
     onMountAutoFocus?: ((event: Event) => any) | undefined;
     onUnmountAutoFocus?: ((event: Event) => any) | undefined;
 }>, {
     loop: boolean;
     trapped: boolean;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
-    currentRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+    currentRef: CreateComponentPublicInstanceWithMixins<Readonly< ExtractPropTypes<{
         asChild: {
             type: BooleanConstructor;
             default: boolean;
         };
         as: {
-            type: import('vue').PropType<import('../Primitive').AsTag | import('vue').Component>;
+            type: PropType< AsTag | Component>;
             default: string;
         };
-    }>> & Readonly<{}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    }>> & Readonly<{}>, () => VNode<RendererNode, RendererElement, {
         [key: string]: any;
-    }>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+    }>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
         asChild: boolean;
-        as: import('../Primitive').AsTag | import('vue').Component;
-    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        as: AsTag | Component;
+    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
         P: {};
         B: {};
         D: {};
         C: {};
         M: {};
         Defaults: {};
-    }, Readonly<import('vue').ExtractPropTypes<{
+    }, Readonly< ExtractPropTypes<{
         asChild: {
             type: BooleanConstructor;
             default: boolean;
         };
         as: {
-            type: import('vue').PropType<import('../Primitive').AsTag | import('vue').Component>;
+            type: PropType< AsTag | Component>;
             default: string;
         };
-    }>> & Readonly<{}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    }>> & Readonly<{}>, () => VNode<RendererNode, RendererElement, {
         [key: string]: any;
     }>, {}, {}, {}, {
         asChild: boolean;
-        as: import('../Primitive').AsTag | import('vue').Component;
+        as: AsTag | Component;
     }> | null;
 }, any>, {
     default?(_: {}): any;

package/dist/components/FocusScope/index.d.ts

@@ -1 +1 @@
-export { default as FocusScope, type FocusScopeEmits, type FocusScopeProps, } from './FocusScope';
+export { default as FocusScope, type FocusScopeEmits, type FocusScopeProps, } from './FocusScope.vue';

package/dist/components/Popover/PopoverAnchor.vue.d.ts

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

package/dist/components/Popover/PopoverArrow.vue.d.ts

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

package/dist/components/Popover/PopoverClose.vue.d.ts

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

package/dist/components/Popover/PopoverContent.vue.d.ts

@@ -0,0 +1,34 @@
+import { PopoverContentImplEmits, PopoverContentImplProps } from './PopoverContentImpl.vue';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { PointerDownOutsideEvent, FocusOutsideEvent } from '../DismissableLayer';
+export type PopoverContentEmits = PopoverContentImplEmits;
+export interface PopoverContentProps extends PopoverContentImplProps {
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with Vue animation libraries.
+     */
+    forceMount?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots< DefineComponent<PopoverContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => any;
+    pointerDownOutside: (event: PointerDownOutsideEvent) => any;
+    focusOutside: (event: FocusOutsideEvent) => any;
+    interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
+    openAutoFocus: (event: Event) => any;
+    closeAutoFocus: (event: Event) => any;
+}, string, PublicProps, Readonly<PopoverContentProps> & Readonly<{
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
+    onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
+    onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
+    onOpenAutoFocus?: ((event: Event) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Popover/{PopoverContentImpl.d.ts → PopoverContentImpl.vue.d.ts}

@@ -1,6 +1,7 @@
-import { DismissableLayerEmits, DismissableLayerProps } from '../DismissableLayer';
+import { DismissableLayerEmits, DismissableLayerProps, PointerDownOutsideEvent, FocusOutsideEvent } from '../DismissableLayer';
 import { FocusScopeProps } from '../FocusScope';
 import { PopperContentProps } from '../Popper';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 export type PopoverContentImplEmits = DismissableLayerEmits & {
     /**
      * Event handler called when auto-focusing on open.
@@ -22,21 +23,21 @@ interface PopoverContentImplPrivateProps extends PopoverContentImplProps {
      */
     trapFocus?: FocusScopeProps["trapped"];
 }
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<PopoverContentImplPrivateProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+declare const _default: __VLS_WithTemplateSlots< DefineComponent<PopoverContentImplPrivateProps, {}, {}, {}, {}, ComponentOptionsMixin, 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;
+    pointerDownOutside: (event: PointerDownOutsideEvent) => any;
+    focusOutside: (event: FocusOutsideEvent) => any;
+    interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
     openAutoFocus: (event: Event) => any;
     closeAutoFocus: (event: Event) => any;
-}, string, import('vue').PublicProps, Readonly<PopoverContentImplPrivateProps> & Readonly<{
+}, string, PublicProps, Readonly<PopoverContentImplPrivateProps> & 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;
+    onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
+    onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
+    onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
     onOpenAutoFocus?: ((event: Event) => any) | undefined;
     onCloseAutoFocus?: ((event: Event) => any) | undefined;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
     default?(_: {}): any;
 }>;
 export default _default;

package/dist/components/Popover/PopoverContentNonModal.vue.d.ts

@@ -0,0 +1,34 @@
+import { PopoverContentImplProps } from './PopoverContentImpl.vue';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { PointerDownOutsideEvent, FocusOutsideEvent } from '../DismissableLayer';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<PopoverContentImplProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => any;
+    pointerDownOutside: (event: PointerDownOutsideEvent) => any;
+    focusOutside: (event: FocusOutsideEvent) => any;
+    interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
+    openAutoFocus: (event: Event) => any;
+    closeAutoFocus: (event: Event) => any;
+}, string, PublicProps, Readonly<PopoverContentImplProps> & Readonly<{
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
+    onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
+    onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
+    onOpenAutoFocus?: ((event: Event) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Popover/PopoverPortal.vue.d.ts

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

package/dist/components/Popover/{PopoverRoot.d.ts → PopoverRoot.vue.d.ts}

@@ -1,4 +1,4 @@
-import { Ref } from 'vue';
+import { Ref, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 export interface PopoverRootProps {
     /**
      * The open state of the popover when it is initially rendered. Use when you do not need to control its open state.
@@ -25,14 +25,14 @@ export interface PopoverRootContext {
     hasCustomAnchor: Ref<boolean>;
 }
 export declare const injectPopoverRootContext: <T extends PopoverRootContext | null | undefined = PopoverRootContext>(fallback?: T | undefined) => T extends null ? PopoverRootContext | null : PopoverRootContext, providePopoverRootContext: (contextValue: PopoverRootContext) => PopoverRootContext;
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<PopoverRootProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+declare const _default: __VLS_WithTemplateSlots< DefineComponent<PopoverRootProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
     "update:open": (value: boolean) => any;
-}, string, import('vue').PublicProps, Readonly<PopoverRootProps> & Readonly<{
+}, string, PublicProps, Readonly<PopoverRootProps> & Readonly<{
     "onUpdate:open"?: ((value: boolean) => any) | undefined;
 }>, {
     defaultOpen: boolean;
     open: boolean;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, Readonly<{
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, Readonly<{
     default?: (props: {
         /** Current open state */
         open: boolean;

package/dist/components/Popover/PopoverTrigger.vue.d.ts

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

package/dist/components/Popover/index.d.ts

@@ -1,7 +1,7 @@
-export { default as PopoverAnchor, type PopoverAnchorProps, } from './PopoverAnchor';
-export { default as PopoverArrow, type PopoverArrowProps, } from './PopoverArrow';
-export { default as PopoverClose, type PopoverCloseProps, } from './PopoverClose';
-export { default as PopoverContent, type PopoverContentEmits, type PopoverContentProps, } from './PopoverContent';
-export { default as PopoverPortal, type PopoverPortalProps, } from './PopoverPortal';
-export { injectPopoverRootContext, default as PopoverRoot, type PopoverRootEmits, type PopoverRootProps, } from './PopoverRoot';
-export { default as PopoverTrigger, type PopoverTriggerProps, } from './PopoverTrigger';
+export { default as PopoverAnchor, type PopoverAnchorProps, } from './PopoverAnchor.vue';
+export { default as PopoverArrow, type PopoverArrowProps, } from './PopoverArrow.vue';
+export { default as PopoverClose, type PopoverCloseProps, } from './PopoverClose.vue';
+export { default as PopoverContent, type PopoverContentEmits, type PopoverContentProps, } from './PopoverContent.vue';
+export { default as PopoverPortal, type PopoverPortalProps, } from './PopoverPortal.vue';
+export { injectPopoverRootContext, default as PopoverRoot, type PopoverRootEmits, type PopoverRootProps, } from './PopoverRoot.vue';
+export { default as PopoverTrigger, type PopoverTriggerProps, } from './PopoverTrigger.vue';

package/dist/components/Popper/{PopperAnchor.d.ts → PopperAnchor.vue.d.ts}

@@ -1,5 +1,6 @@
 import { ReferenceElement } from '@floating-ui/vue';
 import { PrimitiveProps } from '../Primitive';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 export interface PopperAnchorProps extends PrimitiveProps {
     /**
      *  The reference (or anchor) element that is being referred to for positioning.
@@ -8,7 +9,7 @@ export interface PopperAnchorProps extends PrimitiveProps {
      */
     reference?: ReferenceElement;
 }
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<PopperAnchorProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<PopperAnchorProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+declare const _default: __VLS_WithTemplateSlots< DefineComponent<PopperAnchorProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PopperAnchorProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
     default?(_: {}): any;
 }>;
 export default _default;

package/dist/components/Popper/PopperArrow.vue.d.ts

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

package/dist/components/Popper/{PopperContent.d.ts → PopperContent.vue.d.ts}

@@ -1,5 +1,5 @@
 import { ReferenceElement } from '@floating-ui/vue';
-import { Ref } from 'vue';
+import { Ref, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 import { Align, Side } from './utils';
 import { PrimitiveProps } from '../Primitive';
 export declare const PopperContentPropsDefaultValue: {
@@ -146,9 +146,9 @@ export interface PopperContentContext {
     shouldHideArrow: Ref<boolean>;
 }
 export declare const injectPopperContentContext: <T extends PopperContentContext | null | undefined = PopperContentContext>(fallback?: T | undefined) => T extends null ? PopperContentContext | null : PopperContentContext, providePopperContentContext: (contextValue: PopperContentContext) => PopperContentContext;
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<PopperContentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+declare const _default: __VLS_WithTemplateSlots< DefineComponent<PopperContentProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
     placed: (args_0: void) => any;
-}, string, import('vue').PublicProps, Readonly<PopperContentProps> & Readonly<{
+}, string, PublicProps, Readonly<PopperContentProps> & Readonly<{
     onPlaced?: ((args_0?: void | undefined) => any) | undefined;
 }>, {
     side: Side;
@@ -166,7 +166,7 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Po
     positionStrategy: "absolute" | "fixed";
     updatePositionStrategy: "optimized" | "always";
     prioritizePosition: boolean;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
     floatingRef: HTMLDivElement;
 }, any>, {
     default?(_: {}): any;

package/dist/components/Popper/{PopperRoot.d.ts → PopperRoot.vue.d.ts}

@@ -1,5 +1,5 @@
 import { ReferenceElement } from '@floating-ui/vue';
-import { Ref } from 'vue';
+import { Ref, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 export interface Measurable {
     getBoundingClientRect: () => DOMRect;
 }
@@ -8,7 +8,7 @@ interface PopperRootContext {
     onAnchorChange: (element: ReferenceElement | undefined) => void;
 }
 export declare const injectPopperRootContext: <T extends PopperRootContext | null | undefined = PopperRootContext>(fallback?: T | undefined) => T extends null ? PopperRootContext | null : PopperRootContext, providePopperRootContext: (contextValue: PopperRootContext) => PopperRootContext;
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>, {
+declare const _default: __VLS_WithTemplateSlots< DefineComponent<{}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
     default?(_: {}): any;
 }>;
 export default _default;

package/dist/components/Popper/index.d.ts

@@ -1,5 +1,5 @@
-export { default as PopperAnchor, type PopperAnchorProps, } from './PopperAnchor';
-export { default as PopperArrow, type PopperArrowProps, } from './PopperArrow';
-export { default as PopperContent, type PopperContentProps, PopperContentPropsDefaultValue, } from './PopperContent';
-export { injectPopperRootContext, default as PopperRoot } from './PopperRoot';
+export { default as PopperAnchor, type PopperAnchorProps, } from './PopperAnchor.vue';
+export { default as PopperArrow, type PopperArrowProps, } from './PopperArrow.vue';
+export { default as PopperContent, type PopperContentProps, PopperContentPropsDefaultValue, } from './PopperContent.vue';
+export { injectPopperRootContext, default as PopperRoot } from './PopperRoot.vue';
 export * from './utils';

package/dist/components/Presence/Presence.d.ts

@@ -1,4 +1,4 @@
-import { SlotsType, VNode } from 'vue';
+import { SlotsType, VNode, DefineComponent, ExtractPropTypes, RendererNode, RendererElement, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 export interface PresenceProps {
     /**
      * Conditional to mount or unmount the child element. Similar to `v-if`
@@ -15,7 +15,7 @@ export interface PresenceProps {
      */
     forceMount?: boolean;
 }
-declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+declare const _default: DefineComponent<ExtractPropTypes<{
     present: {
         type: BooleanConstructor;
         required: true;
@@ -23,9 +23,9 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
     forceMount: {
         type: BooleanConstructor;
     };
-}>, () => VNode<import('vue').RendererNode, import('vue').RendererElement, {
+}>, () => VNode< RendererNode, RendererElement, {
     [key: string]: any;
-}> | null, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+}> | null, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
     present: {
         type: BooleanConstructor;
         required: true;
@@ -39,5 +39,5 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
     default: (opts: {
         present: boolean;
     }) => any;
-}>, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}>, {}, {}, string, ComponentProvideOptions, true, {}, any>;
 export default _default;

package/dist/components/Presence/usePresence.d.ts

@@ -1,4 +1,4 @@
-import { Ref } from 'vue';
+import { Ref, ComputedRef } from 'vue';
 export declare function usePresence(present: Ref<boolean>, node: Ref<HTMLElement | undefined>): {
-    isPresent: import('vue').ComputedRef<boolean>;
+    isPresent: ComputedRef<boolean>;
 };

package/dist/components/Primitive/Primitive.d.ts

@@ -1,4 +1,4 @@
-import { Component, PropType } from 'vue';
+import { Component, PropType, DefineComponent, ExtractPropTypes, VNode, RendererNode, RendererElement, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 export type AsTag = 'a' | 'button' | 'div' | 'form' | 'h2' | 'h3' | 'img' | 'input' | 'label' | 'li' | 'nav' | 'ol' | 'p' | 'span' | 'svg' | 'ul' | 'template' | ({} & string);
 export interface PrimitiveProps {
     /**
@@ -13,7 +13,7 @@ export interface PrimitiveProps {
      */
     as?: AsTag | Component;
 }
-export declare const Primitive: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+export declare const Primitive: DefineComponent<ExtractPropTypes<{
     asChild: {
         type: BooleanConstructor;
         default: boolean;
@@ -22,9 +22,9 @@ export declare const Primitive: import('vue').DefineComponent<import('vue').Extr
         type: PropType<AsTag | Component>;
         default: string;
     };
-}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+}>, () => VNode<RendererNode, RendererElement, {
     [key: string]: any;
-}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
     asChild: {
         type: BooleanConstructor;
         default: boolean;
@@ -36,4 +36,4 @@ export declare const Primitive: import('vue').DefineComponent<import('vue').Extr
 }>> & Readonly<{}>, {
     asChild: boolean;
     as: AsTag | Component;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

package/dist/components/Primitive/Slot.d.ts

@@ -1,5 +1,6 @@
-export declare const Slot: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+import { DefineComponent, VNode, RendererNode, RendererElement, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export declare const Slot: DefineComponent<{}, () => VNode<RendererNode, RendererElement, {
     [key: string]: any;
-}>[] | import('vue').VNode<import('vue').RendererNode | undefined, import('vue').RendererElement | undefined, {
+}>[] | VNode< RendererNode | undefined, RendererElement | undefined, {
     [key: string]: any;
-}> | null, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}> | null, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

package/dist/components/Primitive/usePrimitiveElement.d.ts

@@ -1,5 +1,5 @@
-import { ComponentPublicInstance } from 'vue';
+import { ComponentPublicInstance, Ref, ComputedRef } from 'vue';
 export declare function usePrimitiveElement<T extends ComponentPublicInstance>(): {
-    primitiveElement: import('vue').Ref<T | undefined, T | undefined>;
-    currentElement: import('vue').ComputedRef<HTMLElement>;
+    primitiveElement: Ref<T | undefined, T | undefined>;
+    currentElement: ComputedRef<HTMLElement>;
 };

package/dist/components/Teleport/{Teleport.d.ts → Teleport.vue.d.ts}

@@ -1,3 +1,4 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
 export interface TeleportProps {
     /**
      * Vue native teleport component prop `:to`
@@ -24,9 +25,9 @@ export interface TeleportProps {
      */
     forceMount?: boolean;
 }
-declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<TeleportProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TeleportProps> & Readonly<{}>, {
+declare const _default: __VLS_WithTemplateSlots< DefineComponent<TeleportProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<TeleportProps> & Readonly<{}>, {
     to: string | HTMLElement;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
     default?(_: {}): any;
 }>;
 export default _default;

package/dist/components/Teleport/index.d.ts

@@ -1 +1 @@
-export { default as TeleportPrimitive, type TeleportProps } from './Teleport';
+export { default as TeleportPrimitive, type TeleportProps } from './Teleport.vue';

package/dist/components/VisuallyHidden/VisuallyHidden.vue.d.ts

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

package/dist/components/VisuallyHidden/{VisuallyHiddenInput.d.ts → VisuallyHiddenInput.vue.d.ts}

@@ -1,11 +1,12 @@
-import { VisuallyHiddenInputBubbleProps } from './VisuallyHiddenInputBubble';
+import { VisuallyHiddenInputBubbleProps } from './VisuallyHiddenInputBubble.vue';
+import { VNodeProps, AllowedComponentProps, ComponentCustomProps, PublicProps, ShallowUnwrapRef, VNode } from 'vue';
 declare const _default: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, never> & VisuallyHiddenInputBubbleProps<T> & Partial<{}>> & import('vue').PublicProps;
-    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, never> & VisuallyHiddenInputBubbleProps<T> & Partial<{}>> & PublicProps;
+    expose(exposed: ShallowUnwrapRef<{}>): void;
     attrs: any;
     slots: {};
     emit: {};
-}>) => import('vue').VNode & {
+}>) => VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };
 export default _default;

package/dist/components/VisuallyHidden/{VisuallyHiddenInputBubble.d.ts → VisuallyHiddenInputBubble.vue.d.ts}

@@ -1,4 +1,5 @@
-import { VisuallyHiddenProps } from './VisuallyHidden';
+import { VisuallyHiddenProps } from './VisuallyHidden.vue';
+import { VNodeProps, AllowedComponentProps, ComponentCustomProps, PublicProps, ShallowUnwrapRef, VNode } from 'vue';
 export interface VisuallyHiddenInputBubbleProps<T> {
     name: string;
     value: T;
@@ -8,12 +9,12 @@ export interface VisuallyHiddenInputBubbleProps<T> {
     feature?: VisuallyHiddenProps["feature"];
 }
 declare const _default: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, never> & VisuallyHiddenInputBubbleProps<T> & Partial<{}>> & import('vue').PublicProps;
-    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, never> & VisuallyHiddenInputBubbleProps<T> & Partial<{}>> & PublicProps;
+    expose(exposed: ShallowUnwrapRef<{}>): void;
     attrs: any;
     slots: {};
     emit: {};
-}>) => import('vue').VNode & {
+}>) => VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };
 export default _default;

package/dist/components/VisuallyHidden/index.d.ts

@@ -1,2 +1,2 @@
-export { default as VisuallyHidden, type VisuallyHiddenProps } from './VisuallyHidden';
-export { default as VisuallyHiddenInput } from './VisuallyHiddenInput';
+export { default as VisuallyHidden, type VisuallyHiddenProps } from './VisuallyHidden.vue';
+export { default as VisuallyHiddenInput } from './VisuallyHiddenInput.vue';