import { ComponentSize } from '../../../hooks';
import type { CSSProperties, ComponentPublicInstance, ComputedRef, Ref, ExtractPropTypes, PropType } from 'vue';
import type Slider from './Slider.vue';
export interface ISliderProps {
    modelValue: number | number[];
    min: number;
    max: number;
    step: number;
    showInput: boolean;
    showInputControls: boolean;
    inputSize: string;
    showStops: boolean;
    showTooltip: boolean;
    formatTooltip: (val: number) => number | string;
    disabled: boolean;
    range: boolean;
    vertical: boolean;
    height: string;
    debounce: number;
    label: string;
    rangeStartLabel: string;
    rangeEndLabel: string;
    formatValueText: (val: number) => string;
    tooltipClass: string;
    marks?: Record<number, any>;
}
export interface ISliderInitData {
    firstValue: number;
    secondValue: number;
    oldValue?: number | number[];
    dragging: boolean;
    sliderSize: number;
}
export interface ISliderProvider {
    disabled: ComputedRef<boolean>;
    min: ComputedRef<number>;
    max: ComputedRef<number>;
    step: ComputedRef<number>;
    showTooltip: ComputedRef<boolean>;
    precision: ComputedRef<number>;
    sliderSize: ComputedRef<number>;
    formatTooltip: ComputedRef<(value: number) => number | string>;
    emitChange: () => void;
    resetSize: () => void;
    updateDragging: (val: boolean) => void;
}
export declare type Mark = {
    point: number;
    position: number;
    mark: {
        [s: string]: any;
    };
};
export declare type Marks = ComputedRef<Mark[]>;
export declare type Stops = {
    stops: ComputedRef<number[]>;
    getStopStyle: (position: number) => CSSProperties;
};
export declare type Slide = {
    slider: Ref<HTMLElement>;
    firstButton: Ref<ISliderButton>;
    secondButton: Ref<ISliderButton>;
    sliderDisabled: ComputedRef<boolean>;
    minValue: ComputedRef<number>;
    maxValue: ComputedRef<number>;
    runwayStyle: ComputedRef<CSSProperties>;
    barStyle: ComputedRef<CSSProperties>;
    resetSize: () => void;
    setPosition: (percent: number) => void;
    emitChange: () => void;
    onSliderClick: (event: MouseEvent) => void;
};
export declare type ButtonRefs = {
    [s in 'firstButton' | 'secondButton']: Ref<ISliderButton | undefined>;
};
export interface ISliderButtonProps {
    modelValue: number;
    vertical: boolean;
    tooltipClass: string;
}
export interface ISliderButtonInitData {
    hovering: boolean;
    dragging: boolean;
    isClick: boolean;
    startX: number;
    currentX: number;
    startY: number;
    currentY: number;
    startPosition: number;
    newPosition: number;
    oldValue: number;
}
export interface ISliderButton extends ComponentPublicInstance {
    tooltip: Ref<HTMLElement | undefined>;
    showTooltip: Ref<boolean>;
    wrapperStyle: ComputedRef<CSSProperties>;
    formatValue: ComputedRef<number | string>;
    dragging: boolean;
    handleMouseEnter: () => void;
    handleMouseLeave: () => void;
    onButtonDown: (event: MouseEvent | TouchEvent) => void;
    onKeyDown: (event: KeyboardEvent) => void;
    setPosition: (newPosition: number) => void;
}
export declare const sliderProps: {
    modelValue: {
        type: PropType<number | number[]>;
        default: number;
    };
    id: {
        type: StringConstructor;
        default: undefined;
    };
    min: {
        type: NumberConstructor;
        default: number;
    };
    max: {
        type: NumberConstructor;
        default: number;
    };
    step: {
        type: NumberConstructor;
        default: number;
    };
    showInput: {
        type: BooleanConstructor;
        default: boolean;
    };
    showInputControls: {
        type: BooleanConstructor;
        default: boolean;
    };
    size: {
        type: PropType<ComponentSize>;
    };
    inputSize: {
        type: PropType<ComponentSize>;
    };
    showStops: {
        type: BooleanConstructor;
        default: boolean;
    };
    showTooltip: {
        type: BooleanConstructor;
        default: boolean;
    };
    formatTooltip: {
        type: PropType<(val: number) => number | string>;
        default: undefined;
    };
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    range: {
        type: BooleanConstructor;
        default: boolean;
    };
    vertical: {
        type: BooleanConstructor;
        default: boolean;
    };
    height: {
        type: StringConstructor;
        default: string;
    };
    debounce: {
        type: NumberConstructor;
        default: number;
    };
    label: {
        type: StringConstructor;
        default: undefined;
    };
    rangeStartLabel: {
        type: StringConstructor;
        default: undefined;
    };
    rangeEndLabel: {
        type: StringConstructor;
        default: undefined;
    };
    formatValueText: {
        type: PropType<(val: number) => string>;
        default: undefined;
    };
    tooltipClass: {
        type: StringConstructor;
        default: undefined;
    };
    marks: ObjectConstructor;
};
export declare const sliderEmits: string[];
export declare type SliderProps = ExtractPropTypes<typeof sliderProps>;
export declare type SliderEmits = typeof sliderEmits;
export declare type SliderInstance = InstanceType<typeof Slider>;