reka-ui 0.0.0 → 0.0.2

package/dist/Popper/PopperContent.d.ts

@@ -0,0 +1,204 @@
+import { Ref } from 'vue';
+import { ReferenceElement } from '@floating-ui/vue';
+import { PrimitiveProps } from '../Primitive';
+import { Align, Side } from './utils';
+
+export declare const PopperContentPropsDefaultValue: {
+    side: "right" | "left" | "top" | "bottom";
+    sideOffset: number;
+    align: "center" | "end" | "start";
+    alignOffset: number;
+    arrowPadding: number;
+    avoidCollisions: boolean;
+    collisionBoundary: () => never[];
+    collisionPadding: number;
+    sticky: "partial" | "always";
+    hideWhenDetached: boolean;
+    positionStrategy: "fixed" | "absolute";
+    updatePositionStrategy: "always" | "optimized";
+    prioritizePosition: boolean;
+};
+export interface PopperContentProps extends PrimitiveProps {
+    /**
+     * The preferred side of the trigger to render against when open.
+     * Will be reversed when collisions occur and avoidCollisions
+     * is enabled.
+     *
+     * @defaultValue "top"
+     */
+    side?: Side;
+    /**
+     * The distance in pixels from the trigger.
+     *
+     * @defaultValue 0
+     */
+    sideOffset?: number;
+    /**
+     * The preferred alignment against the trigger.
+     * May change when collisions occur.
+     *
+     * @defaultValue "center"
+     */
+    align?: Align;
+    /**
+     * An offset in pixels from the `start` or `end` alignment options.
+     *
+     * @defaultValue 0
+     */
+    alignOffset?: number;
+    /**
+     * When `true`, overrides the side and align preferences
+     * to prevent collisions with boundary edges.
+     *
+     * @defaultValue true
+     */
+    avoidCollisions?: boolean;
+    /**
+     * The element used as the collision boundary. By default
+     * this is the viewport, though you can provide additional
+     * element(s) to be included in this check.
+     *
+     * @defaultValue []
+     */
+    collisionBoundary?: Element | null | Array<Element | null>;
+    /**
+     * The distance in pixels from the boundary edges where collision
+     * detection should occur. Accepts a number (same for all sides),
+     * or a partial padding object, for example: { top: 20, left: 20 }.
+     *
+     * @defaultValue 0
+     */
+    collisionPadding?: number | Partial<Record<Side, number>>;
+    /**
+     * The padding between the arrow and the edges of the content.
+     * If your content has border-radius, this will prevent it from
+     * overflowing the corners.
+     *
+     * @defaultValue 0
+     */
+    arrowPadding?: number;
+    /**
+     * The sticky behavior on the align axis. `partial` will keep the
+     * content in the boundary as long as the trigger is at least partially
+     * in the boundary whilst "always" will keep the content in the boundary
+     * regardless.
+     *
+     * @defaultValue "partial"
+     */
+    sticky?: 'partial' | 'always';
+    /**
+     * Whether to hide the content when the trigger becomes fully occluded.
+     *
+     * @defaultValue false
+     */
+    hideWhenDetached?: boolean;
+    /**
+     *  The type of CSS position property to use.
+     */
+    positionStrategy?: 'absolute' | 'fixed';
+    /**
+     * Strategy to update the position of the floating element on every animation frame.
+     *
+     * @defaultValue 'optimized'
+     */
+    updatePositionStrategy?: 'optimized' | 'always';
+    /**
+     * Whether to disable the update position for the content when the layout shifted.
+     *
+     * @defaultValue false
+     */
+    disableUpdateOnLayoutShift?: boolean;
+    /**
+     * Force content to be position within the viewport.
+     *
+     * Might overlap the reference element, which may not be desired.
+     *
+     * @defaultValue false
+     */
+    prioritizePosition?: boolean;
+    /**
+     *  The custom element or virtual element that will be set as the reference
+     *  to position the floating element.
+     *
+     *  If provided, it will replace the default anchor element.
+     */
+    reference?: ReferenceElement;
+}
+export interface PopperContentContext {
+    placedSide: Ref<Side>;
+    onArrowChange: (arrow: HTMLElement | undefined) => void;
+    arrowX?: Ref<number>;
+    arrowY?: Ref<number>;
+    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<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<PopperContentProps>, {
+    side: "right" | "left" | "top" | "bottom";
+    sideOffset: number;
+    align: "center" | "end" | "start";
+    alignOffset: number;
+    arrowPadding: number;
+    avoidCollisions: boolean;
+    collisionBoundary: () => never[];
+    collisionPadding: number;
+    sticky: "partial" | "always";
+    hideWhenDetached: boolean;
+    positionStrategy: "fixed" | "absolute";
+    updatePositionStrategy: "always" | "optimized";
+    prioritizePosition: boolean;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    [x: string]: (...args: unknown[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<PopperContentProps>, {
+    side: "right" | "left" | "top" | "bottom";
+    sideOffset: number;
+    align: "center" | "end" | "start";
+    alignOffset: number;
+    arrowPadding: number;
+    avoidCollisions: boolean;
+    collisionBoundary: () => never[];
+    collisionPadding: number;
+    sticky: "partial" | "always";
+    hideWhenDetached: boolean;
+    positionStrategy: "fixed" | "absolute";
+    updatePositionStrategy: "always" | "optimized";
+    prioritizePosition: boolean;
+}>>>, {
+    side: "right" | "left" | "top" | "bottom";
+    align: "center" | "end" | "start";
+    sideOffset: number;
+    alignOffset: number;
+    avoidCollisions: boolean;
+    collisionBoundary: Element | (Element | null)[] | null;
+    collisionPadding: number | Partial<Record<"right" | "left" | "top" | "bottom", number>>;
+    arrowPadding: number;
+    sticky: "partial" | "always";
+    hideWhenDetached: boolean;
+    positionStrategy: "fixed" | "absolute";
+    updatePositionStrategy: "always" | "optimized";
+    prioritizePosition: 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/Popper/PopperRoot.d.ts

@@ -0,0 +1,20 @@
+import { Ref } from 'vue';
+import { ReferenceElement } from '@floating-ui/vue';
+
+export interface Measurable {
+    getBoundingClientRect: () => DOMRect;
+}
+interface PopperRootContext {
+    anchor: Ref<ReferenceElement | undefined>;
+    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<import('vue').ExtractPropTypes<{}>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Popper/index.d.ts

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

package/dist/Popper/utils.d.ts

@@ -0,0 +1,13 @@
+import { Middleware, Placement } from '@floating-ui/vue';
+
+declare const SIDE_OPTIONS: readonly ["top", "right", "bottom", "left"];
+declare const ALIGN_OPTIONS: readonly ["start", "center", "end"];
+export type Side = (typeof SIDE_OPTIONS)[number];
+export type Align = (typeof ALIGN_OPTIONS)[number];
+export declare function isNotNull<T>(value: T | null): value is T;
+export declare function transformOrigin(options: {
+    arrowWidth: number;
+    arrowHeight: number;
+}): Middleware;
+export declare function getSideAndAlignFromPlacement(placement: Placement): readonly ["right" | "left" | "top" | "bottom", "center" | "end" | "start"];
+export {};

package/dist/Presence/Presence.d.ts

@@ -0,0 +1,44 @@
+import { SlotsType, VNode } from 'vue';
+
+export interface PresenceProps {
+    /**
+     * Conditional to mount or unmount the child element. Similar to `v-if`
+     *
+     * @required true
+     */
+    present: boolean;
+    /**
+     * Force the element to render all the time.
+     *
+     * Useful for programmatically render grandchild component with the exposed `present`
+     *
+     * @defaultValue false
+     */
+    forceMount?: boolean;
+}
+declare const _default: import('vue').DefineComponent<{
+    present: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    forceMount: {
+        type: BooleanConstructor;
+    };
+}, () => VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> | null, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    present: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    forceMount: {
+        type: BooleanConstructor;
+    };
+}>>, {
+    forceMount: boolean;
+}, SlotsType<{
+    default: (opts: {
+        present: boolean;
+    }) => any;
+}>>;
+export default _default;

package/dist/Presence/index.d.ts

@@ -0,0 +1 @@
+export { default as Presence, type PresenceProps } from './Presence';

package/dist/Presence/usePresence.d.ts

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

package/dist/Primitive/Primitive.d.ts

@@ -0,0 +1,40 @@
+import { Component, PropType } 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 {
+    /**
+     * Change the default rendered element for the one passed as a child, merging their props and behavior.
+     *
+     * Read our [Composition](https://www.reka-ui.com/docs/guides/composition) guide for more details.
+     */
+    asChild?: boolean;
+    /**
+     * The element or component this component should render as. Can be overwrite by `asChild`
+     * @defaultValue "div"
+     */
+    as?: AsTag | Component;
+}
+export declare const Primitive: import('vue').DefineComponent<{
+    asChild: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    as: {
+        type: PropType<AsTag | Component>;
+        default: string;
+    };
+}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    asChild: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    as: {
+        type: PropType<AsTag | Component>;
+        default: string;
+    };
+}>>, {
+    asChild: boolean;
+    as: AsTag | Component;
+}, {}>;

package/dist/Primitive/Slot.d.ts

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

package/dist/Primitive/index.d.ts

@@ -0,0 +1,3 @@
+export { Primitive, type PrimitiveProps, type AsTag } from './Primitive';
+export { Slot } from './Slot';
+export { usePrimitiveElement } from './usePrimitiveElement';

package/dist/Primitive/usePrimitiveElement.d.ts

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

package/dist/Progress/ProgressIndicator.d.ts

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

@@ -0,0 +1,77 @@
+import { ComputedRef, Ref } from 'vue';
+import { PrimitiveProps } from '../Primitive';
+
+export type ProgressRootEmits = {
+    /** Event handler called when the progress value changes */
+    'update:modelValue': [value: string[] | undefined];
+    /** Event handler called when the max value changes */
+    'update:max': [value: number];
+};
+export interface ProgressRootProps extends PrimitiveProps {
+    /** The progress value. Can be bind as `v-model`. */
+    modelValue?: number | null;
+    /** The maximum progress value. */
+    max?: number;
+    /**
+     * A function to get the accessible label text representing the current value in a human-readable format.
+     *
+     *  If not provided, the value label will be read as the numeric value as a percentage of the max value.
+     */
+    getValueLabel?: (value: number, max: number) => string;
+}
+interface ProgressRootContext {
+    modelValue?: Readonly<Ref<ProgressRootProps['modelValue']>>;
+    max: Readonly<Ref<number>>;
+    progressState: ComputedRef<ProgressState>;
+}
+export declare const injectProgressRootContext: <T extends ProgressRootContext | null | undefined = ProgressRootContext>(fallback?: T | undefined) => T extends null ? ProgressRootContext | null : ProgressRootContext, provideProgressRootContext: (contextValue: ProgressRootContext) => ProgressRootContext;
+export type ProgressState = 'indeterminate' | 'loading' | 'complete';
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ProgressRootProps>, {
+    max: number;
+    getValueLabel: (value: number, max: number) => string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string[] | undefined) => void;
+    "update:max": (value: number) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ProgressRootProps>, {
+    max: number;
+    getValueLabel: (value: number, max: number) => string;
+}>>> & {
+    "onUpdate:modelValue"?: ((value: string[] | undefined) => any) | undefined;
+    "onUpdate:max"?: ((value: number) => any) | undefined;
+}, {
+    max: number;
+    getValueLabel: (value: number, max: number) => string;
+}, {}>, Readonly<{
+    default: (props: {
+        /** Current input values */
+        modelValue: number | null | undefined;
+    }) => any;
+}> & {
+    default: (props: {
+        /** Current input values */
+        modelValue: number | null | undefined;
+    }) => 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/Progress/index.d.ts

@@ -0,0 +1,2 @@
+export { default as ProgressRoot, type ProgressRootProps, type ProgressRootEmits, } from './ProgressRoot';
+export { default as ProgressIndicator, type ProgressIndicatorProps, } from './ProgressIndicator';

package/dist/RadioGroup/Radio.d.ts

@@ -0,0 +1,71 @@
+import { PrimitiveProps } from '../Primitive';
+import { SelectEvent } from './utils';
+import { AcceptableValue } from '../shared/types';
+
+export type RadioEmits = {
+    'update:checked': [value: boolean];
+    'select': [SelectEvent];
+};
+export interface RadioProps extends PrimitiveProps {
+    id?: string;
+    /** The value given as data when submitted with a `name`. */
+    value?: AcceptableValue;
+    /** When `true`, prevents the user from interacting with the radio item. */
+    disabled?: boolean;
+    /** When `true`, indicates that the user must check the radio item before the owning form can be submitted. */
+    required?: boolean;
+    checked?: boolean;
+    name?: string;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<RadioProps>, {
+    disabled: boolean;
+    checked: undefined;
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (args_0: SelectEvent) => void;
+    "update:checked": (value: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<RadioProps>, {
+    disabled: boolean;
+    checked: undefined;
+    as: string;
+}>>> & {
+    onSelect?: ((args_0: SelectEvent) => any) | undefined;
+    "onUpdate:checked"?: ((value: boolean) => any) | undefined;
+}, {
+    disabled: boolean;
+    as: import('../Primitive').AsTag | import('vue').Component;
+    checked: boolean;
+}, {}>, Readonly<{
+    default: (props: {
+        /** Current checked state */
+        checked: boolean | undefined;
+    }) => any;
+}> & {
+    default: (props: {
+        /** Current checked state */
+        checked: boolean | undefined;
+    }) => 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/RadioGroup/RadioGroupIndicator.d.ts

@@ -0,0 +1,41 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface RadioGroupIndicatorProps 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<RadioGroupIndicatorProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<RadioGroupIndicatorProps>, {
+    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/RadioGroup/RadioGroupItem.d.ts

@@ -0,0 +1,53 @@
+import { ComputedRef } from 'vue';
+import { RadioProps } from './Radio';
+import { SelectEvent } from './utils';
+
+export interface RadioGroupItemProps extends Omit<RadioProps, 'checked'> {
+}
+export type RadioGroupItemEmits = {
+    select: [event: SelectEvent];
+};
+interface RadioGroupItemContext {
+    disabled: ComputedRef<boolean>;
+    checked: ComputedRef<boolean>;
+}
+export declare const injectRadioGroupItemContext: <T extends RadioGroupItemContext | null | undefined = RadioGroupItemContext>(fallback?: T | undefined) => T extends null ? RadioGroupItemContext | null : RadioGroupItemContext, provideRadiogroupItemContext: (contextValue: RadioGroupItemContext) => RadioGroupItemContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<RadioGroupItemProps>, {
+    disabled: boolean;
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (event: SelectEvent) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<RadioGroupItemProps>, {
+    disabled: boolean;
+    as: string;
+}>>> & {
+    onSelect?: ((event: SelectEvent) => any) | undefined;
+}, {
+    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;
+    };
+};