@sprawlify/primitives 0.0.1

package/dist/machines/qr-code/index.mjs

@@ -0,0 +1,167 @@
+import { t as createAnatomy } from "../../create-anatomy-BbDZbHpC.mjs";
+import { Vt as getDataUrl } from "../../dom-query-DFCRhyj1.mjs";
+import { u as createSplitProps } from "../../utils-BZyrxWWR.mjs";
+import { a as createMachine, s as memo } from "../../core-DCFNMTZF.mjs";
+import { t as createProps } from "../../create-props-BnF_vl-E.mjs";
+import { encode } from "uqr";
+
+//#region src/machines/qr-code/qr-code.anatomy.ts
+const anatomy = createAnatomy("qr-code").parts("root", "frame", "pattern", "overlay", "downloadTrigger");
+const parts = anatomy.build();
+
+//#endregion
+//#region src/machines/qr-code/qr-code.dom.ts
+const getRootId = (scope) => scope.ids?.root ?? `qrcode:${scope.id}:root`;
+const getFrameId = (scope) => scope.ids?.frame ?? `qrcode:${scope.id}:frame`;
+const getFrameEl = (scope) => scope.getById(getFrameId(scope));
+
+//#endregion
+//#region src/machines/qr-code/qr-code.connect.ts
+function connect(service, normalize) {
+	const { context, computed, send, scope, prop } = service;
+	const encoded = computed("encoded");
+	const pixelSize = prop("pixelSize");
+	const height = encoded.size * pixelSize;
+	const width = encoded.size * pixelSize;
+	const paths = [];
+	for (let row = 0; row < encoded.size; row++) for (let col = 0; col < encoded.size; col++) {
+		const x = col * pixelSize;
+		const y = row * pixelSize;
+		if (encoded.data[row][col]) paths.push(`M${x},${y}h${pixelSize}v${pixelSize}h-${pixelSize}z`);
+	}
+	return {
+		value: context.get("value"),
+		setValue(value) {
+			send({
+				type: "VALUE.SET",
+				value
+			});
+		},
+		getDataUrl(type, quality) {
+			return getDataUrl(getFrameEl(scope), {
+				type,
+				quality
+			});
+		},
+		getRootProps() {
+			return normalize.element({
+				id: getRootId(scope),
+				...parts.root.attrs,
+				style: {
+					"--qrcode-pixel-size": `${pixelSize}px`,
+					"--qrcode-width": `${width}px`,
+					"--qrcode-height": `${height}px`,
+					position: "relative"
+				}
+			});
+		},
+		getFrameProps() {
+			return normalize.svg({
+				id: getFrameId(scope),
+				...parts.frame.attrs,
+				xmlns: "http://www.w3.org/2000/svg",
+				viewBox: `0 0 ${width} ${height}`
+			});
+		},
+		getPatternProps() {
+			return normalize.path({
+				d: paths.join(""),
+				...parts.pattern.attrs
+			});
+		},
+		getOverlayProps() {
+			return normalize.element({
+				...parts.overlay.attrs,
+				style: {
+					position: "absolute",
+					top: "50%",
+					left: "50%",
+					translate: "-50% -50%"
+				}
+			});
+		},
+		getDownloadTriggerProps(props$1) {
+			return normalize.button({
+				type: "button",
+				...parts.downloadTrigger.attrs,
+				onClick(event) {
+					if (event.defaultPrevented) return;
+					send({
+						type: "DOWNLOAD_TRIGGER.CLICK",
+						...props$1
+					});
+				}
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/machines/qr-code/qr-code.machine.ts
+const machine = createMachine({
+	props({ props: props$1 }) {
+		return {
+			defaultValue: "",
+			pixelSize: 10,
+			...props$1
+		};
+	},
+	initialState() {
+		return "idle";
+	},
+	context({ prop, bindable }) {
+		return { value: bindable(() => ({
+			value: prop("value"),
+			defaultValue: prop("defaultValue"),
+			onChange(value) {
+				prop("onValueChange")?.({ value });
+			}
+		})) };
+	},
+	computed: { encoded: memo(({ context, prop }) => [context.get("value"), prop("encoding")], ([value, encoding]) => encode(value, encoding)) },
+	states: { idle: { on: {
+		"VALUE.SET": { actions: ["setValue"] },
+		"DOWNLOAD_TRIGGER.CLICK": { actions: ["downloadQrCode"] }
+	} } },
+	implementations: { actions: {
+		setValue({ context, event }) {
+			context.set("value", event.value);
+		},
+		downloadQrCode({ event, scope }) {
+			const { mimeType, quality, fileName } = event;
+			const svgEl = getFrameEl(scope);
+			const doc = scope.getDoc();
+			getDataUrl(svgEl, {
+				type: mimeType,
+				quality
+			}).then((dataUri) => {
+				const a = doc.createElement("a");
+				a.href = dataUri;
+				a.rel = "noopener";
+				a.download = fileName;
+				a.click();
+				setTimeout(() => {
+					a.remove();
+				}, 0);
+			});
+		}
+	} }
+});
+
+//#endregion
+//#region src/machines/qr-code/qr-code.props.ts
+const props = createProps()([
+	"ids",
+	"defaultValue",
+	"value",
+	"id",
+	"encoding",
+	"dir",
+	"getRootNode",
+	"onValueChange",
+	"pixelSize"
+]);
+const splitProps = createSplitProps(props);
+
+//#endregion
+export { anatomy, connect, machine, props, splitProps };

package/dist/machines/radio-group/index.cjs

@@ -0,0 +1,436 @@
+const require_create_anatomy = require('../../create-anatomy-CDsIFUXg.cjs');
+const require_dom_query = require('../../dom-query-CWZdWUGp.cjs');
+const require_utils = require('../../utils-_6frwjgJ.cjs');
+const require_core = require('../../core-CQFbMdTl.cjs');
+const require_focus_visible = require('../../focus-visible-DYTWdWpa.cjs');
+const require_create_props = require('../../create-props-YKy7JIKj.cjs');
+
+//#region src/machines/radio-group/radio-group.anatomy.ts
+const anatomy = require_create_anatomy.createAnatomy("radio-group").parts("root", "label", "item", "itemText", "itemControl", "indicator");
+const parts = anatomy.build();
+
+//#endregion
+//#region src/machines/radio-group/radio-group.dom.ts
+const getRootId = (ctx) => ctx.ids?.root ?? `radio-group:${ctx.id}`;
+const getLabelId = (ctx) => ctx.ids?.label ?? `radio-group:${ctx.id}:label`;
+const getItemId = (ctx, value) => ctx.ids?.item?.(value) ?? `radio-group:${ctx.id}:radio:${value}`;
+const getItemHiddenInputId = (ctx, value) => ctx.ids?.itemHiddenInput?.(value) ?? `radio-group:${ctx.id}:radio:input:${value}`;
+const getItemControlId = (ctx, value) => ctx.ids?.itemControl?.(value) ?? `radio-group:${ctx.id}:radio:control:${value}`;
+const getItemLabelId = (ctx, value) => ctx.ids?.itemLabel?.(value) ?? `radio-group:${ctx.id}:radio:label:${value}`;
+const getIndicatorId = (ctx) => ctx.ids?.indicator ?? `radio-group:${ctx.id}:indicator`;
+const getRootEl = (ctx) => ctx.getById(getRootId(ctx));
+const getItemHiddenInputEl = (ctx, value) => ctx.getById(getItemHiddenInputId(ctx, value));
+const getIndicatorEl = (ctx) => ctx.getById(getIndicatorId(ctx));
+const getFirstEnabledInputEl = (ctx) => getRootEl(ctx)?.querySelector("input:not(:disabled)");
+const getFirstEnabledAndCheckedInputEl = (ctx) => getRootEl(ctx)?.querySelector("input:not(:disabled):checked");
+const getInputEls = (ctx) => {
+	const selector = `input[type=radio][data-ownedby='${CSS.escape(getRootId(ctx))}']:not([disabled])`;
+	return require_dom_query.queryAll(getRootEl(ctx), selector);
+};
+const getRadioEl = (ctx, value) => {
+	if (!value) return;
+	return ctx.getById(getItemId(ctx, value));
+};
+const getOffsetRect = (el) => ({
+	x: el?.offsetLeft ?? 0,
+	y: el?.offsetTop ?? 0,
+	width: el?.offsetWidth ?? 0,
+	height: el?.offsetHeight ?? 0
+});
+
+//#endregion
+//#region src/machines/radio-group/radio-group.connect.ts
+function connect(service, normalize) {
+	const { context, send, computed, prop, scope } = service;
+	const groupDisabled = computed("isDisabled");
+	const groupInvalid = prop("invalid");
+	const readOnly = prop("readOnly");
+	function getItemState(props$1) {
+		return {
+			value: props$1.value,
+			invalid: !!props$1.invalid || !!groupInvalid,
+			disabled: !!props$1.disabled || groupDisabled,
+			checked: context.get("value") === props$1.value,
+			focused: context.get("focusedValue") === props$1.value,
+			focusVisible: context.get("focusVisibleValue") === props$1.value,
+			hovered: context.get("hoveredValue") === props$1.value,
+			active: context.get("activeValue") === props$1.value
+		};
+	}
+	function getItemDataAttrs(props$1) {
+		const itemState = getItemState(props$1);
+		return {
+			"data-focus": require_dom_query.dataAttr(itemState.focused),
+			"data-focus-visible": require_dom_query.dataAttr(itemState.focusVisible),
+			"data-disabled": require_dom_query.dataAttr(itemState.disabled),
+			"data-readonly": require_dom_query.dataAttr(readOnly),
+			"data-state": itemState.checked ? "checked" : "unchecked",
+			"data-hover": require_dom_query.dataAttr(itemState.hovered),
+			"data-invalid": require_dom_query.dataAttr(itemState.invalid),
+			"data-orientation": prop("orientation"),
+			"data-ssr": require_dom_query.dataAttr(context.get("ssr"))
+		};
+	}
+	const focus = () => {
+		(getFirstEnabledAndCheckedInputEl(scope) ?? getFirstEnabledInputEl(scope))?.focus();
+	};
+	return {
+		focus,
+		value: context.get("value"),
+		setValue(value) {
+			send({
+				type: "SET_VALUE",
+				value,
+				isTrusted: false
+			});
+		},
+		clearValue() {
+			send({
+				type: "SET_VALUE",
+				value: null,
+				isTrusted: false
+			});
+		},
+		getRootProps() {
+			return normalize.element({
+				...parts.root.attrs,
+				role: "radiogroup",
+				id: getRootId(scope),
+				"aria-labelledby": getLabelId(scope),
+				"aria-required": prop("required") || void 0,
+				"aria-disabled": groupDisabled || void 0,
+				"aria-readonly": readOnly || void 0,
+				"data-orientation": prop("orientation"),
+				"data-disabled": require_dom_query.dataAttr(groupDisabled),
+				"data-invalid": require_dom_query.dataAttr(groupInvalid),
+				"data-required": require_dom_query.dataAttr(prop("required")),
+				"aria-orientation": prop("orientation"),
+				dir: prop("dir"),
+				style: { position: "relative" }
+			});
+		},
+		getLabelProps() {
+			return normalize.element({
+				...parts.label.attrs,
+				dir: prop("dir"),
+				"data-orientation": prop("orientation"),
+				"data-disabled": require_dom_query.dataAttr(groupDisabled),
+				"data-invalid": require_dom_query.dataAttr(groupInvalid),
+				"data-required": require_dom_query.dataAttr(prop("required")),
+				id: getLabelId(scope),
+				onClick: focus
+			});
+		},
+		getItemState,
+		getItemProps(props$1) {
+			const itemState = getItemState(props$1);
+			return normalize.label({
+				...parts.item.attrs,
+				dir: prop("dir"),
+				id: getItemId(scope, props$1.value),
+				htmlFor: getItemHiddenInputId(scope, props$1.value),
+				...getItemDataAttrs(props$1),
+				onPointerMove() {
+					if (itemState.disabled) return;
+					if (itemState.hovered) return;
+					send({
+						type: "SET_HOVERED",
+						value: props$1.value,
+						hovered: true
+					});
+				},
+				onPointerLeave() {
+					if (itemState.disabled) return;
+					send({
+						type: "SET_HOVERED",
+						value: null
+					});
+				},
+				onPointerDown(event) {
+					if (itemState.disabled) return;
+					if (!require_dom_query.isLeftClick(event)) return;
+					if (itemState.focused && event.pointerType === "mouse") event.preventDefault();
+					send({
+						type: "SET_ACTIVE",
+						value: props$1.value,
+						active: true
+					});
+				},
+				onPointerUp() {
+					if (itemState.disabled) return;
+					send({
+						type: "SET_ACTIVE",
+						value: null
+					});
+				},
+				onClick() {
+					if (!itemState.disabled && require_dom_query.isSafari()) getItemHiddenInputEl(scope, props$1.value)?.focus();
+				}
+			});
+		},
+		getItemTextProps(props$1) {
+			return normalize.element({
+				...parts.itemText.attrs,
+				dir: prop("dir"),
+				id: getItemLabelId(scope, props$1.value),
+				...getItemDataAttrs(props$1)
+			});
+		},
+		getItemControlProps(props$1) {
+			const itemState = getItemState(props$1);
+			return normalize.element({
+				...parts.itemControl.attrs,
+				dir: prop("dir"),
+				id: getItemControlId(scope, props$1.value),
+				"data-active": require_dom_query.dataAttr(itemState.active),
+				"aria-hidden": true,
+				...getItemDataAttrs(props$1)
+			});
+		},
+		getItemHiddenInputProps(props$1) {
+			const itemState = getItemState(props$1);
+			return normalize.input({
+				"data-ownedby": getRootId(scope),
+				id: getItemHiddenInputId(scope, props$1.value),
+				type: "radio",
+				name: prop("name") || prop("id"),
+				form: prop("form"),
+				value: props$1.value,
+				required: prop("required"),
+				"aria-invalid": itemState.invalid || void 0,
+				onClick(event) {
+					if (readOnly) {
+						event.preventDefault();
+						return;
+					}
+					if (event.currentTarget.checked) send({
+						type: "SET_VALUE",
+						value: props$1.value,
+						isTrusted: true
+					});
+				},
+				onBlur() {
+					send({
+						type: "SET_FOCUSED",
+						value: null,
+						focused: false,
+						focusVisible: false
+					});
+				},
+				onFocus() {
+					const focusVisible = require_focus_visible.isFocusVisible();
+					send({
+						type: "SET_FOCUSED",
+						value: props$1.value,
+						focused: true,
+						focusVisible
+					});
+				},
+				onKeyDown(event) {
+					if (event.defaultPrevented) return;
+					if (event.key === " ") send({
+						type: "SET_ACTIVE",
+						value: props$1.value,
+						active: true
+					});
+				},
+				onKeyUp(event) {
+					if (event.defaultPrevented) return;
+					if (event.key === " ") send({
+						type: "SET_ACTIVE",
+						value: null
+					});
+				},
+				disabled: itemState.disabled || readOnly,
+				defaultChecked: itemState.checked,
+				style: require_dom_query.visuallyHiddenStyle
+			});
+		},
+		getIndicatorProps() {
+			const rect = context.get("indicatorRect");
+			const rectIsEmpty = rect == null || rect.width === 0 && rect.height === 0 && rect.x === 0 && rect.y === 0;
+			return normalize.element({
+				id: getIndicatorId(scope),
+				...parts.indicator.attrs,
+				dir: prop("dir"),
+				hidden: context.get("value") == null || rectIsEmpty,
+				"data-disabled": require_dom_query.dataAttr(groupDisabled),
+				"data-orientation": prop("orientation"),
+				style: {
+					"--transition-property": "left, top, width, height",
+					"--left": require_utils.toPx(rect?.x),
+					"--top": require_utils.toPx(rect?.y),
+					"--width": require_utils.toPx(rect?.width),
+					"--height": require_utils.toPx(rect?.height),
+					position: "absolute",
+					willChange: "var(--transition-property)",
+					transitionProperty: "var(--transition-property)",
+					transitionDuration: "var(--transition-duration, 150ms)",
+					transitionTimingFunction: "var(--transition-timing-function)",
+					[prop("orientation") === "horizontal" ? "left" : "top"]: prop("orientation") === "horizontal" ? "var(--left)" : "var(--top)"
+				}
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/machines/radio-group/radio-group.machine.ts
+const { not } = require_core.createGuards();
+const machine = require_core.createMachine({
+	props({ props: props$1 }) {
+		return {
+			orientation: "vertical",
+			...props$1
+		};
+	},
+	initialState() {
+		return "idle";
+	},
+	context({ prop, bindable }) {
+		return {
+			value: bindable(() => ({
+				defaultValue: prop("defaultValue"),
+				value: prop("value"),
+				onChange(value) {
+					prop("onValueChange")?.({ value });
+				}
+			})),
+			activeValue: bindable(() => ({ defaultValue: null })),
+			focusedValue: bindable(() => ({ defaultValue: null })),
+			focusVisibleValue: bindable(() => ({ defaultValue: null })),
+			hoveredValue: bindable(() => ({ defaultValue: null })),
+			indicatorRect: bindable(() => ({ defaultValue: null })),
+			fieldsetDisabled: bindable(() => ({ defaultValue: false })),
+			ssr: bindable(() => ({ defaultValue: true }))
+		};
+	},
+	refs() {
+		return {
+			indicatorCleanup: null,
+			focusVisibleValue: null
+		};
+	},
+	computed: { isDisabled: ({ prop, context }) => !!prop("disabled") || context.get("fieldsetDisabled") },
+	entry: ["syncIndicatorRect", "syncSsr"],
+	exit: ["cleanupObserver"],
+	effects: ["trackFormControlState", "trackFocusVisible"],
+	watch({ track, action, context }) {
+		track([() => context.get("value")], () => {
+			action(["syncIndicatorRect", "syncInputElements"]);
+		});
+	},
+	on: {
+		SET_VALUE: [{
+			guard: not("isTrusted"),
+			actions: ["setValue", "dispatchChangeEvent"]
+		}, { actions: ["setValue"] }],
+		SET_HOVERED: { actions: ["setHovered"] },
+		SET_ACTIVE: { actions: ["setActive"] },
+		SET_FOCUSED: { actions: ["setFocused"] }
+	},
+	states: { idle: {} },
+	implementations: {
+		guards: { isTrusted: ({ event }) => !!event.isTrusted },
+		effects: {
+			trackFormControlState({ context, scope }) {
+				return require_dom_query.trackFormControl(getRootEl(scope), {
+					onFieldsetDisabledChange(disabled) {
+						context.set("fieldsetDisabled", disabled);
+					},
+					onFormReset() {
+						context.set("value", context.initial("value"));
+					}
+				});
+			},
+			trackFocusVisible({ scope }) {
+				return require_focus_visible.trackFocusVisible({ root: scope.getRootNode?.() });
+			}
+		},
+		actions: {
+			setValue({ context, event }) {
+				context.set("value", event.value);
+			},
+			setHovered({ context, event }) {
+				context.set("hoveredValue", event.value);
+			},
+			setActive({ context, event }) {
+				context.set("activeValue", event.value);
+			},
+			setFocused({ context, event }) {
+				context.set("focusedValue", event.value);
+				const focusVisibleValue = event.value != null && event.focusVisible ? event.value : null;
+				context.set("focusVisibleValue", focusVisibleValue);
+			},
+			syncInputElements({ context, scope }) {
+				getInputEls(scope).forEach((input) => {
+					input.checked = input.value === context.get("value");
+				});
+			},
+			cleanupObserver({ refs }) {
+				refs.get("indicatorCleanup")?.();
+			},
+			syncSsr({ context }) {
+				context.set("ssr", false);
+			},
+			syncIndicatorRect({ context, scope, refs }) {
+				refs.get("indicatorCleanup")?.();
+				if (!getIndicatorEl(scope)) return;
+				const value = context.get("value");
+				const radioEl = getRadioEl(scope, value);
+				if (value == null || !radioEl) {
+					context.set("indicatorRect", null);
+					return;
+				}
+				const exec = () => {
+					context.set("indicatorRect", getOffsetRect(radioEl));
+				};
+				exec();
+				const indicatorCleanup = require_dom_query.resizeObserverBorderBox.observe(radioEl, exec);
+				refs.set("indicatorCleanup", indicatorCleanup);
+			},
+			dispatchChangeEvent({ context, scope }) {
+				getInputEls(scope).forEach((inputEl) => {
+					const checked = inputEl.value === context.get("value");
+					if (checked === inputEl.checked) return;
+					require_dom_query.dispatchInputCheckedEvent(inputEl, { checked });
+				});
+			}
+		}
+	}
+});
+
+//#endregion
+//#region src/machines/radio-group/radio-group.props.ts
+const props = require_create_props.createProps()([
+	"dir",
+	"disabled",
+	"form",
+	"getRootNode",
+	"id",
+	"ids",
+	"invalid",
+	"name",
+	"onValueChange",
+	"orientation",
+	"readOnly",
+	"required",
+	"value",
+	"defaultValue"
+]);
+const splitProps = require_utils.createSplitProps(props);
+const itemProps = require_create_props.createProps()([
+	"value",
+	"disabled",
+	"invalid"
+]);
+const splitItemProps = require_utils.createSplitProps(itemProps);
+
+//#endregion
+exports.anatomy = anatomy;
+exports.connect = connect;
+exports.itemProps = itemProps;
+exports.machine = machine;
+exports.props = props;
+exports.splitItemProps = splitItemProps;
+exports.splitProps = splitProps;

package/dist/machines/radio-group/index.d.cts

@@ -0,0 +1,106 @@
+import { n as AnatomyInstance } from "../../create-anatomy-BGQ8pv8J.cjs";
+import { p as Machine, u as EventObject, y as Service } from "../../types-DejIu60O.cjs";
+import { b as NormalizeProps, g as RequiredBy, m as Rect, r as DirectionProperty, t as CommonProperties, x as PropTypes } from "../../index-Bqw3r34-.cjs";
+
+//#region src/machines/radio-group/radio-group.anatomy.d.ts
+declare const anatomy: AnatomyInstance<"root" | "item" | "label" | "indicator" | "itemText" | "itemControl">;
+//#endregion
+//#region src/machines/radio-group/radio-group.types.d.ts
+interface ValueChangeDetails {
+  value: string | null;
+}
+type ElementIds = Partial<{
+  root: string;
+  label: string;
+  indicator: string;
+  item: (value: string) => string;
+  itemLabel: (value: string) => string;
+  itemControl: (value: string) => string;
+  itemHiddenInput: (value: string) => string;
+}>;
+interface RadioGroupProps extends DirectionProperty, CommonProperties {
+  ids?: ElementIds | undefined;
+  value?: string | null | undefined;
+  defaultValue?: string | null | undefined;
+  name?: string | undefined;
+  form?: string | undefined;
+  disabled?: boolean | undefined;
+  invalid?: boolean | undefined;
+  required?: boolean | undefined;
+  readOnly?: boolean | undefined;
+  onValueChange?: ((details: ValueChangeDetails) => void) | undefined;
+  orientation?: "horizontal" | "vertical" | undefined;
+}
+interface PrivateContext {
+  value: string | null;
+  activeValue: string | null;
+  focusedValue: string | null;
+  focusVisibleValue: string | null;
+  hoveredValue: string | null;
+  indicatorRect: Rect | null;
+  fieldsetDisabled: boolean;
+  ssr: boolean;
+}
+type PropsWithDefault = "orientation";
+type ComputedContext = Readonly<{
+  isDisabled: boolean;
+}>;
+interface Refs {
+  indicatorCleanup: VoidFunction | null;
+}
+interface RadioGroupSchema {
+  state: "idle";
+  props: RequiredBy<RadioGroupProps, PropsWithDefault>;
+  context: PrivateContext;
+  computed: ComputedContext;
+  refs: Refs;
+  event: EventObject;
+  action: string;
+  effect: string;
+  guard: string;
+}
+type RadioGroupService = Service<RadioGroupSchema>;
+type RadioGroupMachine = Machine<RadioGroupSchema>;
+interface ItemProps {
+  value: string;
+  disabled?: boolean | undefined;
+  invalid?: boolean | undefined;
+}
+interface ItemState {
+  value: string;
+  invalid: boolean;
+  disabled: boolean;
+  checked: boolean;
+  focused: boolean;
+  focusVisible: boolean;
+  hovered: boolean;
+  active: boolean;
+}
+interface RadioGroupApi<T extends PropTypes = PropTypes> {
+  value: string | null;
+  setValue: (value: string) => void;
+  clearValue: VoidFunction;
+  focus: VoidFunction;
+  getItemState: (props: ItemProps) => ItemState;
+  getRootProps: () => T["element"];
+  getLabelProps: () => T["element"];
+  getItemProps: (props: ItemProps) => T["label"];
+  getItemTextProps: (props: ItemProps) => T["element"];
+  getItemControlProps: (props: ItemProps) => T["element"];
+  getItemHiddenInputProps: (props: ItemProps) => T["input"];
+  getIndicatorProps: () => T["element"];
+}
+//#endregion
+//#region src/machines/radio-group/radio-group.connect.d.ts
+declare function connect<T extends PropTypes>(service: RadioGroupService, normalize: NormalizeProps<T>): RadioGroupApi<T>;
+//#endregion
+//#region src/machines/radio-group/radio-group.machine.d.ts
+declare const machine: Machine<RadioGroupSchema>;
+//#endregion
+//#region src/machines/radio-group/radio-group.props.d.ts
+declare const props: (keyof RadioGroupProps)[];
+declare const splitProps: <Props extends Partial<RadioGroupProps>>(props: Props) => [Partial<RadioGroupProps>, Omit<Props, keyof RadioGroupProps>];
+declare const itemProps: (keyof ItemProps)[];
+declare const splitItemProps: <Props extends ItemProps>(props: Props) => [ItemProps, Omit<Props, keyof ItemProps>];
+//#endregion
+export { type RadioGroupApi as Api, type ElementIds, type ItemProps, type ItemState, type RadioGroupMachine as Machine, type RadioGroupProps as Props, type RadioGroupService as Service, type ValueChangeDetails, anatomy, connect, itemProps, machine, props, splitItemProps, splitProps };