CPL
/
banboshi_V2
1
0
Fork 0
Código Incidencias 0 Pull Requests 0 Lanzamientos 1 Wiki Actividad
版博士V2.0程序
No puede seleccionar más de 25 temas Los temas deben comenzar con una letra o número, pueden incluir guiones ('-') y pueden tener hasta 35 caracteres de largo.
61 Commits
5 Ramas
6.2 GiB
 
 
 
 
Rama: TongWei
Ramas Etiquetas
${ item.name }
Crear rama ${ searchTerm }
desde 'TongWei'
${ noResults }
banboshi_V2/HalftoneWeb/node_modules/element-plus/lib/components/scrollbar/index.d.ts

534 líneas
33 KiB
Original Enlace permanente Blame Histórico 

  1. export declare const ElScrollbar: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{

  2.     readonly height: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;

  3.     readonly maxHeight: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;

  4.     readonly native: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  5.     readonly wrapStyle: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown, "", boolean>;

  6.     readonly wrapClass: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;

  7.     readonly viewClass: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;

  8.     readonly viewStyle: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor, ObjectConstructor], unknown, unknown, "", boolean>;

  9.     readonly noresize: BooleanConstructor;

  10.     readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;

  11.     readonly always: BooleanConstructor;

  12.     readonly minSize: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 20, boolean>;

  13. }, {

  14.     COMPONENT_NAME: string;

  15.     props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  16.         readonly height: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;

  17.         readonly maxHeight: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;

  18.         readonly native: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  19.         readonly wrapStyle: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown, "", boolean>;

  20.         readonly wrapClass: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;

  21.         readonly viewClass: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;

  22.         readonly viewStyle: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor, ObjectConstructor], unknown, unknown, "", boolean>;

  23.         readonly noresize: BooleanConstructor;

  24.         readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;

  25.         readonly always: BooleanConstructor;

  26.         readonly minSize: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 20, boolean>;

  27.     }>> & {

  28.         onScroll?: ((args_0: {

  29.             scrollTop: number;

  30.             scrollLeft: number;

  31.         }) => any) | undefined;

  32.     }>>;

  33.     emit: (event: "scroll", args_0: {

  34.         scrollTop: number;

  35.         scrollLeft: number;

  36.     }) => void;

  37.     ns: {

  38.         namespace: import("vue").ComputedRef<string>;

  39.         b: (blockSuffix?: string) => string;

  40.         e: (element?: string | undefined) => string;

  41.         m: (modifier?: string | undefined) => string;

  42.         be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  43.         em: (element?: string | undefined, modifier?: string | undefined) => string;

  44.         bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  45.         bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  46.         is: {

  47.             (name: string, state: boolean | undefined): string;

  48.             (name: string): string;

  49.         };

  50.         cssVar: (object: Record<string, string>) => Record<string, string>;

  51.         cssVarName: (name: string) => string;

  52.         cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  53.         cssVarBlockName: (name: string) => string;

  54.     };

  55.     stopResizeObserver: undefined;

  56.     stopResizeListener: undefined;

  57.     scrollbarRef: import("vue").Ref<HTMLDivElement | undefined>;

  58.     wrapRef: import("vue").Ref<HTMLDivElement | undefined>;

  59.     resizeRef: import("vue").Ref<HTMLElement | undefined>;

  60.     sizeWidth: import("vue").Ref<string>;

  61.     sizeHeight: import("vue").Ref<string>;

  62.     barRef: import("vue").Ref<({

  63.         $: import("vue").ComponentInternalInstance;

  64.         $data: {};

  65.         $props: Partial<{

  66.             readonly always: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  67.             readonly ratioX: number;

  68.             readonly ratioY: number;

  69.         }> & Omit<Readonly<import("vue").ExtractPropTypes<{

  70.             readonly always: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  71.             readonly width: StringConstructor;

  72.             readonly height: StringConstructor;

  73.             readonly ratioX: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;

  74.             readonly ratioY: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;

  75.         }>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "always" | "ratioX" | "ratioY">;

  76.         $attrs: {

  77.             [x: string]: unknown;

  78.         };

  79.         $refs: {

  80.             [x: string]: unknown;

  81.         };

  82.         $slots: Readonly<{

  83.             [name: string]: import("vue").Slot | undefined;

  84.         }>;

  85.         $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null;

  86.         $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null;

  87.         $emit: (event: string, ...args: any[]) => void;

  88.         $el: any;

  89.         $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{

  90.             readonly always: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  91.             readonly width: StringConstructor;

  92.             readonly height: StringConstructor;

  93.             readonly ratioX: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;

  94.             readonly ratioY: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;

  95.         }>>, {

  96.             props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  97.                 readonly always: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  98.                 readonly width: StringConstructor;

  99.                 readonly height: StringConstructor;

  100.                 readonly ratioX: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;

  101.                 readonly ratioY: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;

  102.             }>> & {

  103.                 [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;

  104.             }>>;

  105.             moveX: import("vue").Ref<number>;

  106.             moveY: import("vue").Ref<number>;

  107.             handleScroll: (wrap: HTMLDivElement) => void;

  108.             Thumb: import("vue").DefineComponent<{

  109.                 readonly vertical: BooleanConstructor;

  110.                 readonly size: StringConstructor;

  111.                 readonly move: NumberConstructor;

  112.                 readonly ratio: {

  113.                     readonly type: import("vue").PropType<number>;

  114.                     readonly required: true;

  115.                     readonly validator: ((val: unknown) => boolean) | undefined;

  116.                     __epPropKey: true;

  117.                 };

  118.                 readonly always: BooleanConstructor;

  119.             }, {

  120.                 COMPONENT_NAME: string;

  121.                 props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  122.                     readonly vertical: BooleanConstructor;

  123.                     readonly size: StringConstructor;

  124.                     readonly move: NumberConstructor;

  125.                     readonly ratio: {

  126.                         readonly type: import("vue").PropType<number>;

  127.                         readonly required: true;

  128.                         readonly validator: ((val: unknown) => boolean) | undefined;

  129.                         __epPropKey: true;

  130.                     };

  131.                     readonly always: BooleanConstructor;

  132.                 }>> & {

  133.                     [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;

  134.                 }>>;

  135.                 scrollbar: import("./src/constants").ScrollbarContext;

  136.                 ns: {

  137.                     namespace: import("vue").ComputedRef<string>;

  138.                     b: (blockSuffix?: string) => string;

  139.                     e: (element?: string | undefined) => string;

  140.                     m: (modifier?: string | undefined) => string;

  141.                     be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  142.                     em: (element?: string | undefined, modifier?: string | undefined) => string;

  143.                     bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  144.                     bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  145.                     is: {

  146.                         (name: string, state: boolean | undefined): string;

  147.                         (name: string): string;

  148.                     };

  149.                     cssVar: (object: Record<string, string>) => Record<string, string>;

  150.                     cssVarName: (name: string) => string;

  151.                     cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  152.                     cssVarBlockName: (name: string) => string;

  153.                 };

  154.                 instance: import("vue").Ref<HTMLDivElement | undefined>;

  155.                 thumb: import("vue").Ref<HTMLDivElement | undefined>;

  156.                 thumbState: import("vue").Ref<{

  157.                     X?: number | undefined;

  158.                     Y?: number | undefined;

  159.                 }>;

  160.                 visible: import("vue").Ref<boolean>;

  161.                 cursorDown: boolean;

  162.                 cursorLeave: boolean;

  163.                 originalOnSelectStart: ((this: GlobalEventHandlers, ev: Event) => any) | null;

  164.                 bar: import("vue").ComputedRef<{

  165.                     readonly offset: "offsetHeight";

  166.                     readonly scroll: "scrollTop";

  167.                     readonly scrollSize: "scrollHeight";

  168.                     readonly size: "height";

  169.                     readonly key: "vertical";

  170.                     readonly axis: "Y";

  171.                     readonly client: "clientY";

  172.                     readonly direction: "top";

  173.                 } | {

  174.                     readonly offset: "offsetWidth";

  175.                     readonly scroll: "scrollLeft";

  176.                     readonly scrollSize: "scrollWidth";

  177.                     readonly size: "width";

  178.                     readonly key: "horizontal";

  179.                     readonly axis: "X";

  180.                     readonly client: "clientX";

  181.                     readonly direction: "left";

  182.                 }>;

  183.                 thumbStyle: import("vue").ComputedRef<import("vue").CSSProperties>;

  184.                 offsetRatio: import("vue").ComputedRef<number>;

  185.                 clickThumbHandler: (e: MouseEvent) => void;

  186.                 clickTrackHandler: (e: MouseEvent) => void;

  187.                 startDrag: (e: MouseEvent) => void;

  188.                 mouseMoveDocumentHandler: (e: MouseEvent) => void;

  189.                 mouseUpDocumentHandler: () => void;

  190.                 mouseMoveScrollbarHandler: () => void;

  191.                 mouseLeaveScrollbarHandler: () => void;

  192.                 restoreOnselectstart: () => void;

  193.             }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  194.                 readonly vertical: BooleanConstructor;

  195.                 readonly size: StringConstructor;

  196.                 readonly move: NumberConstructor;

  197.                 readonly ratio: {

  198.                     readonly type: import("vue").PropType<number>;

  199.                     readonly required: true;

  200.                     readonly validator: ((val: unknown) => boolean) | undefined;

  201.                     __epPropKey: true;

  202.                 };

  203.                 readonly always: BooleanConstructor;

  204.             }>>, {

  205.                 readonly vertical: boolean;

  206.                 readonly always: boolean;

  207.             }>;

  208.         }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, {

  209.             readonly always: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  210.             readonly ratioX: number;

  211.             readonly ratioY: number;

  212.         }> & {

  213.             beforeCreate?: ((() => void) | (() => void)[]) | undefined;

  214.             created?: ((() => void) | (() => void)[]) | undefined;

  215.             beforeMount?: ((() => void) | (() => void)[]) | undefined;

  216.             mounted?: ((() => void) | (() => void)[]) | undefined;

  217.             beforeUpdate?: ((() => void) | (() => void)[]) | undefined;

  218.             updated?: ((() => void) | (() => void)[]) | undefined;

  219.             activated?: ((() => void) | (() => void)[]) | undefined;

  220.             deactivated?: ((() => void) | (() => void)[]) | undefined;

  221.             beforeDestroy?: ((() => void) | (() => void)[]) | undefined;

  222.             beforeUnmount?: ((() => void) | (() => void)[]) | undefined;

  223.             destroyed?: ((() => void) | (() => void)[]) | undefined;

  224.             unmounted?: ((() => void) | (() => void)[]) | undefined;

  225.             renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;

  226.             renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;

  227.             errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>> | null, info: string) => boolean | void)[]) | undefined;

  228.         };

  229.         $forceUpdate: () => void;

  230.         $nextTick: typeof import("vue").nextTick;

  231.         $watch(source: string | Function, cb: Function, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;

  232.     } & Readonly<import("vue").ExtractPropTypes<{

  233.         readonly always: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  234.         readonly width: StringConstructor;

  235.         readonly height: StringConstructor;

  236.         readonly ratioX: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;

  237.         readonly ratioY: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;

  238.     }>> & import("vue").ShallowUnwrapRef<{

  239.         props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  240.             readonly always: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  241.             readonly width: StringConstructor;

  242.             readonly height: StringConstructor;

  243.             readonly ratioX: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;

  244.             readonly ratioY: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;

  245.         }>> & {

  246.             [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;

  247.         }>>;

  248.         moveX: import("vue").Ref<number>;

  249.         moveY: import("vue").Ref<number>;

  250.         handleScroll: (wrap: HTMLDivElement) => void;

  251.         Thumb: import("vue").DefineComponent<{

  252.             readonly vertical: BooleanConstructor;

  253.             readonly size: StringConstructor;

  254.             readonly move: NumberConstructor;

  255.             readonly ratio: {

  256.                 readonly type: import("vue").PropType<number>;

  257.                 readonly required: true;

  258.                 readonly validator: ((val: unknown) => boolean) | undefined;

  259.                 __epPropKey: true;

  260.             };

  261.             readonly always: BooleanConstructor;

  262.         }, {

  263.             COMPONENT_NAME: string;

  264.             props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  265.                 readonly vertical: BooleanConstructor;

  266.                 readonly size: StringConstructor;

  267.                 readonly move: NumberConstructor;

  268.                 readonly ratio: {

  269.                     readonly type: import("vue").PropType<number>;

  270.                     readonly required: true;

  271.                     readonly validator: ((val: unknown) => boolean) | undefined;

  272.                     __epPropKey: true;

  273.                 };

  274.                 readonly always: BooleanConstructor;

  275.             }>> & {

  276.                 [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;

  277.             }>>;

  278.             scrollbar: import("./src/constants").ScrollbarContext;

  279.             ns: {

  280.                 namespace: import("vue").ComputedRef<string>;

  281.                 b: (blockSuffix?: string) => string;

  282.                 e: (element?: string | undefined) => string;

  283.                 m: (modifier?: string | undefined) => string;

  284.                 be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  285.                 em: (element?: string | undefined, modifier?: string | undefined) => string;

  286.                 bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  287.                 bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  288.                 is: {

  289.                     (name: string, state: boolean | undefined): string;

  290.                     (name: string): string;

  291.                 };

  292.                 cssVar: (object: Record<string, string>) => Record<string, string>;

  293.                 cssVarName: (name: string) => string;

  294.                 cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  295.                 cssVarBlockName: (name: string) => string;

  296.             };

  297.             instance: import("vue").Ref<HTMLDivElement | undefined>;

  298.             thumb: import("vue").Ref<HTMLDivElement | undefined>;

  299.             thumbState: import("vue").Ref<{

  300.                 X?: number | undefined;

  301.                 Y?: number | undefined;

  302.             }>;

  303.             visible: import("vue").Ref<boolean>;

  304.             cursorDown: boolean;

  305.             cursorLeave: boolean;

  306.             originalOnSelectStart: ((this: GlobalEventHandlers, ev: Event) => any) | null;

  307.             bar: import("vue").ComputedRef<{

  308.                 readonly offset: "offsetHeight";

  309.                 readonly scroll: "scrollTop";

  310.                 readonly scrollSize: "scrollHeight";

  311.                 readonly size: "height";

  312.                 readonly key: "vertical";

  313.                 readonly axis: "Y";

  314.                 readonly client: "clientY";

  315.                 readonly direction: "top";

  316.             } | {

  317.                 readonly offset: "offsetWidth";

  318.                 readonly scroll: "scrollLeft";

  319.                 readonly scrollSize: "scrollWidth";

  320.                 readonly size: "width";

  321.                 readonly key: "horizontal";

  322.                 readonly axis: "X";

  323.                 readonly client: "clientX";

  324.                 readonly direction: "left";

  325.             }>;

  326.             thumbStyle: import("vue").ComputedRef<import("vue").CSSProperties>;

  327.             offsetRatio: import("vue").ComputedRef<number>;

  328.             clickThumbHandler: (e: MouseEvent) => void;

  329.             clickTrackHandler: (e: MouseEvent) => void;

  330.             startDrag: (e: MouseEvent) => void;

  331.             mouseMoveDocumentHandler: (e: MouseEvent) => void;

  332.             mouseUpDocumentHandler: () => void;

  333.             mouseMoveScrollbarHandler: () => void;

  334.             mouseLeaveScrollbarHandler: () => void;

  335.             restoreOnselectstart: () => void;

  336.         }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  337.             readonly vertical: BooleanConstructor;

  338.             readonly size: StringConstructor;

  339.             readonly move: NumberConstructor;

  340.             readonly ratio: {

  341.                 readonly type: import("vue").PropType<number>;

  342.                 readonly required: true;

  343.                 readonly validator: ((val: unknown) => boolean) | undefined;

  344.                 __epPropKey: true;

  345.             };

  346.             readonly always: BooleanConstructor;

  347.         }>>, {

  348.             readonly vertical: boolean;

  349.             readonly always: boolean;

  350.         }>;

  351.     }> & {} & import("vue").ComponentCustomProperties) | undefined>;

  352.     ratioY: import("vue").Ref<number>;

  353.     ratioX: import("vue").Ref<number>;

  354.     style: import("vue").ComputedRef<import("vue").StyleValue>;

  355.     wrapKls: import("vue").ComputedRef<(string | unknown[] | {

  356.         [x: string]: boolean;

  357.     })[]>;

  358.     resizeKls: import("vue").ComputedRef<import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>[]>;

  359.     handleScroll: () => void;

  360.     scrollTo: (arg1: unknown, arg2?: number | undefined) => void;

  361.     setScrollTop: (value: number) => void;

  362.     setScrollLeft: (value: number) => void;

  363.     update: () => void;

  364.     Bar: import("vue").DefineComponent<{

  365.         readonly always: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  366.         readonly width: StringConstructor;

  367.         readonly height: StringConstructor;

  368.         readonly ratioX: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;

  369.         readonly ratioY: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;

  370.     }, {

  371.         props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  372.             readonly always: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  373.             readonly width: StringConstructor;

  374.             readonly height: StringConstructor;

  375.             readonly ratioX: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;

  376.             readonly ratioY: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;

  377.         }>> & {

  378.             [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;

  379.         }>>;

  380.         moveX: import("vue").Ref<number>;

  381.         moveY: import("vue").Ref<number>;

  382.         handleScroll: (wrap: HTMLDivElement) => void;

  383.         Thumb: import("vue").DefineComponent<{

  384.             readonly vertical: BooleanConstructor;

  385.             readonly size: StringConstructor;

  386.             readonly move: NumberConstructor;

  387.             readonly ratio: {

  388.                 readonly type: import("vue").PropType<number>;

  389.                 readonly required: true;

  390.                 readonly validator: ((val: unknown) => boolean) | undefined;

  391.                 __epPropKey: true;

  392.             };

  393.             readonly always: BooleanConstructor;

  394.         }, {

  395.             COMPONENT_NAME: string;

  396.             props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{

  397.                 readonly vertical: BooleanConstructor;

  398.                 readonly size: StringConstructor;

  399.                 readonly move: NumberConstructor;

  400.                 readonly ratio: {

  401.                     readonly type: import("vue").PropType<number>;

  402.                     readonly required: true;

  403.                     readonly validator: ((val: unknown) => boolean) | undefined;

  404.                     __epPropKey: true;

  405.                 };

  406.                 readonly always: BooleanConstructor;

  407.             }>> & {

  408.                 [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;

  409.             }>>;

  410.             scrollbar: import("./src/constants").ScrollbarContext;

  411.             ns: {

  412.                 namespace: import("vue").ComputedRef<string>;

  413.                 b: (blockSuffix?: string) => string;

  414.                 e: (element?: string | undefined) => string;

  415.                 m: (modifier?: string | undefined) => string;

  416.                 be: (blockSuffix?: string | undefined, element?: string | undefined) => string;

  417.                 em: (element?: string | undefined, modifier?: string | undefined) => string;

  418.                 bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;

  419.                 bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;

  420.                 is: {

  421.                     (name: string, state: boolean | undefined): string;

  422.                     (name: string): string;

  423.                 };

  424.                 cssVar: (object: Record<string, string>) => Record<string, string>;

  425.                 cssVarName: (name: string) => string;

  426.                 cssVarBlock: (object: Record<string, string>) => Record<string, string>;

  427.                 cssVarBlockName: (name: string) => string;

  428.             };

  429.             instance: import("vue").Ref<HTMLDivElement | undefined>;

  430.             thumb: import("vue").Ref<HTMLDivElement | undefined>;

  431.             thumbState: import("vue").Ref<{

  432.                 X?: number | undefined;

  433.                 Y?: number | undefined;

  434.             }>;

  435.             visible: import("vue").Ref<boolean>;

  436.             cursorDown: boolean;

  437.             cursorLeave: boolean;

  438.             originalOnSelectStart: ((this: GlobalEventHandlers, ev: Event) => any) | null;

  439.             bar: import("vue").ComputedRef<{

  440.                 readonly offset: "offsetHeight";

  441.                 readonly scroll: "scrollTop";

  442.                 readonly scrollSize: "scrollHeight";

  443.                 readonly size: "height";

  444.                 readonly key: "vertical";

  445.                 readonly axis: "Y";

  446.                 readonly client: "clientY";

  447.                 readonly direction: "top";

  448.             } | {

  449.                 readonly offset: "offsetWidth";

  450.                 readonly scroll: "scrollLeft";

  451.                 readonly scrollSize: "scrollWidth";

  452.                 readonly size: "width";

  453.                 readonly key: "horizontal";

  454.                 readonly axis: "X";

  455.                 readonly client: "clientX";

  456.                 readonly direction: "left";

  457.             }>;

  458.             thumbStyle: import("vue").ComputedRef<import("vue").CSSProperties>;

  459.             offsetRatio: import("vue").ComputedRef<number>;

  460.             clickThumbHandler: (e: MouseEvent) => void;

  461.             clickTrackHandler: (e: MouseEvent) => void;

  462.             startDrag: (e: MouseEvent) => void;

  463.             mouseMoveDocumentHandler: (e: MouseEvent) => void;

  464.             mouseUpDocumentHandler: () => void;

  465.             mouseMoveScrollbarHandler: () => void;

  466.             mouseLeaveScrollbarHandler: () => void;

  467.             restoreOnselectstart: () => void;

  468.         }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  469.             readonly vertical: BooleanConstructor;

  470.             readonly size: StringConstructor;

  471.             readonly move: NumberConstructor;

  472.             readonly ratio: {

  473.                 readonly type: import("vue").PropType<number>;

  474.                 readonly required: true;

  475.                 readonly validator: ((val: unknown) => boolean) | undefined;

  476.                 __epPropKey: true;

  477.             };

  478.             readonly always: BooleanConstructor;

  479.         }>>, {

  480.             readonly vertical: boolean;

  481.             readonly always: boolean;

  482.         }>;

  483.     }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  484.         readonly always: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;

  485.         readonly width: StringConstructor;

  486.         readonly height: StringConstructor;

  487.         readonly ratioX: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;

  488.         readonly ratioY: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 1, boolean>;

  489.     }>>, {

  490.         readonly always: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  491.         readonly ratioX: number;

  492.         readonly ratioY: number;

  493.     }>;

  494. }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {

  495.     scroll: ({ scrollTop, scrollLeft, }: {

  496.         scrollTop: number;

  497.         scrollLeft: number;

  498.     }) => boolean;

  499. }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{

  500.     readonly height: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;

  501.     readonly maxHeight: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;

  502.     readonly native: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;

  503.     readonly wrapStyle: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue) | ((new (...args: any[]) => import("vue").StyleValue & {}) | (() => import("vue").StyleValue))[], unknown, unknown, "", boolean>;

  504.     readonly wrapClass: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;

  505.     readonly viewClass: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;

  506.     readonly viewStyle: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor, ObjectConstructor], unknown, unknown, "", boolean>;

  507.     readonly noresize: BooleanConstructor;

  508.     readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;

  509.     readonly always: BooleanConstructor;

  510.     readonly minSize: import("element-plus/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 20, boolean>;

  511. }>> & {

  512.     onScroll?: ((args_0: {

  513.         scrollTop: number;

  514.         scrollLeft: number;

  515.     }) => any) | undefined;

  516. }, {

  517.     readonly height: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;

  518.     readonly always: boolean;

  519.     readonly maxHeight: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;

  520.     readonly native: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;

  521.     readonly wrapStyle: import("vue").StyleValue;

  522.     readonly wrapClass: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;

  523.     readonly viewClass: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;

  524.     readonly viewStyle: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, ArrayConstructor, ObjectConstructor], unknown, unknown>;

  525.     readonly tag: string;

  526.     readonly minSize: number;

  527.     readonly noresize: boolean;

  528. }>> & Record<string, any>;

  529. export default ElScrollbar;

  530. export * from './src/util';

  531. export * from './src/scrollbar';

  532. export * from './src/thumb';

  533. export * from './src/constants';