reka-ui 0.0.0 → 0.0.2

package/dist/Calendar/CalendarRoot.d.ts

@@ -0,0 +1,242 @@
+import { DateValue } from '@internationalized/date';
+import { Ref } from 'vue';
+import { PrimitiveProps } from '../Primitive';
+import { Formatter } from '../shared';
+import { Grid, Matcher, WeekDayFormat } from '../date';
+import { Direction } from '../shared/types';
+
+type CalendarRootContext = {
+    locale: Ref<string>;
+    modelValue: Ref<DateValue | 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>;
+    multiple: Ref<boolean>;
+    numberOfMonths: Ref<number>;
+    disabled: Ref<boolean>;
+    readonly: Ref<boolean>;
+    initialFocus: Ref<boolean>;
+    onDateChange: (date: DateValue) => void;
+    onPlaceholderChange: (date: DateValue) => void;
+    fullCalendarLabel: Ref<string>;
+    parentElement: Ref<HTMLElement | undefined>;
+    headingValue: Ref<string>;
+    isInvalid: Ref<boolean>;
+    isDateDisabled: Matcher;
+    isDateSelected: Matcher;
+    isDateUnavailable?: Matcher;
+    isOutsideVisibleView: (date: DateValue) => boolean;
+    prevPage: (prevPageFunc?: (date: DateValue) => DateValue) => void;
+    nextPage: (nextPageFunc?: (date: DateValue) => DateValue) => void;
+    isNextButtonDisabled: (nextPageFunc?: (date: DateValue) => DateValue) => boolean;
+    isPrevButtonDisabled: (prevPageFunc?: (date: DateValue) => DateValue) => boolean;
+    formatter: Formatter;
+    dir: Ref<Direction>;
+};
+interface BaseCalendarRootProps 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;
+    /** This property causes the previous and next buttons to navigate by the number of months displayed at once, rather than one month */
+    pagedNavigation?: boolean;
+    /** Whether or not to prevent the user from deselecting a date without selecting another date first */
+    preventDeselect?: boolean;
+    /** The day of the week to start the calendar on */
+    weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    /** The format to use for the weekday strings provided via the weekdays slot prop */
+    weekdayFormat?: WeekDayFormat;
+    /** The accessible label for the calendar */
+    calendarLabel?: string;
+    /** Whether or not to always display 6 weeks in the calendar */
+    fixedWeeks?: 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;
+    /** The number of months to display at once */
+    numberOfMonths?: number;
+    /** Whether or not the calendar is disabled */
+    disabled?: boolean;
+    /** Whether or not the calendar is readonly */
+    readonly?: boolean;
+    /** If true, the calendar will focus the selected day, today, or the first day of the month depending on what is visible when the calendar is mounted */
+    initialFocus?: boolean;
+    /** A function that returns whether or not a date is disabled */
+    isDateDisabled?: Matcher;
+    /** A function that returns whether or not a date is unavailable */
+    isDateUnavailable?: Matcher;
+    /** The reading direction of the calendar when applicable. <br> If omitted, inherits globally from `ConfigProvider` or assumes LTR (left-to-right) reading mode. */
+    dir?: Direction;
+    /** A function that returns the next page of the calendar. It receives the current placeholder as an argument inside the component. */
+    nextPage?: (placeholder: DateValue) => DateValue;
+    /** A function that returns the previous page of the calendar. It receives the current placeholder as an argument inside the component. */
+    prevPage?: (placeholder: DateValue) => DateValue;
+}
+export interface MultipleCalendarRootProps extends BaseCalendarRootProps {
+    /** The controlled checked state of the calendar. Can be bound as `v-model`. */
+    modelValue?: DateValue[] | undefined;
+    /** Whether or not multiple dates can be selected */
+    multiple: true;
+}
+export interface SingleCalendarRootProps extends BaseCalendarRootProps {
+    /** The controlled checked state of the calendar. Can be bound as `v-model`. */
+    modelValue?: DateValue | undefined;
+    /** Whether or not multiple dates can be selected */
+    multiple?: false;
+}
+export type CalendarRootProps = MultipleCalendarRootProps | SingleCalendarRootProps;
+export type CalendarRootEmits = {
+    /** 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 injectCalendarRootContext: <T extends CalendarRootContext | null | undefined = CalendarRootContext>(fallback?: T | undefined) => T extends null ? CalendarRootContext | null : CalendarRootContext, provideCalendarRootContext: (contextValue: CalendarRootContext) => CalendarRootContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<CalendarRootProps>, {
+    defaultValue: undefined;
+    as: string;
+    pagedNavigation: boolean;
+    preventDeselect: boolean;
+    weekStartsOn: number;
+    weekdayFormat: string;
+    fixedWeeks: boolean;
+    multiple: boolean;
+    numberOfMonths: number;
+    disabled: boolean;
+    readonly: boolean;
+    initialFocus: boolean;
+    placeholder: undefined;
+    isDateDisabled: undefined;
+    isDateUnavailable: undefined;
+}>, {}, 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<MultipleCalendarRootProps>, {
+    defaultValue: undefined;
+    as: string;
+    pagedNavigation: boolean;
+    preventDeselect: boolean;
+    weekStartsOn: number;
+    weekdayFormat: string;
+    fixedWeeks: boolean;
+    multiple: boolean;
+    numberOfMonths: number;
+    disabled: boolean;
+    readonly: boolean;
+    initialFocus: boolean;
+    placeholder: undefined;
+    isDateDisabled: undefined;
+    isDateUnavailable: undefined;
+}>> | import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<SingleCalendarRootProps>, {
+    defaultValue: undefined;
+    as: string;
+    pagedNavigation: boolean;
+    preventDeselect: boolean;
+    weekStartsOn: number;
+    weekdayFormat: string;
+    fixedWeeks: boolean;
+    multiple: boolean;
+    numberOfMonths: number;
+    disabled: boolean;
+    readonly: boolean;
+    initialFocus: boolean;
+    placeholder: undefined;
+    isDateDisabled: undefined;
+    isDateUnavailable: undefined;
+}>>> & {
+    "onUpdate:modelValue"?: ((date: DateValue | undefined) => any) | undefined;
+    "onUpdate:placeholder"?: ((date: DateValue) => any) | undefined;
+}, {
+    defaultValue: DateValue;
+    disabled: boolean;
+    multiple: true;
+    weekStartsOn: 0 | 2 | 1 | 3 | 4 | 5 | 6;
+    fixedWeeks: boolean;
+    numberOfMonths: number;
+    pagedNavigation: boolean;
+    as: import('../Primitive').AsTag | import('vue').Component;
+    placeholder: DateValue;
+    preventDeselect: boolean;
+    weekdayFormat: WeekDayFormat;
+    readonly: boolean;
+    initialFocus: boolean;
+    isDateDisabled: Matcher;
+    isDateUnavailable: Matcher;
+} | {
+    defaultValue: DateValue;
+    disabled: boolean;
+    multiple: false;
+    weekStartsOn: 0 | 2 | 1 | 3 | 4 | 5 | 6;
+    fixedWeeks: boolean;
+    numberOfMonths: number;
+    pagedNavigation: boolean;
+    as: import('../Primitive').AsTag | import('vue').Component;
+    placeholder: DateValue;
+    preventDeselect: boolean;
+    weekdayFormat: WeekDayFormat;
+    readonly: boolean;
+    initialFocus: boolean;
+    isDateDisabled: Matcher;
+    isDateUnavailable: Matcher;
+}, {}>, Readonly<{
+    default: (props: {
+        /** The current date of the placeholder */
+        date: DateValue;
+        /** The grid of dates */
+        grid: Grid<DateValue>[];
+        /** The days of the week */
+        weekDays: string[];
+        /** The start of the week */
+        weekStartsOn: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+        /** The calendar locale */
+        locale: string;
+        /** Whether or not to always display 6 weeks in the calendar */
+        fixedWeeks: boolean;
+    }) => any;
+}> & {
+    default: (props: {
+        /** The current date of the placeholder */
+        date: DateValue;
+        /** The grid of dates */
+        grid: Grid<DateValue>[];
+        /** The days of the week */
+        weekDays: string[];
+        /** The start of the week */
+        weekStartsOn: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+        /** The calendar locale */
+        locale: string;
+        /** Whether or not to always display 6 weeks in the calendar */
+        fixedWeeks: 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/Calendar/index.d.ts

@@ -0,0 +1,12 @@
+export { default as CalendarRoot, type CalendarRootProps, type CalendarRootEmits, } from './CalendarRoot';
+export { default as CalendarHeader, type CalendarHeaderProps, } from './CalendarHeader';
+export { default as CalendarHeading, type CalendarHeadingProps, } from './CalendarHeading';
+export { default as CalendarGrid, type CalendarGridProps, } from './CalendarGrid';
+export { default as CalendarCell, type CalendarCellProps, } from './CalendarCell';
+export { default as CalendarHeadCell, type CalendarHeadCellProps, } from './CalendarHeadCell';
+export { default as CalendarNext, type CalendarNextProps, } from './CalendarNext';
+export { default as CalendarPrev, type CalendarPrevProps, } from './CalendarPrev';
+export { default as CalendarGridHead, type CalendarGridHeadProps, } from './CalendarGridHead';
+export { default as CalendarGridBody, type CalendarGridBodyProps, } from './CalendarGridBody';
+export { default as CalendarGridRow, type CalendarGridRowProps, } from './CalendarGridRow';
+export { default as CalendarCellTrigger, type CalendarCellTriggerProps, } from './CalendarCellTrigger';

package/dist/Calendar/useCalendar.d.ts

@@ -0,0 +1,45 @@
+import { DateValue } from '@internationalized/date';
+import { Ref } from 'vue';
+import { Grid, Matcher, WeekDayFormat } from '../date';
+
+export type UseCalendarProps = {
+    locale: Ref<string>;
+    placeholder: Ref<DateValue>;
+    weekStartsOn: Ref<0 | 1 | 2 | 3 | 4 | 5 | 6>;
+    fixedWeeks: Ref<boolean>;
+    numberOfMonths: Ref<number>;
+    minValue: Ref<DateValue | undefined>;
+    maxValue: Ref<DateValue | undefined>;
+    disabled: Ref<boolean>;
+    weekdayFormat: Ref<WeekDayFormat>;
+    pagedNavigation: Ref<boolean>;
+    isDateDisabled?: Matcher;
+    isDateUnavailable?: Matcher;
+    calendarLabel: Ref<string | undefined>;
+    nextPage: Ref<((placeholder: DateValue) => DateValue) | undefined>;
+    prevPage: Ref<((placeholder: DateValue) => DateValue) | undefined>;
+};
+export type UseCalendarStateProps = {
+    isDateDisabled: Matcher;
+    isDateUnavailable: Matcher;
+    date: Ref<DateValue | DateValue[] | undefined>;
+};
+export declare function useCalendarState(props: UseCalendarStateProps): {
+    isDateSelected: (dateObj: DateValue) => boolean;
+    isInvalid: import('vue').ComputedRef<boolean>;
+};
+export declare function useCalendar(props: UseCalendarProps): {
+    isDateDisabled: (dateObj: DateValue) => boolean;
+    isDateUnavailable: (date: DateValue) => boolean;
+    isNextButtonDisabled: (nextPageFunc?: ((date: DateValue) => DateValue) | undefined) => boolean;
+    isPrevButtonDisabled: (prevPageFunc?: ((date: DateValue) => DateValue) | undefined) => boolean;
+    grid: Ref<Grid<DateValue>[]>;
+    weekdays: import('vue').ComputedRef<string[]>;
+    visibleView: import('vue').ComputedRef<DateValue[]>;
+    isOutsideVisibleView: (date: DateValue) => boolean;
+    formatter: import('../shared').Formatter;
+    nextPage: (nextPageFunc?: ((date: DateValue) => DateValue) | undefined) => void;
+    prevPage: (prevPageFunc?: ((date: DateValue) => DateValue) | undefined) => void;
+    headingValue: import('vue').ComputedRef<string>;
+    fullCalendarLabel: import('vue').ComputedRef<string>;
+};

package/dist/Checkbox/CheckboxGroupRoot.d.ts

@@ -0,0 +1,98 @@
+import { Ref } from 'vue';
+import { RovingFocusGroupProps } from '../RovingFocus';
+import { AcceptableValue } from '../shared/types';
+
+export interface CheckboxGroupRootProps<T = AcceptableValue> extends Pick<RovingFocusGroupProps, 'as' | 'asChild' | 'dir' | 'orientation' | 'loop'> {
+    /** The value of the checkbox when it is initially rendered. Use when you do not need to control its value. */
+    defaultValue?: T[];
+    /** The controlled value of the checkbox. Can be binded with v-model. */
+    modelValue?: T[];
+    /** When `false`, navigating through the items using arrow keys will be disabled. */
+    rovingFocus?: boolean;
+    /** When `true`, prevents the user from interacting with the checkboxes */
+    disabled?: boolean;
+    /** When `true`, indicates that the user must check the checkbox before the owning form can be submitted. */
+    required?: boolean;
+    /** The name of the checkbox. Submitted with its owning form as part of a name/value pair. */
+    name?: string;
+}
+export type CheckboxGroupRootEmits<T = AcceptableValue> = {
+    /** Event handler called when the value of the checkbox changes. */
+    'update:modelValue': [value: T[]];
+};
+interface CheckboxGroupRootContext {
+    modelValue: Ref<AcceptableValue[]>;
+    rovingFocus: Ref<boolean>;
+    disabled: Ref<boolean>;
+}
+export declare const injectCheckboxGroupRootContext: <T extends CheckboxGroupRootContext | null | undefined = CheckboxGroupRootContext>(fallback?: T | undefined) => T extends null ? CheckboxGroupRootContext | null : CheckboxGroupRootContext, provideCheckboxGroupRootContext: (contextValue: CheckboxGroupRootContext) => CheckboxGroupRootContext;
+declare const _default: <T extends AcceptableValue = AcceptableValue>(__VLS_props: {
+    defaultValue?: T[] | undefined;
+    dir?: import('../RovingFocus/utils').Direction | undefined;
+    disabled?: boolean | undefined;
+    loop?: boolean | undefined;
+    name?: string | undefined;
+    asChild?: boolean | undefined;
+    as?: import('../Primitive').AsTag | import('vue').Component | undefined;
+    required?: boolean | undefined;
+    modelValue?: T[] | undefined;
+    orientation?: import('../RovingFocus/utils').Orientation | undefined;
+    "onUpdate:modelValue"?: ((value: T[]) => any) | undefined;
+    rovingFocus?: boolean | undefined;
+} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, __VLS_ctx?: {
+    slots: {
+        default?(_: {}): any;
+    };
+    attrs: any;
+    emit: (evt: "update:modelValue", value: T[]) => void;
+} | undefined, __VLS_expose?: ((exposed: import('vue').ShallowUnwrapRef<{}>) => void) | undefined, __VLS_setup?: Promise<{
+    props: {
+        defaultValue?: T[] | undefined;
+        dir?: import('../RovingFocus/utils').Direction | undefined;
+        disabled?: boolean | undefined;
+        loop?: boolean | undefined;
+        name?: string | undefined;
+        asChild?: boolean | undefined;
+        as?: import('../Primitive').AsTag | import('vue').Component | undefined;
+        required?: boolean | undefined;
+        modelValue?: T[] | undefined;
+        orientation?: import('../RovingFocus/utils').Orientation | undefined;
+        "onUpdate:modelValue"?: ((value: T[]) => any) | undefined;
+        rovingFocus?: boolean | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        default?(_: {}): any;
+    };
+    emit: (evt: "update:modelValue", value: T[]) => void;
+}>) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> & {
+    __ctx?: {
+        props: {
+            defaultValue?: T[] | undefined;
+            dir?: import('../RovingFocus/utils').Direction | undefined;
+            disabled?: boolean | undefined;
+            loop?: boolean | undefined;
+            name?: string | undefined;
+            asChild?: boolean | undefined;
+            as?: import('../Primitive').AsTag | import('vue').Component | undefined;
+            required?: boolean | undefined;
+            modelValue?: T[] | undefined;
+            orientation?: import('../RovingFocus/utils').Orientation | undefined;
+            "onUpdate:modelValue"?: ((value: T[]) => any) | undefined;
+            rovingFocus?: boolean | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: {
+            default?(_: {}): any;
+        };
+        emit: (evt: "update:modelValue", value: T[]) => void;
+    } | undefined;
+};
+export default _default;
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/Checkbox/CheckboxIndicator.d.ts

@@ -0,0 +1,41 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface CheckboxIndicatorProps extends PrimitiveProps {
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with Vue animation libraries.
+     */
+    forceMount?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<CheckboxIndicatorProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<CheckboxIndicatorProps>, {
+    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/Checkbox/CheckboxRoot.d.ts

@@ -0,0 +1,87 @@
+import { PrimitiveProps } from '../Primitive';
+import { Ref } from 'vue';
+import { CheckedState } from './utils';
+import { AcceptableValue } from '../shared/types';
+
+export interface CheckboxRootProps extends PrimitiveProps {
+    /** The value of the checkbox when it is initially rendered. Use when you do not need to control its value. */
+    defaultValue?: boolean | 'indeterminate';
+    /** The controlled value of the checkbox. Can be binded with v-model. */
+    modelValue?: boolean | 'indeterminate';
+    /** When `true`, prevents the user from interacting with the checkbox */
+    disabled?: boolean;
+    /** When `true`, indicates that the user must check the checkbox before the owning form can be submitted. */
+    required?: boolean;
+    /** The name of the checkbox. Submitted with its owning form as part of a name/value pair. */
+    name?: string;
+    /**
+     * The value given as data when submitted with a `name`.
+     *  @defaultValue "on"
+     */
+    value?: AcceptableValue;
+    /** Id of the element */
+    id?: string;
+}
+export type CheckboxRootEmits = {
+    /** Event handler called when the value of the checkbox changes. */
+    'update:modelValue': [value: AcceptableValue];
+};
+interface CheckboxRootContext {
+    disabled: Ref<boolean>;
+    state: Ref<CheckedState>;
+}
+export declare const injectCheckboxRootContext: <T extends CheckboxRootContext | null | undefined = CheckboxRootContext>(fallback?: T | undefined) => T extends null ? CheckboxRootContext | null : CheckboxRootContext, provideCheckboxRootContext: (contextValue: CheckboxRootContext) => CheckboxRootContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<CheckboxRootProps>, {
+    defaultValue: boolean;
+    value: string;
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: AcceptableValue) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<CheckboxRootProps>, {
+    defaultValue: boolean;
+    value: string;
+    as: string;
+}>>> & {
+    "onUpdate:modelValue"?: ((value: AcceptableValue) => any) | undefined;
+}, {
+    defaultValue: boolean | "indeterminate";
+    value: AcceptableValue;
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, Readonly<{
+    default: (props: {
+        /** Current value */
+        modelValue: CheckedState;
+        /** Current state */
+        state: CheckedState;
+    }) => any;
+}> & {
+    default: (props: {
+        /** Current value */
+        modelValue: CheckedState;
+        /** Current state */
+        state: CheckedState;
+    }) => 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/Checkbox/index.d.ts

@@ -0,0 +1,4 @@
+export { default as CheckboxGroupRoot, type CheckboxGroupRootProps, type CheckboxGroupRootEmits, } from './CheckboxGroupRoot';
+export { default as CheckboxRoot, type CheckboxRootProps, type CheckboxRootEmits, } from './CheckboxRoot';
+export { default as CheckboxIndicator, type CheckboxIndicatorProps, } from './CheckboxIndicator';
+export type { CheckedState as CheckboxCheckedState, } from './utils';

package/dist/Checkbox/utils.d.ts

@@ -0,0 +1,3 @@
+export type CheckedState = boolean | 'indeterminate';
+export declare function isIndeterminate(checked?: CheckedState): checked is 'indeterminate';
+export declare function getState(checked: CheckedState): "indeterminate" | "checked" | "unchecked";

package/dist/Collapsible/CollapsibleContent.d.ts

@@ -0,0 +1,27 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface CollapsibleContentProps extends PrimitiveProps {
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with Vue animation libraries.
+     */
+    forceMount?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<CollapsibleContentProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<CollapsibleContentProps>>>, {}, {}>, {
+    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/Collapsible/CollapsibleRoot.d.ts

@@ -0,0 +1,77 @@
+import { PrimitiveProps } from '../Primitive';
+import { Ref } from 'vue';
+
+export interface CollapsibleRootProps extends PrimitiveProps {
+    /** The open state of the collapsible when it is initially rendered. <br> Use when you do not need to control its open state. */
+    defaultOpen?: boolean;
+    /** The controlled open state of the collapsible. Can be binded with `v-model`. */
+    open?: boolean;
+    /** When `true`, prevents the user from interacting with the collapsible. */
+    disabled?: boolean;
+    /** When `true`, the element will be unmounted on closed state. */
+    unmountOnHide?: boolean;
+}
+export type CollapsibleRootEmits = {
+    /** Event handler called when the open state of the collapsible changes. */
+    'update:open': [value: boolean];
+};
+interface CollapsibleRootContext {
+    contentId: string;
+    disabled?: Ref<boolean>;
+    open: Ref<boolean>;
+    unmountOnHide: Ref<boolean>;
+    onOpenToggle: () => void;
+}
+export declare const injectCollapsibleRootContext: <T extends CollapsibleRootContext | null | undefined = CollapsibleRootContext>(fallback?: T | undefined) => T extends null ? CollapsibleRootContext | null : CollapsibleRootContext, provideCollapsibleRootContext: (contextValue: CollapsibleRootContext) => CollapsibleRootContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<CollapsibleRootProps>, {
+    open: undefined;
+    defaultOpen: boolean;
+    unmountOnHide: boolean;
+}>, {
+    open: Ref<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<CollapsibleRootProps>, {
+    open: undefined;
+    defaultOpen: boolean;
+    unmountOnHide: boolean;
+}>>> & {
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}, {
+    defaultOpen: boolean;
+    open: boolean;
+    unmountOnHide: 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;
+    };
+};