@wix/site-ui 1.30.0 → 1.32.0

package/dist/Progress/index.d.ts

@@ -1,30 +1,160 @@
-import { ProgressIndicatorProps } from '@base-ui/react/progress';
-import { ProgressLabelProps } from '@base-ui/react/progress';
-import { ProgressRootProps } from '@base-ui/react/progress';
-import { ProgressTrackProps } from '@base-ui/react/progress';
-import { ProgressValueProps } from '@base-ui/react/progress';
+import { ProgressIndicatorProps as ProgressIndicatorProps_2 } from '@base-ui/react/progress';
+import { ProgressLabelProps as ProgressLabelProps_2 } from '@base-ui/react/progress';
+import { ProgressRootProps as ProgressRootProps_2 } from '@base-ui/react/progress';
+import { ProgressTrackProps as ProgressTrackProps_2 } from '@base-ui/react/progress';
+import { ProgressValueProps as ProgressValueProps_2 } from '@base-ui/react/progress';
 import * as React_2 from 'react';
 
+/**
+ * Props shared by all Base UI components.
+ * Contains `className` (string or callback taking the component's state as an argument) and `render` (function to customize rendering).
+ */
+declare type BaseUIComponentProps<ElementType extends React_2.ElementType, State, RenderFunctionProps = HTMLProps> = Omit<WithBaseUIEvent<React_2.ComponentPropsWithRef<ElementType>>, 'className' | 'color' | 'defaultValue' | 'defaultChecked' | 'style'> & {
+    /**
+     * CSS class applied to the element, or a function that
+     * returns a class based on the component's state.
+     */
+    className?: string | ((state: State) => string | undefined) | undefined;
+    /**
+     * Allows you to replace the component's HTML element
+     * with a different tag, or compose it with another component.
+     *
+     * Accepts a `ReactElement` or a function that returns the element to render.
+     */
+    render?: React_2.ReactElement | ComponentRenderFn<RenderFunctionProps, State> | undefined;
+    /**
+     * Style applied to the element, or a function that
+     * returns a style object based on the component's state.
+     */
+    style?: React_2.CSSProperties | ((state: State) => React_2.CSSProperties | undefined) | undefined;
+};
+
+declare type BaseUIEvent<E extends React_2.SyntheticEvent<Element, Event>> = E & {
+    preventBaseUIHandler: () => void;
+    readonly baseUIHandlerPrevented?: boolean | undefined;
+};
+
+/**
+ * Shape of the render prop: a function that takes props to be spread on the element and component's state and returns a React element.
+ *
+ * @template Props Props to be spread on the rendered element.
+ * @template State Component's internal state.
+ */
+declare type ComponentRenderFn<Props, State> = (props: Props, state: State) => React_2.ReactElement<unknown>;
+
+declare type HTMLProps<T = any> = React_2.HTMLAttributes<T> & {
+    ref?: React_2.Ref<T> | undefined;
+};
+
 export declare const Progress: {
-    Root: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<ProgressRootProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    Root: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<ProgressRootProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & {
         size?: number | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
-    Track: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<ProgressTrackProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    Track: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<ProgressTrackProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
-    Indicator: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<ProgressIndicatorProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    Indicator: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<ProgressIndicatorProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
-    Value: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<ProgressValueProps, "ref"> & React_2.RefAttributes<HTMLSpanElement>, "ref">, "className"> & {
+    Value: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<ProgressValueProps_2, "ref"> & React_2.RefAttributes<HTMLSpanElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLSpanElement>>;
-    Label: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<ProgressLabelProps, "ref"> & React_2.RefAttributes<HTMLSpanElement>, "ref">, "className"> & {
+    Label: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<ProgressLabelProps_2, "ref"> & React_2.RefAttributes<HTMLSpanElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLSpanElement>>;
 };
 
+/**
+ * Visualizes the completion status of the task.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Progress](https://base-ui.com/react/components/progress)
+ */
+export declare const ProgressIndicator: React_2.ForwardRefExoticComponent<Omit<ProgressIndicatorProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace ProgressIndicator {
+    export type State = ProgressIndicatorState;
+    export type Props = ProgressIndicatorProps;
+}
+
+export declare interface ProgressIndicatorProps extends BaseUIComponentProps<'div', ProgressIndicatorState> {}
+
+export declare interface ProgressIndicatorState extends ProgressRootState {}
+
+/**
+ * An accessible label for the progress bar.
+ * Renders a `<span>` element.
+ *
+ * Documentation: [Base UI Progress](https://base-ui.com/react/components/progress)
+ */
+export declare const ProgressLabel: React_2.ForwardRefExoticComponent<Omit<ProgressLabelProps, "ref"> & React_2.RefAttributes<HTMLSpanElement>>;
+
+export declare namespace ProgressLabel {
+    export type State = ProgressLabelState;
+    export type Props = ProgressLabelProps;
+}
+
+export declare interface ProgressLabelProps extends BaseUIComponentProps<'span', ProgressLabelState> {}
+
+export declare interface ProgressLabelState extends ProgressRootState {}
+
+/**
+ * Groups all parts of the progress bar and provides the task completion status to screen readers.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Progress](https://base-ui.com/react/components/progress)
+ */
+export declare const ProgressRoot: React_2.ForwardRefExoticComponent<Omit<ProgressRootProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace ProgressRoot {
+    export type State = ProgressRootState;
+    export type Props = ProgressRootProps;
+}
+
+export declare interface ProgressRootProps extends BaseUIComponentProps<'div', ProgressRootState> {
+    /**
+     * A string value that provides a user-friendly name for `aria-valuenow`, the current value of the progress bar.
+     */
+    'aria-valuetext'?: React_2.AriaAttributes['aria-valuetext'] | undefined;
+    /**
+     * Options to format the value.
+     */
+    format?: Intl.NumberFormatOptions | undefined;
+    /**
+     * Accepts a function which returns a string value that provides a human-readable text alternative for the current value of the progress bar.
+     */
+    getAriaValueText?: ((formattedValue: string | null, value: number | null) => string) | undefined;
+    /**
+     * The locale used by `Intl.NumberFormat` when formatting the value.
+     * Defaults to the user's runtime locale.
+     */
+    locale?: Intl.LocalesArgument | undefined;
+    /**
+     * The maximum value.
+     * @default 100
+     */
+    max?: number | undefined;
+    /**
+     * The minimum value.
+     * @default 0
+     */
+    min?: number | undefined;
+    /**
+     * The current value. The component is indeterminate when value is `null`.
+     * @default null
+     */
+    value: number | null;
+}
+
+export declare interface ProgressRootState {
+    /**
+     * The current status.
+     */
+    status: ProgressStatus;
+}
+
 export declare const ProgressSize: {
     readonly thin: 4;
     readonly small: 6;
@@ -32,7 +162,49 @@ export declare const ProgressSize: {
     readonly large: 12;
 };
 
+export declare type ProgressStatus = 'indeterminate' | 'progressing' | 'complete';
+
+/**
+ * Contains the progress bar indicator.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Progress](https://base-ui.com/react/components/progress)
+ */
+export declare const ProgressTrack: React_2.ForwardRefExoticComponent<Omit<ProgressTrackProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace ProgressTrack {
+    export type State = ProgressTrackState;
+    export type Props = ProgressTrackProps;
+}
+
+export declare interface ProgressTrackProps extends BaseUIComponentProps<'div', ProgressTrackState> {}
+
+export declare interface ProgressTrackState extends ProgressRootState {}
+
+/**
+ * A text label displaying the current value.
+ * Renders a `<span>` element.
+ *
+ * Documentation: [Base UI Progress](https://base-ui.com/react/components/progress)
+ */
+export declare const ProgressValue: React_2.ForwardRefExoticComponent<Omit<ProgressValueProps, "ref"> & React_2.RefAttributes<HTMLSpanElement>>;
+
+export declare namespace ProgressValue {
+    export type State = ProgressValueState;
+    export type Props = ProgressValueProps;
+}
+
+export declare interface ProgressValueProps extends Omit<BaseUIComponentProps<'span', ProgressValueState>, 'children'> {
+    children?: null | ((formattedValue: string | null, value: number | null) => React_2.ReactNode) | undefined;
+}
+
+export declare interface ProgressValueState extends ProgressRootState {}
+
+/**
+ * Adds a `preventBaseUIHandler` method to all event handlers.
+ */
+declare type WithBaseUIEvent<T> = { [K in keyof T]: WithPreventBaseUIHandler<T[K]> };
 
-export * from "@base-ui/react/progress";
+declare type WithPreventBaseUIHandler<T> = T extends ((event: infer E) => any) ? E extends React_2.SyntheticEvent<Element, Event> ? (event: BaseUIEvent<E>) => ReturnType<T> : T : T extends undefined ? undefined : T;
 
 export { }

package/dist/Progress/index.js

@@ -1,7 +1,179 @@
-import { jsx } from "react/jsx-runtime";
-import { Progress } from "@base-ui/react/progress";
+import { jsx, jsxs } from "react/jsx-runtime";
 import clsx from "clsx";
+import { useRenderElement, esm_formatErrorMessage } from "../8272.js";
+import { useValueAsRef } from "../4707.js";
+import { formatNumberValue } from "../6914.js";
+import { visuallyHidden } from "../8225.js";
+import { valueToPercent } from "../3395.js";
+import { useRegisteredLabelId } from "../6706.js";
 import * as __rspack_external_react from "react";
+const ProgressRootContext = /*#__PURE__*/ __rspack_external_react.createContext(void 0);
+if ("production" !== process.env.NODE_ENV) ProgressRootContext.displayName = "ProgressRootContext";
+function useProgressRootContext() {
+    const context = __rspack_external_react.useContext(ProgressRootContext);
+    if (void 0 === context) throw new Error("production" !== process.env.NODE_ENV ? 'Base UI: ProgressRootContext is missing. Progress parts must be placed within <Progress.Root>.' : esm_formatErrorMessage(51));
+    return context;
+}
+let ProgressRootDataAttributes_ProgressRootDataAttributes = /*#__PURE__*/ function(ProgressRootDataAttributes) {
+    ProgressRootDataAttributes["complete"] = "data-complete";
+    ProgressRootDataAttributes["indeterminate"] = "data-indeterminate";
+    ProgressRootDataAttributes["progressing"] = "data-progressing";
+    return ProgressRootDataAttributes;
+}({});
+const progressStateAttributesMapping = {
+    status (value) {
+        if ('progressing' === value) return {
+            [ProgressRootDataAttributes_ProgressRootDataAttributes.progressing]: ''
+        };
+        if ('complete' === value) return {
+            [ProgressRootDataAttributes_ProgressRootDataAttributes.complete]: ''
+        };
+        if ('indeterminate' === value) return {
+            [ProgressRootDataAttributes_ProgressRootDataAttributes.indeterminate]: ''
+        };
+        return null;
+    }
+};
+function getDefaultAriaValueText(formattedValue, value) {
+    if (null == value) return 'indeterminate progress';
+    return formattedValue || `${value}%`;
+}
+const ProgressRoot_ProgressRoot = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { format, getAriaValueText = getDefaultAriaValueText, locale, max = 100, min = 0, value, render, className, children, style, ...elementProps } = componentProps;
+    const [labelId, setLabelId] = __rspack_external_react.useState();
+    const formatOptionsRef = useValueAsRef(format);
+    let status = 'indeterminate';
+    if (Number.isFinite(value)) status = value === max ? 'complete' : 'progressing';
+    const formattedValue = formatNumberValue(value, locale, formatOptionsRef.current);
+    const state = __rspack_external_react.useMemo(()=>({
+            status
+        }), [
+        status
+    ]);
+    const defaultProps = {
+        'aria-labelledby': labelId,
+        'aria-valuemax': max,
+        'aria-valuemin': min,
+        'aria-valuenow': value ?? void 0,
+        'aria-valuetext': getAriaValueText(formattedValue, value),
+        role: 'progressbar',
+        children: /*#__PURE__*/ jsxs(__rspack_external_react.Fragment, {
+            children: [
+                children,
+                /*#__PURE__*/ jsx("span", {
+                    role: "presentation",
+                    style: visuallyHidden,
+                    children: "x"
+                })
+            ]
+        })
+    };
+    const contextValue = __rspack_external_react.useMemo(()=>({
+            formattedValue,
+            max,
+            min,
+            setLabelId,
+            state,
+            status,
+            value
+        }), [
+        formattedValue,
+        max,
+        min,
+        setLabelId,
+        state,
+        status,
+        value
+    ]);
+    const element = useRenderElement('div', componentProps, {
+        state,
+        ref: forwardedRef,
+        props: [
+            defaultProps,
+            elementProps
+        ],
+        stateAttributesMapping: progressStateAttributesMapping
+    });
+    return /*#__PURE__*/ jsx(ProgressRootContext.Provider, {
+        value: contextValue,
+        children: element
+    });
+});
+if ("production" !== process.env.NODE_ENV) ProgressRoot_ProgressRoot.displayName = "ProgressRoot";
+const ProgressTrack_ProgressTrack = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, ...elementProps } = componentProps;
+    const { state } = useProgressRootContext();
+    const element = useRenderElement('div', componentProps, {
+        state,
+        ref: forwardedRef,
+        props: elementProps,
+        stateAttributesMapping: progressStateAttributesMapping
+    });
+    return element;
+});
+if ("production" !== process.env.NODE_ENV) ProgressTrack_ProgressTrack.displayName = "ProgressTrack";
+const ProgressIndicator_ProgressIndicator = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, ...elementProps } = componentProps;
+    const { max, min, value, state } = useProgressRootContext();
+    const percentageValue = Number.isFinite(value) && null !== value ? valueToPercent(value, min, max) : null;
+    const indicatorStyle = null == percentageValue ? {} : {
+        insetInlineStart: 0,
+        height: 'inherit',
+        width: `${percentageValue}%`
+    };
+    const element = useRenderElement('div', componentProps, {
+        state,
+        ref: forwardedRef,
+        props: [
+            {
+                style: indicatorStyle
+            },
+            elementProps
+        ],
+        stateAttributesMapping: progressStateAttributesMapping
+    });
+    return element;
+});
+if ("production" !== process.env.NODE_ENV) ProgressIndicator_ProgressIndicator.displayName = "ProgressIndicator";
+const ProgressValue_ProgressValue = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { className, render, children, style, ...elementProps } = componentProps;
+    const { value, formattedValue, state } = useProgressRootContext();
+    const formattedValueArg = null == value ? 'indeterminate' : formattedValue;
+    const formattedValueDisplay = null == value ? null : formattedValue;
+    const element = useRenderElement('span', componentProps, {
+        state,
+        ref: forwardedRef,
+        props: [
+            {
+                'aria-hidden': true,
+                children: 'function' == typeof children ? children(formattedValueArg, value) : formattedValueDisplay
+            },
+            elementProps
+        ],
+        stateAttributesMapping: progressStateAttributesMapping
+    });
+    return element;
+});
+if ("production" !== process.env.NODE_ENV) ProgressValue_ProgressValue.displayName = "ProgressValue";
+const ProgressLabel_ProgressLabel = /*#__PURE__*/ __rspack_external_react.forwardRef(function(componentProps, forwardedRef) {
+    const { render, className, style, id: idProp, ...elementProps } = componentProps;
+    const { setLabelId, state } = useProgressRootContext();
+    const id = useRegisteredLabelId(idProp, setLabelId);
+    const element = useRenderElement('span', componentProps, {
+        state,
+        ref: forwardedRef,
+        props: [
+            {
+                id,
+                role: 'presentation'
+            },
+            elementProps
+        ],
+        stateAttributesMapping: progressStateAttributesMapping
+    });
+    return element;
+});
+if ("production" !== process.env.NODE_ENV) ProgressLabel_ProgressLabel.displayName = "ProgressLabel";
 const Progress_module = {
     root: "root-VDHmKD",
     track: "track-_XqaKn",
@@ -15,7 +187,7 @@ const ProgressSize = {
     medium: 8,
     large: 12
 };
-const Root = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, size = ProgressSize.small, style, ...props }, ref)=>/*#__PURE__*/ jsx(Progress.Root, {
+const Root = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, size = ProgressSize.small, style, ...props }, ref)=>/*#__PURE__*/ jsx(ProgressRoot_ProgressRoot, {
         ref: ref,
         className: clsx(Progress_module.root, className),
         style: {
@@ -24,31 +196,31 @@ const Root = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, size
         },
         ...props
     }));
-const Track = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Progress.Track, {
+const Track = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(ProgressTrack_ProgressTrack, {
         ref: ref,
         className: clsx(Progress_module.track, className),
         ...props
     }));
-const Indicator = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Progress.Indicator, {
+const Indicator = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(ProgressIndicator_ProgressIndicator, {
         ref: ref,
         className: clsx(Progress_module.indicator, className),
         ...props
     }));
-const Value = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Progress.Value, {
+const Value = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(ProgressValue_ProgressValue, {
         ref: ref,
         className: clsx(Progress_module.value, className),
         ...props
     }));
-const Label = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(Progress.Label, {
+const Label = /*#__PURE__*/ __rspack_external_react.forwardRef(({ className, ...props }, ref)=>/*#__PURE__*/ jsx(ProgressLabel_ProgressLabel, {
         ref: ref,
         className: clsx(Progress_module.label, className),
         ...props
     }));
-const Progress_Progress = {
+const Progress = {
     Root: Root,
     Track: Track,
     Indicator: Indicator,
     Value: Value,
     Label: Label
 };
-export { ProgressSize, Progress_Progress as Progress };
+export { Progress, ProgressSize };

package/dist/Radio/index.d.ts

@@ -1,15 +1,188 @@
 import { JSX as JSX_2 } from 'react/jsx-runtime';
-import { Radio as Radio_2 } from '@base-ui/react/radio';
-import { RadioIndicatorProps } from '@base-ui/react/radio';
+import { RadioIndicatorProps as RadioIndicatorProps_2 } from '@base-ui/react/radio';
 import * as React_2 from 'react';
 
+/**
+ * Props shared by all Base UI components.
+ * Contains `className` (string or callback taking the component's state as an argument) and `render` (function to customize rendering).
+ */
+declare type BaseUIComponentProps<ElementType extends React_2.ElementType, State, RenderFunctionProps = HTMLProps> = Omit<WithBaseUIEvent<React_2.ComponentPropsWithRef<ElementType>>, 'className' | 'color' | 'defaultValue' | 'defaultChecked' | 'style'> & {
+    /**
+     * CSS class applied to the element, or a function that
+     * returns a class based on the component's state.
+     */
+    className?: string | ((state: State) => string | undefined) | undefined;
+    /**
+     * Allows you to replace the component's HTML element
+     * with a different tag, or compose it with another component.
+     *
+     * Accepts a `ReactElement` or a function that returns the element to render.
+     */
+    render?: React_2.ReactElement | ComponentRenderFn<RenderFunctionProps, State> | undefined;
+    /**
+     * Style applied to the element, or a function that
+     * returns a style object based on the component's state.
+     */
+    style?: React_2.CSSProperties | ((state: State) => React_2.CSSProperties | undefined) | undefined;
+};
+
+declare type BaseUIEvent<E extends React_2.SyntheticEvent<Element, Event>> = E & {
+    preventBaseUIHandler: () => void;
+    readonly baseUIHandlerPrevented?: boolean | undefined;
+};
+
+/**
+ * Shape of the render prop: a function that takes props to be spread on the element and component's state and returns a React element.
+ *
+ * @template Props Props to be spread on the rendered element.
+ * @template State Component's internal state.
+ */
+declare type ComponentRenderFn<Props, State> = (props: Props, state: State) => React_2.ReactElement<unknown>;
+
+declare interface FieldRootState {
+    /**
+     * Whether the component should ignore user interaction.
+     */
+    disabled: boolean;
+    /**
+     * Whether the field has been touched.
+     */
+    touched: boolean;
+    /**
+     * Whether the field value has changed from its initial value.
+     */
+    dirty: boolean;
+    /**
+     * Whether the field is valid.
+     */
+    valid: boolean | null;
+    /**
+     * Whether the field has a value.
+     */
+    filled: boolean;
+    /**
+     * Whether the field is focused.
+     */
+    focused: boolean;
+}
+
+declare type HTMLProps<T = any> = React_2.HTMLAttributes<T> & {
+    ref?: React_2.Ref<T> | undefined;
+};
+
+declare interface NonNativeButtonProps {
+    /**
+     * Whether the component renders a native `<button>` element when replacing it
+     * via the `render` prop.
+     * Set to `true` if the rendered element is a native button.
+     * @default false
+     */
+    nativeButton?: boolean | undefined;
+}
+
 export declare const Radio: {
-    Indicator: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<RadioIndicatorProps, "ref"> & React_2.RefAttributes<HTMLSpanElement>, "ref">, "className"> & {
+    Indicator: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<RadioIndicatorProps_2, "ref"> & React_2.RefAttributes<HTMLSpanElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLSpanElement>>;
     Root: typeof Root;
 };
 
+export declare namespace Radio_2 {
+    export {
+        RadioRoot as Root,
+        RadioIndicator as Indicator
+    }
+}
+
+/**
+ * Indicates whether the radio button is selected.
+ * Renders a `<span>` element.
+ *
+ * Documentation: [Base UI Radio](https://base-ui.com/react/components/radio)
+ */
+export declare const RadioIndicator: React_2.ForwardRefExoticComponent<Omit<RadioIndicatorProps, "ref"> & React_2.RefAttributes<HTMLSpanElement>>;
+
+export declare namespace RadioIndicator {
+    export type Props = RadioIndicatorProps;
+    export type State = RadioIndicatorState;
+}
+
+export declare interface RadioIndicatorProps extends BaseUIComponentProps<'span', RadioIndicatorState> {
+    /**
+     * Whether to keep the HTML element in the DOM when the radio button is inactive.
+     * @default false
+     */
+    keepMounted?: boolean | undefined;
+}
+
+export declare interface RadioIndicatorState {
+    /**
+     * Whether the radio button is currently selected.
+     */
+    checked: boolean;
+    /**
+     * The transition status of the component.
+     */
+    transitionStatus: TransitionStatus;
+}
+
+/**
+ * Represents the radio button itself.
+ * Renders a `<span>` element and a hidden `<input>` beside.
+ *
+ * Documentation: [Base UI Radio](https://base-ui.com/react/components/radio)
+ */
+export declare const RadioRoot: {
+    <Value>(props: RadioRoot.Props<Value>): React_2.JSX.Element;
+};
+
+export declare namespace RadioRoot {
+    export type State = RadioRootState;
+    export type Props<TValue = any> = RadioRootProps<TValue>;
+}
+
+export declare interface RadioRootProps<Value = any> extends NonNativeButtonProps, Omit<BaseUIComponentProps<'span', RadioRootState>, 'value'> {
+    /**
+     * The unique identifying value of the radio in a group.
+     */
+    value: Value;
+    /**
+     * Whether the component should ignore user interaction.
+     */
+    disabled?: boolean | undefined;
+    /**
+     * Whether the user must choose a value before submitting a form.
+     */
+    required?: boolean | undefined;
+    /**
+     * Whether the user should be unable to select the radio button.
+     */
+    readOnly?: boolean | undefined;
+    /**
+     * A ref to access the hidden input element.
+     */
+    inputRef?: React_2.Ref<HTMLInputElement> | undefined;
+}
+
+export declare interface RadioRootState extends FieldRootState {
+    /**
+     * Whether the radio button is currently selected.
+     */
+    checked: boolean;
+    /**
+     * Whether the component should ignore user interaction.
+     */
+    disabled: boolean;
+    /**
+     * Whether the user should be unable to select the radio button.
+     */
+    readOnly: boolean;
+    /**
+     * Whether the user must choose a value before submitting a form.
+     */
+    required: boolean;
+}
+
 export declare const RadioSize: {
     readonly small: 12;
     readonly medium: 16;
@@ -22,11 +195,17 @@ declare type RootProps<Value> = WithStringClassName<Radio_2.Root.Props<Value>> &
     size?: number;
 };
 
+declare type TransitionStatus = 'starting' | 'ending' | 'idle' | undefined;
+
+/**
+ * Adds a `preventBaseUIHandler` method to all event handlers.
+ */
+declare type WithBaseUIEvent<T> = { [K in keyof T]: WithPreventBaseUIHandler<T[K]> };
+
+declare type WithPreventBaseUIHandler<T> = T extends ((event: infer E) => any) ? E extends React_2.SyntheticEvent<Element, Event> ? (event: BaseUIEvent<E>) => ReturnType<T> : T : T extends undefined ? undefined : T;
+
 declare type WithStringClassName<P> = Omit<P, 'className'> & {
     className?: string;
 };
 
-
-export * from "@base-ui/react/radio";
-
 export { }