import * as _radix_ui_react_context from '@radix-ui/react-context';
import { Scope } from '@radix-ui/react-context';
import * as React from 'react';
import { Primitive } from '@radix-ui/react-primitive';

declare const Orientation: {
    readonly Vertical: "vertical";
    readonly Horizontal: "horizontal";
};
type Orientation = (typeof Orientation)[keyof typeof Orientation];
declare const Direction: {
    readonly LTR: "ltr";
    readonly RTL: "rtl";
};
type Direction = (typeof Direction)[keyof typeof Direction];
declare global {
    interface FocusOptions {
        /**
         * A boolean value that should be set to `true` to force, or `false` to prevent
         * visible indication that the element is focused. If the property is not
         * specified, a browser will provide visible indication if it determines
         * that this would improve accessibility for users.
         *
         * @see
         * https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus#focusvisible
         */
        focusVisible?: boolean | undefined;
    }
}
type ScopedProps<P> = P & {
    __scopeSlider?: Scope | undefined;
};
declare const createSliderScope: _radix_ui_react_context.CreateScope;
interface SliderProps extends Omit<SliderHorizontalProps | SliderVerticalProps, keyof SliderOrientationPrivateProps | 'defaultValue'> {
    name?: string | undefined;
    disabled?: boolean | undefined;
    orientation?: Orientation | undefined;
    dir?: Direction | undefined;
    min?: number | undefined;
    max?: number | undefined;
    step?: number | undefined;
    minStepsBetweenThumbs?: number | undefined;
    /**
     * When `true`, thumbs keep their relative order and won't cross over one
     * another while dragging. Each thumb is constrained to the values of its
     * neighbors instead of swapping positions when dragged past them.
     *
     * @defaultValue false
     */
    preserveThumbOrder?: boolean | undefined;
    value?: number[] | undefined;
    defaultValue?: number[] | undefined;
    onValueChange?: {
        bivarianceHack(value: number[]): void;
    }['bivarianceHack'] | undefined;
    onValueCommit?: {
        bivarianceHack(value: number[]): void;
    }['bivarianceHack'] | undefined;
    inverted?: boolean | undefined;
    form?: string | undefined;
}
declare const Slider: React.ForwardRefExoticComponent<SliderProps & React.RefAttributes<HTMLSpanElement>>;
type SliderOrientationPrivateProps = {
    min: number;
    max: number;
    inverted: boolean;
    onSlideStart?: {
        bivarianceHack(value: number): void;
    }['bivarianceHack'] | undefined;
    onSlideMove?: {
        bivarianceHack(value: number): void;
    }['bivarianceHack'] | undefined;
    onSlideEnd?: (() => void) | undefined;
    onHomeKeyDown(event: React.KeyboardEvent): void;
    onEndKeyDown(event: React.KeyboardEvent): void;
    onStepKeyDown(step: {
        event: React.KeyboardEvent;
        direction: number;
    }): void;
};
interface SliderOrientationProps extends Omit<SliderImplProps, keyof SliderImplPrivateProps>, SliderOrientationPrivateProps {
}
interface SliderHorizontalProps extends SliderOrientationProps {
    dir?: Direction | undefined;
}
interface SliderVerticalProps extends SliderOrientationProps {
}
type PrimitiveSpanProps = React.ComponentPropsWithoutRef<typeof Primitive.span>;
type SliderImplPrivateProps = {
    onSlideStart(event: React.PointerEvent): void;
    onSlideMove(event: React.PointerEvent): void;
    onSlideEnd(event: React.PointerEvent): void;
    onHomeKeyDown(event: React.KeyboardEvent): void;
    onEndKeyDown(event: React.KeyboardEvent): void;
    onStepKeyDown(event: React.KeyboardEvent): void;
};
interface SliderImplProps extends PrimitiveSpanProps, SliderImplPrivateProps {
}
interface SliderTrackProps extends PrimitiveSpanProps {
}
declare const SliderTrack: React.ForwardRefExoticComponent<SliderTrackProps & React.RefAttributes<HTMLSpanElement>>;
interface SliderRangeProps extends PrimitiveSpanProps {
}
declare const SliderRange: React.ForwardRefExoticComponent<SliderRangeProps & React.RefAttributes<HTMLSpanElement>>;
interface SliderThumbProviderProps {
    name?: string | undefined;
    children?: React.ReactNode | undefined;
}
declare function SliderThumbProvider(props: ScopedProps<SliderThumbProviderProps>): React.JSX.Element;
interface SliderThumbTriggerProps extends PrimitiveSpanProps {
}
declare const SliderThumbTrigger: React.ForwardRefExoticComponent<SliderThumbTriggerProps & React.RefAttributes<HTMLSpanElement>>;
interface SliderThumbProps extends SliderThumbTriggerProps {
    name?: string | undefined;
}
declare const SliderThumb: React.ForwardRefExoticComponent<SliderThumbProps & React.RefAttributes<HTMLSpanElement>>;
type PrimitiveInputProps = React.ComponentPropsWithoutRef<typeof Primitive.input>;
interface SliderBubbleInputProps extends Omit<PrimitiveInputProps, 'value'> {
}
declare const SliderBubbleInput: React.ForwardRefExoticComponent<SliderBubbleInputProps & React.RefAttributes<HTMLInputElement>>;

export { SliderRange as Range, Slider as Root, Slider, type SliderProps, SliderRange, type SliderRangeProps, SliderThumb, type SliderThumbProps, SliderTrack, type SliderTrackProps, SliderThumb as Thumb, SliderTrack as Track, createSliderScope, SliderBubbleInput as unstable_BubbleInput, SliderBubbleInput as unstable_SliderBubbleInput, type SliderBubbleInputProps as unstable_SliderBubbleInputProps, SliderThumbProvider as unstable_SliderThumbProvider, type SliderThumbProviderProps as unstable_SliderThumbProviderProps, SliderThumbTrigger as unstable_SliderThumbTrigger, type SliderThumbTriggerProps as unstable_SliderThumbTriggerProps, SliderThumbProvider as unstable_ThumbProvider, SliderThumbTrigger as unstable_ThumbTrigger };