@vunset/vue 0.0.0-stage → 1.0.0-rc.2

package/dist/components/progress/ProgressRoot.vue.d.ts

@@ -0,0 +1,33 @@
+import { type GaugeState } from '../../shared/use-gauge';
+type __VLS_Props = {
+    /** The value, or `null` while there is no telling how far along it is. */
+    value: number | null;
+    /** The lower end of the range. */
+    min?: number;
+    /** The upper end of the range. */
+    max?: number;
+    /** How the value is shown and read out, as `Intl.NumberFormat` options. The bare number otherwise. */
+    format?: Intl.NumberFormatOptions;
+    /** The locale `format` uses. The runtime's own by default. */
+    locale?: Intl.LocalesArgument;
+    /** The text read out for the value, from the formatted value and the raw one: "3 of 7 steps" rather than "3". */
+    getValueText?: (formattedValue: string, value: number | null) => string;
+    /** Element or component to render. */
+    as?: string | object;
+};
+type __VLS_Slots = {
+    default(props: GaugeState): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, import("../../shared/use-gauge").UseGaugeReturn, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    as: string | object;
+    min: number;
+    max: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/progress/ProgressRoot.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,43 @@
+import { mergeProps as mergeProps$1 } from "../../shared/merge-props.js";
+import { Part } from "../../shared/part.js";
+import { provideGaugeContext, useGauge } from "../../shared/use-gauge.js";
+import { computed, createBlock, defineComponent, guardReactiveProps, mergeProps, normalizeProps, openBlock, renderSlot, unref, useAttrs, withCtx } from "vue";
+//#region src/components/progress/ProgressRoot.vue?vue&type=script&setup=true&lang.ts
+var ProgressRoot_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "ProgressRoot",
+	inheritAttrs: false,
+	__name: "ProgressRoot",
+	props: {
+		value: {},
+		min: { default: 0 },
+		max: { default: 100 },
+		format: {},
+		locale: {},
+		getValueText: {},
+		as: { default: "div" }
+	},
+	setup(__props, { expose: __expose }) {
+		const props = __props;
+		const api = useGauge({
+			role: "progressbar",
+			value: () => props.value,
+			min: () => props.min,
+			max: () => props.max,
+			format: () => props.format,
+			locale: () => props.locale,
+			getValueText: props.getValueText
+		});
+		provideGaugeContext(api);
+		__expose(api);
+		const attrs = useAttrs();
+		const rootProps = computed(() => mergeProps$1(api.rootProps.value, attrs));
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Part), mergeProps({ as: props.as }, rootProps.value), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(unref(api).state.value)))]),
+				_: 3
+			}, 16, ["as"]);
+		};
+	}
+});
+//#endregion
+export { ProgressRoot_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/progress/ProgressTrack.js

@@ -0,0 +1,5 @@
+import ProgressTrack_vue_vue_type_script_setup_true_lang_default from "./ProgressTrack.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/progress/ProgressTrack.vue
+var ProgressTrack_default = ProgressTrack_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { ProgressTrack_default as default };

package/dist/components/progress/ProgressTrack.vue.d.ts

@@ -0,0 +1,22 @@
+import { type GaugeState } from '../../shared/use-gauge';
+type __VLS_Props = {
+    /** Element or component to render. */
+    as?: string | object;
+};
+type __VLS_Slots = {
+    /**
+     * @slotOnly The element carries only `data-status`.
+     */
+    default(props: GaugeState): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    as: string | object;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/progress/ProgressTrack.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,24 @@
+import { Part } from "../../shared/part.js";
+import { usePartProps } from "../../shared/use-part-props.js";
+import { useGaugeContext } from "../../shared/use-gauge.js";
+import { createBlock, defineComponent, guardReactiveProps, mergeProps, normalizeProps, openBlock, renderSlot, unref, withCtx } from "vue";
+//#region src/components/progress/ProgressTrack.vue?vue&type=script&setup=true&lang.ts
+var ProgressTrack_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "ProgressTrack",
+	inheritAttrs: false,
+	__name: "ProgressTrack",
+	props: { as: { default: "div" } },
+	setup(__props) {
+		const props = __props;
+		const { trackProps, state } = useGaugeContext();
+		const merged = usePartProps(trackProps);
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Part), mergeProps({ as: props.as }, unref(merged)), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(unref(state))))]),
+				_: 3
+			}, 16, ["as"]);
+		};
+	}
+});
+//#endregion
+export { ProgressTrack_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/progress/ProgressValue.js

@@ -0,0 +1,5 @@
+import ProgressValue_vue_vue_type_script_setup_true_lang_default from "./ProgressValue.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/progress/ProgressValue.vue
+var ProgressValue_default = ProgressValue_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { ProgressValue_default as default };

package/dist/components/progress/ProgressValue.vue.d.ts

@@ -0,0 +1,23 @@
+import { type GaugeState } from '../../shared/use-gauge';
+type __VLS_Props = {
+    /** Element or component to render. */
+    as?: string | object;
+};
+type __VLS_Slots = {
+    /**
+     * Shows the formatted value when left empty.
+     * @slotOnly The element carries no state, and is hidden from assistive technology: the root reads the value out.
+     */
+    default(props: GaugeState): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    as: string | object;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/progress/ProgressValue.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,24 @@
+import { Part } from "../../shared/part.js";
+import { usePartProps } from "../../shared/use-part-props.js";
+import { useGaugeContext } from "../../shared/use-gauge.js";
+import { createBlock, createTextVNode, defineComponent, guardReactiveProps, mergeProps, normalizeProps, openBlock, renderSlot, toDisplayString, unref, withCtx } from "vue";
+//#region src/components/progress/ProgressValue.vue?vue&type=script&setup=true&lang.ts
+var ProgressValue_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "ProgressValue",
+	inheritAttrs: false,
+	__name: "ProgressValue",
+	props: { as: { default: "span" } },
+	setup(__props) {
+		const props = __props;
+		const { valueProps, state } = useGaugeContext();
+		const merged = usePartProps(valueProps);
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Part), mergeProps({ as: props.as }, unref(merged)), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(unref(state))), () => [createTextVNode(toDisplayString(unref(state).formattedValue), 1)])]),
+				_: 3
+			}, 16, ["as"]);
+		};
+	}
+});
+//#endregion
+export { ProgressValue_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/radio/RadioGroup.js

@@ -0,0 +1,5 @@
+import RadioGroup_vue_vue_type_script_setup_true_lang_default from "./RadioGroup.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/radio/RadioGroup.vue
+var RadioGroup_default = RadioGroup_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { RadioGroup_default as default };

package/dist/components/radio/RadioGroup.vue.d.ts

@@ -0,0 +1,53 @@
+import { type RadioValue } from './use-radio-group';
+type __VLS_Props = {
+    /** The chosen radio's `value`, bound with `v-model`. */
+    modelValue?: RadioValue;
+    /** The value chosen at first, when no `v-model` owns it. */
+    defaultValue?: RadioValue;
+    /** Disables every radio, and the form leaves the group out. */
+    disabled?: boolean;
+    /** Keeps the radios focusable but unchangeable. */
+    readOnly?: boolean;
+    /** A radio must be chosen. Announced and styled, not enforced. Inside a `FieldRoot`, follows the field. */
+    required?: boolean;
+    /** Marks the value invalid, for styling through `data-invalid`. */
+    invalid?: boolean;
+    /** The form field name every radio shares. Generated when not given. */
+    name?: string;
+    /** The id of a `<form>` to submit with, when the group sits outside it. */
+    form?: string;
+    /** Whether arrow keys wrap past the ends. */
+    loop?: boolean;
+    /** Element or component to render. */
+    as?: string | object;
+};
+declare var __VLS_8: {
+    value: RadioValue | undefined;
+    disabled: boolean;
+    readOnly: boolean;
+    required: boolean;
+    invalid: boolean;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, import("./use-radio-group").UseRadioGroupReturn, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (value: RadioValue, event: Event) => any;
+    "update:modelValue": (value: RadioValue) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((value: RadioValue, event: Event) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: RadioValue) => any) | undefined;
+}>, {
+    defaultValue: RadioValue;
+    as: string | object;
+    modelValue: RadioValue;
+    loop: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/radio/RadioGroup.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,55 @@
+import { Part } from "../../shared/part.js";
+import { usePartProps } from "../../shared/use-part-props.js";
+import { useRadioGroup } from "./use-radio-group.js";
+import { createBlock, defineComponent, guardReactiveProps, mergeProps, normalizeProps, openBlock, renderSlot, toRef, unref, withCtx } from "vue";
+//#region src/components/radio/RadioGroup.vue?vue&type=script&setup=true&lang.ts
+var RadioGroup_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "RadioGroup",
+	inheritAttrs: false,
+	__name: "RadioGroup",
+	props: {
+		modelValue: { default: void 0 },
+		defaultValue: { default: void 0 },
+		disabled: { type: Boolean },
+		readOnly: { type: Boolean },
+		required: { type: Boolean },
+		invalid: { type: Boolean },
+		name: {},
+		form: {},
+		loop: {
+			type: Boolean,
+			default: true
+		},
+		as: { default: "div" }
+	},
+	emits: ["update:modelValue", "change"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const api = useRadioGroup({
+			value: toRef(() => props.modelValue),
+			defaultValue: toRef(() => props.defaultValue),
+			disabled: toRef(() => props.disabled ?? false),
+			readOnly: toRef(() => props.readOnly ?? false),
+			required: toRef(() => props.required ?? false),
+			invalid: toRef(() => props.invalid ?? false),
+			name: toRef(() => props.name),
+			form: toRef(() => props.form),
+			loop: toRef(() => props.loop ?? true),
+			onChange: (value, event) => {
+				emit("update:modelValue", value);
+				emit("change", value, event);
+			}
+		});
+		__expose(api);
+		const merged = usePartProps(api.groupProps);
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Part), mergeProps({ as: props.as }, unref(merged)), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(unref(api).state.value)))]),
+				_: 3
+			}, 16, ["as"]);
+		};
+	}
+});
+//#endregion
+export { RadioGroup_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/radio/RadioIndicator.js

@@ -0,0 +1,5 @@
+import RadioIndicator_vue_vue_type_script_setup_true_lang_default from "./RadioIndicator.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/radio/RadioIndicator.vue
+var RadioIndicator_default = RadioIndicator_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { RadioIndicator_default as default };

package/dist/components/radio/RadioIndicator.vue.d.ts

@@ -0,0 +1,28 @@
+type __VLS_Props = {
+    /** Stays in the DOM while unchecked, for styling both states yourself. */
+    keepMounted?: boolean;
+    /** Element or component to render. */
+    as?: string | object;
+};
+declare var __VLS_8: {
+    checked: boolean;
+    disabled: boolean;
+    readOnly: boolean;
+    required: boolean;
+    invalid: boolean;
+    transitionStatus: import("../..").TransitionStatus;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    as: string | object;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/radio/RadioIndicator.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,30 @@
+import { Part } from "../../shared/part.js";
+import { usePartProps } from "../../shared/use-part-props.js";
+import { useToggleIndicator } from "../../shared/use-toggle-indicator.js";
+import { createBlock, createCommentVNode, defineComponent, guardReactiveProps, mergeProps, normalizeProps, openBlock, renderSlot, unref, withCtx } from "vue";
+//#region src/components/radio/RadioIndicator.vue?vue&type=script&setup=true&lang.ts
+var RadioIndicator_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "RadioIndicator",
+	inheritAttrs: false,
+	__name: "RadioIndicator",
+	props: {
+		keepMounted: { type: Boolean },
+		as: { default: "span" }
+	},
+	setup(__props) {
+		const props = __props;
+		const { mounted, state, indicatorProps } = useToggleIndicator();
+		const merged = usePartProps(indicatorProps);
+		return (_ctx, _cache) => {
+			return unref(mounted) || props.keepMounted ? (openBlock(), createBlock(unref(Part), mergeProps({
+				key: 0,
+				as: props.as
+			}, unref(merged)), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(unref(state))))]),
+				_: 3
+			}, 16, ["as"])) : createCommentVNode("", true);
+		};
+	}
+});
+//#endregion
+export { RadioIndicator_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/radio/RadioRoot.js

@@ -0,0 +1,5 @@
+import RadioRoot_vue_vue_type_script_setup_true_lang_default from "./RadioRoot.vue_vue_type_script_setup_true_lang.js";
+//#region src/components/radio/RadioRoot.vue
+var RadioRoot_default = RadioRoot_vue_vue_type_script_setup_true_lang_default;
+//#endregion
+export { RadioRoot_default as default };

package/dist/components/radio/RadioRoot.vue.d.ts

@@ -0,0 +1,33 @@
+import { type RadioValue } from './use-radio-group';
+type __VLS_Props = {
+    /** What the group's `v-model` holds while this radio is chosen. */
+    value: RadioValue;
+    /** Takes this one radio out of reach; arrow keys skip it. */
+    disabled?: boolean;
+    /** The root's id. Generated when not given. */
+    id?: string;
+    /** Element or component to render. Anything but a `button` gets Enter/Space keys, and a `<label>` no longer names it. */
+    as?: string | object;
+};
+declare var __VLS_7: {
+    checked: boolean;
+    disabled: boolean;
+    readOnly: boolean;
+    required: boolean;
+    invalid: boolean;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_7) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, import("./use-radio-group").UseRadioReturn, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    as: string | object;
+    disabled: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/radio/RadioRoot.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,48 @@
+import { mergeProps as mergeProps$1 } from "../../shared/merge-props.js";
+import { Part } from "../../shared/part.js";
+import { provideToggleIndicator } from "../../shared/use-toggle-indicator.js";
+import { useRadio } from "./use-radio-group.js";
+import { Fragment, computed, createElementBlock, createElementVNode, createVNode, defineComponent, guardReactiveProps, mergeProps, normalizeProps, openBlock, renderSlot, toRef, unref, useAttrs, withCtx } from "vue";
+//#region src/components/radio/RadioRoot.vue?vue&type=script&setup=true&lang.ts
+var RadioRoot_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "RadioRoot",
+	inheritAttrs: false,
+	__name: "RadioRoot",
+	props: {
+		value: {},
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		id: {},
+		as: { default: "button" }
+	},
+	setup(__props, { expose: __expose }) {
+		const props = __props;
+		const api = useRadio({
+			value: toRef(() => props.value),
+			disabled: toRef(() => props.disabled),
+			id: toRef(() => props.id),
+			native: toRef(() => props.as === "button")
+		});
+		provideToggleIndicator({
+			state: api.state,
+			hooks: api.hooks,
+			present: () => api.checked.value
+		});
+		__expose(api);
+		const attrs = useAttrs();
+		const rootProps = computed(() => mergeProps$1({
+			"data-part": "root",
+			...api.rootProps.value
+		}, attrs));
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock(Fragment, null, [createVNode(unref(Part), mergeProps({ as: props.as }, rootProps.value), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(unref(api).state.value)))]),
+				_: 3
+			}, 16, ["as"]), createElementVNode("input", normalizeProps(guardReactiveProps(unref(api).inputProps.value)), null, 16)], 64);
+		};
+	}
+});
+//#endregion
+export { RadioRoot_vue_vue_type_script_setup_true_lang_default as default };

package/dist/components/radio/use-radio-group.d.ts

@@ -0,0 +1,87 @@
+import { type ComputedRef, type MaybeRefOrGetter, type Ref, type WritableComputedRef } from 'vue';
+export type RadioValue = string | number;
+export interface RadioGroupState {
+    /**
+     * The chosen radio's value.
+     * @attribute none
+     */
+    value: RadioValue | undefined;
+    /** Whether every radio ignores interaction. */
+    disabled: boolean;
+    /** Whether the radios can be focused but not changed. */
+    readOnly: boolean;
+    /** Whether a radio must be chosen before the form submits. */
+    required: boolean;
+    /** Whether the value is invalid. */
+    invalid: boolean;
+}
+export interface UseRadioGroupOptions {
+    value?: MaybeRefOrGetter<RadioValue | undefined>;
+    defaultValue?: MaybeRefOrGetter<RadioValue | undefined>;
+    disabled?: MaybeRefOrGetter<boolean>;
+    readOnly?: MaybeRefOrGetter<boolean>;
+    required?: MaybeRefOrGetter<boolean>;
+    invalid?: MaybeRefOrGetter<boolean>;
+    name?: MaybeRefOrGetter<string | undefined>;
+    form?: MaybeRefOrGetter<string | undefined>;
+    /** Whether arrow keys wrap past the ends. @default true */
+    loop?: MaybeRefOrGetter<boolean>;
+    onChange?: (value: RadioValue, event: Event) => void;
+}
+interface RadioRegistration {
+    value: RadioValue;
+    disabled: () => boolean;
+}
+export interface RadioGroupContext {
+    value: Ref<RadioValue | undefined>;
+    select: (value: RadioValue, event: Event) => void;
+    disabled: () => boolean;
+    readOnly: () => boolean;
+    required: () => boolean;
+    invalid: () => boolean;
+    name: () => string;
+    form: () => string | undefined;
+    loop: () => boolean;
+    containerRef: Ref<HTMLElement | null>;
+    register: (entry: RadioRegistration) => () => void;
+    firstEnabledValue: ComputedRef<RadioValue | undefined>;
+    resolve: (raw: string) => RadioValue | undefined;
+}
+export interface UseRadioGroupReturn {
+    value: WritableComputedRef<RadioValue | undefined>;
+    state: ComputedRef<RadioGroupState>;
+    groupProps: ComputedRef<Record<string, unknown>>;
+}
+export declare function useRadioGroup(options?: UseRadioGroupOptions): UseRadioGroupReturn;
+export declare const provideRadioGroupContext: (value: RadioGroupContext) => RadioGroupContext, useRadioGroupContext: () => RadioGroupContext;
+export interface RadioState {
+    /**
+     * Whether this radio is the chosen one.
+     * @attribute `data-checked` while chosen, `data-unchecked` otherwise
+     */
+    checked: boolean;
+    /** Whether it ignores interaction, on its own or through the group. */
+    disabled: boolean;
+    /** Whether the group can be focused but not changed. */
+    readOnly: boolean;
+    /** Whether the group must have a choice before the form submits. */
+    required: boolean;
+    /** Whether the group's value is invalid. */
+    invalid: boolean;
+}
+export interface UseRadioOptions {
+    value: MaybeRefOrGetter<RadioValue>;
+    disabled?: MaybeRefOrGetter<boolean>;
+    id?: MaybeRefOrGetter<string | undefined>;
+    /** Whether the root is a real `<button>`, which supplies its own key handling. */
+    native?: MaybeRefOrGetter<boolean>;
+}
+export interface UseRadioReturn {
+    checked: ComputedRef<boolean>;
+    state: ComputedRef<RadioState>;
+    hooks: ComputedRef<Record<string, string>>;
+    rootProps: ComputedRef<Record<string, unknown>>;
+    inputProps: ComputedRef<Record<string, unknown>>;
+}
+export declare function useRadio(options: UseRadioOptions): UseRadioReturn;
+export {};