reka-ui 0.0.0 → 0.0.2

package/dist/DatePicker/DatePickerRoot.d.ts

@@ -0,0 +1,132 @@
+import { DateValue } from '@internationalized/date';
+import { Ref } from 'vue';
+import { Granularity, HourCycle } from '../shared/date';
+import { Matcher, WeekDayFormat } from '../date';
+import { CalendarRootProps, DateFieldRoot, DateFieldRootProps, PopoverRootProps } from '..';
+import { Direction } from '../shared/types';
+
+type DatePickerRootContext = {
+    id: Ref<string | undefined>;
+    name: Ref<string | undefined>;
+    minValue: Ref<DateValue | undefined>;
+    maxValue: Ref<DateValue | undefined>;
+    hourCycle: Ref<HourCycle | undefined>;
+    granularity: Ref<Granularity | undefined>;
+    hideTimeZone: Ref<boolean>;
+    required: Ref<boolean>;
+    locale: Ref<string>;
+    dateFieldRef: Ref<InstanceType<typeof DateFieldRoot> | undefined>;
+    modelValue: Ref<DateValue | undefined>;
+    placeholder: Ref<DateValue>;
+    pagedNavigation: Ref<boolean>;
+    preventDeselect: Ref<boolean>;
+    weekStartsOn: Ref<0 | 1 | 2 | 3 | 4 | 5 | 6>;
+    weekdayFormat: Ref<WeekDayFormat>;
+    fixedWeeks: Ref<boolean>;
+    numberOfMonths: Ref<number>;
+    disabled: Ref<boolean>;
+    readonly: Ref<boolean>;
+    isDateDisabled?: Matcher;
+    isDateUnavailable?: Matcher;
+    defaultOpen: Ref<boolean>;
+    open: Ref<boolean>;
+    modal: Ref<boolean>;
+    onDateChange: (date: DateValue | undefined) => void;
+    onPlaceholderChange: (date: DateValue) => void;
+    dir: Ref<Direction>;
+};
+export type DatePickerRootProps = DateFieldRootProps & PopoverRootProps & Pick<CalendarRootProps, 'isDateDisabled' | 'pagedNavigation' | 'weekStartsOn' | 'weekdayFormat' | 'fixedWeeks' | 'numberOfMonths' | 'preventDeselect'>;
+export type DatePickerRootEmits = {
+    /** 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 injectDatePickerRootContext: <T extends DatePickerRootContext | null | undefined = DatePickerRootContext>(fallback?: T | undefined) => T extends null ? DatePickerRootContext | null : DatePickerRootContext, provideDatePickerRootContext: (contextValue: DatePickerRootContext) => DatePickerRootContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<DatePickerRootProps>, {
+    defaultValue: undefined;
+    defaultOpen: boolean;
+    open: undefined;
+    modal: boolean;
+    pagedNavigation: boolean;
+    preventDeselect: boolean;
+    weekStartsOn: number;
+    weekdayFormat: string;
+    fixedWeeks: boolean;
+    numberOfMonths: number;
+    disabled: boolean;
+    readonly: boolean;
+    initialFocus: boolean;
+    placeholder: undefined;
+    locale: string;
+    isDateDisabled: undefined;
+    isDateUnavailable: undefined;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (value: boolean) => void;
+    "update:modelValue": (date: DateValue | undefined) => void;
+    "update:placeholder": (date: DateValue) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<DatePickerRootProps>, {
+    defaultValue: undefined;
+    defaultOpen: boolean;
+    open: undefined;
+    modal: boolean;
+    pagedNavigation: boolean;
+    preventDeselect: boolean;
+    weekStartsOn: number;
+    weekdayFormat: string;
+    fixedWeeks: boolean;
+    numberOfMonths: number;
+    disabled: boolean;
+    readonly: boolean;
+    initialFocus: boolean;
+    placeholder: undefined;
+    locale: string;
+    isDateDisabled: undefined;
+    isDateUnavailable: undefined;
+}>>> & {
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    "onUpdate:modelValue"?: ((date: DateValue | undefined) => any) | undefined;
+    "onUpdate:placeholder"?: ((date: DateValue) => any) | undefined;
+}, {
+    defaultValue: DateValue;
+    disabled: boolean;
+    locale: string;
+    weekStartsOn: 0 | 2 | 1 | 3 | 4 | 5 | 6;
+    fixedWeeks: boolean;
+    numberOfMonths: number;
+    pagedNavigation: boolean;
+    defaultOpen: boolean;
+    open: boolean;
+    modal: boolean;
+    placeholder: DateValue;
+    preventDeselect: boolean;
+    weekdayFormat: WeekDayFormat;
+    readonly: boolean;
+    isDateDisabled: Matcher;
+    isDateUnavailable: Matcher;
+}, {}>, {
+    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/DatePicker/DatePickerTrigger.d.ts

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

@@ -0,0 +1,20 @@
+export { default as DatePickerHeader, type DatePickerHeaderProps } from './DatePickerHeader';
+export { default as DatePickerHeading, type DatePickerHeadingProps } from './DatePickerHeading';
+export { default as DatePickerGrid, type DatePickerGridProps } from './DatePickerGrid';
+export { default as DatePickerCell, type DatePickerCellProps } from './DatePickerCell';
+export { default as DatePickerHeadCell, type DatePickerHeadCellProps } from './DatePickerHeadCell';
+export { default as DatePickerNext, type DatePickerNextProps } from './DatePickerNext';
+export { default as DatePickerPrev, type DatePickerPrevProps } from './DatePickerPrev';
+export { default as DatePickerGridHead, type DatePickerGridHeadProps } from './DatePickerGridHead';
+export { default as DatePickerGridBody, type DatePickerGridBodyProps } from './DatePickerGridBody';
+export { default as DatePickerGridRow, type DatePickerGridRowProps } from './DatePickerGridRow';
+export { default as DatePickerCellTrigger, type DatePickerCellTriggerProps } from './DatePickerCellTrigger';
+export { default as DatePickerInput, type DatePickerInputProps } from './DatePickerInput';
+export { default as DatePickerRoot, type DatePickerRootProps, type DatePickerRootEmits } from './DatePickerRoot';
+export { default as DatePickerCalendar } from './DatePickerCalendar';
+export { default as DatePickerField } from './DatePickerField';
+export { default as DatePickerAnchor } from './DatePickerAnchor';
+export { default as DatePickerArrow } from './DatePickerArrow';
+export { default as DatePickerClose } from './DatePickerClose';
+export { default as DatePickerTrigger, type DatePickerTriggerProps } from './DatePickerTrigger';
+export { default as DatePickerContent, type DatePickerContentProps } from './DatePickerContent';

package/dist/DateRangeField/DateRangeFieldInput.d.ts

@@ -0,0 +1,28 @@
+import { PrimitiveProps } from '../Primitive';
+import { SegmentPart } from '../shared/date';
+import { DateRangeType } from './DateRangeFieldRoot';
+
+export interface DateRangeFieldInputProps extends PrimitiveProps {
+    /** The part of the date to render */
+    part: SegmentPart;
+    /** The type of field to render (start or end) */
+    type: DateRangeType;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<DateRangeFieldInputProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<DateRangeFieldInputProps>>>, {}, {}>, {
+    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/DateRangeField/DateRangeFieldRoot.d.ts

@@ -0,0 +1,142 @@
+import { DateValue } from '@internationalized/date';
+import { Ref } from 'vue';
+import { PrimitiveProps } from '../Primitive';
+import { Formatter } from '../shared';
+import { DateRange, Granularity, HourCycle, SegmentPart, SegmentValueObj } from '../shared/date';
+import { Matcher } from '../date';
+import { Direction } from '../shared/types';
+
+export type DateRangeType = 'start' | 'end';
+type DateRangeFieldRootContext = {
+    locale: Ref<string>;
+    startValue: Ref<DateValue | undefined>;
+    endValue: Ref<DateValue | undefined>;
+    placeholder: Ref<DateValue>;
+    isDateUnavailable?: Matcher;
+    isInvalid: Ref<boolean>;
+    disabled: Ref<boolean>;
+    readonly: Ref<boolean>;
+    formatter: Formatter;
+    hourCycle: HourCycle;
+    segmentValues: Record<DateRangeType, Ref<SegmentValueObj>>;
+    segmentContents: Ref<{
+        start: {
+            part: SegmentPart;
+            value: string;
+        }[];
+        end: {
+            part: SegmentPart;
+            value: string;
+        }[];
+    }>;
+    elements: Ref<Set<HTMLElement>>;
+    focusNext: () => void;
+    setFocusedElement: (el: HTMLElement) => void;
+};
+export interface DateRangeFieldRootProps extends PrimitiveProps {
+    /** The default value for the calendar */
+    defaultValue?: DateRange;
+    /** 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?: DateRange;
+    /** 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. */
+    /** 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 DateRangeFieldRootEmits = {
+    /** Event handler called whenever the model value changes */
+    'update:modelValue': [DateRange];
+    /** Event handler called whenever the placeholder value changes */
+    'update:placeholder': [date: DateValue];
+};
+export declare const injectDateRangeFieldRootContext: <T extends DateRangeFieldRootContext | null | undefined = DateRangeFieldRootContext>(fallback?: T | undefined) => T extends null ? DateRangeFieldRootContext | null : DateRangeFieldRootContext, provideDateRangeFieldRootContext: (contextValue: DateRangeFieldRootContext) => DateRangeFieldRootContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<DateRangeFieldRootProps>, {
+    defaultValue: undefined;
+    disabled: boolean;
+    readonly: boolean;
+    placeholder: undefined;
+    isDateUnavailable: undefined;
+}>, {
+    setFocusedElement: (el: HTMLElement) => void;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (args_0: DateRange) => void;
+    "update:placeholder": (date: DateValue) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<DateRangeFieldRootProps>, {
+    defaultValue: undefined;
+    disabled: boolean;
+    readonly: boolean;
+    placeholder: undefined;
+    isDateUnavailable: undefined;
+}>>> & {
+    "onUpdate:modelValue"?: ((args_0: DateRange) => any) | undefined;
+    "onUpdate:placeholder"?: ((date: DateValue) => any) | undefined;
+}, {
+    defaultValue: DateRange;
+    disabled: boolean;
+    placeholder: DateValue;
+    readonly: boolean;
+    isDateUnavailable: Matcher;
+}, {}>, {
+    default?(_: {
+        modelValue: DateRange;
+        segments: {
+            start: {
+                part: SegmentPart;
+                value: string;
+            }[];
+            end: {
+                part: SegmentPart;
+                value: string;
+            }[];
+        };
+    }): 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/DateRangeField/index.d.ts

@@ -0,0 +1,2 @@
+export { type DateRangeFieldRootEmits, type DateRangeFieldRootProps, default as DateRangeFieldRoot } from './DateRangeFieldRoot';
+export { type DateRangeFieldInputProps, default as DateRangeFieldInput } from './DateRangeFieldInput';

package/dist/DateRangePicker/DateRangePickerAnchor.d.ts

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

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

@@ -0,0 +1,16 @@
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{}>>, {}, {}>, {
+    default?(_: {
+        date: import('@internationalized/date').DateValue;
+        grid: import('../date').Grid<import('@internationalized/date').DateValue>[];
+        weekDays: string[];
+        weekStartsOn: 0 | 2 | 1 | 3 | 4 | 5 | 6;
+        locale: string;
+        fixedWeeks: boolean;
+    }): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/DateRangePicker/DateRangePickerCell.d.ts

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

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

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

@@ -0,0 +1,38 @@
+import { PopoverContentEmits, PopoverContentProps } from '..';
+
+export interface DateRangePickerContentProps extends PopoverContentProps {
+}
+export interface DateRangePickerContentEmits extends PopoverContentEmits {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<DateRangePickerContentProps>, {}, 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<DateRangePickerContentProps>>> & {
+    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/DateRangePicker/DateRangePickerField.d.ts

@@ -0,0 +1,21 @@
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{}>>, {}, {}>, {
+    default?(_: {
+        segments: {
+            start: {
+                part: import('../shared/date').SegmentPart;
+                value: string;
+            }[];
+            end: {
+                part: import('../shared/date').SegmentPart;
+                value: string;
+            }[];
+        };
+        modelValue: import('../shared/date/types').DateRange;
+    }): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/DateRangePicker/DateRangePickerGrid.d.ts

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

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

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

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