reka-ui 0.0.0 → 0.0.2

package/dist/ContextMenu/ContextMenuItemIndicator.d.ts

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

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

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

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

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

@@ -0,0 +1,50 @@
+import { Ref } from 'vue';
+import { Direction } from '../shared/types';
+import { MenuEmits, MenuProps } from '../Menu';
+
+type ContextMenuRootContext = {
+    open: Ref<boolean>;
+    onOpenChange: (open: boolean) => void;
+    modal: Ref<boolean>;
+    dir: Ref<Direction>;
+};
+export interface ContextMenuRootProps extends Omit<MenuProps, 'open'> {
+}
+export type ContextMenuRootEmits = MenuEmits;
+export declare const injectContextMenuRootContext: <T extends ContextMenuRootContext | null | undefined = ContextMenuRootContext>(fallback?: T | undefined) => T extends null ? ContextMenuRootContext | null : ContextMenuRootContext, provideContextMenuRootContext: (contextValue: ContextMenuRootContext) => ContextMenuRootContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ContextMenuRootProps>, {
+    modal: boolean;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (payload: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ContextMenuRootProps>, {
+    modal: boolean;
+}>>> & {
+    "onUpdate:open"?: ((payload: boolean) => any) | undefined;
+}, {
+    modal: 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/ContextMenu/ContextMenuSeparator.d.ts

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

@@ -0,0 +1,51 @@
+import { MenuSubEmits, MenuSubProps } from '../Menu';
+
+export type ContextMenuSubEmits = MenuSubEmits;
+export interface ContextMenuSubProps extends MenuSubProps {
+    /** The open state of the submenu when it is initially rendered. Use when you do not need to control its open state. */
+    defaultOpen?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ContextMenuSubProps>, {
+    open: undefined;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (payload: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ContextMenuSubProps>, {
+    open: undefined;
+}>>> & {
+    "onUpdate:open"?: ((payload: boolean) => any) | undefined;
+}, {
+    open: boolean;
+}, {}>, Readonly<{
+    default: (props: {
+        /** Current open state */
+        open: boolean;
+    }) => any;
+}> & {
+    default: (props: {
+        /** Current open state */
+        open: boolean;
+    }) => any;
+}>;
+export default _default;
+type __VLS_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/ContextMenu/ContextMenuSubContent.d.ts

@@ -0,0 +1,39 @@
+import { MenuSubContentEmits, MenuSubContentProps } from '../Menu';
+
+export type ContextMenuSubContentEmits = MenuSubContentEmits;
+export interface ContextMenuSubContentProps extends MenuSubContentProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<ContextMenuSubContentProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => void;
+    pointerDownOutside: (event: import('../DismissableLayer').PointerDownOutsideEvent) => void;
+    focusOutside: (event: import('../DismissableLayer').FocusOutsideEvent) => void;
+    interactOutside: (event: import('../DismissableLayer').PointerDownOutsideEvent | import('../DismissableLayer').FocusOutsideEvent) => void;
+    openAutoFocus: (event: Event) => void;
+    closeAutoFocus: (event: Event) => void;
+    entryFocus: (event: Event) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<ContextMenuSubContentProps>>> & {
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: import('../DismissableLayer').PointerDownOutsideEvent) => any) | undefined;
+    onFocusOutside?: ((event: import('../DismissableLayer').FocusOutsideEvent) => any) | undefined;
+    onInteractOutside?: ((event: import('../DismissableLayer').PointerDownOutsideEvent | import('../DismissableLayer').FocusOutsideEvent) => any) | undefined;
+    onOpenAutoFocus?: ((event: Event) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+    onEntryFocus?: ((event: Event) => any) | undefined;
+}, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_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/ContextMenu/ContextMenuSubTrigger.d.ts

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

@@ -0,0 +1,45 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface ContextMenuTriggerProps extends PrimitiveProps {
+    /**
+     * When `true`, the context menu would not open when right-clicking.
+     *
+     * Note that this will also restore the native context menu.
+     */
+    disabled?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ContextMenuTriggerProps>, {
+    as: string;
+    disabled: boolean;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ContextMenuTriggerProps>, {
+    as: string;
+    disabled: boolean;
+}>>>, {
+    disabled: boolean;
+    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/ContextMenu/index.d.ts

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

package/dist/ContextMenu/utils.d.ts

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

package/dist/DateField/DateFieldInput.d.ts

@@ -0,0 +1,25 @@
+import { PrimitiveProps } from '../Primitive';
+import { SegmentPart } from '../shared/date';
+
+export interface DateFieldInputProps extends PrimitiveProps {
+    /** The part of the date to render */
+    part: SegmentPart;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<DateFieldInputProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<DateFieldInputProps>>>, {}, {}>, {
+    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/DateField/DateFieldRoot.d.ts

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

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