CPL
/
banboshi_V2
1
0
Форкнуть 0
Код Задачи 0 Pull Request'ы 0 Релизы 1 Вики Активность
版博士V2.0程序
Вы не можете выбрать более 25 тем Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.
61 коммит
5 Ветки
6.2 GiB
 
 
 
 
Дерево: d271ad1b21
Ветки Теги
${ item.name }
Создать ветку ${ searchTerm }
из 'd271ad1b21'
${ noResults }
banboshi_V2/HalftoneWeb/node_modules/element-plus/lib/components/input/index.d.ts

415 строки
31 KiB
Исходник Вина История 

  1. import Input from './src/input.vue';

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

  3.     readonly id: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;

  4.     readonly size: {

  5.         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  6.         readonly required: false;

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

  8.         __epPropKey: true;

  9.     };

  10.     readonly disabled: BooleanConstructor;

  11.     readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown, "", boolean>;

  12.     readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "text", boolean>;

  13.     readonly resize: {

  14.         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "none" | "both" | "horizontal" | "vertical", unknown>>;

  15.         readonly required: false;

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

  17.         __epPropKey: true;

  18.     };

  19.     readonly autosize: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/input").InputAutoSize & {}) | (() => import("./src/input").InputAutoSize) | ((new (...args: any[]) => import("./src/input").InputAutoSize & {}) | (() => import("./src/input").InputAutoSize))[], unknown, unknown, false, boolean>;

  20.     readonly autocomplete: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "off", boolean>;

  21.     readonly formatter: {

  22.         readonly type: import("vue").PropType<Function>;

  23.         readonly required: false;

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

  25.         __epPropKey: true;

  26.     };

  27.     readonly parser: {

  28.         readonly type: import("vue").PropType<Function>;

  29.         readonly required: false;

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

  31.         __epPropKey: true;

  32.     };

  33.     readonly placeholder: {

  34.         readonly type: import("vue").PropType<string>;

  35.         readonly required: false;

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

  37.         __epPropKey: true;

  38.     };

  39.     readonly form: {

  40.         readonly type: import("vue").PropType<string>;

  41.         readonly required: false;

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

  43.         __epPropKey: true;

  44.     };

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

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

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

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

  49.     readonly suffixIcon: {

  50.         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;

  51.         readonly required: false;

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

  53.         __epPropKey: true;

  54.     };

  55.     readonly prefixIcon: {

  56.         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;

  57.         readonly required: false;

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

  59.         __epPropKey: true;

  60.     };

  61.     readonly containerRole: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;

  62.     readonly label: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;

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

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

  65.     readonly inputStyle: 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, () => import("element-plus/es/utils").Mutable<{}>, boolean>;

  66. }, {

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

  68.         readonly id: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;

  69.         readonly size: {

  70.             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  71.             readonly required: false;

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

  73.             __epPropKey: true;

  74.         };

  75.         readonly disabled: BooleanConstructor;

  76.         readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown, "", boolean>;

  77.         readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "text", boolean>;

  78.         readonly resize: {

  79.             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "none" | "both" | "horizontal" | "vertical", unknown>>;

  80.             readonly required: false;

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

  82.             __epPropKey: true;

  83.         };

  84.         readonly autosize: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/input").InputAutoSize & {}) | (() => import("./src/input").InputAutoSize) | ((new (...args: any[]) => import("./src/input").InputAutoSize & {}) | (() => import("./src/input").InputAutoSize))[], unknown, unknown, false, boolean>;

  85.         readonly autocomplete: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "off", boolean>;

  86.         readonly formatter: {

  87.             readonly type: import("vue").PropType<Function>;

  88.             readonly required: false;

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

  90.             __epPropKey: true;

  91.         };

  92.         readonly parser: {

  93.             readonly type: import("vue").PropType<Function>;

  94.             readonly required: false;

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

  96.             __epPropKey: true;

  97.         };

  98.         readonly placeholder: {

  99.             readonly type: import("vue").PropType<string>;

  100.             readonly required: false;

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

  102.             __epPropKey: true;

  103.         };

  104.         readonly form: {

  105.             readonly type: import("vue").PropType<string>;

  106.             readonly required: false;

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

  108.             __epPropKey: true;

  109.         };

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

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

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

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

  114.         readonly suffixIcon: {

  115.             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;

  116.             readonly required: false;

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

  118.             __epPropKey: true;

  119.         };

  120.         readonly prefixIcon: {

  121.             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;

  122.             readonly required: false;

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

  124.             __epPropKey: true;

  125.         };

  126.         readonly containerRole: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;

  127.         readonly label: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;

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

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

  130.         readonly inputStyle: 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, () => import("element-plus/es/utils").Mutable<{}>, boolean>;

  131.     }>> & {

  132.         onChange?: ((value: string) => any) | undefined;

  133.         "onUpdate:modelValue"?: ((value: string) => any) | undefined;

  134.         onInput?: ((value: string) => any) | undefined;

  135.         onFocus?: ((evt: FocusEvent) => any) | undefined;

  136.         onBlur?: ((evt: FocusEvent) => any) | undefined;

  137.         onClear?: (() => any) | undefined;

  138.         onMouseleave?: ((evt: MouseEvent) => any) | undefined;

  139.         onMouseenter?: ((evt: MouseEvent) => any) | undefined;

  140.         onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;

  141.         onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;

  142.         onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;

  143.         onCompositionend?: ((evt: CompositionEvent) => any) | undefined;

  144.     }>>;

  145.     emit: ((event: "update:modelValue", value: string) => void) & ((event: "change", value: string) => void) & ((event: "input", value: string) => void) & ((event: "focus", evt: FocusEvent) => void) & ((event: "blur", evt: FocusEvent) => void) & ((event: "clear") => void) & ((event: "mouseleave", evt: MouseEvent) => void) & ((event: "mouseenter", evt: MouseEvent) => void) & ((event: "keydown", evt: Event | KeyboardEvent) => void) & ((event: "compositionstart", evt: CompositionEvent) => void) & ((event: "compositionupdate", evt: CompositionEvent) => void) & ((event: "compositionend", evt: CompositionEvent) => void);

  146.     rawAttrs: {

  147.         [x: string]: unknown;

  148.     };

  149.     slots: Readonly<{

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

  151.     }>;

  152.     containerAttrs: import("vue").ComputedRef<Record<string, unknown>>;

  153.     containerKls: import("vue").ComputedRef<unknown[]>;

  154.     wrapperKls: import("vue").ComputedRef<string[]>;

  155.     attrs: import("vue").ComputedRef<Record<string, unknown>>;

  156.     form: import("..").FormContext | undefined;

  157.     formItem: import("..").FormItemContext | undefined;

  158.     inputId: import("vue").Ref<string | undefined>;

  159.     inputSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;

  160.     inputDisabled: import("vue").ComputedRef<boolean>;

  161.     nsInput: {

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

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

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

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

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

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

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

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

  170.         is: {

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

  172.             (name: string): string;

  173.         };

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

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

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

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

  178.     };

  179.     nsTextarea: {

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

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

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

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

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

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

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

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

  188.         is: {

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

  190.             (name: string): string;

  191.         };

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

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

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

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

  196.     };

  197.     input: import("vue").ShallowRef<HTMLInputElement | undefined>;

  198.     textarea: import("vue").ShallowRef<HTMLTextAreaElement | undefined>;

  199.     focused: import("vue").Ref<boolean>;

  200.     hovering: import("vue").Ref<boolean>;

  201.     isComposing: import("vue").Ref<boolean>;

  202.     passwordVisible: import("vue").Ref<boolean>;

  203.     countStyle: import("vue").Ref<import("vue").StyleValue | undefined>;

  204.     textareaCalcStyle: import("vue").ShallowRef<import("vue").StyleValue>;

  205.     _ref: import("vue").ComputedRef<HTMLInputElement | HTMLTextAreaElement | undefined>;

  206.     needStatusIcon: import("vue").ComputedRef<boolean>;

  207.     validateState: import("vue").ComputedRef<"" | "success" | "error" | "validating">;

  208.     validateIcon: import("vue").ComputedRef<"" | import("vue").DefineComponent<{}, {}, {}, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>>;

  209.     passwordIcon: import("vue").ComputedRef<import("vue").DefineComponent<{}, {}, {}, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>>;

  210.     containerStyle: import("vue").ComputedRef<import("vue").StyleValue>;

  211.     textareaStyle: import("vue").ComputedRef<import("vue").StyleValue>;

  212.     nativeInputValue: import("vue").ComputedRef<string>;

  213.     showClear: import("vue").ComputedRef<boolean>;

  214.     showPwdVisible: import("vue").ComputedRef<boolean>;

  215.     isWordLimitVisible: import("vue").ComputedRef<boolean>;

  216.     textLength: import("vue").ComputedRef<number>;

  217.     inputExceed: import("vue").ComputedRef<boolean>;

  218.     suffixVisible: import("vue").ComputedRef<boolean>;

  219.     recordCursor: () => void;

  220.     setCursor: () => void;

  221.     resizeTextarea: () => void;

  222.     createOnceInitResize: (resizeTextarea: () => void) => () => void;

  223.     onceInitSizeTextarea: () => void;

  224.     setNativeInputValue: () => void;

  225.     handleInput: (event: Event) => Promise<void>;

  226.     handleChange: (event: Event) => void;

  227.     handleCompositionStart: (event: CompositionEvent) => void;

  228.     handleCompositionUpdate: (event: CompositionEvent) => void;

  229.     handleCompositionEnd: (event: CompositionEvent) => void;

  230.     handlePasswordVisible: () => void;

  231.     focus: () => Promise<void>;

  232.     blur: () => void | undefined;

  233.     handleFocus: (event: FocusEvent) => void;

  234.     handleBlur: (event: FocusEvent) => void;

  235.     handleMouseLeave: (evt: MouseEvent) => void;

  236.     handleMouseEnter: (evt: MouseEvent) => void;

  237.     handleKeydown: (evt: KeyboardEvent) => void;

  238.     select: () => void;

  239.     clear: () => void;

  240.     ElIcon: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{

  241.         readonly size: {

  242.             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;

  243.             readonly required: false;

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

  245.             __epPropKey: true;

  246.         };

  247.         readonly color: {

  248.             readonly type: import("vue").PropType<string>;

  249.             readonly required: false;

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

  251.             __epPropKey: true;

  252.         };

  253.     }, {

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

  255.             readonly size: {

  256.                 readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;

  257.                 readonly required: false;

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

  259.                 __epPropKey: true;

  260.             };

  261.             readonly color: {

  262.                 readonly type: import("vue").PropType<string>;

  263.                 readonly required: false;

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

  265.                 __epPropKey: true;

  266.             };

  267.         }>> & {

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

  269.         }>>;

  270.         ns: {

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

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

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

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

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

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

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

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

  279.             is: {

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

  281.                 (name: string): string;

  282.             };

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

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

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

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

  287.         };

  288.         style: import("vue").ComputedRef<import("vue").CSSProperties>;

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

  290.         readonly size: {

  291.             readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;

  292.             readonly required: false;

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

  294.             __epPropKey: true;

  295.         };

  296.         readonly color: {

  297.             readonly type: import("vue").PropType<string>;

  298.             readonly required: false;

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

  300.             __epPropKey: true;

  301.         };

  302.     }>>, {}>> & Record<string, any>;

  303.     CircleClose: import("vue").DefineComponent<{}, {}, {}, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;

  304.     NOOP: () => void;

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

  306.     "update:modelValue": (value: string) => boolean;

  307.     input: (value: string) => boolean;

  308.     change: (value: string) => boolean;

  309.     focus: (evt: FocusEvent) => boolean;

  310.     blur: (evt: FocusEvent) => boolean;

  311.     clear: () => boolean;

  312.     mouseleave: (evt: MouseEvent) => boolean;

  313.     mouseenter: (evt: MouseEvent) => boolean;

  314.     keydown: (evt: Event | KeyboardEvent) => boolean;

  315.     compositionstart: (evt: CompositionEvent) => boolean;

  316.     compositionupdate: (evt: CompositionEvent) => boolean;

  317.     compositionend: (evt: CompositionEvent) => boolean;

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

  319.     readonly id: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;

  320.     readonly size: {

  321.         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;

  322.         readonly required: false;

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

  324.         __epPropKey: true;

  325.     };

  326.     readonly disabled: BooleanConstructor;

  327.     readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown, "", boolean>;

  328.     readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "text", boolean>;

  329.     readonly resize: {

  330.         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "none" | "both" | "horizontal" | "vertical", unknown>>;

  331.         readonly required: false;

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

  333.         __epPropKey: true;

  334.     };

  335.     readonly autosize: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./src/input").InputAutoSize & {}) | (() => import("./src/input").InputAutoSize) | ((new (...args: any[]) => import("./src/input").InputAutoSize & {}) | (() => import("./src/input").InputAutoSize))[], unknown, unknown, false, boolean>;

  336.     readonly autocomplete: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "off", boolean>;

  337.     readonly formatter: {

  338.         readonly type: import("vue").PropType<Function>;

  339.         readonly required: false;

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

  341.         __epPropKey: true;

  342.     };

  343.     readonly parser: {

  344.         readonly type: import("vue").PropType<Function>;

  345.         readonly required: false;

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

  347.         __epPropKey: true;

  348.     };

  349.     readonly placeholder: {

  350.         readonly type: import("vue").PropType<string>;

  351.         readonly required: false;

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

  353.         __epPropKey: true;

  354.     };

  355.     readonly form: {

  356.         readonly type: import("vue").PropType<string>;

  357.         readonly required: false;

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

  359.         __epPropKey: true;

  360.     };

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

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

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

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

  365.     readonly suffixIcon: {

  366.         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;

  367.         readonly required: false;

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

  369.         __epPropKey: true;

  370.     };

  371.     readonly prefixIcon: {

  372.         readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>))[], unknown, unknown>>;

  373.         readonly required: false;

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

  375.         __epPropKey: true;

  376.     };

  377.     readonly containerRole: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;

  378.     readonly label: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;

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

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

  381.     readonly inputStyle: 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, () => import("element-plus/es/utils").Mutable<{}>, boolean>;

  382. }>> & {

  383.     onChange?: ((value: string) => any) | undefined;

  384.     "onUpdate:modelValue"?: ((value: string) => any) | undefined;

  385.     onInput?: ((value: string) => any) | undefined;

  386.     onFocus?: ((evt: FocusEvent) => any) | undefined;

  387.     onBlur?: ((evt: FocusEvent) => any) | undefined;

  388.     onClear?: (() => any) | undefined;

  389.     onMouseleave?: ((evt: MouseEvent) => any) | undefined;

  390.     onMouseenter?: ((evt: MouseEvent) => any) | undefined;

  391.     onKeydown?: ((evt: Event | KeyboardEvent) => any) | undefined;

  392.     onCompositionstart?: ((evt: CompositionEvent) => any) | undefined;

  393.     onCompositionupdate?: ((evt: CompositionEvent) => any) | undefined;

  394.     onCompositionend?: ((evt: CompositionEvent) => any) | undefined;

  395. }, {

  396.     readonly type: string;

  397.     readonly modelValue: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined) | ((new (...args: any[]) => (string | number | null | undefined) & {}) | (() => string | number | null | undefined))[], unknown, unknown>;

  398.     readonly label: string;

  399.     readonly id: string;

  400.     readonly disabled: boolean;

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

  402.     readonly autosize: import("./src/input").InputAutoSize;

  403.     readonly autocomplete: string;

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

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

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

  407.     readonly containerRole: string;

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

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

  410.     readonly inputStyle: import("vue").StyleValue;

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

  412. export default ElInput;

  413. export * from './src/input';

  414. export declare type InputInstance = InstanceType<typeof Input>;