import { PropType } from 'vue';
import { VideoSegment } from './symbol';
declare function __VLS_template(): {
    attrs: Partial<{}>;
    slots: {
        trigger?(_: {}): any;
        preview?(_: {}): any;
    };
    refs: {
        wrapper: HTMLDivElement;
        slider: ({
            $: import('vue').ComponentInternalInstance;
            $data: {};
            $props: Partial<{}> & Omit<{
                readonly value?: number | number[] | undefined;
                readonly inherit?: boolean | undefined;
                readonly reverse?: boolean | undefined;
                readonly vertical?: boolean | undefined;
                readonly loading?: boolean | undefined;
                readonly slots?: import('../slider').SliderSlots | undefined;
                readonly onChange?: ((value: number | number[]) => void) | ((value: number | number[]) => void)[] | undefined;
                readonly onInput?: ((value: number | number[]) => void) | ((value: number | number[]) => void)[] | undefined;
                readonly disabled?: boolean | undefined;
                readonly sync?: boolean | undefined;
                readonly min?: number | undefined;
                readonly max?: number | undefined;
                readonly range?: boolean | undefined;
                readonly state?: "default" | "success" | "error" | "warning" | undefined;
                readonly loadingLock?: boolean | undefined;
                readonly markers?: Record<string | number, string | import('../slider').SliderMarker> | (number | (import('../slider').SliderMarker & {
                    value: number;
                }))[] | undefined;
                readonly step?: number | undefined;
                readonly tipTransfer?: string | boolean | undefined;
                readonly hideTip?: boolean | undefined;
                readonly tipHover?: boolean | undefined;
                readonly tipProps?: import('../slider').SliderTipProps | undefined;
                readonly markerOnly?: boolean | undefined;
                readonly flipMarker?: boolean | undefined;
                readonly triggerFade?: boolean | undefined;
                readonly rangeDraggable?: boolean | undefined;
                readonly "onUpdate:value"?: ((...args: any[]) => any) | undefined;
            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>;
            $attrs: {
                [x: string]: unknown;
            };
            $refs: {
                [x: string]: unknown;
            } & {
                track: HTMLDivElement;
                filler: HTMLDivElement;
                startTrigger: ({
                    $: import('vue').ComponentInternalInstance;
                    $data: {};
                    $props: Partial<{
                        value: number;
                        reverse: boolean;
                        vertical: boolean;
                        loading: boolean;
                        disabled: boolean;
                        min: number;
                        max: number;
                        tipTransfer: string | boolean;
                        hideTip: boolean;
                        sliding: boolean;
                        tipHover: boolean;
                        tipProps: import('../slider').SliderTipProps;
                    }> & Omit<{
                        readonly value: number;
                        readonly reverse: boolean;
                        readonly vertical: boolean;
                        readonly loading: boolean;
                        readonly disabled: boolean;
                        readonly min: number;
                        readonly max: number;
                        readonly tipTransfer: string | boolean;
                        readonly hideTip: boolean;
                        readonly sliding: boolean;
                        readonly tipHover: boolean;
                        readonly tipProps: import('../slider').SliderTipProps;
                        readonly "onKey-minus"?: ((...args: any[]) => any) | undefined;
                        readonly "onKey-plus"?: ((...args: any[]) => any) | undefined;
                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps">;
                    $attrs: {
                        [x: string]: unknown;
                    };
                    $refs: {
                        [x: string]: unknown;
                    } & {
                        wrapper: HTMLDivElement;
                        tooltip: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                            inherit: PropType<boolean>;
                            trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                            wrapper: PropType<string | boolean>;
                            noArrow: PropType<boolean>;
                            transitionName: PropType<string>;
                            visible: PropType<boolean>;
                            placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                            outsideClose: PropType<boolean>;
                            noHover: PropType<boolean>;
                            tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                            tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                            transfer: PropType<string | boolean>;
                            disabled: PropType<boolean>;
                            raw: PropType<boolean>;
                            delay: PropType<number | number[]>;
                            tipAlive: PropType<boolean>;
                            reverse: PropType<boolean>;
                            width: PropType<number | "trigger" | "auto">;
                            virtual: PropType<{
                                getBoundingClientRect: () => DOMRect;
                            } | {
                                $el: {
                                    getBoundingClientRect: () => DOMRect;
                                };
                            } | {
                                x: number;
                                y: number;
                            }>;
                            shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                            onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                            onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        }>> & Readonly<{
                            onClickoutside?: ((...args: any[]) => any) | undefined;
                            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                        }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("clickoutside" | "update:visible")[], import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                            P: {};
                            B: {};
                            D: {};
                            C: {};
                            M: {};
                            Defaults: {};
                        }, Readonly<import('vue').ExtractPropTypes<{
                            inherit: PropType<boolean>;
                            trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                            wrapper: PropType<string | boolean>;
                            noArrow: PropType<boolean>;
                            transitionName: PropType<string>;
                            visible: PropType<boolean>;
                            placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                            outsideClose: PropType<boolean>;
                            noHover: PropType<boolean>;
                            tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                            tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                            transfer: PropType<string | boolean>;
                            disabled: PropType<boolean>;
                            raw: PropType<boolean>;
                            delay: PropType<number | number[]>;
                            tipAlive: PropType<boolean>;
                            reverse: PropType<boolean>;
                            width: PropType<number | "trigger" | "auto">;
                            virtual: PropType<{
                                getBoundingClientRect: () => DOMRect;
                            } | {
                                $el: {
                                    getBoundingClientRect: () => DOMRect;
                                };
                            } | {
                                x: number;
                                y: number;
                            }>;
                            shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                            onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                            onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        }>> & Readonly<{
                            onClickoutside?: ((...args: any[]) => any) | undefined;
                            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                        }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, {}> | null;
                        handler: HTMLDivElement;
                    };
                    $slots: Readonly<{
                        [name: string]: import('vue').Slot<any> | undefined;
                    }>;
                    $root: import('vue').ComponentPublicInstance | null;
                    $parent: import('vue').ComponentPublicInstance | null;
                    $host: Element | null;
                    $emit: ((event: "key-minus", ...args: any[]) => void) & ((event: "key-plus", ...args: any[]) => void);
                    $el: HTMLDivElement;
                    $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                        value: {
                            type: NumberConstructor;
                            default: number;
                        };
                        tipTransfer: {
                            type: (BooleanConstructor | StringConstructor)[];
                            default: boolean;
                        };
                        hideTip: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        vertical: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        min: {
                            type: NumberConstructor;
                            default: number;
                        };
                        max: {
                            type: NumberConstructor;
                            default: number;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        loading: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        reverse: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        sliding: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        tipHover: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        tipProps: {
                            type: PropType<import('../slider').SliderTipProps>;
                            default: () => {};
                        };
                    }>> & Readonly<{
                        "onKey-minus"?: ((...args: any[]) => any) | undefined;
                        "onKey-plus"?: ((...args: any[]) => any) | undefined;
                    }>, {
                        updateTooltip: () => void;
                        focus: (options?: FocusOptions) => void;
                        blur: () => void;
                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                        "key-minus": (...args: any[]) => void;
                        "key-plus": (...args: any[]) => void;
                    }, string, {
                        value: number;
                        reverse: boolean;
                        vertical: boolean;
                        loading: boolean;
                        disabled: boolean;
                        min: number;
                        max: number;
                        tipTransfer: string | boolean;
                        hideTip: boolean;
                        sliding: boolean;
                        tipHover: boolean;
                        tipProps: import('../slider').SliderTipProps;
                    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                        beforeCreate?: (() => void) | (() => void)[];
                        created?: (() => void) | (() => void)[];
                        beforeMount?: (() => void) | (() => void)[];
                        mounted?: (() => void) | (() => void)[];
                        beforeUpdate?: (() => void) | (() => void)[];
                        updated?: (() => void) | (() => void)[];
                        activated?: (() => void) | (() => void)[];
                        deactivated?: (() => void) | (() => void)[];
                        beforeDestroy?: (() => void) | (() => void)[];
                        beforeUnmount?: (() => void) | (() => void)[];
                        destroyed?: (() => void) | (() => void)[];
                        unmounted?: (() => void) | (() => void)[];
                        renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                        renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                        errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
                    };
                    $forceUpdate: () => void;
                    $nextTick: typeof import('vue').nextTick;
                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
                } & Readonly<{
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }> & Omit<Readonly<import('vue').ExtractPropTypes<{
                    value: {
                        type: NumberConstructor;
                        default: number;
                    };
                    tipTransfer: {
                        type: (BooleanConstructor | StringConstructor)[];
                        default: boolean;
                    };
                    hideTip: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    vertical: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    min: {
                        type: NumberConstructor;
                        default: number;
                    };
                    max: {
                        type: NumberConstructor;
                        default: number;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    reverse: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    sliding: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipHover: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipProps: {
                        type: PropType<import('../slider').SliderTipProps>;
                        default: () => {};
                    };
                }>> & Readonly<{
                    "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    "onKey-plus"?: ((...args: any[]) => any) | undefined;
                }>, "blur" | "focus" | "updateTooltip" | ("value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps")> & import('vue').ShallowUnwrapRef<{
                    updateTooltip: () => void;
                    focus: (options?: FocusOptions) => void;
                    blur: () => void;
                }> & {} & import('vue').ComponentCustomProperties & {} & {
                    $slots: Readonly<{
                        default: () => any;
                        tip: () => any;
                    }> & {
                        default: () => any;
                        tip: () => any;
                    };
                }) | null;
                endTrigger: ({
                    $: import('vue').ComponentInternalInstance;
                    $data: {};
                    $props: Partial<{
                        value: number;
                        reverse: boolean;
                        vertical: boolean;
                        loading: boolean;
                        disabled: boolean;
                        min: number;
                        max: number;
                        tipTransfer: string | boolean;
                        hideTip: boolean;
                        sliding: boolean;
                        tipHover: boolean;
                        tipProps: import('../slider').SliderTipProps;
                    }> & Omit<{
                        readonly value: number;
                        readonly reverse: boolean;
                        readonly vertical: boolean;
                        readonly loading: boolean;
                        readonly disabled: boolean;
                        readonly min: number;
                        readonly max: number;
                        readonly tipTransfer: string | boolean;
                        readonly hideTip: boolean;
                        readonly sliding: boolean;
                        readonly tipHover: boolean;
                        readonly tipProps: import('../slider').SliderTipProps;
                        readonly "onKey-minus"?: ((...args: any[]) => any) | undefined;
                        readonly "onKey-plus"?: ((...args: any[]) => any) | undefined;
                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps">;
                    $attrs: {
                        [x: string]: unknown;
                    };
                    $refs: {
                        [x: string]: unknown;
                    } & {
                        wrapper: HTMLDivElement;
                        tooltip: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                            inherit: PropType<boolean>;
                            trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                            wrapper: PropType<string | boolean>;
                            noArrow: PropType<boolean>;
                            transitionName: PropType<string>;
                            visible: PropType<boolean>;
                            placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                            outsideClose: PropType<boolean>;
                            noHover: PropType<boolean>;
                            tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                            tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                            transfer: PropType<string | boolean>;
                            disabled: PropType<boolean>;
                            raw: PropType<boolean>;
                            delay: PropType<number | number[]>;
                            tipAlive: PropType<boolean>;
                            reverse: PropType<boolean>;
                            width: PropType<number | "trigger" | "auto">;
                            virtual: PropType<{
                                getBoundingClientRect: () => DOMRect;
                            } | {
                                $el: {
                                    getBoundingClientRect: () => DOMRect;
                                };
                            } | {
                                x: number;
                                y: number;
                            }>;
                            shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                            onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                            onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        }>> & Readonly<{
                            onClickoutside?: ((...args: any[]) => any) | undefined;
                            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                        }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("clickoutside" | "update:visible")[], import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                            P: {};
                            B: {};
                            D: {};
                            C: {};
                            M: {};
                            Defaults: {};
                        }, Readonly<import('vue').ExtractPropTypes<{
                            inherit: PropType<boolean>;
                            trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                            wrapper: PropType<string | boolean>;
                            noArrow: PropType<boolean>;
                            transitionName: PropType<string>;
                            visible: PropType<boolean>;
                            placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                            outsideClose: PropType<boolean>;
                            noHover: PropType<boolean>;
                            tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                            tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                            transfer: PropType<string | boolean>;
                            disabled: PropType<boolean>;
                            raw: PropType<boolean>;
                            delay: PropType<number | number[]>;
                            tipAlive: PropType<boolean>;
                            reverse: PropType<boolean>;
                            width: PropType<number | "trigger" | "auto">;
                            virtual: PropType<{
                                getBoundingClientRect: () => DOMRect;
                            } | {
                                $el: {
                                    getBoundingClientRect: () => DOMRect;
                                };
                            } | {
                                x: number;
                                y: number;
                            }>;
                            shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                            onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                            onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        }>> & Readonly<{
                            onClickoutside?: ((...args: any[]) => any) | undefined;
                            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                        }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, {}> | null;
                        handler: HTMLDivElement;
                    };
                    $slots: Readonly<{
                        [name: string]: import('vue').Slot<any> | undefined;
                    }>;
                    $root: import('vue').ComponentPublicInstance | null;
                    $parent: import('vue').ComponentPublicInstance | null;
                    $host: Element | null;
                    $emit: ((event: "key-minus", ...args: any[]) => void) & ((event: "key-plus", ...args: any[]) => void);
                    $el: HTMLDivElement;
                    $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                        value: {
                            type: NumberConstructor;
                            default: number;
                        };
                        tipTransfer: {
                            type: (BooleanConstructor | StringConstructor)[];
                            default: boolean;
                        };
                        hideTip: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        vertical: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        min: {
                            type: NumberConstructor;
                            default: number;
                        };
                        max: {
                            type: NumberConstructor;
                            default: number;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        loading: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        reverse: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        sliding: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        tipHover: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        tipProps: {
                            type: PropType<import('../slider').SliderTipProps>;
                            default: () => {};
                        };
                    }>> & Readonly<{
                        "onKey-minus"?: ((...args: any[]) => any) | undefined;
                        "onKey-plus"?: ((...args: any[]) => any) | undefined;
                    }>, {
                        updateTooltip: () => void;
                        focus: (options?: FocusOptions) => void;
                        blur: () => void;
                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                        "key-minus": (...args: any[]) => void;
                        "key-plus": (...args: any[]) => void;
                    }, string, {
                        value: number;
                        reverse: boolean;
                        vertical: boolean;
                        loading: boolean;
                        disabled: boolean;
                        min: number;
                        max: number;
                        tipTransfer: string | boolean;
                        hideTip: boolean;
                        sliding: boolean;
                        tipHover: boolean;
                        tipProps: import('../slider').SliderTipProps;
                    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                        beforeCreate?: (() => void) | (() => void)[];
                        created?: (() => void) | (() => void)[];
                        beforeMount?: (() => void) | (() => void)[];
                        mounted?: (() => void) | (() => void)[];
                        beforeUpdate?: (() => void) | (() => void)[];
                        updated?: (() => void) | (() => void)[];
                        activated?: (() => void) | (() => void)[];
                        deactivated?: (() => void) | (() => void)[];
                        beforeDestroy?: (() => void) | (() => void)[];
                        beforeUnmount?: (() => void) | (() => void)[];
                        destroyed?: (() => void) | (() => void)[];
                        unmounted?: (() => void) | (() => void)[];
                        renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                        renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                        errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
                    };
                    $forceUpdate: () => void;
                    $nextTick: typeof import('vue').nextTick;
                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
                } & Readonly<{
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }> & Omit<Readonly<import('vue').ExtractPropTypes<{
                    value: {
                        type: NumberConstructor;
                        default: number;
                    };
                    tipTransfer: {
                        type: (BooleanConstructor | StringConstructor)[];
                        default: boolean;
                    };
                    hideTip: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    vertical: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    min: {
                        type: NumberConstructor;
                        default: number;
                    };
                    max: {
                        type: NumberConstructor;
                        default: number;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    reverse: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    sliding: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipHover: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipProps: {
                        type: PropType<import('../slider').SliderTipProps>;
                        default: () => {};
                    };
                }>> & Readonly<{
                    "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    "onKey-plus"?: ((...args: any[]) => any) | undefined;
                }>, "blur" | "focus" | "updateTooltip" | ("value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps")> & import('vue').ShallowUnwrapRef<{
                    updateTooltip: () => void;
                    focus: (options?: FocusOptions) => void;
                    blur: () => void;
                }> & {} & import('vue').ComponentCustomProperties & {} & {
                    $slots: Readonly<{
                        default: () => any;
                        tip: () => any;
                    }> & {
                        default: () => any;
                        tip: () => any;
                    };
                }) | null;
            };
            $slots: Readonly<{
                [name: string]: import('vue').Slot<any> | undefined;
            }>;
            $root: import('vue').ComponentPublicInstance | null;
            $parent: import('vue').ComponentPublicInstance | null;
            $host: Element | null;
            $emit: (event: "update:value", ...args: any[]) => void;
            $el: HTMLDivElement;
            $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                inherit: PropType<boolean>;
                state: PropType<"default" | "success" | "error" | "warning">;
                value: PropType<number | number[]>;
                min: PropType<number>;
                max: PropType<number>;
                step: PropType<number>;
                vertical: PropType<boolean>;
                hideTip: PropType<boolean>;
                tipTransfer: PropType<string | boolean>;
                disabled: PropType<boolean>;
                loading: PropType<boolean>;
                loadingLock: PropType<boolean>;
                reverse: PropType<boolean>;
                range: PropType<boolean>;
                markers: PropType<Record<string | number, string | import('../slider').SliderMarker> | (number | (import('../slider').SliderMarker & {
                    value: number;
                }))[]>;
                markerOnly: PropType<boolean>;
                tipHover: PropType<boolean>;
                flipMarker: PropType<boolean>;
                triggerFade: PropType<boolean>;
                tipProps: PropType<import('../slider').SliderTipProps>;
                sync: PropType<boolean>;
                rangeDraggable: PropType<boolean>;
                slots: PropType<import('../slider').SliderSlots>;
                onChange: PropType<((value: number | number[]) => void) | ((value: number | number[]) => void)[]>;
                onInput: PropType<((value: number | number[]) => void) | ((value: number | number[]) => void)[]>;
            }>> & Readonly<{
                "onUpdate:value"?: ((...args: any[]) => any) | undefined;
            }>, {
                idFor: import('vue').ComputedRef<string | undefined>;
                sliding: import('vue').Ref<boolean[], boolean[]>;
                track: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
                startTrigger: import('vue').Ref<({
                    $: import('vue').ComponentInternalInstance;
                    $data: {};
                    $props: Partial<{
                        value: number;
                        reverse: boolean;
                        vertical: boolean;
                        loading: boolean;
                        disabled: boolean;
                        min: number;
                        max: number;
                        tipTransfer: string | boolean;
                        hideTip: boolean;
                        sliding: boolean;
                        tipHover: boolean;
                        tipProps: import('../slider').SliderTipProps;
                    }> & Omit<{
                        readonly value: number;
                        readonly reverse: boolean;
                        readonly vertical: boolean;
                        readonly loading: boolean;
                        readonly disabled: boolean;
                        readonly min: number;
                        readonly max: number;
                        readonly tipTransfer: string | boolean;
                        readonly hideTip: boolean;
                        readonly sliding: boolean;
                        readonly tipHover: boolean;
                        readonly tipProps: import('../slider').SliderTipProps;
                        readonly "onKey-minus"?: ((...args: any[]) => any) | undefined;
                        readonly "onKey-plus"?: ((...args: any[]) => any) | undefined;
                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps">;
                    $attrs: {
                        [x: string]: unknown;
                    };
                    $refs: {
                        [x: string]: unknown;
                    } & {
                        wrapper: HTMLDivElement;
                        tooltip: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                            inherit: PropType<boolean>;
                            trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                            wrapper: PropType<string | boolean>;
                            noArrow: PropType<boolean>;
                            transitionName: PropType<string>;
                            visible: PropType<boolean>;
                            placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                            outsideClose: PropType<boolean>;
                            noHover: PropType<boolean>;
                            tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                            tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                            transfer: PropType<string | boolean>;
                            disabled: PropType<boolean>;
                            raw: PropType<boolean>;
                            delay: PropType<number | number[]>;
                            tipAlive: PropType<boolean>;
                            reverse: PropType<boolean>;
                            width: PropType<number | "trigger" | "auto">;
                            virtual: PropType<{
                                getBoundingClientRect: () => DOMRect;
                            } | {
                                $el: {
                                    getBoundingClientRect: () => DOMRect;
                                };
                            } | {
                                x: number;
                                y: number;
                            }>;
                            shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                            onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                            onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        }>> & Readonly<{
                            onClickoutside?: ((...args: any[]) => any) | undefined;
                            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                        }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("clickoutside" | "update:visible")[], import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                            P: {};
                            B: {};
                            D: {};
                            C: {};
                            M: {};
                            Defaults: {};
                        }, Readonly<import('vue').ExtractPropTypes<{
                            inherit: PropType<boolean>;
                            trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                            wrapper: PropType<string | boolean>;
                            noArrow: PropType<boolean>;
                            transitionName: PropType<string>;
                            visible: PropType<boolean>;
                            placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                            outsideClose: PropType<boolean>;
                            noHover: PropType<boolean>;
                            tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                            tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                            transfer: PropType<string | boolean>;
                            disabled: PropType<boolean>;
                            raw: PropType<boolean>;
                            delay: PropType<number | number[]>;
                            tipAlive: PropType<boolean>;
                            reverse: PropType<boolean>;
                            width: PropType<number | "trigger" | "auto">;
                            virtual: PropType<{
                                getBoundingClientRect: () => DOMRect;
                            } | {
                                $el: {
                                    getBoundingClientRect: () => DOMRect;
                                };
                            } | {
                                x: number;
                                y: number;
                            }>;
                            shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                            onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                            onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        }>> & Readonly<{
                            onClickoutside?: ((...args: any[]) => any) | undefined;
                            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                        }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, {}> | null;
                        handler: HTMLDivElement;
                    };
                    $slots: Readonly<{
                        [name: string]: import('vue').Slot<any> | undefined;
                    }>;
                    $root: import('vue').ComponentPublicInstance | null;
                    $parent: import('vue').ComponentPublicInstance | null;
                    $host: Element | null;
                    $emit: ((event: "key-minus", ...args: any[]) => void) & ((event: "key-plus", ...args: any[]) => void);
                    $el: HTMLDivElement;
                    $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                        value: {
                            type: NumberConstructor;
                            default: number;
                        };
                        tipTransfer: {
                            type: (BooleanConstructor | StringConstructor)[];
                            default: boolean;
                        };
                        hideTip: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        vertical: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        min: {
                            type: NumberConstructor;
                            default: number;
                        };
                        max: {
                            type: NumberConstructor;
                            default: number;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        loading: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        reverse: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        sliding: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        tipHover: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        tipProps: {
                            type: PropType<import('../slider').SliderTipProps>;
                            default: () => {};
                        };
                    }>> & Readonly<{
                        "onKey-minus"?: ((...args: any[]) => any) | undefined;
                        "onKey-plus"?: ((...args: any[]) => any) | undefined;
                    }>, {
                        updateTooltip: () => void;
                        focus: (options?: FocusOptions) => void;
                        blur: () => void;
                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                        "key-minus": (...args: any[]) => void;
                        "key-plus": (...args: any[]) => void;
                    }, string, {
                        value: number;
                        reverse: boolean;
                        vertical: boolean;
                        loading: boolean;
                        disabled: boolean;
                        min: number;
                        max: number;
                        tipTransfer: string | boolean;
                        hideTip: boolean;
                        sliding: boolean;
                        tipHover: boolean;
                        tipProps: import('../slider').SliderTipProps;
                    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                        beforeCreate?: (() => void) | (() => void)[];
                        created?: (() => void) | (() => void)[];
                        beforeMount?: (() => void) | (() => void)[];
                        mounted?: (() => void) | (() => void)[];
                        beforeUpdate?: (() => void) | (() => void)[];
                        updated?: (() => void) | (() => void)[];
                        activated?: (() => void) | (() => void)[];
                        deactivated?: (() => void) | (() => void)[];
                        beforeDestroy?: (() => void) | (() => void)[];
                        beforeUnmount?: (() => void) | (() => void)[];
                        destroyed?: (() => void) | (() => void)[];
                        unmounted?: (() => void) | (() => void)[];
                        renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                        renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                        errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
                    };
                    $forceUpdate: () => void;
                    $nextTick: typeof import('vue').nextTick;
                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
                } & Readonly<{
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }> & Omit<Readonly<import('vue').ExtractPropTypes<{
                    value: {
                        type: NumberConstructor;
                        default: number;
                    };
                    tipTransfer: {
                        type: (BooleanConstructor | StringConstructor)[];
                        default: boolean;
                    };
                    hideTip: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    vertical: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    min: {
                        type: NumberConstructor;
                        default: number;
                    };
                    max: {
                        type: NumberConstructor;
                        default: number;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    reverse: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    sliding: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipHover: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipProps: {
                        type: PropType<import('../slider').SliderTipProps>;
                        default: () => {};
                    };
                }>> & Readonly<{
                    "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    "onKey-plus"?: ((...args: any[]) => any) | undefined;
                }>, "blur" | "focus" | "updateTooltip" | ("value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps")> & import('vue').ShallowUnwrapRef<{
                    updateTooltip: () => void;
                    focus: (options?: FocusOptions) => void;
                    blur: () => void;
                }> & {} & import('vue').ComponentCustomProperties & {} & {
                    $slots: Readonly<{
                        default: () => any;
                        tip: () => any;
                    }> & {
                        default: () => any;
                        tip: () => any;
                    };
                }) | undefined, ({
                    $: import('vue').ComponentInternalInstance;
                    $data: {};
                    $props: Partial<{
                        value: number;
                        reverse: boolean;
                        vertical: boolean;
                        loading: boolean;
                        disabled: boolean;
                        min: number;
                        max: number;
                        tipTransfer: string | boolean;
                        hideTip: boolean;
                        sliding: boolean;
                        tipHover: boolean;
                        tipProps: import('../slider').SliderTipProps;
                    }> & Omit<{
                        readonly value: number;
                        readonly reverse: boolean;
                        readonly vertical: boolean;
                        readonly loading: boolean;
                        readonly disabled: boolean;
                        readonly min: number;
                        readonly max: number;
                        readonly tipTransfer: string | boolean;
                        readonly hideTip: boolean;
                        readonly sliding: boolean;
                        readonly tipHover: boolean;
                        readonly tipProps: import('../slider').SliderTipProps;
                        readonly "onKey-minus"?: ((...args: any[]) => any) | undefined;
                        readonly "onKey-plus"?: ((...args: any[]) => any) | undefined;
                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps">;
                    $attrs: {
                        [x: string]: unknown;
                    };
                    $refs: {
                        [x: string]: unknown;
                    } & {
                        wrapper: HTMLDivElement;
                        tooltip: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                            inherit: PropType<boolean>;
                            trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                            wrapper: PropType<string | boolean>;
                            noArrow: PropType<boolean>;
                            transitionName: PropType<string>;
                            visible: PropType<boolean>;
                            placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                            outsideClose: PropType<boolean>;
                            noHover: PropType<boolean>;
                            tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                            tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                            transfer: PropType<string | boolean>;
                            disabled: PropType<boolean>;
                            raw: PropType<boolean>;
                            delay: PropType<number | number[]>;
                            tipAlive: PropType<boolean>;
                            reverse: PropType<boolean>;
                            width: PropType<number | "trigger" | "auto">;
                            virtual: PropType<{
                                getBoundingClientRect: () => DOMRect;
                            } | {
                                $el: {
                                    getBoundingClientRect: () => DOMRect;
                                };
                            } | {
                                x: number;
                                y: number;
                            }>;
                            shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                            onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                            onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        }>> & Readonly<{
                            onClickoutside?: ((...args: any[]) => any) | undefined;
                            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                        }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("clickoutside" | "update:visible")[], import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                            P: {};
                            B: {};
                            D: {};
                            C: {};
                            M: {};
                            Defaults: {};
                        }, Readonly<import('vue').ExtractPropTypes<{
                            inherit: PropType<boolean>;
                            trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                            wrapper: PropType<string | boolean>;
                            noArrow: PropType<boolean>;
                            transitionName: PropType<string>;
                            visible: PropType<boolean>;
                            placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                            outsideClose: PropType<boolean>;
                            noHover: PropType<boolean>;
                            tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                            tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                            transfer: PropType<string | boolean>;
                            disabled: PropType<boolean>;
                            raw: PropType<boolean>;
                            delay: PropType<number | number[]>;
                            tipAlive: PropType<boolean>;
                            reverse: PropType<boolean>;
                            width: PropType<number | "trigger" | "auto">;
                            virtual: PropType<{
                                getBoundingClientRect: () => DOMRect;
                            } | {
                                $el: {
                                    getBoundingClientRect: () => DOMRect;
                                };
                            } | {
                                x: number;
                                y: number;
                            }>;
                            shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                            onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                            onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        }>> & Readonly<{
                            onClickoutside?: ((...args: any[]) => any) | undefined;
                            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                        }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, {}> | null;
                        handler: HTMLDivElement;
                    };
                    $slots: Readonly<{
                        [name: string]: import('vue').Slot<any> | undefined;
                    }>;
                    $root: import('vue').ComponentPublicInstance | null;
                    $parent: import('vue').ComponentPublicInstance | null;
                    $host: Element | null;
                    $emit: ((event: "key-minus", ...args: any[]) => void) & ((event: "key-plus", ...args: any[]) => void);
                    $el: HTMLDivElement;
                    $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                        value: {
                            type: NumberConstructor;
                            default: number;
                        };
                        tipTransfer: {
                            type: (BooleanConstructor | StringConstructor)[];
                            default: boolean;
                        };
                        hideTip: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        vertical: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        min: {
                            type: NumberConstructor;
                            default: number;
                        };
                        max: {
                            type: NumberConstructor;
                            default: number;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        loading: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        reverse: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        sliding: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        tipHover: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        tipProps: {
                            type: PropType<import('../slider').SliderTipProps>;
                            default: () => {};
                        };
                    }>> & Readonly<{
                        "onKey-minus"?: ((...args: any[]) => any) | undefined;
                        "onKey-plus"?: ((...args: any[]) => any) | undefined;
                    }>, {
                        updateTooltip: () => void;
                        focus: (options?: FocusOptions) => void;
                        blur: () => void;
                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                        "key-minus": (...args: any[]) => void;
                        "key-plus": (...args: any[]) => void;
                    }, string, {
                        value: number;
                        reverse: boolean;
                        vertical: boolean;
                        loading: boolean;
                        disabled: boolean;
                        min: number;
                        max: number;
                        tipTransfer: string | boolean;
                        hideTip: boolean;
                        sliding: boolean;
                        tipHover: boolean;
                        tipProps: import('../slider').SliderTipProps;
                    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                        beforeCreate?: (() => void) | (() => void)[];
                        created?: (() => void) | (() => void)[];
                        beforeMount?: (() => void) | (() => void)[];
                        mounted?: (() => void) | (() => void)[];
                        beforeUpdate?: (() => void) | (() => void)[];
                        updated?: (() => void) | (() => void)[];
                        activated?: (() => void) | (() => void)[];
                        deactivated?: (() => void) | (() => void)[];
                        beforeDestroy?: (() => void) | (() => void)[];
                        beforeUnmount?: (() => void) | (() => void)[];
                        destroyed?: (() => void) | (() => void)[];
                        unmounted?: (() => void) | (() => void)[];
                        renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                        renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                        errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
                    };
                    $forceUpdate: () => void;
                    $nextTick: typeof import('vue').nextTick;
                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
                } & Readonly<{
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }> & Omit<Readonly<import('vue').ExtractPropTypes<{
                    value: {
                        type: NumberConstructor;
                        default: number;
                    };
                    tipTransfer: {
                        type: (BooleanConstructor | StringConstructor)[];
                        default: boolean;
                    };
                    hideTip: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    vertical: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    min: {
                        type: NumberConstructor;
                        default: number;
                    };
                    max: {
                        type: NumberConstructor;
                        default: number;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    reverse: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    sliding: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipHover: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipProps: {
                        type: PropType<import('../slider').SliderTipProps>;
                        default: () => {};
                    };
                }>> & Readonly<{
                    "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    "onKey-plus"?: ((...args: any[]) => any) | undefined;
                }>, "blur" | "focus" | "updateTooltip" | ("value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps")> & import('vue').ShallowUnwrapRef<{
                    updateTooltip: () => void;
                    focus: (options?: FocusOptions) => void;
                    blur: () => void;
                }> & {} & import('vue').ComponentCustomProperties & {} & {
                    $slots: Readonly<{
                        default: () => any;
                        tip: () => any;
                    }> & {
                        default: () => any;
                        tip: () => any;
                    };
                }) | undefined>;
                endTrigger: import('vue').Ref<({
                    $: import('vue').ComponentInternalInstance;
                    $data: {};
                    $props: Partial<{
                        value: number;
                        reverse: boolean;
                        vertical: boolean;
                        loading: boolean;
                        disabled: boolean;
                        min: number;
                        max: number;
                        tipTransfer: string | boolean;
                        hideTip: boolean;
                        sliding: boolean;
                        tipHover: boolean;
                        tipProps: import('../slider').SliderTipProps;
                    }> & Omit<{
                        readonly value: number;
                        readonly reverse: boolean;
                        readonly vertical: boolean;
                        readonly loading: boolean;
                        readonly disabled: boolean;
                        readonly min: number;
                        readonly max: number;
                        readonly tipTransfer: string | boolean;
                        readonly hideTip: boolean;
                        readonly sliding: boolean;
                        readonly tipHover: boolean;
                        readonly tipProps: import('../slider').SliderTipProps;
                        readonly "onKey-minus"?: ((...args: any[]) => any) | undefined;
                        readonly "onKey-plus"?: ((...args: any[]) => any) | undefined;
                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps">;
                    $attrs: {
                        [x: string]: unknown;
                    };
                    $refs: {
                        [x: string]: unknown;
                    } & {
                        wrapper: HTMLDivElement;
                        tooltip: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                            inherit: PropType<boolean>;
                            trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                            wrapper: PropType<string | boolean>;
                            noArrow: PropType<boolean>;
                            transitionName: PropType<string>;
                            visible: PropType<boolean>;
                            placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                            outsideClose: PropType<boolean>;
                            noHover: PropType<boolean>;
                            tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                            tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                            transfer: PropType<string | boolean>;
                            disabled: PropType<boolean>;
                            raw: PropType<boolean>;
                            delay: PropType<number | number[]>;
                            tipAlive: PropType<boolean>;
                            reverse: PropType<boolean>;
                            width: PropType<number | "trigger" | "auto">;
                            virtual: PropType<{
                                getBoundingClientRect: () => DOMRect;
                            } | {
                                $el: {
                                    getBoundingClientRect: () => DOMRect;
                                };
                            } | {
                                x: number;
                                y: number;
                            }>;
                            shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                            onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                            onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        }>> & Readonly<{
                            onClickoutside?: ((...args: any[]) => any) | undefined;
                            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                        }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("clickoutside" | "update:visible")[], import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                            P: {};
                            B: {};
                            D: {};
                            C: {};
                            M: {};
                            Defaults: {};
                        }, Readonly<import('vue').ExtractPropTypes<{
                            inherit: PropType<boolean>;
                            trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                            wrapper: PropType<string | boolean>;
                            noArrow: PropType<boolean>;
                            transitionName: PropType<string>;
                            visible: PropType<boolean>;
                            placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                            outsideClose: PropType<boolean>;
                            noHover: PropType<boolean>;
                            tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                            tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                            transfer: PropType<string | boolean>;
                            disabled: PropType<boolean>;
                            raw: PropType<boolean>;
                            delay: PropType<number | number[]>;
                            tipAlive: PropType<boolean>;
                            reverse: PropType<boolean>;
                            width: PropType<number | "trigger" | "auto">;
                            virtual: PropType<{
                                getBoundingClientRect: () => DOMRect;
                            } | {
                                $el: {
                                    getBoundingClientRect: () => DOMRect;
                                };
                            } | {
                                x: number;
                                y: number;
                            }>;
                            shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                            onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                            onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        }>> & Readonly<{
                            onClickoutside?: ((...args: any[]) => any) | undefined;
                            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                        }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, {}> | null;
                        handler: HTMLDivElement;
                    };
                    $slots: Readonly<{
                        [name: string]: import('vue').Slot<any> | undefined;
                    }>;
                    $root: import('vue').ComponentPublicInstance | null;
                    $parent: import('vue').ComponentPublicInstance | null;
                    $host: Element | null;
                    $emit: ((event: "key-minus", ...args: any[]) => void) & ((event: "key-plus", ...args: any[]) => void);
                    $el: HTMLDivElement;
                    $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                        value: {
                            type: NumberConstructor;
                            default: number;
                        };
                        tipTransfer: {
                            type: (BooleanConstructor | StringConstructor)[];
                            default: boolean;
                        };
                        hideTip: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        vertical: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        min: {
                            type: NumberConstructor;
                            default: number;
                        };
                        max: {
                            type: NumberConstructor;
                            default: number;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        loading: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        reverse: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        sliding: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        tipHover: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        tipProps: {
                            type: PropType<import('../slider').SliderTipProps>;
                            default: () => {};
                        };
                    }>> & Readonly<{
                        "onKey-minus"?: ((...args: any[]) => any) | undefined;
                        "onKey-plus"?: ((...args: any[]) => any) | undefined;
                    }>, {
                        updateTooltip: () => void;
                        focus: (options?: FocusOptions) => void;
                        blur: () => void;
                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                        "key-minus": (...args: any[]) => void;
                        "key-plus": (...args: any[]) => void;
                    }, string, {
                        value: number;
                        reverse: boolean;
                        vertical: boolean;
                        loading: boolean;
                        disabled: boolean;
                        min: number;
                        max: number;
                        tipTransfer: string | boolean;
                        hideTip: boolean;
                        sliding: boolean;
                        tipHover: boolean;
                        tipProps: import('../slider').SliderTipProps;
                    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                        beforeCreate?: (() => void) | (() => void)[];
                        created?: (() => void) | (() => void)[];
                        beforeMount?: (() => void) | (() => void)[];
                        mounted?: (() => void) | (() => void)[];
                        beforeUpdate?: (() => void) | (() => void)[];
                        updated?: (() => void) | (() => void)[];
                        activated?: (() => void) | (() => void)[];
                        deactivated?: (() => void) | (() => void)[];
                        beforeDestroy?: (() => void) | (() => void)[];
                        beforeUnmount?: (() => void) | (() => void)[];
                        destroyed?: (() => void) | (() => void)[];
                        unmounted?: (() => void) | (() => void)[];
                        renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                        renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                        errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
                    };
                    $forceUpdate: () => void;
                    $nextTick: typeof import('vue').nextTick;
                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
                } & Readonly<{
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }> & Omit<Readonly<import('vue').ExtractPropTypes<{
                    value: {
                        type: NumberConstructor;
                        default: number;
                    };
                    tipTransfer: {
                        type: (BooleanConstructor | StringConstructor)[];
                        default: boolean;
                    };
                    hideTip: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    vertical: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    min: {
                        type: NumberConstructor;
                        default: number;
                    };
                    max: {
                        type: NumberConstructor;
                        default: number;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    reverse: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    sliding: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipHover: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipProps: {
                        type: PropType<import('../slider').SliderTipProps>;
                        default: () => {};
                    };
                }>> & Readonly<{
                    "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    "onKey-plus"?: ((...args: any[]) => any) | undefined;
                }>, "blur" | "focus" | "updateTooltip" | ("value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps")> & import('vue').ShallowUnwrapRef<{
                    updateTooltip: () => void;
                    focus: (options?: FocusOptions) => void;
                    blur: () => void;
                }> & {} & import('vue').ComponentCustomProperties & {} & {
                    $slots: Readonly<{
                        default: () => any;
                        tip: () => any;
                    }> & {
                        default: () => any;
                        tip: () => any;
                    };
                }) | undefined, ({
                    $: import('vue').ComponentInternalInstance;
                    $data: {};
                    $props: Partial<{
                        value: number;
                        reverse: boolean;
                        vertical: boolean;
                        loading: boolean;
                        disabled: boolean;
                        min: number;
                        max: number;
                        tipTransfer: string | boolean;
                        hideTip: boolean;
                        sliding: boolean;
                        tipHover: boolean;
                        tipProps: import('../slider').SliderTipProps;
                    }> & Omit<{
                        readonly value: number;
                        readonly reverse: boolean;
                        readonly vertical: boolean;
                        readonly loading: boolean;
                        readonly disabled: boolean;
                        readonly min: number;
                        readonly max: number;
                        readonly tipTransfer: string | boolean;
                        readonly hideTip: boolean;
                        readonly sliding: boolean;
                        readonly tipHover: boolean;
                        readonly tipProps: import('../slider').SliderTipProps;
                        readonly "onKey-minus"?: ((...args: any[]) => any) | undefined;
                        readonly "onKey-plus"?: ((...args: any[]) => any) | undefined;
                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps">;
                    $attrs: {
                        [x: string]: unknown;
                    };
                    $refs: {
                        [x: string]: unknown;
                    } & {
                        wrapper: HTMLDivElement;
                        tooltip: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                            inherit: PropType<boolean>;
                            trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                            wrapper: PropType<string | boolean>;
                            noArrow: PropType<boolean>;
                            transitionName: PropType<string>;
                            visible: PropType<boolean>;
                            placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                            outsideClose: PropType<boolean>;
                            noHover: PropType<boolean>;
                            tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                            tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                            transfer: PropType<string | boolean>;
                            disabled: PropType<boolean>;
                            raw: PropType<boolean>;
                            delay: PropType<number | number[]>;
                            tipAlive: PropType<boolean>;
                            reverse: PropType<boolean>;
                            width: PropType<number | "trigger" | "auto">;
                            virtual: PropType<{
                                getBoundingClientRect: () => DOMRect;
                            } | {
                                $el: {
                                    getBoundingClientRect: () => DOMRect;
                                };
                            } | {
                                x: number;
                                y: number;
                            }>;
                            shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                            onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                            onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        }>> & Readonly<{
                            onClickoutside?: ((...args: any[]) => any) | undefined;
                            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                        }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("clickoutside" | "update:visible")[], import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                            P: {};
                            B: {};
                            D: {};
                            C: {};
                            M: {};
                            Defaults: {};
                        }, Readonly<import('vue').ExtractPropTypes<{
                            inherit: PropType<boolean>;
                            trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                            wrapper: PropType<string | boolean>;
                            noArrow: PropType<boolean>;
                            transitionName: PropType<string>;
                            visible: PropType<boolean>;
                            placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                            outsideClose: PropType<boolean>;
                            noHover: PropType<boolean>;
                            tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                            tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                            transfer: PropType<string | boolean>;
                            disabled: PropType<boolean>;
                            raw: PropType<boolean>;
                            delay: PropType<number | number[]>;
                            tipAlive: PropType<boolean>;
                            reverse: PropType<boolean>;
                            width: PropType<number | "trigger" | "auto">;
                            virtual: PropType<{
                                getBoundingClientRect: () => DOMRect;
                            } | {
                                $el: {
                                    getBoundingClientRect: () => DOMRect;
                                };
                            } | {
                                x: number;
                                y: number;
                            }>;
                            shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                            onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                            onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                            onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        }>> & Readonly<{
                            onClickoutside?: ((...args: any[]) => any) | undefined;
                            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                        }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, {}> | null;
                        handler: HTMLDivElement;
                    };
                    $slots: Readonly<{
                        [name: string]: import('vue').Slot<any> | undefined;
                    }>;
                    $root: import('vue').ComponentPublicInstance | null;
                    $parent: import('vue').ComponentPublicInstance | null;
                    $host: Element | null;
                    $emit: ((event: "key-minus", ...args: any[]) => void) & ((event: "key-plus", ...args: any[]) => void);
                    $el: HTMLDivElement;
                    $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                        value: {
                            type: NumberConstructor;
                            default: number;
                        };
                        tipTransfer: {
                            type: (BooleanConstructor | StringConstructor)[];
                            default: boolean;
                        };
                        hideTip: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        vertical: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        min: {
                            type: NumberConstructor;
                            default: number;
                        };
                        max: {
                            type: NumberConstructor;
                            default: number;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        loading: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        reverse: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        sliding: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        tipHover: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        tipProps: {
                            type: PropType<import('../slider').SliderTipProps>;
                            default: () => {};
                        };
                    }>> & Readonly<{
                        "onKey-minus"?: ((...args: any[]) => any) | undefined;
                        "onKey-plus"?: ((...args: any[]) => any) | undefined;
                    }>, {
                        updateTooltip: () => void;
                        focus: (options?: FocusOptions) => void;
                        blur: () => void;
                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                        "key-minus": (...args: any[]) => void;
                        "key-plus": (...args: any[]) => void;
                    }, string, {
                        value: number;
                        reverse: boolean;
                        vertical: boolean;
                        loading: boolean;
                        disabled: boolean;
                        min: number;
                        max: number;
                        tipTransfer: string | boolean;
                        hideTip: boolean;
                        sliding: boolean;
                        tipHover: boolean;
                        tipProps: import('../slider').SliderTipProps;
                    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                        beforeCreate?: (() => void) | (() => void)[];
                        created?: (() => void) | (() => void)[];
                        beforeMount?: (() => void) | (() => void)[];
                        mounted?: (() => void) | (() => void)[];
                        beforeUpdate?: (() => void) | (() => void)[];
                        updated?: (() => void) | (() => void)[];
                        activated?: (() => void) | (() => void)[];
                        deactivated?: (() => void) | (() => void)[];
                        beforeDestroy?: (() => void) | (() => void)[];
                        beforeUnmount?: (() => void) | (() => void)[];
                        destroyed?: (() => void) | (() => void)[];
                        unmounted?: (() => void) | (() => void)[];
                        renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                        renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                        errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
                    };
                    $forceUpdate: () => void;
                    $nextTick: typeof import('vue').nextTick;
                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
                } & Readonly<{
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }> & Omit<Readonly<import('vue').ExtractPropTypes<{
                    value: {
                        type: NumberConstructor;
                        default: number;
                    };
                    tipTransfer: {
                        type: (BooleanConstructor | StringConstructor)[];
                        default: boolean;
                    };
                    hideTip: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    vertical: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    min: {
                        type: NumberConstructor;
                        default: number;
                    };
                    max: {
                        type: NumberConstructor;
                        default: number;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    reverse: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    sliding: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipHover: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipProps: {
                        type: PropType<import('../slider').SliderTipProps>;
                        default: () => {};
                    };
                }>> & Readonly<{
                    "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    "onKey-plus"?: ((...args: any[]) => any) | undefined;
                }>, "blur" | "focus" | "updateTooltip" | ("value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps")> & import('vue').ShallowUnwrapRef<{
                    updateTooltip: () => void;
                    focus: (options?: FocusOptions) => void;
                    blur: () => void;
                }> & {} & import('vue').ComponentCustomProperties & {} & {
                    $slots: Readonly<{
                        default: () => any;
                        tip: () => any;
                    }> & {
                        default: () => any;
                        tip: () => any;
                    };
                }) | undefined>;
                isValueInRange: (value: number | string) => boolean;
                focus: (options?: FocusOptions) => void;
                blur: () => void;
            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                "update:value": (...args: any[]) => void;
            }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                beforeCreate?: (() => void) | (() => void)[];
                created?: (() => void) | (() => void)[];
                beforeMount?: (() => void) | (() => void)[];
                mounted?: (() => void) | (() => void)[];
                beforeUpdate?: (() => void) | (() => void)[];
                updated?: (() => void) | (() => void)[];
                activated?: (() => void) | (() => void)[];
                deactivated?: (() => void) | (() => void)[];
                beforeDestroy?: (() => void) | (() => void)[];
                beforeUnmount?: (() => void) | (() => void)[];
                destroyed?: (() => void) | (() => void)[];
                unmounted?: (() => void) | (() => void)[];
                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
            };
            $forceUpdate: () => void;
            $nextTick: typeof import('vue').nextTick;
            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
        } & Readonly<{}> & Omit<Readonly<import('vue').ExtractPropTypes<{
            inherit: PropType<boolean>;
            state: PropType<"default" | "success" | "error" | "warning">;
            value: PropType<number | number[]>;
            min: PropType<number>;
            max: PropType<number>;
            step: PropType<number>;
            vertical: PropType<boolean>;
            hideTip: PropType<boolean>;
            tipTransfer: PropType<string | boolean>;
            disabled: PropType<boolean>;
            loading: PropType<boolean>;
            loadingLock: PropType<boolean>;
            reverse: PropType<boolean>;
            range: PropType<boolean>;
            markers: PropType<Record<string | number, string | import('../slider').SliderMarker> | (number | (import('../slider').SliderMarker & {
                value: number;
            }))[]>;
            markerOnly: PropType<boolean>;
            tipHover: PropType<boolean>;
            flipMarker: PropType<boolean>;
            triggerFade: PropType<boolean>;
            tipProps: PropType<import('../slider').SliderTipProps>;
            sync: PropType<boolean>;
            rangeDraggable: PropType<boolean>;
            slots: PropType<import('../slider').SliderSlots>;
            onChange: PropType<((value: number | number[]) => void) | ((value: number | number[]) => void)[]>;
            onInput: PropType<((value: number | number[]) => void) | ((value: number | number[]) => void)[]>;
        }>> & Readonly<{
            "onUpdate:value"?: ((...args: any[]) => any) | undefined;
        }>, "track" | "blur" | "focus" | "idFor" | "sliding" | "startTrigger" | "endTrigger" | "isValueInRange"> & import('vue').ShallowUnwrapRef<{
            idFor: import('vue').ComputedRef<string | undefined>;
            sliding: import('vue').Ref<boolean[], boolean[]>;
            track: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
            startTrigger: import('vue').Ref<({
                $: import('vue').ComponentInternalInstance;
                $data: {};
                $props: Partial<{
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }> & Omit<{
                    readonly value: number;
                    readonly reverse: boolean;
                    readonly vertical: boolean;
                    readonly loading: boolean;
                    readonly disabled: boolean;
                    readonly min: number;
                    readonly max: number;
                    readonly tipTransfer: string | boolean;
                    readonly hideTip: boolean;
                    readonly sliding: boolean;
                    readonly tipHover: boolean;
                    readonly tipProps: import('../slider').SliderTipProps;
                    readonly "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    readonly "onKey-plus"?: ((...args: any[]) => any) | undefined;
                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps">;
                $attrs: {
                    [x: string]: unknown;
                };
                $refs: {
                    [x: string]: unknown;
                } & {
                    wrapper: HTMLDivElement;
                    tooltip: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                        inherit: PropType<boolean>;
                        trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                        wrapper: PropType<string | boolean>;
                        noArrow: PropType<boolean>;
                        transitionName: PropType<string>;
                        visible: PropType<boolean>;
                        placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                        outsideClose: PropType<boolean>;
                        noHover: PropType<boolean>;
                        tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                        tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                        transfer: PropType<string | boolean>;
                        disabled: PropType<boolean>;
                        raw: PropType<boolean>;
                        delay: PropType<number | number[]>;
                        tipAlive: PropType<boolean>;
                        reverse: PropType<boolean>;
                        width: PropType<number | "trigger" | "auto">;
                        virtual: PropType<{
                            getBoundingClientRect: () => DOMRect;
                        } | {
                            $el: {
                                getBoundingClientRect: () => DOMRect;
                            };
                        } | {
                            x: number;
                            y: number;
                        }>;
                        shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                        onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                        onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    }>> & Readonly<{
                        onClickoutside?: ((...args: any[]) => any) | undefined;
                        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                    }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("clickoutside" | "update:visible")[], import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<import('vue').ExtractPropTypes<{
                        inherit: PropType<boolean>;
                        trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                        wrapper: PropType<string | boolean>;
                        noArrow: PropType<boolean>;
                        transitionName: PropType<string>;
                        visible: PropType<boolean>;
                        placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                        outsideClose: PropType<boolean>;
                        noHover: PropType<boolean>;
                        tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                        tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                        transfer: PropType<string | boolean>;
                        disabled: PropType<boolean>;
                        raw: PropType<boolean>;
                        delay: PropType<number | number[]>;
                        tipAlive: PropType<boolean>;
                        reverse: PropType<boolean>;
                        width: PropType<number | "trigger" | "auto">;
                        virtual: PropType<{
                            getBoundingClientRect: () => DOMRect;
                        } | {
                            $el: {
                                getBoundingClientRect: () => DOMRect;
                            };
                        } | {
                            x: number;
                            y: number;
                        }>;
                        shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                        onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                        onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    }>> & Readonly<{
                        onClickoutside?: ((...args: any[]) => any) | undefined;
                        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                    }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, {}> | null;
                    handler: HTMLDivElement;
                };
                $slots: Readonly<{
                    [name: string]: import('vue').Slot<any> | undefined;
                }>;
                $root: import('vue').ComponentPublicInstance | null;
                $parent: import('vue').ComponentPublicInstance | null;
                $host: Element | null;
                $emit: ((event: "key-minus", ...args: any[]) => void) & ((event: "key-plus", ...args: any[]) => void);
                $el: HTMLDivElement;
                $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                    value: {
                        type: NumberConstructor;
                        default: number;
                    };
                    tipTransfer: {
                        type: (BooleanConstructor | StringConstructor)[];
                        default: boolean;
                    };
                    hideTip: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    vertical: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    min: {
                        type: NumberConstructor;
                        default: number;
                    };
                    max: {
                        type: NumberConstructor;
                        default: number;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    reverse: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    sliding: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipHover: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipProps: {
                        type: PropType<import('../slider').SliderTipProps>;
                        default: () => {};
                    };
                }>> & Readonly<{
                    "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    "onKey-plus"?: ((...args: any[]) => any) | undefined;
                }>, {
                    updateTooltip: () => void;
                    focus: (options?: FocusOptions) => void;
                    blur: () => void;
                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                    "key-minus": (...args: any[]) => void;
                    "key-plus": (...args: any[]) => void;
                }, string, {
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                    beforeCreate?: (() => void) | (() => void)[];
                    created?: (() => void) | (() => void)[];
                    beforeMount?: (() => void) | (() => void)[];
                    mounted?: (() => void) | (() => void)[];
                    beforeUpdate?: (() => void) | (() => void)[];
                    updated?: (() => void) | (() => void)[];
                    activated?: (() => void) | (() => void)[];
                    deactivated?: (() => void) | (() => void)[];
                    beforeDestroy?: (() => void) | (() => void)[];
                    beforeUnmount?: (() => void) | (() => void)[];
                    destroyed?: (() => void) | (() => void)[];
                    unmounted?: (() => void) | (() => void)[];
                    renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                    renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                    errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
                };
                $forceUpdate: () => void;
                $nextTick: typeof import('vue').nextTick;
                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
            } & Readonly<{
                value: number;
                reverse: boolean;
                vertical: boolean;
                loading: boolean;
                disabled: boolean;
                min: number;
                max: number;
                tipTransfer: string | boolean;
                hideTip: boolean;
                sliding: boolean;
                tipHover: boolean;
                tipProps: import('../slider').SliderTipProps;
            }> & Omit<Readonly<import('vue').ExtractPropTypes<{
                value: {
                    type: NumberConstructor;
                    default: number;
                };
                tipTransfer: {
                    type: (BooleanConstructor | StringConstructor)[];
                    default: boolean;
                };
                hideTip: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                vertical: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                min: {
                    type: NumberConstructor;
                    default: number;
                };
                max: {
                    type: NumberConstructor;
                    default: number;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                reverse: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                sliding: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipHover: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipProps: {
                    type: PropType<import('../slider').SliderTipProps>;
                    default: () => {};
                };
            }>> & Readonly<{
                "onKey-minus"?: ((...args: any[]) => any) | undefined;
                "onKey-plus"?: ((...args: any[]) => any) | undefined;
            }>, "blur" | "focus" | "updateTooltip" | ("value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps")> & import('vue').ShallowUnwrapRef<{
                updateTooltip: () => void;
                focus: (options?: FocusOptions) => void;
                blur: () => void;
            }> & {} & import('vue').ComponentCustomProperties & {} & {
                $slots: Readonly<{
                    default: () => any;
                    tip: () => any;
                }> & {
                    default: () => any;
                    tip: () => any;
                };
            }) | undefined, ({
                $: import('vue').ComponentInternalInstance;
                $data: {};
                $props: Partial<{
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }> & Omit<{
                    readonly value: number;
                    readonly reverse: boolean;
                    readonly vertical: boolean;
                    readonly loading: boolean;
                    readonly disabled: boolean;
                    readonly min: number;
                    readonly max: number;
                    readonly tipTransfer: string | boolean;
                    readonly hideTip: boolean;
                    readonly sliding: boolean;
                    readonly tipHover: boolean;
                    readonly tipProps: import('../slider').SliderTipProps;
                    readonly "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    readonly "onKey-plus"?: ((...args: any[]) => any) | undefined;
                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps">;
                $attrs: {
                    [x: string]: unknown;
                };
                $refs: {
                    [x: string]: unknown;
                } & {
                    wrapper: HTMLDivElement;
                    tooltip: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                        inherit: PropType<boolean>;
                        trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                        wrapper: PropType<string | boolean>;
                        noArrow: PropType<boolean>;
                        transitionName: PropType<string>;
                        visible: PropType<boolean>;
                        placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                        outsideClose: PropType<boolean>;
                        noHover: PropType<boolean>;
                        tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                        tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                        transfer: PropType<string | boolean>;
                        disabled: PropType<boolean>;
                        raw: PropType<boolean>;
                        delay: PropType<number | number[]>;
                        tipAlive: PropType<boolean>;
                        reverse: PropType<boolean>;
                        width: PropType<number | "trigger" | "auto">;
                        virtual: PropType<{
                            getBoundingClientRect: () => DOMRect;
                        } | {
                            $el: {
                                getBoundingClientRect: () => DOMRect;
                            };
                        } | {
                            x: number;
                            y: number;
                        }>;
                        shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                        onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                        onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    }>> & Readonly<{
                        onClickoutside?: ((...args: any[]) => any) | undefined;
                        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                    }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("clickoutside" | "update:visible")[], import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<import('vue').ExtractPropTypes<{
                        inherit: PropType<boolean>;
                        trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                        wrapper: PropType<string | boolean>;
                        noArrow: PropType<boolean>;
                        transitionName: PropType<string>;
                        visible: PropType<boolean>;
                        placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                        outsideClose: PropType<boolean>;
                        noHover: PropType<boolean>;
                        tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                        tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                        transfer: PropType<string | boolean>;
                        disabled: PropType<boolean>;
                        raw: PropType<boolean>;
                        delay: PropType<number | number[]>;
                        tipAlive: PropType<boolean>;
                        reverse: PropType<boolean>;
                        width: PropType<number | "trigger" | "auto">;
                        virtual: PropType<{
                            getBoundingClientRect: () => DOMRect;
                        } | {
                            $el: {
                                getBoundingClientRect: () => DOMRect;
                            };
                        } | {
                            x: number;
                            y: number;
                        }>;
                        shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                        onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                        onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    }>> & Readonly<{
                        onClickoutside?: ((...args: any[]) => any) | undefined;
                        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                    }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, {}> | null;
                    handler: HTMLDivElement;
                };
                $slots: Readonly<{
                    [name: string]: import('vue').Slot<any> | undefined;
                }>;
                $root: import('vue').ComponentPublicInstance | null;
                $parent: import('vue').ComponentPublicInstance | null;
                $host: Element | null;
                $emit: ((event: "key-minus", ...args: any[]) => void) & ((event: "key-plus", ...args: any[]) => void);
                $el: HTMLDivElement;
                $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                    value: {
                        type: NumberConstructor;
                        default: number;
                    };
                    tipTransfer: {
                        type: (BooleanConstructor | StringConstructor)[];
                        default: boolean;
                    };
                    hideTip: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    vertical: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    min: {
                        type: NumberConstructor;
                        default: number;
                    };
                    max: {
                        type: NumberConstructor;
                        default: number;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    reverse: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    sliding: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipHover: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipProps: {
                        type: PropType<import('../slider').SliderTipProps>;
                        default: () => {};
                    };
                }>> & Readonly<{
                    "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    "onKey-plus"?: ((...args: any[]) => any) | undefined;
                }>, {
                    updateTooltip: () => void;
                    focus: (options?: FocusOptions) => void;
                    blur: () => void;
                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                    "key-minus": (...args: any[]) => void;
                    "key-plus": (...args: any[]) => void;
                }, string, {
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                    beforeCreate?: (() => void) | (() => void)[];
                    created?: (() => void) | (() => void)[];
                    beforeMount?: (() => void) | (() => void)[];
                    mounted?: (() => void) | (() => void)[];
                    beforeUpdate?: (() => void) | (() => void)[];
                    updated?: (() => void) | (() => void)[];
                    activated?: (() => void) | (() => void)[];
                    deactivated?: (() => void) | (() => void)[];
                    beforeDestroy?: (() => void) | (() => void)[];
                    beforeUnmount?: (() => void) | (() => void)[];
                    destroyed?: (() => void) | (() => void)[];
                    unmounted?: (() => void) | (() => void)[];
                    renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                    renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                    errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
                };
                $forceUpdate: () => void;
                $nextTick: typeof import('vue').nextTick;
                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
            } & Readonly<{
                value: number;
                reverse: boolean;
                vertical: boolean;
                loading: boolean;
                disabled: boolean;
                min: number;
                max: number;
                tipTransfer: string | boolean;
                hideTip: boolean;
                sliding: boolean;
                tipHover: boolean;
                tipProps: import('../slider').SliderTipProps;
            }> & Omit<Readonly<import('vue').ExtractPropTypes<{
                value: {
                    type: NumberConstructor;
                    default: number;
                };
                tipTransfer: {
                    type: (BooleanConstructor | StringConstructor)[];
                    default: boolean;
                };
                hideTip: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                vertical: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                min: {
                    type: NumberConstructor;
                    default: number;
                };
                max: {
                    type: NumberConstructor;
                    default: number;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                reverse: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                sliding: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipHover: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipProps: {
                    type: PropType<import('../slider').SliderTipProps>;
                    default: () => {};
                };
            }>> & Readonly<{
                "onKey-minus"?: ((...args: any[]) => any) | undefined;
                "onKey-plus"?: ((...args: any[]) => any) | undefined;
            }>, "blur" | "focus" | "updateTooltip" | ("value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps")> & import('vue').ShallowUnwrapRef<{
                updateTooltip: () => void;
                focus: (options?: FocusOptions) => void;
                blur: () => void;
            }> & {} & import('vue').ComponentCustomProperties & {} & {
                $slots: Readonly<{
                    default: () => any;
                    tip: () => any;
                }> & {
                    default: () => any;
                    tip: () => any;
                };
            }) | undefined>;
            endTrigger: import('vue').Ref<({
                $: import('vue').ComponentInternalInstance;
                $data: {};
                $props: Partial<{
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }> & Omit<{
                    readonly value: number;
                    readonly reverse: boolean;
                    readonly vertical: boolean;
                    readonly loading: boolean;
                    readonly disabled: boolean;
                    readonly min: number;
                    readonly max: number;
                    readonly tipTransfer: string | boolean;
                    readonly hideTip: boolean;
                    readonly sliding: boolean;
                    readonly tipHover: boolean;
                    readonly tipProps: import('../slider').SliderTipProps;
                    readonly "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    readonly "onKey-plus"?: ((...args: any[]) => any) | undefined;
                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps">;
                $attrs: {
                    [x: string]: unknown;
                };
                $refs: {
                    [x: string]: unknown;
                } & {
                    wrapper: HTMLDivElement;
                    tooltip: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                        inherit: PropType<boolean>;
                        trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                        wrapper: PropType<string | boolean>;
                        noArrow: PropType<boolean>;
                        transitionName: PropType<string>;
                        visible: PropType<boolean>;
                        placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                        outsideClose: PropType<boolean>;
                        noHover: PropType<boolean>;
                        tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                        tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                        transfer: PropType<string | boolean>;
                        disabled: PropType<boolean>;
                        raw: PropType<boolean>;
                        delay: PropType<number | number[]>;
                        tipAlive: PropType<boolean>;
                        reverse: PropType<boolean>;
                        width: PropType<number | "trigger" | "auto">;
                        virtual: PropType<{
                            getBoundingClientRect: () => DOMRect;
                        } | {
                            $el: {
                                getBoundingClientRect: () => DOMRect;
                            };
                        } | {
                            x: number;
                            y: number;
                        }>;
                        shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                        onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                        onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    }>> & Readonly<{
                        onClickoutside?: ((...args: any[]) => any) | undefined;
                        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                    }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("clickoutside" | "update:visible")[], import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<import('vue').ExtractPropTypes<{
                        inherit: PropType<boolean>;
                        trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                        wrapper: PropType<string | boolean>;
                        noArrow: PropType<boolean>;
                        transitionName: PropType<string>;
                        visible: PropType<boolean>;
                        placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                        outsideClose: PropType<boolean>;
                        noHover: PropType<boolean>;
                        tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                        tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                        transfer: PropType<string | boolean>;
                        disabled: PropType<boolean>;
                        raw: PropType<boolean>;
                        delay: PropType<number | number[]>;
                        tipAlive: PropType<boolean>;
                        reverse: PropType<boolean>;
                        width: PropType<number | "trigger" | "auto">;
                        virtual: PropType<{
                            getBoundingClientRect: () => DOMRect;
                        } | {
                            $el: {
                                getBoundingClientRect: () => DOMRect;
                            };
                        } | {
                            x: number;
                            y: number;
                        }>;
                        shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                        onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                        onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    }>> & Readonly<{
                        onClickoutside?: ((...args: any[]) => any) | undefined;
                        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                    }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, {}> | null;
                    handler: HTMLDivElement;
                };
                $slots: Readonly<{
                    [name: string]: import('vue').Slot<any> | undefined;
                }>;
                $root: import('vue').ComponentPublicInstance | null;
                $parent: import('vue').ComponentPublicInstance | null;
                $host: Element | null;
                $emit: ((event: "key-minus", ...args: any[]) => void) & ((event: "key-plus", ...args: any[]) => void);
                $el: HTMLDivElement;
                $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                    value: {
                        type: NumberConstructor;
                        default: number;
                    };
                    tipTransfer: {
                        type: (BooleanConstructor | StringConstructor)[];
                        default: boolean;
                    };
                    hideTip: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    vertical: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    min: {
                        type: NumberConstructor;
                        default: number;
                    };
                    max: {
                        type: NumberConstructor;
                        default: number;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    reverse: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    sliding: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipHover: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipProps: {
                        type: PropType<import('../slider').SliderTipProps>;
                        default: () => {};
                    };
                }>> & Readonly<{
                    "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    "onKey-plus"?: ((...args: any[]) => any) | undefined;
                }>, {
                    updateTooltip: () => void;
                    focus: (options?: FocusOptions) => void;
                    blur: () => void;
                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                    "key-minus": (...args: any[]) => void;
                    "key-plus": (...args: any[]) => void;
                }, string, {
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                    beforeCreate?: (() => void) | (() => void)[];
                    created?: (() => void) | (() => void)[];
                    beforeMount?: (() => void) | (() => void)[];
                    mounted?: (() => void) | (() => void)[];
                    beforeUpdate?: (() => void) | (() => void)[];
                    updated?: (() => void) | (() => void)[];
                    activated?: (() => void) | (() => void)[];
                    deactivated?: (() => void) | (() => void)[];
                    beforeDestroy?: (() => void) | (() => void)[];
                    beforeUnmount?: (() => void) | (() => void)[];
                    destroyed?: (() => void) | (() => void)[];
                    unmounted?: (() => void) | (() => void)[];
                    renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                    renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                    errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
                };
                $forceUpdate: () => void;
                $nextTick: typeof import('vue').nextTick;
                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
            } & Readonly<{
                value: number;
                reverse: boolean;
                vertical: boolean;
                loading: boolean;
                disabled: boolean;
                min: number;
                max: number;
                tipTransfer: string | boolean;
                hideTip: boolean;
                sliding: boolean;
                tipHover: boolean;
                tipProps: import('../slider').SliderTipProps;
            }> & Omit<Readonly<import('vue').ExtractPropTypes<{
                value: {
                    type: NumberConstructor;
                    default: number;
                };
                tipTransfer: {
                    type: (BooleanConstructor | StringConstructor)[];
                    default: boolean;
                };
                hideTip: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                vertical: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                min: {
                    type: NumberConstructor;
                    default: number;
                };
                max: {
                    type: NumberConstructor;
                    default: number;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                reverse: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                sliding: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipHover: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipProps: {
                    type: PropType<import('../slider').SliderTipProps>;
                    default: () => {};
                };
            }>> & Readonly<{
                "onKey-minus"?: ((...args: any[]) => any) | undefined;
                "onKey-plus"?: ((...args: any[]) => any) | undefined;
            }>, "blur" | "focus" | "updateTooltip" | ("value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps")> & import('vue').ShallowUnwrapRef<{
                updateTooltip: () => void;
                focus: (options?: FocusOptions) => void;
                blur: () => void;
            }> & {} & import('vue').ComponentCustomProperties & {} & {
                $slots: Readonly<{
                    default: () => any;
                    tip: () => any;
                }> & {
                    default: () => any;
                    tip: () => any;
                };
            }) | undefined, ({
                $: import('vue').ComponentInternalInstance;
                $data: {};
                $props: Partial<{
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }> & Omit<{
                    readonly value: number;
                    readonly reverse: boolean;
                    readonly vertical: boolean;
                    readonly loading: boolean;
                    readonly disabled: boolean;
                    readonly min: number;
                    readonly max: number;
                    readonly tipTransfer: string | boolean;
                    readonly hideTip: boolean;
                    readonly sliding: boolean;
                    readonly tipHover: boolean;
                    readonly tipProps: import('../slider').SliderTipProps;
                    readonly "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    readonly "onKey-plus"?: ((...args: any[]) => any) | undefined;
                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps">;
                $attrs: {
                    [x: string]: unknown;
                };
                $refs: {
                    [x: string]: unknown;
                } & {
                    wrapper: HTMLDivElement;
                    tooltip: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                        inherit: PropType<boolean>;
                        trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                        wrapper: PropType<string | boolean>;
                        noArrow: PropType<boolean>;
                        transitionName: PropType<string>;
                        visible: PropType<boolean>;
                        placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                        outsideClose: PropType<boolean>;
                        noHover: PropType<boolean>;
                        tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                        tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                        transfer: PropType<string | boolean>;
                        disabled: PropType<boolean>;
                        raw: PropType<boolean>;
                        delay: PropType<number | number[]>;
                        tipAlive: PropType<boolean>;
                        reverse: PropType<boolean>;
                        width: PropType<number | "trigger" | "auto">;
                        virtual: PropType<{
                            getBoundingClientRect: () => DOMRect;
                        } | {
                            $el: {
                                getBoundingClientRect: () => DOMRect;
                            };
                        } | {
                            x: number;
                            y: number;
                        }>;
                        shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                        onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                        onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    }>> & Readonly<{
                        onClickoutside?: ((...args: any[]) => any) | undefined;
                        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                    }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("clickoutside" | "update:visible")[], import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<import('vue').ExtractPropTypes<{
                        inherit: PropType<boolean>;
                        trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                        wrapper: PropType<string | boolean>;
                        noArrow: PropType<boolean>;
                        transitionName: PropType<string>;
                        visible: PropType<boolean>;
                        placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                        outsideClose: PropType<boolean>;
                        noHover: PropType<boolean>;
                        tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                        tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                        transfer: PropType<string | boolean>;
                        disabled: PropType<boolean>;
                        raw: PropType<boolean>;
                        delay: PropType<number | number[]>;
                        tipAlive: PropType<boolean>;
                        reverse: PropType<boolean>;
                        width: PropType<number | "trigger" | "auto">;
                        virtual: PropType<{
                            getBoundingClientRect: () => DOMRect;
                        } | {
                            $el: {
                                getBoundingClientRect: () => DOMRect;
                            };
                        } | {
                            x: number;
                            y: number;
                        }>;
                        shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                        onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                        onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    }>> & Readonly<{
                        onClickoutside?: ((...args: any[]) => any) | undefined;
                        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                    }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, {}> | null;
                    handler: HTMLDivElement;
                };
                $slots: Readonly<{
                    [name: string]: import('vue').Slot<any> | undefined;
                }>;
                $root: import('vue').ComponentPublicInstance | null;
                $parent: import('vue').ComponentPublicInstance | null;
                $host: Element | null;
                $emit: ((event: "key-minus", ...args: any[]) => void) & ((event: "key-plus", ...args: any[]) => void);
                $el: HTMLDivElement;
                $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                    value: {
                        type: NumberConstructor;
                        default: number;
                    };
                    tipTransfer: {
                        type: (BooleanConstructor | StringConstructor)[];
                        default: boolean;
                    };
                    hideTip: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    vertical: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    min: {
                        type: NumberConstructor;
                        default: number;
                    };
                    max: {
                        type: NumberConstructor;
                        default: number;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    reverse: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    sliding: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipHover: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipProps: {
                        type: PropType<import('../slider').SliderTipProps>;
                        default: () => {};
                    };
                }>> & Readonly<{
                    "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    "onKey-plus"?: ((...args: any[]) => any) | undefined;
                }>, {
                    updateTooltip: () => void;
                    focus: (options?: FocusOptions) => void;
                    blur: () => void;
                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                    "key-minus": (...args: any[]) => void;
                    "key-plus": (...args: any[]) => void;
                }, string, {
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                    beforeCreate?: (() => void) | (() => void)[];
                    created?: (() => void) | (() => void)[];
                    beforeMount?: (() => void) | (() => void)[];
                    mounted?: (() => void) | (() => void)[];
                    beforeUpdate?: (() => void) | (() => void)[];
                    updated?: (() => void) | (() => void)[];
                    activated?: (() => void) | (() => void)[];
                    deactivated?: (() => void) | (() => void)[];
                    beforeDestroy?: (() => void) | (() => void)[];
                    beforeUnmount?: (() => void) | (() => void)[];
                    destroyed?: (() => void) | (() => void)[];
                    unmounted?: (() => void) | (() => void)[];
                    renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                    renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                    errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
                };
                $forceUpdate: () => void;
                $nextTick: typeof import('vue').nextTick;
                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
            } & Readonly<{
                value: number;
                reverse: boolean;
                vertical: boolean;
                loading: boolean;
                disabled: boolean;
                min: number;
                max: number;
                tipTransfer: string | boolean;
                hideTip: boolean;
                sliding: boolean;
                tipHover: boolean;
                tipProps: import('../slider').SliderTipProps;
            }> & Omit<Readonly<import('vue').ExtractPropTypes<{
                value: {
                    type: NumberConstructor;
                    default: number;
                };
                tipTransfer: {
                    type: (BooleanConstructor | StringConstructor)[];
                    default: boolean;
                };
                hideTip: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                vertical: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                min: {
                    type: NumberConstructor;
                    default: number;
                };
                max: {
                    type: NumberConstructor;
                    default: number;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                reverse: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                sliding: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipHover: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipProps: {
                    type: PropType<import('../slider').SliderTipProps>;
                    default: () => {};
                };
            }>> & Readonly<{
                "onKey-minus"?: ((...args: any[]) => any) | undefined;
                "onKey-plus"?: ((...args: any[]) => any) | undefined;
            }>, "blur" | "focus" | "updateTooltip" | ("value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps")> & import('vue').ShallowUnwrapRef<{
                updateTooltip: () => void;
                focus: (options?: FocusOptions) => void;
                blur: () => void;
            }> & {} & import('vue').ComponentCustomProperties & {} & {
                $slots: Readonly<{
                    default: () => any;
                    tip: () => any;
                }> & {
                    default: () => any;
                    tip: () => any;
                };
            }) | undefined>;
            isValueInRange: (value: number | string) => boolean;
            focus: (options?: FocusOptions) => void;
            blur: () => void;
        }> & {} & import('vue').ComponentCustomProperties & {} & {
            $slots: Readonly<import('../slider').SliderSlots> & import('../slider').SliderSlots;
        }) | null;
        preview: HTMLDivElement;
    };
    rootEl: HTMLDivElement;
};
type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
    time: {
        type: NumberConstructor;
        default: number;
    };
    duration: {
        type: NumberConstructor;
        default: number;
    };
    segments: {
        type: PropType<VideoSegment[]>;
        default: () => never[];
    };
    noPreview: {
        type: BooleanConstructor;
        default: boolean;
    };
    previewSrc: {
        type: StringConstructor;
        default: string;
    };
}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
    change: (...args: any[]) => void;
}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
    time: {
        type: NumberConstructor;
        default: number;
    };
    duration: {
        type: NumberConstructor;
        default: number;
    };
    segments: {
        type: PropType<VideoSegment[]>;
        default: () => never[];
    };
    noPreview: {
        type: BooleanConstructor;
        default: boolean;
    };
    previewSrc: {
        type: StringConstructor;
        default: string;
    };
}>> & Readonly<{
    onChange?: ((...args: any[]) => any) | undefined;
}>, {
    time: number;
    duration: number;
    noPreview: boolean;
    previewSrc: string;
    segments: VideoSegment[];
}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
    wrapper: HTMLDivElement;
    slider: ({
        $: import('vue').ComponentInternalInstance;
        $data: {};
        $props: Partial<{}> & Omit<{
            readonly value?: number | number[] | undefined;
            readonly inherit?: boolean | undefined;
            readonly reverse?: boolean | undefined;
            readonly vertical?: boolean | undefined;
            readonly loading?: boolean | undefined;
            readonly slots?: import('../slider').SliderSlots | undefined;
            readonly onChange?: ((value: number | number[]) => void) | ((value: number | number[]) => void)[] | undefined;
            readonly onInput?: ((value: number | number[]) => void) | ((value: number | number[]) => void)[] | undefined;
            readonly disabled?: boolean | undefined;
            readonly sync?: boolean | undefined;
            readonly min?: number | undefined;
            readonly max?: number | undefined;
            readonly range?: boolean | undefined;
            readonly state?: "default" | "success" | "error" | "warning" | undefined;
            readonly loadingLock?: boolean | undefined;
            readonly markers?: Record<string | number, string | import('../slider').SliderMarker> | (number | (import('../slider').SliderMarker & {
                value: number;
            }))[] | undefined;
            readonly step?: number | undefined;
            readonly tipTransfer?: string | boolean | undefined;
            readonly hideTip?: boolean | undefined;
            readonly tipHover?: boolean | undefined;
            readonly tipProps?: import('../slider').SliderTipProps | undefined;
            readonly markerOnly?: boolean | undefined;
            readonly flipMarker?: boolean | undefined;
            readonly triggerFade?: boolean | undefined;
            readonly rangeDraggable?: boolean | undefined;
            readonly "onUpdate:value"?: ((...args: any[]) => any) | undefined;
        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>;
        $attrs: {
            [x: string]: unknown;
        };
        $refs: {
            [x: string]: unknown;
        } & {
            track: HTMLDivElement;
            filler: HTMLDivElement;
            startTrigger: ({
                $: import('vue').ComponentInternalInstance;
                $data: {};
                $props: Partial<{
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }> & Omit<{
                    readonly value: number;
                    readonly reverse: boolean;
                    readonly vertical: boolean;
                    readonly loading: boolean;
                    readonly disabled: boolean;
                    readonly min: number;
                    readonly max: number;
                    readonly tipTransfer: string | boolean;
                    readonly hideTip: boolean;
                    readonly sliding: boolean;
                    readonly tipHover: boolean;
                    readonly tipProps: import('../slider').SliderTipProps;
                    readonly "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    readonly "onKey-plus"?: ((...args: any[]) => any) | undefined;
                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps">;
                $attrs: {
                    [x: string]: unknown;
                };
                $refs: {
                    [x: string]: unknown;
                } & {
                    wrapper: HTMLDivElement;
                    tooltip: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                        inherit: PropType<boolean>;
                        trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                        wrapper: PropType<string | boolean>;
                        noArrow: PropType<boolean>;
                        transitionName: PropType<string>;
                        visible: PropType<boolean>;
                        placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                        outsideClose: PropType<boolean>;
                        noHover: PropType<boolean>;
                        tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                        tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                        transfer: PropType<string | boolean>;
                        disabled: PropType<boolean>;
                        raw: PropType<boolean>;
                        delay: PropType<number | number[]>;
                        tipAlive: PropType<boolean>;
                        reverse: PropType<boolean>;
                        width: PropType<number | "trigger" | "auto">;
                        virtual: PropType<{
                            getBoundingClientRect: () => DOMRect;
                        } | {
                            $el: {
                                getBoundingClientRect: () => DOMRect;
                            };
                        } | {
                            x: number;
                            y: number;
                        }>;
                        shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                        onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                        onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    }>> & Readonly<{
                        onClickoutside?: ((...args: any[]) => any) | undefined;
                        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                    }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("clickoutside" | "update:visible")[], import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<import('vue').ExtractPropTypes<{
                        inherit: PropType<boolean>;
                        trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                        wrapper: PropType<string | boolean>;
                        noArrow: PropType<boolean>;
                        transitionName: PropType<string>;
                        visible: PropType<boolean>;
                        placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                        outsideClose: PropType<boolean>;
                        noHover: PropType<boolean>;
                        tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                        tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                        transfer: PropType<string | boolean>;
                        disabled: PropType<boolean>;
                        raw: PropType<boolean>;
                        delay: PropType<number | number[]>;
                        tipAlive: PropType<boolean>;
                        reverse: PropType<boolean>;
                        width: PropType<number | "trigger" | "auto">;
                        virtual: PropType<{
                            getBoundingClientRect: () => DOMRect;
                        } | {
                            $el: {
                                getBoundingClientRect: () => DOMRect;
                            };
                        } | {
                            x: number;
                            y: number;
                        }>;
                        shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                        onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                        onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    }>> & Readonly<{
                        onClickoutside?: ((...args: any[]) => any) | undefined;
                        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                    }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, {}> | null;
                    handler: HTMLDivElement;
                };
                $slots: Readonly<{
                    [name: string]: import('vue').Slot<any> | undefined;
                }>;
                $root: import('vue').ComponentPublicInstance | null;
                $parent: import('vue').ComponentPublicInstance | null;
                $host: Element | null;
                $emit: ((event: "key-minus", ...args: any[]) => void) & ((event: "key-plus", ...args: any[]) => void);
                $el: HTMLDivElement;
                $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                    value: {
                        type: NumberConstructor;
                        default: number;
                    };
                    tipTransfer: {
                        type: (BooleanConstructor | StringConstructor)[];
                        default: boolean;
                    };
                    hideTip: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    vertical: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    min: {
                        type: NumberConstructor;
                        default: number;
                    };
                    max: {
                        type: NumberConstructor;
                        default: number;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    reverse: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    sliding: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipHover: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipProps: {
                        type: PropType<import('../slider').SliderTipProps>;
                        default: () => {};
                    };
                }>> & Readonly<{
                    "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    "onKey-plus"?: ((...args: any[]) => any) | undefined;
                }>, {
                    updateTooltip: () => void;
                    focus: (options?: FocusOptions) => void;
                    blur: () => void;
                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                    "key-minus": (...args: any[]) => void;
                    "key-plus": (...args: any[]) => void;
                }, string, {
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                    beforeCreate?: (() => void) | (() => void)[];
                    created?: (() => void) | (() => void)[];
                    beforeMount?: (() => void) | (() => void)[];
                    mounted?: (() => void) | (() => void)[];
                    beforeUpdate?: (() => void) | (() => void)[];
                    updated?: (() => void) | (() => void)[];
                    activated?: (() => void) | (() => void)[];
                    deactivated?: (() => void) | (() => void)[];
                    beforeDestroy?: (() => void) | (() => void)[];
                    beforeUnmount?: (() => void) | (() => void)[];
                    destroyed?: (() => void) | (() => void)[];
                    unmounted?: (() => void) | (() => void)[];
                    renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                    renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                    errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
                };
                $forceUpdate: () => void;
                $nextTick: typeof import('vue').nextTick;
                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
            } & Readonly<{
                value: number;
                reverse: boolean;
                vertical: boolean;
                loading: boolean;
                disabled: boolean;
                min: number;
                max: number;
                tipTransfer: string | boolean;
                hideTip: boolean;
                sliding: boolean;
                tipHover: boolean;
                tipProps: import('../slider').SliderTipProps;
            }> & Omit<Readonly<import('vue').ExtractPropTypes<{
                value: {
                    type: NumberConstructor;
                    default: number;
                };
                tipTransfer: {
                    type: (BooleanConstructor | StringConstructor)[];
                    default: boolean;
                };
                hideTip: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                vertical: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                min: {
                    type: NumberConstructor;
                    default: number;
                };
                max: {
                    type: NumberConstructor;
                    default: number;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                reverse: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                sliding: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipHover: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipProps: {
                    type: PropType<import('../slider').SliderTipProps>;
                    default: () => {};
                };
            }>> & Readonly<{
                "onKey-minus"?: ((...args: any[]) => any) | undefined;
                "onKey-plus"?: ((...args: any[]) => any) | undefined;
            }>, "blur" | "focus" | "updateTooltip" | ("value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps")> & import('vue').ShallowUnwrapRef<{
                updateTooltip: () => void;
                focus: (options?: FocusOptions) => void;
                blur: () => void;
            }> & {} & import('vue').ComponentCustomProperties & {} & {
                $slots: Readonly<{
                    default: () => any;
                    tip: () => any;
                }> & {
                    default: () => any;
                    tip: () => any;
                };
            }) | null;
            endTrigger: ({
                $: import('vue').ComponentInternalInstance;
                $data: {};
                $props: Partial<{
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }> & Omit<{
                    readonly value: number;
                    readonly reverse: boolean;
                    readonly vertical: boolean;
                    readonly loading: boolean;
                    readonly disabled: boolean;
                    readonly min: number;
                    readonly max: number;
                    readonly tipTransfer: string | boolean;
                    readonly hideTip: boolean;
                    readonly sliding: boolean;
                    readonly tipHover: boolean;
                    readonly tipProps: import('../slider').SliderTipProps;
                    readonly "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    readonly "onKey-plus"?: ((...args: any[]) => any) | undefined;
                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps">;
                $attrs: {
                    [x: string]: unknown;
                };
                $refs: {
                    [x: string]: unknown;
                } & {
                    wrapper: HTMLDivElement;
                    tooltip: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                        inherit: PropType<boolean>;
                        trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                        wrapper: PropType<string | boolean>;
                        noArrow: PropType<boolean>;
                        transitionName: PropType<string>;
                        visible: PropType<boolean>;
                        placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                        outsideClose: PropType<boolean>;
                        noHover: PropType<boolean>;
                        tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                        tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                        transfer: PropType<string | boolean>;
                        disabled: PropType<boolean>;
                        raw: PropType<boolean>;
                        delay: PropType<number | number[]>;
                        tipAlive: PropType<boolean>;
                        reverse: PropType<boolean>;
                        width: PropType<number | "trigger" | "auto">;
                        virtual: PropType<{
                            getBoundingClientRect: () => DOMRect;
                        } | {
                            $el: {
                                getBoundingClientRect: () => DOMRect;
                            };
                        } | {
                            x: number;
                            y: number;
                        }>;
                        shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                        onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                        onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    }>> & Readonly<{
                        onClickoutside?: ((...args: any[]) => any) | undefined;
                        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                    }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("clickoutside" | "update:visible")[], import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<import('vue').ExtractPropTypes<{
                        inherit: PropType<boolean>;
                        trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                        wrapper: PropType<string | boolean>;
                        noArrow: PropType<boolean>;
                        transitionName: PropType<string>;
                        visible: PropType<boolean>;
                        placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                        outsideClose: PropType<boolean>;
                        noHover: PropType<boolean>;
                        tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                        tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                        transfer: PropType<string | boolean>;
                        disabled: PropType<boolean>;
                        raw: PropType<boolean>;
                        delay: PropType<number | number[]>;
                        tipAlive: PropType<boolean>;
                        reverse: PropType<boolean>;
                        width: PropType<number | "trigger" | "auto">;
                        virtual: PropType<{
                            getBoundingClientRect: () => DOMRect;
                        } | {
                            $el: {
                                getBoundingClientRect: () => DOMRect;
                            };
                        } | {
                            x: number;
                            y: number;
                        }>;
                        shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                        onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                        onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    }>> & Readonly<{
                        onClickoutside?: ((...args: any[]) => any) | undefined;
                        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                    }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, {}> | null;
                    handler: HTMLDivElement;
                };
                $slots: Readonly<{
                    [name: string]: import('vue').Slot<any> | undefined;
                }>;
                $root: import('vue').ComponentPublicInstance | null;
                $parent: import('vue').ComponentPublicInstance | null;
                $host: Element | null;
                $emit: ((event: "key-minus", ...args: any[]) => void) & ((event: "key-plus", ...args: any[]) => void);
                $el: HTMLDivElement;
                $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                    value: {
                        type: NumberConstructor;
                        default: number;
                    };
                    tipTransfer: {
                        type: (BooleanConstructor | StringConstructor)[];
                        default: boolean;
                    };
                    hideTip: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    vertical: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    min: {
                        type: NumberConstructor;
                        default: number;
                    };
                    max: {
                        type: NumberConstructor;
                        default: number;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    reverse: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    sliding: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipHover: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipProps: {
                        type: PropType<import('../slider').SliderTipProps>;
                        default: () => {};
                    };
                }>> & Readonly<{
                    "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    "onKey-plus"?: ((...args: any[]) => any) | undefined;
                }>, {
                    updateTooltip: () => void;
                    focus: (options?: FocusOptions) => void;
                    blur: () => void;
                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                    "key-minus": (...args: any[]) => void;
                    "key-plus": (...args: any[]) => void;
                }, string, {
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                    beforeCreate?: (() => void) | (() => void)[];
                    created?: (() => void) | (() => void)[];
                    beforeMount?: (() => void) | (() => void)[];
                    mounted?: (() => void) | (() => void)[];
                    beforeUpdate?: (() => void) | (() => void)[];
                    updated?: (() => void) | (() => void)[];
                    activated?: (() => void) | (() => void)[];
                    deactivated?: (() => void) | (() => void)[];
                    beforeDestroy?: (() => void) | (() => void)[];
                    beforeUnmount?: (() => void) | (() => void)[];
                    destroyed?: (() => void) | (() => void)[];
                    unmounted?: (() => void) | (() => void)[];
                    renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                    renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                    errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
                };
                $forceUpdate: () => void;
                $nextTick: typeof import('vue').nextTick;
                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
            } & Readonly<{
                value: number;
                reverse: boolean;
                vertical: boolean;
                loading: boolean;
                disabled: boolean;
                min: number;
                max: number;
                tipTransfer: string | boolean;
                hideTip: boolean;
                sliding: boolean;
                tipHover: boolean;
                tipProps: import('../slider').SliderTipProps;
            }> & Omit<Readonly<import('vue').ExtractPropTypes<{
                value: {
                    type: NumberConstructor;
                    default: number;
                };
                tipTransfer: {
                    type: (BooleanConstructor | StringConstructor)[];
                    default: boolean;
                };
                hideTip: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                vertical: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                min: {
                    type: NumberConstructor;
                    default: number;
                };
                max: {
                    type: NumberConstructor;
                    default: number;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                reverse: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                sliding: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipHover: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipProps: {
                    type: PropType<import('../slider').SliderTipProps>;
                    default: () => {};
                };
            }>> & Readonly<{
                "onKey-minus"?: ((...args: any[]) => any) | undefined;
                "onKey-plus"?: ((...args: any[]) => any) | undefined;
            }>, "blur" | "focus" | "updateTooltip" | ("value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps")> & import('vue').ShallowUnwrapRef<{
                updateTooltip: () => void;
                focus: (options?: FocusOptions) => void;
                blur: () => void;
            }> & {} & import('vue').ComponentCustomProperties & {} & {
                $slots: Readonly<{
                    default: () => any;
                    tip: () => any;
                }> & {
                    default: () => any;
                    tip: () => any;
                };
            }) | null;
        };
        $slots: Readonly<{
            [name: string]: import('vue').Slot<any> | undefined;
        }>;
        $root: import('vue').ComponentPublicInstance | null;
        $parent: import('vue').ComponentPublicInstance | null;
        $host: Element | null;
        $emit: (event: "update:value", ...args: any[]) => void;
        $el: HTMLDivElement;
        $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            inherit: PropType<boolean>;
            state: PropType<"default" | "success" | "error" | "warning">;
            value: PropType<number | number[]>;
            min: PropType<number>;
            max: PropType<number>;
            step: PropType<number>;
            vertical: PropType<boolean>;
            hideTip: PropType<boolean>;
            tipTransfer: PropType<string | boolean>;
            disabled: PropType<boolean>;
            loading: PropType<boolean>;
            loadingLock: PropType<boolean>;
            reverse: PropType<boolean>;
            range: PropType<boolean>;
            markers: PropType<Record<string | number, string | import('../slider').SliderMarker> | (number | (import('../slider').SliderMarker & {
                value: number;
            }))[]>;
            markerOnly: PropType<boolean>;
            tipHover: PropType<boolean>;
            flipMarker: PropType<boolean>;
            triggerFade: PropType<boolean>;
            tipProps: PropType<import('../slider').SliderTipProps>;
            sync: PropType<boolean>;
            rangeDraggable: PropType<boolean>;
            slots: PropType<import('../slider').SliderSlots>;
            onChange: PropType<((value: number | number[]) => void) | ((value: number | number[]) => void)[]>;
            onInput: PropType<((value: number | number[]) => void) | ((value: number | number[]) => void)[]>;
        }>> & Readonly<{
            "onUpdate:value"?: ((...args: any[]) => any) | undefined;
        }>, {
            idFor: import('vue').ComputedRef<string | undefined>;
            sliding: import('vue').Ref<boolean[], boolean[]>;
            track: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
            startTrigger: import('vue').Ref<({
                $: import('vue').ComponentInternalInstance;
                $data: {};
                $props: Partial<{
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }> & Omit<{
                    readonly value: number;
                    readonly reverse: boolean;
                    readonly vertical: boolean;
                    readonly loading: boolean;
                    readonly disabled: boolean;
                    readonly min: number;
                    readonly max: number;
                    readonly tipTransfer: string | boolean;
                    readonly hideTip: boolean;
                    readonly sliding: boolean;
                    readonly tipHover: boolean;
                    readonly tipProps: import('../slider').SliderTipProps;
                    readonly "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    readonly "onKey-plus"?: ((...args: any[]) => any) | undefined;
                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps">;
                $attrs: {
                    [x: string]: unknown;
                };
                $refs: {
                    [x: string]: unknown;
                } & {
                    wrapper: HTMLDivElement;
                    tooltip: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                        inherit: PropType<boolean>;
                        trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                        wrapper: PropType<string | boolean>;
                        noArrow: PropType<boolean>;
                        transitionName: PropType<string>;
                        visible: PropType<boolean>;
                        placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                        outsideClose: PropType<boolean>;
                        noHover: PropType<boolean>;
                        tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                        tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                        transfer: PropType<string | boolean>;
                        disabled: PropType<boolean>;
                        raw: PropType<boolean>;
                        delay: PropType<number | number[]>;
                        tipAlive: PropType<boolean>;
                        reverse: PropType<boolean>;
                        width: PropType<number | "trigger" | "auto">;
                        virtual: PropType<{
                            getBoundingClientRect: () => DOMRect;
                        } | {
                            $el: {
                                getBoundingClientRect: () => DOMRect;
                            };
                        } | {
                            x: number;
                            y: number;
                        }>;
                        shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                        onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                        onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    }>> & Readonly<{
                        onClickoutside?: ((...args: any[]) => any) | undefined;
                        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                    }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("clickoutside" | "update:visible")[], import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<import('vue').ExtractPropTypes<{
                        inherit: PropType<boolean>;
                        trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                        wrapper: PropType<string | boolean>;
                        noArrow: PropType<boolean>;
                        transitionName: PropType<string>;
                        visible: PropType<boolean>;
                        placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                        outsideClose: PropType<boolean>;
                        noHover: PropType<boolean>;
                        tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                        tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                        transfer: PropType<string | boolean>;
                        disabled: PropType<boolean>;
                        raw: PropType<boolean>;
                        delay: PropType<number | number[]>;
                        tipAlive: PropType<boolean>;
                        reverse: PropType<boolean>;
                        width: PropType<number | "trigger" | "auto">;
                        virtual: PropType<{
                            getBoundingClientRect: () => DOMRect;
                        } | {
                            $el: {
                                getBoundingClientRect: () => DOMRect;
                            };
                        } | {
                            x: number;
                            y: number;
                        }>;
                        shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                        onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                        onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    }>> & Readonly<{
                        onClickoutside?: ((...args: any[]) => any) | undefined;
                        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                    }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, {}> | null;
                    handler: HTMLDivElement;
                };
                $slots: Readonly<{
                    [name: string]: import('vue').Slot<any> | undefined;
                }>;
                $root: import('vue').ComponentPublicInstance | null;
                $parent: import('vue').ComponentPublicInstance | null;
                $host: Element | null;
                $emit: ((event: "key-minus", ...args: any[]) => void) & ((event: "key-plus", ...args: any[]) => void);
                $el: HTMLDivElement;
                $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                    value: {
                        type: NumberConstructor;
                        default: number;
                    };
                    tipTransfer: {
                        type: (BooleanConstructor | StringConstructor)[];
                        default: boolean;
                    };
                    hideTip: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    vertical: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    min: {
                        type: NumberConstructor;
                        default: number;
                    };
                    max: {
                        type: NumberConstructor;
                        default: number;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    reverse: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    sliding: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipHover: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipProps: {
                        type: PropType<import('../slider').SliderTipProps>;
                        default: () => {};
                    };
                }>> & Readonly<{
                    "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    "onKey-plus"?: ((...args: any[]) => any) | undefined;
                }>, {
                    updateTooltip: () => void;
                    focus: (options?: FocusOptions) => void;
                    blur: () => void;
                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                    "key-minus": (...args: any[]) => void;
                    "key-plus": (...args: any[]) => void;
                }, string, {
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                    beforeCreate?: (() => void) | (() => void)[];
                    created?: (() => void) | (() => void)[];
                    beforeMount?: (() => void) | (() => void)[];
                    mounted?: (() => void) | (() => void)[];
                    beforeUpdate?: (() => void) | (() => void)[];
                    updated?: (() => void) | (() => void)[];
                    activated?: (() => void) | (() => void)[];
                    deactivated?: (() => void) | (() => void)[];
                    beforeDestroy?: (() => void) | (() => void)[];
                    beforeUnmount?: (() => void) | (() => void)[];
                    destroyed?: (() => void) | (() => void)[];
                    unmounted?: (() => void) | (() => void)[];
                    renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                    renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                    errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
                };
                $forceUpdate: () => void;
                $nextTick: typeof import('vue').nextTick;
                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
            } & Readonly<{
                value: number;
                reverse: boolean;
                vertical: boolean;
                loading: boolean;
                disabled: boolean;
                min: number;
                max: number;
                tipTransfer: string | boolean;
                hideTip: boolean;
                sliding: boolean;
                tipHover: boolean;
                tipProps: import('../slider').SliderTipProps;
            }> & Omit<Readonly<import('vue').ExtractPropTypes<{
                value: {
                    type: NumberConstructor;
                    default: number;
                };
                tipTransfer: {
                    type: (BooleanConstructor | StringConstructor)[];
                    default: boolean;
                };
                hideTip: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                vertical: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                min: {
                    type: NumberConstructor;
                    default: number;
                };
                max: {
                    type: NumberConstructor;
                    default: number;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                reverse: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                sliding: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipHover: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipProps: {
                    type: PropType<import('../slider').SliderTipProps>;
                    default: () => {};
                };
            }>> & Readonly<{
                "onKey-minus"?: ((...args: any[]) => any) | undefined;
                "onKey-plus"?: ((...args: any[]) => any) | undefined;
            }>, "blur" | "focus" | "updateTooltip" | ("value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps")> & import('vue').ShallowUnwrapRef<{
                updateTooltip: () => void;
                focus: (options?: FocusOptions) => void;
                blur: () => void;
            }> & {} & import('vue').ComponentCustomProperties & {} & {
                $slots: Readonly<{
                    default: () => any;
                    tip: () => any;
                }> & {
                    default: () => any;
                    tip: () => any;
                };
            }) | undefined, ({
                $: import('vue').ComponentInternalInstance;
                $data: {};
                $props: Partial<{
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }> & Omit<{
                    readonly value: number;
                    readonly reverse: boolean;
                    readonly vertical: boolean;
                    readonly loading: boolean;
                    readonly disabled: boolean;
                    readonly min: number;
                    readonly max: number;
                    readonly tipTransfer: string | boolean;
                    readonly hideTip: boolean;
                    readonly sliding: boolean;
                    readonly tipHover: boolean;
                    readonly tipProps: import('../slider').SliderTipProps;
                    readonly "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    readonly "onKey-plus"?: ((...args: any[]) => any) | undefined;
                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps">;
                $attrs: {
                    [x: string]: unknown;
                };
                $refs: {
                    [x: string]: unknown;
                } & {
                    wrapper: HTMLDivElement;
                    tooltip: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                        inherit: PropType<boolean>;
                        trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                        wrapper: PropType<string | boolean>;
                        noArrow: PropType<boolean>;
                        transitionName: PropType<string>;
                        visible: PropType<boolean>;
                        placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                        outsideClose: PropType<boolean>;
                        noHover: PropType<boolean>;
                        tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                        tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                        transfer: PropType<string | boolean>;
                        disabled: PropType<boolean>;
                        raw: PropType<boolean>;
                        delay: PropType<number | number[]>;
                        tipAlive: PropType<boolean>;
                        reverse: PropType<boolean>;
                        width: PropType<number | "trigger" | "auto">;
                        virtual: PropType<{
                            getBoundingClientRect: () => DOMRect;
                        } | {
                            $el: {
                                getBoundingClientRect: () => DOMRect;
                            };
                        } | {
                            x: number;
                            y: number;
                        }>;
                        shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                        onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                        onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    }>> & Readonly<{
                        onClickoutside?: ((...args: any[]) => any) | undefined;
                        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                    }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("clickoutside" | "update:visible")[], import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<import('vue').ExtractPropTypes<{
                        inherit: PropType<boolean>;
                        trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                        wrapper: PropType<string | boolean>;
                        noArrow: PropType<boolean>;
                        transitionName: PropType<string>;
                        visible: PropType<boolean>;
                        placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                        outsideClose: PropType<boolean>;
                        noHover: PropType<boolean>;
                        tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                        tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                        transfer: PropType<string | boolean>;
                        disabled: PropType<boolean>;
                        raw: PropType<boolean>;
                        delay: PropType<number | number[]>;
                        tipAlive: PropType<boolean>;
                        reverse: PropType<boolean>;
                        width: PropType<number | "trigger" | "auto">;
                        virtual: PropType<{
                            getBoundingClientRect: () => DOMRect;
                        } | {
                            $el: {
                                getBoundingClientRect: () => DOMRect;
                            };
                        } | {
                            x: number;
                            y: number;
                        }>;
                        shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                        onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                        onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    }>> & Readonly<{
                        onClickoutside?: ((...args: any[]) => any) | undefined;
                        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                    }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, {}> | null;
                    handler: HTMLDivElement;
                };
                $slots: Readonly<{
                    [name: string]: import('vue').Slot<any> | undefined;
                }>;
                $root: import('vue').ComponentPublicInstance | null;
                $parent: import('vue').ComponentPublicInstance | null;
                $host: Element | null;
                $emit: ((event: "key-minus", ...args: any[]) => void) & ((event: "key-plus", ...args: any[]) => void);
                $el: HTMLDivElement;
                $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                    value: {
                        type: NumberConstructor;
                        default: number;
                    };
                    tipTransfer: {
                        type: (BooleanConstructor | StringConstructor)[];
                        default: boolean;
                    };
                    hideTip: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    vertical: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    min: {
                        type: NumberConstructor;
                        default: number;
                    };
                    max: {
                        type: NumberConstructor;
                        default: number;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    reverse: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    sliding: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipHover: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipProps: {
                        type: PropType<import('../slider').SliderTipProps>;
                        default: () => {};
                    };
                }>> & Readonly<{
                    "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    "onKey-plus"?: ((...args: any[]) => any) | undefined;
                }>, {
                    updateTooltip: () => void;
                    focus: (options?: FocusOptions) => void;
                    blur: () => void;
                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                    "key-minus": (...args: any[]) => void;
                    "key-plus": (...args: any[]) => void;
                }, string, {
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                    beforeCreate?: (() => void) | (() => void)[];
                    created?: (() => void) | (() => void)[];
                    beforeMount?: (() => void) | (() => void)[];
                    mounted?: (() => void) | (() => void)[];
                    beforeUpdate?: (() => void) | (() => void)[];
                    updated?: (() => void) | (() => void)[];
                    activated?: (() => void) | (() => void)[];
                    deactivated?: (() => void) | (() => void)[];
                    beforeDestroy?: (() => void) | (() => void)[];
                    beforeUnmount?: (() => void) | (() => void)[];
                    destroyed?: (() => void) | (() => void)[];
                    unmounted?: (() => void) | (() => void)[];
                    renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                    renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                    errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
                };
                $forceUpdate: () => void;
                $nextTick: typeof import('vue').nextTick;
                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
            } & Readonly<{
                value: number;
                reverse: boolean;
                vertical: boolean;
                loading: boolean;
                disabled: boolean;
                min: number;
                max: number;
                tipTransfer: string | boolean;
                hideTip: boolean;
                sliding: boolean;
                tipHover: boolean;
                tipProps: import('../slider').SliderTipProps;
            }> & Omit<Readonly<import('vue').ExtractPropTypes<{
                value: {
                    type: NumberConstructor;
                    default: number;
                };
                tipTransfer: {
                    type: (BooleanConstructor | StringConstructor)[];
                    default: boolean;
                };
                hideTip: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                vertical: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                min: {
                    type: NumberConstructor;
                    default: number;
                };
                max: {
                    type: NumberConstructor;
                    default: number;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                reverse: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                sliding: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipHover: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipProps: {
                    type: PropType<import('../slider').SliderTipProps>;
                    default: () => {};
                };
            }>> & Readonly<{
                "onKey-minus"?: ((...args: any[]) => any) | undefined;
                "onKey-plus"?: ((...args: any[]) => any) | undefined;
            }>, "blur" | "focus" | "updateTooltip" | ("value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps")> & import('vue').ShallowUnwrapRef<{
                updateTooltip: () => void;
                focus: (options?: FocusOptions) => void;
                blur: () => void;
            }> & {} & import('vue').ComponentCustomProperties & {} & {
                $slots: Readonly<{
                    default: () => any;
                    tip: () => any;
                }> & {
                    default: () => any;
                    tip: () => any;
                };
            }) | undefined>;
            endTrigger: import('vue').Ref<({
                $: import('vue').ComponentInternalInstance;
                $data: {};
                $props: Partial<{
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }> & Omit<{
                    readonly value: number;
                    readonly reverse: boolean;
                    readonly vertical: boolean;
                    readonly loading: boolean;
                    readonly disabled: boolean;
                    readonly min: number;
                    readonly max: number;
                    readonly tipTransfer: string | boolean;
                    readonly hideTip: boolean;
                    readonly sliding: boolean;
                    readonly tipHover: boolean;
                    readonly tipProps: import('../slider').SliderTipProps;
                    readonly "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    readonly "onKey-plus"?: ((...args: any[]) => any) | undefined;
                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps">;
                $attrs: {
                    [x: string]: unknown;
                };
                $refs: {
                    [x: string]: unknown;
                } & {
                    wrapper: HTMLDivElement;
                    tooltip: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                        inherit: PropType<boolean>;
                        trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                        wrapper: PropType<string | boolean>;
                        noArrow: PropType<boolean>;
                        transitionName: PropType<string>;
                        visible: PropType<boolean>;
                        placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                        outsideClose: PropType<boolean>;
                        noHover: PropType<boolean>;
                        tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                        tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                        transfer: PropType<string | boolean>;
                        disabled: PropType<boolean>;
                        raw: PropType<boolean>;
                        delay: PropType<number | number[]>;
                        tipAlive: PropType<boolean>;
                        reverse: PropType<boolean>;
                        width: PropType<number | "trigger" | "auto">;
                        virtual: PropType<{
                            getBoundingClientRect: () => DOMRect;
                        } | {
                            $el: {
                                getBoundingClientRect: () => DOMRect;
                            };
                        } | {
                            x: number;
                            y: number;
                        }>;
                        shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                        onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                        onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    }>> & Readonly<{
                        onClickoutside?: ((...args: any[]) => any) | undefined;
                        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                    }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("clickoutside" | "update:visible")[], import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<import('vue').ExtractPropTypes<{
                        inherit: PropType<boolean>;
                        trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                        wrapper: PropType<string | boolean>;
                        noArrow: PropType<boolean>;
                        transitionName: PropType<string>;
                        visible: PropType<boolean>;
                        placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                        outsideClose: PropType<boolean>;
                        noHover: PropType<boolean>;
                        tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                        tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                        transfer: PropType<string | boolean>;
                        disabled: PropType<boolean>;
                        raw: PropType<boolean>;
                        delay: PropType<number | number[]>;
                        tipAlive: PropType<boolean>;
                        reverse: PropType<boolean>;
                        width: PropType<number | "trigger" | "auto">;
                        virtual: PropType<{
                            getBoundingClientRect: () => DOMRect;
                        } | {
                            $el: {
                                getBoundingClientRect: () => DOMRect;
                            };
                        } | {
                            x: number;
                            y: number;
                        }>;
                        shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                        onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                        onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    }>> & Readonly<{
                        onClickoutside?: ((...args: any[]) => any) | undefined;
                        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                    }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, {}> | null;
                    handler: HTMLDivElement;
                };
                $slots: Readonly<{
                    [name: string]: import('vue').Slot<any> | undefined;
                }>;
                $root: import('vue').ComponentPublicInstance | null;
                $parent: import('vue').ComponentPublicInstance | null;
                $host: Element | null;
                $emit: ((event: "key-minus", ...args: any[]) => void) & ((event: "key-plus", ...args: any[]) => void);
                $el: HTMLDivElement;
                $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                    value: {
                        type: NumberConstructor;
                        default: number;
                    };
                    tipTransfer: {
                        type: (BooleanConstructor | StringConstructor)[];
                        default: boolean;
                    };
                    hideTip: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    vertical: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    min: {
                        type: NumberConstructor;
                        default: number;
                    };
                    max: {
                        type: NumberConstructor;
                        default: number;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    reverse: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    sliding: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipHover: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipProps: {
                        type: PropType<import('../slider').SliderTipProps>;
                        default: () => {};
                    };
                }>> & Readonly<{
                    "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    "onKey-plus"?: ((...args: any[]) => any) | undefined;
                }>, {
                    updateTooltip: () => void;
                    focus: (options?: FocusOptions) => void;
                    blur: () => void;
                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                    "key-minus": (...args: any[]) => void;
                    "key-plus": (...args: any[]) => void;
                }, string, {
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                    beforeCreate?: (() => void) | (() => void)[];
                    created?: (() => void) | (() => void)[];
                    beforeMount?: (() => void) | (() => void)[];
                    mounted?: (() => void) | (() => void)[];
                    beforeUpdate?: (() => void) | (() => void)[];
                    updated?: (() => void) | (() => void)[];
                    activated?: (() => void) | (() => void)[];
                    deactivated?: (() => void) | (() => void)[];
                    beforeDestroy?: (() => void) | (() => void)[];
                    beforeUnmount?: (() => void) | (() => void)[];
                    destroyed?: (() => void) | (() => void)[];
                    unmounted?: (() => void) | (() => void)[];
                    renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                    renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                    errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
                };
                $forceUpdate: () => void;
                $nextTick: typeof import('vue').nextTick;
                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
            } & Readonly<{
                value: number;
                reverse: boolean;
                vertical: boolean;
                loading: boolean;
                disabled: boolean;
                min: number;
                max: number;
                tipTransfer: string | boolean;
                hideTip: boolean;
                sliding: boolean;
                tipHover: boolean;
                tipProps: import('../slider').SliderTipProps;
            }> & Omit<Readonly<import('vue').ExtractPropTypes<{
                value: {
                    type: NumberConstructor;
                    default: number;
                };
                tipTransfer: {
                    type: (BooleanConstructor | StringConstructor)[];
                    default: boolean;
                };
                hideTip: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                vertical: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                min: {
                    type: NumberConstructor;
                    default: number;
                };
                max: {
                    type: NumberConstructor;
                    default: number;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                reverse: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                sliding: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipHover: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipProps: {
                    type: PropType<import('../slider').SliderTipProps>;
                    default: () => {};
                };
            }>> & Readonly<{
                "onKey-minus"?: ((...args: any[]) => any) | undefined;
                "onKey-plus"?: ((...args: any[]) => any) | undefined;
            }>, "blur" | "focus" | "updateTooltip" | ("value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps")> & import('vue').ShallowUnwrapRef<{
                updateTooltip: () => void;
                focus: (options?: FocusOptions) => void;
                blur: () => void;
            }> & {} & import('vue').ComponentCustomProperties & {} & {
                $slots: Readonly<{
                    default: () => any;
                    tip: () => any;
                }> & {
                    default: () => any;
                    tip: () => any;
                };
            }) | undefined, ({
                $: import('vue').ComponentInternalInstance;
                $data: {};
                $props: Partial<{
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }> & Omit<{
                    readonly value: number;
                    readonly reverse: boolean;
                    readonly vertical: boolean;
                    readonly loading: boolean;
                    readonly disabled: boolean;
                    readonly min: number;
                    readonly max: number;
                    readonly tipTransfer: string | boolean;
                    readonly hideTip: boolean;
                    readonly sliding: boolean;
                    readonly tipHover: boolean;
                    readonly tipProps: import('../slider').SliderTipProps;
                    readonly "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    readonly "onKey-plus"?: ((...args: any[]) => any) | undefined;
                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps">;
                $attrs: {
                    [x: string]: unknown;
                };
                $refs: {
                    [x: string]: unknown;
                } & {
                    wrapper: HTMLDivElement;
                    tooltip: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                        inherit: PropType<boolean>;
                        trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                        wrapper: PropType<string | boolean>;
                        noArrow: PropType<boolean>;
                        transitionName: PropType<string>;
                        visible: PropType<boolean>;
                        placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                        outsideClose: PropType<boolean>;
                        noHover: PropType<boolean>;
                        tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                        tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                        transfer: PropType<string | boolean>;
                        disabled: PropType<boolean>;
                        raw: PropType<boolean>;
                        delay: PropType<number | number[]>;
                        tipAlive: PropType<boolean>;
                        reverse: PropType<boolean>;
                        width: PropType<number | "trigger" | "auto">;
                        virtual: PropType<{
                            getBoundingClientRect: () => DOMRect;
                        } | {
                            $el: {
                                getBoundingClientRect: () => DOMRect;
                            };
                        } | {
                            x: number;
                            y: number;
                        }>;
                        shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                        onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                        onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    }>> & Readonly<{
                        onClickoutside?: ((...args: any[]) => any) | undefined;
                        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                    }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("clickoutside" | "update:visible")[], import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<import('vue').ExtractPropTypes<{
                        inherit: PropType<boolean>;
                        trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                        wrapper: PropType<string | boolean>;
                        noArrow: PropType<boolean>;
                        transitionName: PropType<string>;
                        visible: PropType<boolean>;
                        placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                        outsideClose: PropType<boolean>;
                        noHover: PropType<boolean>;
                        tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                        tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                        transfer: PropType<string | boolean>;
                        disabled: PropType<boolean>;
                        raw: PropType<boolean>;
                        delay: PropType<number | number[]>;
                        tipAlive: PropType<boolean>;
                        reverse: PropType<boolean>;
                        width: PropType<number | "trigger" | "auto">;
                        virtual: PropType<{
                            getBoundingClientRect: () => DOMRect;
                        } | {
                            $el: {
                                getBoundingClientRect: () => DOMRect;
                            };
                        } | {
                            x: number;
                            y: number;
                        }>;
                        shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                        onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                        onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                        onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    }>> & Readonly<{
                        onClickoutside?: ((...args: any[]) => any) | undefined;
                        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                    }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, {}> | null;
                    handler: HTMLDivElement;
                };
                $slots: Readonly<{
                    [name: string]: import('vue').Slot<any> | undefined;
                }>;
                $root: import('vue').ComponentPublicInstance | null;
                $parent: import('vue').ComponentPublicInstance | null;
                $host: Element | null;
                $emit: ((event: "key-minus", ...args: any[]) => void) & ((event: "key-plus", ...args: any[]) => void);
                $el: HTMLDivElement;
                $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                    value: {
                        type: NumberConstructor;
                        default: number;
                    };
                    tipTransfer: {
                        type: (BooleanConstructor | StringConstructor)[];
                        default: boolean;
                    };
                    hideTip: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    vertical: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    min: {
                        type: NumberConstructor;
                        default: number;
                    };
                    max: {
                        type: NumberConstructor;
                        default: number;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    loading: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    reverse: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    sliding: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipHover: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    tipProps: {
                        type: PropType<import('../slider').SliderTipProps>;
                        default: () => {};
                    };
                }>> & Readonly<{
                    "onKey-minus"?: ((...args: any[]) => any) | undefined;
                    "onKey-plus"?: ((...args: any[]) => any) | undefined;
                }>, {
                    updateTooltip: () => void;
                    focus: (options?: FocusOptions) => void;
                    blur: () => void;
                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                    "key-minus": (...args: any[]) => void;
                    "key-plus": (...args: any[]) => void;
                }, string, {
                    value: number;
                    reverse: boolean;
                    vertical: boolean;
                    loading: boolean;
                    disabled: boolean;
                    min: number;
                    max: number;
                    tipTransfer: string | boolean;
                    hideTip: boolean;
                    sliding: boolean;
                    tipHover: boolean;
                    tipProps: import('../slider').SliderTipProps;
                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                    beforeCreate?: (() => void) | (() => void)[];
                    created?: (() => void) | (() => void)[];
                    beforeMount?: (() => void) | (() => void)[];
                    mounted?: (() => void) | (() => void)[];
                    beforeUpdate?: (() => void) | (() => void)[];
                    updated?: (() => void) | (() => void)[];
                    activated?: (() => void) | (() => void)[];
                    deactivated?: (() => void) | (() => void)[];
                    beforeDestroy?: (() => void) | (() => void)[];
                    beforeUnmount?: (() => void) | (() => void)[];
                    destroyed?: (() => void) | (() => void)[];
                    unmounted?: (() => void) | (() => void)[];
                    renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                    renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                    errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
                };
                $forceUpdate: () => void;
                $nextTick: typeof import('vue').nextTick;
                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
            } & Readonly<{
                value: number;
                reverse: boolean;
                vertical: boolean;
                loading: boolean;
                disabled: boolean;
                min: number;
                max: number;
                tipTransfer: string | boolean;
                hideTip: boolean;
                sliding: boolean;
                tipHover: boolean;
                tipProps: import('../slider').SliderTipProps;
            }> & Omit<Readonly<import('vue').ExtractPropTypes<{
                value: {
                    type: NumberConstructor;
                    default: number;
                };
                tipTransfer: {
                    type: (BooleanConstructor | StringConstructor)[];
                    default: boolean;
                };
                hideTip: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                vertical: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                min: {
                    type: NumberConstructor;
                    default: number;
                };
                max: {
                    type: NumberConstructor;
                    default: number;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                reverse: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                sliding: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipHover: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipProps: {
                    type: PropType<import('../slider').SliderTipProps>;
                    default: () => {};
                };
            }>> & Readonly<{
                "onKey-minus"?: ((...args: any[]) => any) | undefined;
                "onKey-plus"?: ((...args: any[]) => any) | undefined;
            }>, "blur" | "focus" | "updateTooltip" | ("value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps")> & import('vue').ShallowUnwrapRef<{
                updateTooltip: () => void;
                focus: (options?: FocusOptions) => void;
                blur: () => void;
            }> & {} & import('vue').ComponentCustomProperties & {} & {
                $slots: Readonly<{
                    default: () => any;
                    tip: () => any;
                }> & {
                    default: () => any;
                    tip: () => any;
                };
            }) | undefined>;
            isValueInRange: (value: number | string) => boolean;
            focus: (options?: FocusOptions) => void;
            blur: () => void;
        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
            "update:value": (...args: any[]) => void;
        }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
            beforeCreate?: (() => void) | (() => void)[];
            created?: (() => void) | (() => void)[];
            beforeMount?: (() => void) | (() => void)[];
            mounted?: (() => void) | (() => void)[];
            beforeUpdate?: (() => void) | (() => void)[];
            updated?: (() => void) | (() => void)[];
            activated?: (() => void) | (() => void)[];
            deactivated?: (() => void) | (() => void)[];
            beforeDestroy?: (() => void) | (() => void)[];
            beforeUnmount?: (() => void) | (() => void)[];
            destroyed?: (() => void) | (() => void)[];
            unmounted?: (() => void) | (() => void)[];
            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
        };
        $forceUpdate: () => void;
        $nextTick: typeof import('vue').nextTick;
        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
    } & Readonly<{}> & Omit<Readonly<import('vue').ExtractPropTypes<{
        inherit: PropType<boolean>;
        state: PropType<"default" | "success" | "error" | "warning">;
        value: PropType<number | number[]>;
        min: PropType<number>;
        max: PropType<number>;
        step: PropType<number>;
        vertical: PropType<boolean>;
        hideTip: PropType<boolean>;
        tipTransfer: PropType<string | boolean>;
        disabled: PropType<boolean>;
        loading: PropType<boolean>;
        loadingLock: PropType<boolean>;
        reverse: PropType<boolean>;
        range: PropType<boolean>;
        markers: PropType<Record<string | number, string | import('../slider').SliderMarker> | (number | (import('../slider').SliderMarker & {
            value: number;
        }))[]>;
        markerOnly: PropType<boolean>;
        tipHover: PropType<boolean>;
        flipMarker: PropType<boolean>;
        triggerFade: PropType<boolean>;
        tipProps: PropType<import('../slider').SliderTipProps>;
        sync: PropType<boolean>;
        rangeDraggable: PropType<boolean>;
        slots: PropType<import('../slider').SliderSlots>;
        onChange: PropType<((value: number | number[]) => void) | ((value: number | number[]) => void)[]>;
        onInput: PropType<((value: number | number[]) => void) | ((value: number | number[]) => void)[]>;
    }>> & Readonly<{
        "onUpdate:value"?: ((...args: any[]) => any) | undefined;
    }>, "track" | "blur" | "focus" | "idFor" | "sliding" | "startTrigger" | "endTrigger" | "isValueInRange"> & import('vue').ShallowUnwrapRef<{
        idFor: import('vue').ComputedRef<string | undefined>;
        sliding: import('vue').Ref<boolean[], boolean[]>;
        track: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
        startTrigger: import('vue').Ref<({
            $: import('vue').ComponentInternalInstance;
            $data: {};
            $props: Partial<{
                value: number;
                reverse: boolean;
                vertical: boolean;
                loading: boolean;
                disabled: boolean;
                min: number;
                max: number;
                tipTransfer: string | boolean;
                hideTip: boolean;
                sliding: boolean;
                tipHover: boolean;
                tipProps: import('../slider').SliderTipProps;
            }> & Omit<{
                readonly value: number;
                readonly reverse: boolean;
                readonly vertical: boolean;
                readonly loading: boolean;
                readonly disabled: boolean;
                readonly min: number;
                readonly max: number;
                readonly tipTransfer: string | boolean;
                readonly hideTip: boolean;
                readonly sliding: boolean;
                readonly tipHover: boolean;
                readonly tipProps: import('../slider').SliderTipProps;
                readonly "onKey-minus"?: ((...args: any[]) => any) | undefined;
                readonly "onKey-plus"?: ((...args: any[]) => any) | undefined;
            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps">;
            $attrs: {
                [x: string]: unknown;
            };
            $refs: {
                [x: string]: unknown;
            } & {
                wrapper: HTMLDivElement;
                tooltip: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    inherit: PropType<boolean>;
                    trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                    wrapper: PropType<string | boolean>;
                    noArrow: PropType<boolean>;
                    transitionName: PropType<string>;
                    visible: PropType<boolean>;
                    placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                    outsideClose: PropType<boolean>;
                    noHover: PropType<boolean>;
                    tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                    tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                    transfer: PropType<string | boolean>;
                    disabled: PropType<boolean>;
                    raw: PropType<boolean>;
                    delay: PropType<number | number[]>;
                    tipAlive: PropType<boolean>;
                    reverse: PropType<boolean>;
                    width: PropType<number | "trigger" | "auto">;
                    virtual: PropType<{
                        getBoundingClientRect: () => DOMRect;
                    } | {
                        $el: {
                            getBoundingClientRect: () => DOMRect;
                        };
                    } | {
                        x: number;
                        y: number;
                    }>;
                    shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                    onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                    onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                }>> & Readonly<{
                    onClickoutside?: ((...args: any[]) => any) | undefined;
                    "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("clickoutside" | "update:visible")[], import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import('vue').ExtractPropTypes<{
                    inherit: PropType<boolean>;
                    trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                    wrapper: PropType<string | boolean>;
                    noArrow: PropType<boolean>;
                    transitionName: PropType<string>;
                    visible: PropType<boolean>;
                    placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                    outsideClose: PropType<boolean>;
                    noHover: PropType<boolean>;
                    tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                    tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                    transfer: PropType<string | boolean>;
                    disabled: PropType<boolean>;
                    raw: PropType<boolean>;
                    delay: PropType<number | number[]>;
                    tipAlive: PropType<boolean>;
                    reverse: PropType<boolean>;
                    width: PropType<number | "trigger" | "auto">;
                    virtual: PropType<{
                        getBoundingClientRect: () => DOMRect;
                    } | {
                        $el: {
                            getBoundingClientRect: () => DOMRect;
                        };
                    } | {
                        x: number;
                        y: number;
                    }>;
                    shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                    onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                    onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                }>> & Readonly<{
                    onClickoutside?: ((...args: any[]) => any) | undefined;
                    "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, {}> | null;
                handler: HTMLDivElement;
            };
            $slots: Readonly<{
                [name: string]: import('vue').Slot<any> | undefined;
            }>;
            $root: import('vue').ComponentPublicInstance | null;
            $parent: import('vue').ComponentPublicInstance | null;
            $host: Element | null;
            $emit: ((event: "key-minus", ...args: any[]) => void) & ((event: "key-plus", ...args: any[]) => void);
            $el: HTMLDivElement;
            $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                value: {
                    type: NumberConstructor;
                    default: number;
                };
                tipTransfer: {
                    type: (BooleanConstructor | StringConstructor)[];
                    default: boolean;
                };
                hideTip: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                vertical: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                min: {
                    type: NumberConstructor;
                    default: number;
                };
                max: {
                    type: NumberConstructor;
                    default: number;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                reverse: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                sliding: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipHover: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipProps: {
                    type: PropType<import('../slider').SliderTipProps>;
                    default: () => {};
                };
            }>> & Readonly<{
                "onKey-minus"?: ((...args: any[]) => any) | undefined;
                "onKey-plus"?: ((...args: any[]) => any) | undefined;
            }>, {
                updateTooltip: () => void;
                focus: (options?: FocusOptions) => void;
                blur: () => void;
            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                "key-minus": (...args: any[]) => void;
                "key-plus": (...args: any[]) => void;
            }, string, {
                value: number;
                reverse: boolean;
                vertical: boolean;
                loading: boolean;
                disabled: boolean;
                min: number;
                max: number;
                tipTransfer: string | boolean;
                hideTip: boolean;
                sliding: boolean;
                tipHover: boolean;
                tipProps: import('../slider').SliderTipProps;
            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                beforeCreate?: (() => void) | (() => void)[];
                created?: (() => void) | (() => void)[];
                beforeMount?: (() => void) | (() => void)[];
                mounted?: (() => void) | (() => void)[];
                beforeUpdate?: (() => void) | (() => void)[];
                updated?: (() => void) | (() => void)[];
                activated?: (() => void) | (() => void)[];
                deactivated?: (() => void) | (() => void)[];
                beforeDestroy?: (() => void) | (() => void)[];
                beforeUnmount?: (() => void) | (() => void)[];
                destroyed?: (() => void) | (() => void)[];
                unmounted?: (() => void) | (() => void)[];
                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
            };
            $forceUpdate: () => void;
            $nextTick: typeof import('vue').nextTick;
            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
        } & Readonly<{
            value: number;
            reverse: boolean;
            vertical: boolean;
            loading: boolean;
            disabled: boolean;
            min: number;
            max: number;
            tipTransfer: string | boolean;
            hideTip: boolean;
            sliding: boolean;
            tipHover: boolean;
            tipProps: import('../slider').SliderTipProps;
        }> & Omit<Readonly<import('vue').ExtractPropTypes<{
            value: {
                type: NumberConstructor;
                default: number;
            };
            tipTransfer: {
                type: (BooleanConstructor | StringConstructor)[];
                default: boolean;
            };
            hideTip: {
                type: BooleanConstructor;
                default: boolean;
            };
            vertical: {
                type: BooleanConstructor;
                default: boolean;
            };
            min: {
                type: NumberConstructor;
                default: number;
            };
            max: {
                type: NumberConstructor;
                default: number;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            loading: {
                type: BooleanConstructor;
                default: boolean;
            };
            reverse: {
                type: BooleanConstructor;
                default: boolean;
            };
            sliding: {
                type: BooleanConstructor;
                default: boolean;
            };
            tipHover: {
                type: BooleanConstructor;
                default: boolean;
            };
            tipProps: {
                type: PropType<import('../slider').SliderTipProps>;
                default: () => {};
            };
        }>> & Readonly<{
            "onKey-minus"?: ((...args: any[]) => any) | undefined;
            "onKey-plus"?: ((...args: any[]) => any) | undefined;
        }>, "blur" | "focus" | "updateTooltip" | ("value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps")> & import('vue').ShallowUnwrapRef<{
            updateTooltip: () => void;
            focus: (options?: FocusOptions) => void;
            blur: () => void;
        }> & {} & import('vue').ComponentCustomProperties & {} & {
            $slots: Readonly<{
                default: () => any;
                tip: () => any;
            }> & {
                default: () => any;
                tip: () => any;
            };
        }) | undefined, ({
            $: import('vue').ComponentInternalInstance;
            $data: {};
            $props: Partial<{
                value: number;
                reverse: boolean;
                vertical: boolean;
                loading: boolean;
                disabled: boolean;
                min: number;
                max: number;
                tipTransfer: string | boolean;
                hideTip: boolean;
                sliding: boolean;
                tipHover: boolean;
                tipProps: import('../slider').SliderTipProps;
            }> & Omit<{
                readonly value: number;
                readonly reverse: boolean;
                readonly vertical: boolean;
                readonly loading: boolean;
                readonly disabled: boolean;
                readonly min: number;
                readonly max: number;
                readonly tipTransfer: string | boolean;
                readonly hideTip: boolean;
                readonly sliding: boolean;
                readonly tipHover: boolean;
                readonly tipProps: import('../slider').SliderTipProps;
                readonly "onKey-minus"?: ((...args: any[]) => any) | undefined;
                readonly "onKey-plus"?: ((...args: any[]) => any) | undefined;
            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps">;
            $attrs: {
                [x: string]: unknown;
            };
            $refs: {
                [x: string]: unknown;
            } & {
                wrapper: HTMLDivElement;
                tooltip: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    inherit: PropType<boolean>;
                    trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                    wrapper: PropType<string | boolean>;
                    noArrow: PropType<boolean>;
                    transitionName: PropType<string>;
                    visible: PropType<boolean>;
                    placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                    outsideClose: PropType<boolean>;
                    noHover: PropType<boolean>;
                    tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                    tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                    transfer: PropType<string | boolean>;
                    disabled: PropType<boolean>;
                    raw: PropType<boolean>;
                    delay: PropType<number | number[]>;
                    tipAlive: PropType<boolean>;
                    reverse: PropType<boolean>;
                    width: PropType<number | "trigger" | "auto">;
                    virtual: PropType<{
                        getBoundingClientRect: () => DOMRect;
                    } | {
                        $el: {
                            getBoundingClientRect: () => DOMRect;
                        };
                    } | {
                        x: number;
                        y: number;
                    }>;
                    shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                    onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                    onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                }>> & Readonly<{
                    onClickoutside?: ((...args: any[]) => any) | undefined;
                    "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("clickoutside" | "update:visible")[], import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import('vue').ExtractPropTypes<{
                    inherit: PropType<boolean>;
                    trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                    wrapper: PropType<string | boolean>;
                    noArrow: PropType<boolean>;
                    transitionName: PropType<string>;
                    visible: PropType<boolean>;
                    placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                    outsideClose: PropType<boolean>;
                    noHover: PropType<boolean>;
                    tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                    tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                    transfer: PropType<string | boolean>;
                    disabled: PropType<boolean>;
                    raw: PropType<boolean>;
                    delay: PropType<number | number[]>;
                    tipAlive: PropType<boolean>;
                    reverse: PropType<boolean>;
                    width: PropType<number | "trigger" | "auto">;
                    virtual: PropType<{
                        getBoundingClientRect: () => DOMRect;
                    } | {
                        $el: {
                            getBoundingClientRect: () => DOMRect;
                        };
                    } | {
                        x: number;
                        y: number;
                    }>;
                    shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                    onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                    onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                }>> & Readonly<{
                    onClickoutside?: ((...args: any[]) => any) | undefined;
                    "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, {}> | null;
                handler: HTMLDivElement;
            };
            $slots: Readonly<{
                [name: string]: import('vue').Slot<any> | undefined;
            }>;
            $root: import('vue').ComponentPublicInstance | null;
            $parent: import('vue').ComponentPublicInstance | null;
            $host: Element | null;
            $emit: ((event: "key-minus", ...args: any[]) => void) & ((event: "key-plus", ...args: any[]) => void);
            $el: HTMLDivElement;
            $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                value: {
                    type: NumberConstructor;
                    default: number;
                };
                tipTransfer: {
                    type: (BooleanConstructor | StringConstructor)[];
                    default: boolean;
                };
                hideTip: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                vertical: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                min: {
                    type: NumberConstructor;
                    default: number;
                };
                max: {
                    type: NumberConstructor;
                    default: number;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                reverse: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                sliding: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipHover: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipProps: {
                    type: PropType<import('../slider').SliderTipProps>;
                    default: () => {};
                };
            }>> & Readonly<{
                "onKey-minus"?: ((...args: any[]) => any) | undefined;
                "onKey-plus"?: ((...args: any[]) => any) | undefined;
            }>, {
                updateTooltip: () => void;
                focus: (options?: FocusOptions) => void;
                blur: () => void;
            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                "key-minus": (...args: any[]) => void;
                "key-plus": (...args: any[]) => void;
            }, string, {
                value: number;
                reverse: boolean;
                vertical: boolean;
                loading: boolean;
                disabled: boolean;
                min: number;
                max: number;
                tipTransfer: string | boolean;
                hideTip: boolean;
                sliding: boolean;
                tipHover: boolean;
                tipProps: import('../slider').SliderTipProps;
            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                beforeCreate?: (() => void) | (() => void)[];
                created?: (() => void) | (() => void)[];
                beforeMount?: (() => void) | (() => void)[];
                mounted?: (() => void) | (() => void)[];
                beforeUpdate?: (() => void) | (() => void)[];
                updated?: (() => void) | (() => void)[];
                activated?: (() => void) | (() => void)[];
                deactivated?: (() => void) | (() => void)[];
                beforeDestroy?: (() => void) | (() => void)[];
                beforeUnmount?: (() => void) | (() => void)[];
                destroyed?: (() => void) | (() => void)[];
                unmounted?: (() => void) | (() => void)[];
                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
            };
            $forceUpdate: () => void;
            $nextTick: typeof import('vue').nextTick;
            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
        } & Readonly<{
            value: number;
            reverse: boolean;
            vertical: boolean;
            loading: boolean;
            disabled: boolean;
            min: number;
            max: number;
            tipTransfer: string | boolean;
            hideTip: boolean;
            sliding: boolean;
            tipHover: boolean;
            tipProps: import('../slider').SliderTipProps;
        }> & Omit<Readonly<import('vue').ExtractPropTypes<{
            value: {
                type: NumberConstructor;
                default: number;
            };
            tipTransfer: {
                type: (BooleanConstructor | StringConstructor)[];
                default: boolean;
            };
            hideTip: {
                type: BooleanConstructor;
                default: boolean;
            };
            vertical: {
                type: BooleanConstructor;
                default: boolean;
            };
            min: {
                type: NumberConstructor;
                default: number;
            };
            max: {
                type: NumberConstructor;
                default: number;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            loading: {
                type: BooleanConstructor;
                default: boolean;
            };
            reverse: {
                type: BooleanConstructor;
                default: boolean;
            };
            sliding: {
                type: BooleanConstructor;
                default: boolean;
            };
            tipHover: {
                type: BooleanConstructor;
                default: boolean;
            };
            tipProps: {
                type: PropType<import('../slider').SliderTipProps>;
                default: () => {};
            };
        }>> & Readonly<{
            "onKey-minus"?: ((...args: any[]) => any) | undefined;
            "onKey-plus"?: ((...args: any[]) => any) | undefined;
        }>, "blur" | "focus" | "updateTooltip" | ("value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps")> & import('vue').ShallowUnwrapRef<{
            updateTooltip: () => void;
            focus: (options?: FocusOptions) => void;
            blur: () => void;
        }> & {} & import('vue').ComponentCustomProperties & {} & {
            $slots: Readonly<{
                default: () => any;
                tip: () => any;
            }> & {
                default: () => any;
                tip: () => any;
            };
        }) | undefined>;
        endTrigger: import('vue').Ref<({
            $: import('vue').ComponentInternalInstance;
            $data: {};
            $props: Partial<{
                value: number;
                reverse: boolean;
                vertical: boolean;
                loading: boolean;
                disabled: boolean;
                min: number;
                max: number;
                tipTransfer: string | boolean;
                hideTip: boolean;
                sliding: boolean;
                tipHover: boolean;
                tipProps: import('../slider').SliderTipProps;
            }> & Omit<{
                readonly value: number;
                readonly reverse: boolean;
                readonly vertical: boolean;
                readonly loading: boolean;
                readonly disabled: boolean;
                readonly min: number;
                readonly max: number;
                readonly tipTransfer: string | boolean;
                readonly hideTip: boolean;
                readonly sliding: boolean;
                readonly tipHover: boolean;
                readonly tipProps: import('../slider').SliderTipProps;
                readonly "onKey-minus"?: ((...args: any[]) => any) | undefined;
                readonly "onKey-plus"?: ((...args: any[]) => any) | undefined;
            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps">;
            $attrs: {
                [x: string]: unknown;
            };
            $refs: {
                [x: string]: unknown;
            } & {
                wrapper: HTMLDivElement;
                tooltip: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    inherit: PropType<boolean>;
                    trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                    wrapper: PropType<string | boolean>;
                    noArrow: PropType<boolean>;
                    transitionName: PropType<string>;
                    visible: PropType<boolean>;
                    placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                    outsideClose: PropType<boolean>;
                    noHover: PropType<boolean>;
                    tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                    tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                    transfer: PropType<string | boolean>;
                    disabled: PropType<boolean>;
                    raw: PropType<boolean>;
                    delay: PropType<number | number[]>;
                    tipAlive: PropType<boolean>;
                    reverse: PropType<boolean>;
                    width: PropType<number | "trigger" | "auto">;
                    virtual: PropType<{
                        getBoundingClientRect: () => DOMRect;
                    } | {
                        $el: {
                            getBoundingClientRect: () => DOMRect;
                        };
                    } | {
                        x: number;
                        y: number;
                    }>;
                    shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                    onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                    onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                }>> & Readonly<{
                    onClickoutside?: ((...args: any[]) => any) | undefined;
                    "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("clickoutside" | "update:visible")[], import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import('vue').ExtractPropTypes<{
                    inherit: PropType<boolean>;
                    trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                    wrapper: PropType<string | boolean>;
                    noArrow: PropType<boolean>;
                    transitionName: PropType<string>;
                    visible: PropType<boolean>;
                    placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                    outsideClose: PropType<boolean>;
                    noHover: PropType<boolean>;
                    tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                    tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                    transfer: PropType<string | boolean>;
                    disabled: PropType<boolean>;
                    raw: PropType<boolean>;
                    delay: PropType<number | number[]>;
                    tipAlive: PropType<boolean>;
                    reverse: PropType<boolean>;
                    width: PropType<number | "trigger" | "auto">;
                    virtual: PropType<{
                        getBoundingClientRect: () => DOMRect;
                    } | {
                        $el: {
                            getBoundingClientRect: () => DOMRect;
                        };
                    } | {
                        x: number;
                        y: number;
                    }>;
                    shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                    onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                    onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                }>> & Readonly<{
                    onClickoutside?: ((...args: any[]) => any) | undefined;
                    "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, {}> | null;
                handler: HTMLDivElement;
            };
            $slots: Readonly<{
                [name: string]: import('vue').Slot<any> | undefined;
            }>;
            $root: import('vue').ComponentPublicInstance | null;
            $parent: import('vue').ComponentPublicInstance | null;
            $host: Element | null;
            $emit: ((event: "key-minus", ...args: any[]) => void) & ((event: "key-plus", ...args: any[]) => void);
            $el: HTMLDivElement;
            $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                value: {
                    type: NumberConstructor;
                    default: number;
                };
                tipTransfer: {
                    type: (BooleanConstructor | StringConstructor)[];
                    default: boolean;
                };
                hideTip: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                vertical: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                min: {
                    type: NumberConstructor;
                    default: number;
                };
                max: {
                    type: NumberConstructor;
                    default: number;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                reverse: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                sliding: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipHover: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipProps: {
                    type: PropType<import('../slider').SliderTipProps>;
                    default: () => {};
                };
            }>> & Readonly<{
                "onKey-minus"?: ((...args: any[]) => any) | undefined;
                "onKey-plus"?: ((...args: any[]) => any) | undefined;
            }>, {
                updateTooltip: () => void;
                focus: (options?: FocusOptions) => void;
                blur: () => void;
            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                "key-minus": (...args: any[]) => void;
                "key-plus": (...args: any[]) => void;
            }, string, {
                value: number;
                reverse: boolean;
                vertical: boolean;
                loading: boolean;
                disabled: boolean;
                min: number;
                max: number;
                tipTransfer: string | boolean;
                hideTip: boolean;
                sliding: boolean;
                tipHover: boolean;
                tipProps: import('../slider').SliderTipProps;
            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                beforeCreate?: (() => void) | (() => void)[];
                created?: (() => void) | (() => void)[];
                beforeMount?: (() => void) | (() => void)[];
                mounted?: (() => void) | (() => void)[];
                beforeUpdate?: (() => void) | (() => void)[];
                updated?: (() => void) | (() => void)[];
                activated?: (() => void) | (() => void)[];
                deactivated?: (() => void) | (() => void)[];
                beforeDestroy?: (() => void) | (() => void)[];
                beforeUnmount?: (() => void) | (() => void)[];
                destroyed?: (() => void) | (() => void)[];
                unmounted?: (() => void) | (() => void)[];
                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
            };
            $forceUpdate: () => void;
            $nextTick: typeof import('vue').nextTick;
            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
        } & Readonly<{
            value: number;
            reverse: boolean;
            vertical: boolean;
            loading: boolean;
            disabled: boolean;
            min: number;
            max: number;
            tipTransfer: string | boolean;
            hideTip: boolean;
            sliding: boolean;
            tipHover: boolean;
            tipProps: import('../slider').SliderTipProps;
        }> & Omit<Readonly<import('vue').ExtractPropTypes<{
            value: {
                type: NumberConstructor;
                default: number;
            };
            tipTransfer: {
                type: (BooleanConstructor | StringConstructor)[];
                default: boolean;
            };
            hideTip: {
                type: BooleanConstructor;
                default: boolean;
            };
            vertical: {
                type: BooleanConstructor;
                default: boolean;
            };
            min: {
                type: NumberConstructor;
                default: number;
            };
            max: {
                type: NumberConstructor;
                default: number;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            loading: {
                type: BooleanConstructor;
                default: boolean;
            };
            reverse: {
                type: BooleanConstructor;
                default: boolean;
            };
            sliding: {
                type: BooleanConstructor;
                default: boolean;
            };
            tipHover: {
                type: BooleanConstructor;
                default: boolean;
            };
            tipProps: {
                type: PropType<import('../slider').SliderTipProps>;
                default: () => {};
            };
        }>> & Readonly<{
            "onKey-minus"?: ((...args: any[]) => any) | undefined;
            "onKey-plus"?: ((...args: any[]) => any) | undefined;
        }>, "blur" | "focus" | "updateTooltip" | ("value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps")> & import('vue').ShallowUnwrapRef<{
            updateTooltip: () => void;
            focus: (options?: FocusOptions) => void;
            blur: () => void;
        }> & {} & import('vue').ComponentCustomProperties & {} & {
            $slots: Readonly<{
                default: () => any;
                tip: () => any;
            }> & {
                default: () => any;
                tip: () => any;
            };
        }) | undefined, ({
            $: import('vue').ComponentInternalInstance;
            $data: {};
            $props: Partial<{
                value: number;
                reverse: boolean;
                vertical: boolean;
                loading: boolean;
                disabled: boolean;
                min: number;
                max: number;
                tipTransfer: string | boolean;
                hideTip: boolean;
                sliding: boolean;
                tipHover: boolean;
                tipProps: import('../slider').SliderTipProps;
            }> & Omit<{
                readonly value: number;
                readonly reverse: boolean;
                readonly vertical: boolean;
                readonly loading: boolean;
                readonly disabled: boolean;
                readonly min: number;
                readonly max: number;
                readonly tipTransfer: string | boolean;
                readonly hideTip: boolean;
                readonly sliding: boolean;
                readonly tipHover: boolean;
                readonly tipProps: import('../slider').SliderTipProps;
                readonly "onKey-minus"?: ((...args: any[]) => any) | undefined;
                readonly "onKey-plus"?: ((...args: any[]) => any) | undefined;
            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps">;
            $attrs: {
                [x: string]: unknown;
            };
            $refs: {
                [x: string]: unknown;
            } & {
                wrapper: HTMLDivElement;
                tooltip: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    inherit: PropType<boolean>;
                    trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                    wrapper: PropType<string | boolean>;
                    noArrow: PropType<boolean>;
                    transitionName: PropType<string>;
                    visible: PropType<boolean>;
                    placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                    outsideClose: PropType<boolean>;
                    noHover: PropType<boolean>;
                    tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                    tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                    transfer: PropType<string | boolean>;
                    disabled: PropType<boolean>;
                    raw: PropType<boolean>;
                    delay: PropType<number | number[]>;
                    tipAlive: PropType<boolean>;
                    reverse: PropType<boolean>;
                    width: PropType<number | "trigger" | "auto">;
                    virtual: PropType<{
                        getBoundingClientRect: () => DOMRect;
                    } | {
                        $el: {
                            getBoundingClientRect: () => DOMRect;
                        };
                    } | {
                        x: number;
                        y: number;
                    }>;
                    shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                    onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                    onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                }>> & Readonly<{
                    onClickoutside?: ((...args: any[]) => any) | undefined;
                    "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("clickoutside" | "update:visible")[], import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import('vue').ExtractPropTypes<{
                    inherit: PropType<boolean>;
                    trigger: PropType<"click" | "focus" | "hover" | "hover-focus" | "custom">;
                    wrapper: PropType<string | boolean>;
                    noArrow: PropType<boolean>;
                    transitionName: PropType<string>;
                    visible: PropType<boolean>;
                    placement: PropType<"bottom" | "top" | "right" | "left" | "bottom-start" | "bottom-end" | "top-start" | "top-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                    outsideClose: PropType<boolean>;
                    noHover: PropType<boolean>;
                    tipClass: PropType<string | Record<string, any> | (string | Record<string, any>)[]>;
                    tipStyle: PropType<string | import('vue').CSSProperties | (string | import('vue').CSSProperties)[]>;
                    transfer: PropType<string | boolean>;
                    disabled: PropType<boolean>;
                    raw: PropType<boolean>;
                    delay: PropType<number | number[]>;
                    tipAlive: PropType<boolean>;
                    reverse: PropType<boolean>;
                    width: PropType<number | "trigger" | "auto">;
                    virtual: PropType<{
                        getBoundingClientRect: () => DOMRect;
                    } | {
                        $el: {
                            getBoundingClientRect: () => DOMRect;
                        };
                    } | {
                        x: number;
                        y: number;
                    }>;
                    shift: PropType<boolean | "horizontal" | "vertical" | "both">;
                    onToggle: PropType<((visible: boolean) => void) | ((visible: boolean) => void)[]>;
                    onTipEnter: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    onTipLeave: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    onClickOutside: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                    onOutsideClose: PropType<import('@vexip-ui/config').AnyFunction | import('@vexip-ui/config').AnyFunction[]>;
                }>> & Readonly<{
                    onClickoutside?: ((...args: any[]) => any) | undefined;
                    "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
                }>, () => (false | import("vue/jsx-runtime").JSX.Element | null)[], {}, {}, {}, {}> | null;
                handler: HTMLDivElement;
            };
            $slots: Readonly<{
                [name: string]: import('vue').Slot<any> | undefined;
            }>;
            $root: import('vue').ComponentPublicInstance | null;
            $parent: import('vue').ComponentPublicInstance | null;
            $host: Element | null;
            $emit: ((event: "key-minus", ...args: any[]) => void) & ((event: "key-plus", ...args: any[]) => void);
            $el: HTMLDivElement;
            $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                value: {
                    type: NumberConstructor;
                    default: number;
                };
                tipTransfer: {
                    type: (BooleanConstructor | StringConstructor)[];
                    default: boolean;
                };
                hideTip: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                vertical: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                min: {
                    type: NumberConstructor;
                    default: number;
                };
                max: {
                    type: NumberConstructor;
                    default: number;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                loading: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                reverse: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                sliding: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipHover: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                tipProps: {
                    type: PropType<import('../slider').SliderTipProps>;
                    default: () => {};
                };
            }>> & Readonly<{
                "onKey-minus"?: ((...args: any[]) => any) | undefined;
                "onKey-plus"?: ((...args: any[]) => any) | undefined;
            }>, {
                updateTooltip: () => void;
                focus: (options?: FocusOptions) => void;
                blur: () => void;
            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                "key-minus": (...args: any[]) => void;
                "key-plus": (...args: any[]) => void;
            }, string, {
                value: number;
                reverse: boolean;
                vertical: boolean;
                loading: boolean;
                disabled: boolean;
                min: number;
                max: number;
                tipTransfer: string | boolean;
                hideTip: boolean;
                sliding: boolean;
                tipHover: boolean;
                tipProps: import('../slider').SliderTipProps;
            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                beforeCreate?: (() => void) | (() => void)[];
                created?: (() => void) | (() => void)[];
                beforeMount?: (() => void) | (() => void)[];
                mounted?: (() => void) | (() => void)[];
                beforeUpdate?: (() => void) | (() => void)[];
                updated?: (() => void) | (() => void)[];
                activated?: (() => void) | (() => void)[];
                deactivated?: (() => void) | (() => void)[];
                beforeDestroy?: (() => void) | (() => void)[];
                beforeUnmount?: (() => void) | (() => void)[];
                destroyed?: (() => void) | (() => void)[];
                unmounted?: (() => void) | (() => void)[];
                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
            };
            $forceUpdate: () => void;
            $nextTick: typeof import('vue').nextTick;
            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
        } & Readonly<{
            value: number;
            reverse: boolean;
            vertical: boolean;
            loading: boolean;
            disabled: boolean;
            min: number;
            max: number;
            tipTransfer: string | boolean;
            hideTip: boolean;
            sliding: boolean;
            tipHover: boolean;
            tipProps: import('../slider').SliderTipProps;
        }> & Omit<Readonly<import('vue').ExtractPropTypes<{
            value: {
                type: NumberConstructor;
                default: number;
            };
            tipTransfer: {
                type: (BooleanConstructor | StringConstructor)[];
                default: boolean;
            };
            hideTip: {
                type: BooleanConstructor;
                default: boolean;
            };
            vertical: {
                type: BooleanConstructor;
                default: boolean;
            };
            min: {
                type: NumberConstructor;
                default: number;
            };
            max: {
                type: NumberConstructor;
                default: number;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            loading: {
                type: BooleanConstructor;
                default: boolean;
            };
            reverse: {
                type: BooleanConstructor;
                default: boolean;
            };
            sliding: {
                type: BooleanConstructor;
                default: boolean;
            };
            tipHover: {
                type: BooleanConstructor;
                default: boolean;
            };
            tipProps: {
                type: PropType<import('../slider').SliderTipProps>;
                default: () => {};
            };
        }>> & Readonly<{
            "onKey-minus"?: ((...args: any[]) => any) | undefined;
            "onKey-plus"?: ((...args: any[]) => any) | undefined;
        }>, "blur" | "focus" | "updateTooltip" | ("value" | "reverse" | "vertical" | "loading" | "disabled" | "min" | "max" | "tipTransfer" | "hideTip" | "sliding" | "tipHover" | "tipProps")> & import('vue').ShallowUnwrapRef<{
            updateTooltip: () => void;
            focus: (options?: FocusOptions) => void;
            blur: () => void;
        }> & {} & import('vue').ComponentCustomProperties & {} & {
            $slots: Readonly<{
                default: () => any;
                tip: () => any;
            }> & {
                default: () => any;
                tip: () => any;
            };
        }) | undefined>;
        isValueInRange: (value: number | string) => boolean;
        focus: (options?: FocusOptions) => void;
        blur: () => void;
    }> & {} & import('vue').ComponentCustomProperties & {} & {
        $slots: Readonly<import('../slider').SliderSlots> & import('../slider').SliderSlots;
    }) | null;
    preview: HTMLDivElement;
}, HTMLDivElement>;
declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
export default _default;
type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};