@wix/site-ui 1.30.0 → 1.31.0

package/dist/Slider/index.d.ts

@@ -1,12 +1,294 @@
 import { JSX as JSX_2 } from 'react/jsx-runtime';
 import * as React_2 from 'react';
-import { Slider as Slider_2 } from '@base-ui/react/slider';
-import { SliderControlProps } from '@base-ui/react/slider';
-import { SliderIndicatorProps } from '@base-ui/react/slider';
-import { SliderLabelProps } from '@base-ui/react/slider';
-import { SliderThumbProps } from '@base-ui/react/slider';
-import { SliderTrackProps } from '@base-ui/react/slider';
-import { SliderValueProps } from '@base-ui/react/slider';
+import { SliderControlProps as SliderControlProps_2 } from '@base-ui/react/slider';
+import { SliderIndicatorProps as SliderIndicatorProps_2 } from '@base-ui/react/slider';
+import { SliderLabelProps as SliderLabelProps_2 } from '@base-ui/react/slider';
+import { SliderThumbProps as SliderThumbProps_2 } from '@base-ui/react/slider';
+import { SliderTrackProps as SliderTrackProps_2 } from '@base-ui/react/slider';
+import { SliderValueProps as SliderValueProps_2 } from '@base-ui/react/slider';
+
+declare type BaseUIChangeEventDetail<Reason extends string, CustomProperties extends object> = {
+    /**
+     * The reason for the event.
+     */
+    reason: Reason;
+    /**
+     * The native event associated with the custom event.
+     */
+    event: ReasonToEvent<Reason>;
+    /**
+     * Cancels Base UI from handling the event.
+     */
+    cancel: () => void;
+    /**
+     * Allows the event to propagate in cases where Base UI will stop the propagation.
+     */
+    allowPropagation: () => void;
+    /**
+     * Indicates whether the event has been canceled.
+     */
+    isCanceled: boolean;
+    /**
+     * Indicates whether the event is allowed to propagate.
+     */
+    isPropagationAllowed: boolean;
+    /**
+     * The element that triggered the event, if applicable.
+     */
+    trigger: Element | undefined;
+} & CustomProperties;
+
+/**
+ * Details of custom change events emitted by Base UI components.
+ */
+declare type BaseUIChangeEventDetails<Reason extends string, CustomProperties extends object = {}> = Reason extends string ? BaseUIChangeEventDetail<Reason, CustomProperties> & {} : never;
+
+/**
+ * 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;
+};
+
+/**
+ * Details of custom generic events emitted by Base UI components.
+ */
+declare type BaseUIGenericEventDetail<Reason extends string, CustomProperties extends object> = {
+    /**
+     * The reason for the event.
+     */
+    reason: Reason;
+    /**
+     * The native event associated with the custom event.
+     */
+    event: ReasonToEvent<Reason>;
+} & CustomProperties;
+
+declare type BaseUIGenericEventDetails<Reason extends string, CustomProperties extends object = {}> = Reason extends string ? BaseUIGenericEventDetail<Reason, CustomProperties> & {} : never;
+
+declare const cancelOpen: "cancel-open";
+
+declare const chipRemovePress: "chip-remove-press";
+
+declare const clearPress: "clear-press";
+
+declare const closePress: "close-press";
+
+declare const closeWatcher: "close-watcher";
+
+/**
+ * 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 const decrementPress: "decrement-press";
+
+declare const disabled: "disabled";
+
+declare const drag: "drag";
+
+declare const escapeKey: "escape-key";
+
+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 const focusOut: "focus-out";
+
+declare type HTMLProps<T = any> = React_2.HTMLAttributes<T> & {
+    ref?: React_2.Ref<T> | undefined;
+};
+
+declare const imperativeAction: "imperative-action";
+
+declare const incrementPress: "increment-press";
+
+declare const initial: "initial";
+
+declare const inputBlur: "input-blur";
+
+declare const inputChange: "input-change";
+
+declare const inputClear: "input-clear";
+
+declare const inputPaste: "input-paste";
+
+declare const inputPress: "input-press";
+
+declare const itemPress: "item-press";
+
+declare const keyboard: "keyboard";
+
+declare interface LabelableContext {
+    /**
+     * The `id` of the labelable element.
+     * When `null` the association is implicit.
+     */
+    controlId: string | null | undefined;
+    registerControlId: (source: symbol, id: string | null | undefined) => void;
+    /**
+     * The `id` of the label.
+     */
+    labelId: string | undefined;
+    setLabelId: React_2.Dispatch<React_2.SetStateAction<string | undefined>>;
+    /**
+     * An array of `id`s of elements that provide an accessible description.
+     */
+    messageIds: string[];
+    setMessageIds: React_2.Dispatch<React_2.SetStateAction<string[]>>;
+    getDescriptionProps: (externalProps: HTMLProps) => HTMLProps;
+}
+
+/**
+ * A context for providing [labelable elements](https://html.spec.whatwg.org/multipage/forms.html#category-label)\
+ * with an accessible name (label) and description.
+ */
+declare const LabelableContext: React_2.Context<LabelableContext>;
+
+declare const linkPress: "link-press";
+
+declare const listNavigation: "list-navigation";
+
+declare const missing: "missing";
+
+declare const none: "none";
+
+declare type Orientation = 'horizontal' | 'vertical';
+
+declare const outsidePress: "outside-press";
+
+declare const pointer: "pointer";
+
+declare namespace REASONS {
+    export {
+        none,
+        triggerPress,
+        triggerHover,
+        triggerFocus,
+        outsidePress,
+        itemPress,
+        closePress,
+        linkPress,
+        clearPress,
+        chipRemovePress,
+        trackPress,
+        incrementPress,
+        decrementPress,
+        inputChange,
+        inputClear,
+        inputBlur,
+        inputPaste,
+        inputPress,
+        focusOut,
+        escapeKey,
+        closeWatcher,
+        listNavigation,
+        keyboard,
+        pointer,
+        drag,
+        wheel,
+        scrub,
+        cancelOpen,
+        siblingOpen,
+        disabled,
+        missing,
+        initial,
+        imperativeAction,
+        swipe,
+        windowResize
+    }
+}
+
+/**
+ * Maps a change `reason` string to the corresponding native event type.
+ */
+declare type ReasonToEvent<Reason extends string> = Reason extends keyof ReasonToEventMap ? ReasonToEventMap[Reason] : Event;
+
+declare interface ReasonToEventMap {
+    [REASONS.none]: Event;
+    [REASONS.triggerPress]: MouseEvent | PointerEvent | TouchEvent | KeyboardEvent;
+    [REASONS.triggerHover]: MouseEvent;
+    [REASONS.triggerFocus]: FocusEvent;
+    [REASONS.outsidePress]: MouseEvent | PointerEvent | TouchEvent;
+    [REASONS.itemPress]: MouseEvent | KeyboardEvent | PointerEvent;
+    [REASONS.closePress]: MouseEvent | KeyboardEvent | PointerEvent;
+    [REASONS.linkPress]: MouseEvent | PointerEvent;
+    [REASONS.clearPress]: PointerEvent | MouseEvent | KeyboardEvent;
+    [REASONS.chipRemovePress]: PointerEvent | MouseEvent | KeyboardEvent;
+    [REASONS.trackPress]: PointerEvent | MouseEvent | TouchEvent;
+    [REASONS.incrementPress]: PointerEvent | MouseEvent | TouchEvent;
+    [REASONS.decrementPress]: PointerEvent | MouseEvent | TouchEvent;
+    [REASONS.inputChange]: InputEvent | Event;
+    [REASONS.inputClear]: InputEvent | FocusEvent | Event;
+    [REASONS.inputBlur]: FocusEvent;
+    [REASONS.inputPaste]: ClipboardEvent;
+    [REASONS.inputPress]: MouseEvent | PointerEvent | TouchEvent | KeyboardEvent;
+    [REASONS.focusOut]: FocusEvent | KeyboardEvent;
+    [REASONS.escapeKey]: KeyboardEvent;
+    [REASONS.closeWatcher]: Event;
+    [REASONS.listNavigation]: KeyboardEvent;
+    [REASONS.keyboard]: KeyboardEvent;
+    [REASONS.pointer]: PointerEvent;
+    [REASONS.drag]: PointerEvent | TouchEvent;
+    [REASONS.swipe]: PointerEvent | TouchEvent;
+    [REASONS.wheel]: WheelEvent;
+    [REASONS.scrub]: PointerEvent;
+    [REASONS.cancelOpen]: MouseEvent;
+    [REASONS.siblingOpen]: Event;
+    [REASONS.disabled]: Event;
+    [REASONS.missing]: Event;
+    [REASONS.initial]: Event;
+    [REASONS.imperativeAction]: Event;
+    [REASONS.windowResize]: UIEvent;
+}
 
 declare function Root<Value extends number | readonly number[]>({ className, size, style, ...props }: RootProps<Value>): JSX_2.Element;
 
@@ -14,39 +296,419 @@ declare type RootProps<Value extends number | readonly number[]> = WithStringCla
     size?: number;
 };
 
+declare const scrub: "scrub";
+
+declare const siblingOpen: "sibling-open";
+
 export declare const Slider: {
-    Label: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<SliderLabelProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    Label: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<SliderLabelProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
-    Value: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<SliderValueProps, "ref"> & React_2.RefAttributes<HTMLOutputElement>, "ref">, "className"> & {
+    Value: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<SliderValueProps_2, "ref"> & React_2.RefAttributes<HTMLOutputElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLOutputElement>>;
-    Control: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<SliderControlProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    Control: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<SliderControlProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
-    Track: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<SliderTrackProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    Track: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<SliderTrackProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
-    Thumb: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<SliderThumbProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    Thumb: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<SliderThumbProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
-    Indicator: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<SliderIndicatorProps, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
+    Indicator: React_2.ForwardRefExoticComponent<Omit<Omit<Omit<SliderIndicatorProps_2, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref">, "className"> & {
         className?: string | undefined;
     } & React_2.RefAttributes<HTMLDivElement>>;
     Root: typeof Root;
 };
 
+export declare namespace Slider_2 {
+    export {
+        SliderRoot as Root,
+        SliderLabel as Label,
+        SliderValue as Value,
+        SliderControl as Control,
+        SliderTrack as Track,
+        SliderThumb as Thumb,
+        SliderIndicator as Indicator
+    }
+}
+
+/**
+ * The clickable, interactive part of the slider.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Slider](https://base-ui.com/react/components/slider)
+ */
+export declare const SliderControl: React_2.ForwardRefExoticComponent<Omit<SliderControlProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace SliderControl {
+    export type State = SliderControlState;
+    export type Props = SliderControlProps;
+}
+
+export declare interface SliderControlProps extends BaseUIComponentProps<'div', SliderControlState> {}
+
+export declare interface SliderControlState extends SliderRootState {}
+
+/**
+ * Visualizes the current value of the slider.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Slider](https://base-ui.com/react/components/slider)
+ */
+export declare const SliderIndicator: React_2.ForwardRefExoticComponent<Omit<SliderIndicatorProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace SliderIndicator {
+    export type State = SliderIndicatorState;
+    export type Props = SliderIndicatorProps;
+}
+
+export declare interface SliderIndicatorProps extends BaseUIComponentProps<'div', SliderIndicatorState> {}
+
+export declare interface SliderIndicatorState extends SliderRootState {}
+
+/**
+ * An accessible label that is automatically associated with the slider thumbs.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Slider](https://base-ui.com/react/components/slider)
+ */
+export declare const SliderLabel: React_2.ForwardRefExoticComponent<Omit<SliderLabelProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace SliderLabel {
+    export type State = SliderLabelState;
+    export type Props = SliderLabelProps;
+}
+
+export declare interface SliderLabelProps extends Omit<BaseUIComponentProps<'div', SliderLabel.State>, 'id'> {}
+
+export declare type SliderLabelState = SliderRoot.State;
+
+/**
+ * Groups all parts of the slider.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Slider](https://base-ui.com/react/components/slider)
+ */
+export declare const SliderRoot: {
+    <Value extends number | readonly number[]>(props: SliderRoot.Props<Value> & {
+        ref?: React_2.Ref<HTMLDivElement> | undefined;
+    }): React_2.JSX.Element;
+};
+
+export declare namespace SliderRoot {
+    export type State = SliderRootState;
+    export type Props<Value extends number | readonly number[] = number | readonly number[]> = SliderRootProps<Value>;
+    export type ChangeEventReason = SliderRootChangeEventReason;
+    export type ChangeEventDetails = SliderRootChangeEventDetails;
+    export type CommitEventReason = SliderRootCommitEventReason;
+    export type CommitEventDetails = SliderRootCommitEventDetails;
+}
+
+export declare interface SliderRootChangeEventCustomProperties {
+    /**
+     * The index of the active thumb at the time of the change.
+     */
+    activeThumbIndex: number;
+}
+
+export declare type SliderRootChangeEventDetails = BaseUIChangeEventDetails<SliderRoot.ChangeEventReason, SliderRootChangeEventCustomProperties>;
+
+export declare type SliderRootChangeEventReason = typeof REASONS.inputChange | typeof REASONS.trackPress | typeof REASONS.drag | typeof REASONS.keyboard | typeof REASONS.none;
+
+export declare type SliderRootCommitEventDetails = BaseUIGenericEventDetails<SliderRoot.CommitEventReason>;
+
+export declare type SliderRootCommitEventReason = typeof REASONS.inputChange | typeof REASONS.trackPress | typeof REASONS.drag | typeof REASONS.keyboard | typeof REASONS.none;
+
+export declare interface SliderRootProps<Value extends number | readonly number[] = number | readonly number[]> extends BaseUIComponentProps<'div', SliderRootState> {
+    /**
+     * The uncontrolled value of the slider when it's initially rendered.
+     *
+     * To render a controlled slider, use the `value` prop instead.
+     */
+    defaultValue?: Value | undefined;
+    /**
+     * Whether the slider should ignore user interaction.
+     * @default false
+     */
+    disabled?: boolean | undefined;
+    /**
+     * Options to format the input value.
+     */
+    format?: Intl.NumberFormatOptions | undefined;
+    /**
+     * The locale used by `Intl.NumberFormat` when formatting the value.
+     * Defaults to the user's runtime locale.
+     */
+    locale?: Intl.LocalesArgument | undefined;
+    /**
+     * The maximum allowed value of the slider.
+     * Should not be equal to min.
+     * @default 100
+     */
+    max?: number | undefined;
+    /**
+     * The minimum allowed value of the slider.
+     * Should not be equal to max.
+     * @default 0
+     */
+    min?: number | undefined;
+    /**
+     * The minimum steps between values in a range slider.
+     * @default 0
+     */
+    minStepsBetweenValues?: number | undefined;
+    /**
+     * Identifies the field when a form is submitted.
+     */
+    name?: string | undefined;
+    /**
+     * Identifies the form that owns the slider inputs.
+     * Useful when the slider is rendered outside the form.
+     */
+    form?: string | undefined;
+    /**
+     * The component orientation.
+     * @default 'horizontal'
+     */
+    orientation?: Orientation | undefined;
+    /**
+     * The granularity with which the slider can step through values. (A "discrete" slider.)
+     * The `min` prop serves as the origin for the valid values.
+     * We recommend (max - min) to be evenly divisible by the step.
+     * @default 1
+     */
+    step?: number | undefined;
+    /**
+     * The granularity with which the slider can step through values when using Page Up/Page Down or Shift + Arrow Up/Arrow Down.
+     * @default 10
+     */
+    largeStep?: number | undefined;
+    /**
+     * How the thumb(s) are aligned relative to `Slider.Control` when the value is at `min` or `max`:
+     * - `center`: The center of the thumb is aligned with the control edge
+     * - `edge`: The thumb is inset within the control such that its edge is aligned with the control edge
+     * - `edge-client-only`: Same as `edge` but renders after React hydration on the client, reducing bundle size in return
+     * @default 'center'
+     */
+    thumbAlignment?: 'center' | 'edge' | 'edge-client-only' | undefined;
+    /**
+     * Controls how thumbs behave when they collide during pointer interactions.
+     *
+     * - `'push'` (default): Thumbs push each other without restoring their previous positions when dragged back.
+     * - `'swap'`: Thumbs swap places when dragged past each other.
+     * - `'none'`: Thumbs cannot move past each other; excess movement is ignored.
+     *
+     * @default 'push'
+     */
+    thumbCollisionBehavior?: 'push' | 'swap' | 'none' | undefined;
+    /**
+     * The value of the slider.
+     * For ranged sliders, provide an array with two values.
+     */
+    value?: Value | undefined;
+    /**
+     * Callback function that is fired when the slider's value changed.
+     * You can pull out the new value by accessing `event.target.value` (any).
+     *
+     * The `eventDetails.reason` indicates what triggered the change:
+     *
+     * - `'input-change'` when the hidden range input emits a change event (for example, via form integration)
+     * - `'track-press'` when the control track is pressed
+     * - `'drag'` while dragging a thumb
+     * - `'keyboard'` for keyboard input
+     * - `'none'` when the change is triggered without a specific interaction
+     */
+    onValueChange?: ((value: Value extends number ? number : Value, eventDetails: SliderRoot.ChangeEventDetails) => void) | undefined;
+    /**
+     * Callback function that is fired when the `pointerup` is triggered.
+     * **Warning**: This is a generic event not a change event.
+     *
+     * The `eventDetails.reason` indicates what triggered the commit:
+     *
+     * - `'drag'` while dragging a thumb
+     * - `'track-press'` when the control track is pressed
+     * - `'keyboard'` for keyboard input
+     * - `'input-change'` when the hidden range input emits a change event (for example, via form integration)
+     * - `'none'` when the commit occurs without a specific interaction
+     */
+    onValueCommitted?: ((value: Value extends number ? number : Value, eventDetails: SliderRoot.CommitEventDetails) => void) | undefined;
+}
+
+export declare interface SliderRootState extends FieldRootState {
+    /**
+     * The index of the active thumb.
+     */
+    activeThumbIndex: number;
+    /**
+     * Whether the component should ignore user interaction.
+     */
+    disabled: boolean;
+    /**
+     * Whether the thumb is currently being dragged.
+     */
+    dragging: boolean;
+    /**
+     * The maximum value.
+     */
+    max: number;
+    /**
+     * The minimum value.
+     */
+    min: number;
+    /**
+     * The minimum steps between values in a range slider.
+     * @default 0
+     */
+    minStepsBetweenValues: number;
+    /**
+     * The component orientation.
+     */
+    orientation: Orientation;
+    /**
+     * The step increment of the slider when incrementing or decrementing. It will snap
+     * to multiples of this value. Decimal values are supported.
+     * @default 1
+     */
+    step: number;
+    /**
+     * The raw number value of the slider.
+     */
+    values: readonly number[];
+}
+
 export declare const SliderSize: {
     readonly small: 12;
     readonly medium: 16;
     readonly large: 20;
 };
 
+/**
+ * The draggable part of the slider at the tip of the indicator.
+ * Renders a `<div>` element and a nested `<input type="range">`.
+ *
+ * Documentation: [Base UI Slider](https://base-ui.com/react/components/slider)
+ */
+export declare const SliderThumb: React_2.ForwardRefExoticComponent<Omit<SliderThumbProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace SliderThumb {
+    export type State = SliderThumbState;
+    export type Props = SliderThumbProps;
+}
+
+export declare interface SliderThumbProps extends Omit<BaseUIComponentProps<'div', SliderThumbState>, 'onBlur' | 'onFocus'> {
+    /**
+     * Whether the thumb should ignore user interaction.
+     * @default false
+     */
+    disabled?: boolean | undefined;
+    /**
+     * A function which returns a string value for the [`aria-label`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Reference/Attributes/aria-label) attribute of the `input`.
+     */
+    getAriaLabel?: ((index: number) => string) | null | undefined;
+    /**
+     * A function which returns a string value for the [`aria-valuetext`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Reference/Attributes/aria-valuetext) attribute of the `input`.
+     * This is important for screen reader users.
+     */
+    getAriaValueText?: ((formattedValue: string, value: number, index: number) => string) | null | undefined;
+    /**
+     * The index of the thumb which corresponds to the index of its value in the
+     * `value` or `defaultValue` array.
+     * This prop is required to support server-side rendering for range sliders
+     * with multiple thumbs.
+     * @example
+     * ```tsx
+     * <Slider.Root value={[10, 20]}>
+     *   <Slider.Thumb index={0} />
+     *   <Slider.Thumb index={1} />
+     * </Slider.Root>
+     * ```
+     */
+    index?: number | undefined;
+    /**
+     * A ref to access the nested input element.
+     */
+    inputRef?: React_2.Ref<HTMLInputElement> | undefined;
+    /**
+     * A blur handler forwarded to the `input`.
+     */
+    onBlur?: React_2.FocusEventHandler<HTMLInputElement> | undefined;
+    /**
+     * A focus handler forwarded to the `input`.
+     */
+    onFocus?: React_2.FocusEventHandler<HTMLInputElement> | undefined;
+    /**
+     * Optional tab index attribute forwarded to the `input`.
+     */
+    tabIndex?: number | undefined;
+}
+
+export declare interface SliderThumbState extends SliderRootState {}
+
+/**
+ * Contains the slider indicator and represents the entire range of the slider.
+ * Renders a `<div>` element.
+ *
+ * Documentation: [Base UI Slider](https://base-ui.com/react/components/slider)
+ */
+export declare const SliderTrack: React_2.ForwardRefExoticComponent<Omit<SliderTrackProps, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+
+export declare namespace SliderTrack {
+    export type State = SliderTrackState;
+    export type Props = SliderTrackProps;
+}
+
+export declare interface SliderTrackProps extends BaseUIComponentProps<'div', SliderTrackState> {}
+
+export declare interface SliderTrackState extends SliderRootState {}
+
+/**
+ * Displays the current value of the slider as text.
+ * Renders an `<output>` element.
+ *
+ * Documentation: [Base UI Slider](https://base-ui.com/react/components/slider)
+ */
+export declare const SliderValue: React_2.ForwardRefExoticComponent<Omit<SliderValueProps, "ref"> & React_2.RefAttributes<HTMLOutputElement>>;
+
+export declare namespace SliderValue {
+    export type State = SliderValueState;
+    export type Props = SliderValueProps;
+}
+
+export declare interface SliderValueProps extends Omit<BaseUIComponentProps<'output', SliderValueState>, 'children'> {
+    children?: null | ((formattedValues: readonly string[], values: readonly number[]) => React_2.ReactNode) | undefined;
+}
+
+export declare interface SliderValueState extends SliderRootState {}
+
+declare const swipe: "swipe";
+
+export declare interface ThumbMetadata {
+    inputId: LabelableContext['controlId'];
+}
+
+declare const trackPress: "track-press";
+
+declare const triggerFocus: "trigger-focus";
+
+declare const triggerHover: "trigger-hover";
+
+declare const triggerPress: "trigger-press";
+
+declare const wheel: "wheel";
+
+declare const windowResize: "window-resize";
+
+/**
+ * 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/slider";
-
 export { }