@antdv-next/mobile 0.0.0-stage → 0.1.1

package/dist/input/InputPassword.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,219 @@
+import { isRenderable } from "../_util/index.js";
+import { useControlled } from "../_util/hooks/useControlled.js";
+import RenderNode_default from "../_util/RenderNode.js";
+import { useDisabled } from "../config-provider/context.js";
+import Input_default from "./Input.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { computed, createBlock, createCommentVNode, createElementBlock, createSlots, createVNode, defineComponent, mergeProps, openBlock, ref, renderSlot, unref, useSlots, withCtx, withKeys, withModifiers } from "vue";
+import { EyeInvisibleOutlined, EyeOutlined } from "@antdv-next/icons";
+// src/input/InputPassword.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = [
+	"tabindex",
+	"aria-pressed",
+	"aria-disabled",
+	"onKeydown"
+];
+var InputPassword_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmInputPassword",
+	inheritAttrs: false,
+	__name: "InputPassword",
+	props: {
+		value: { default: void 0 },
+		defaultValue: {},
+		placeholder: {},
+		disabled: {
+			type: Boolean,
+			default: void 0
+		},
+		readOnly: { type: Boolean },
+		readonly: { type: Boolean },
+		maxlength: {},
+		showCount: {
+			type: [Boolean, Object],
+			default: false
+		},
+		allowClear: {
+			type: [Boolean, Object],
+			default: false
+		},
+		clearTrigger: { default: "focus" },
+		prefix: {
+			type: [
+				Object,
+				String,
+				Number,
+				Boolean,
+				null,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		suffix: {
+			type: [
+				Object,
+				String,
+				Number,
+				Boolean,
+				null,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		size: {},
+		status: {},
+		variant: {},
+		inputmode: {},
+		enterkeyhint: {},
+		autofocus: { type: Boolean },
+		autocomplete: {},
+		name: {},
+		id: {},
+		align: {},
+		visibilityToggle: {
+			type: Boolean,
+			default: true
+		},
+		iconVisible: {
+			type: Boolean,
+			default: void 0
+		},
+		iconRender: {},
+		rootClass: {},
+		classes: {},
+		styles: {}
+	},
+	emits: [
+		"update:value",
+		"update:iconVisible",
+		"change",
+		"input",
+		"pressEnter",
+		"focus",
+		"blur",
+		"clear"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const slots = useSlots();
+		const disabled = useDisabled(() => props.disabled);
+		const rootRef = ref();
+		const [visible, setVisible] = useControlled(props, "iconVisible", {
+			defaultValue: false,
+			onChange: (next) => emit("update:iconVisible", next)
+		});
+		function toggle() {
+			if (disabled.value) return;
+			setVisible(!visible.value);
+		}
+		const hasSuffix = computed(() => props.visibilityToggle || !!slots.suffix || isRenderable(props.suffix));
+		__expose({
+			focus: (options) => rootRef.value?.focus(options),
+			blur: () => rootRef.value?.blur(),
+			select: () => rootRef.value?.select(),
+			get input() {
+				return rootRef.value?.input;
+			},
+			get nativeElement() {
+				return rootRef.value?.nativeElement;
+			}
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(Input_default, mergeProps(_ctx.$attrs, {
+				id: __props.id,
+				ref_key: "rootRef",
+				ref: rootRef,
+				class: "am-input-password",
+				"root-class": __props.rootClass,
+				classes: __props.classes,
+				styles: __props.styles,
+				type: unref(visible) ? "text" : "password",
+				value: __props.value,
+				"default-value": __props.defaultValue,
+				placeholder: __props.placeholder,
+				disabled: unref(disabled),
+				"read-only": __props.readOnly || __props.readonly,
+				maxlength: __props.maxlength,
+				"show-count": __props.showCount,
+				"allow-clear": __props.allowClear,
+				"clear-trigger": __props.clearTrigger,
+				prefix: __props.prefix,
+				size: __props.size,
+				status: __props.status,
+				variant: __props.variant,
+				inputmode: __props.inputmode,
+				enterkeyhint: __props.enterkeyhint,
+				autofocus: __props.autofocus,
+				autocomplete: __props.autocomplete,
+				name: __props.name,
+				align: __props.align,
+				"onUpdate:value": _cache[1] || (_cache[1] = ($event) => emit("update:value", $event)),
+				onChange: _cache[2] || (_cache[2] = ($event) => emit("change", $event)),
+				onInput: _cache[3] || (_cache[3] = ($event) => emit("input", $event)),
+				onPressEnter: _cache[4] || (_cache[4] = ($event) => emit("pressEnter", $event)),
+				onFocus: _cache[5] || (_cache[5] = ($event) => emit("focus", $event)),
+				onBlur: _cache[6] || (_cache[6] = ($event) => emit("blur", $event)),
+				onClear: _cache[7] || (_cache[7] = ($event) => emit("clear"))
+			}), createSlots({ _: 2 }, [
+				_ctx.$slots.prefix ? {
+					name: "prefix",
+					fn: withCtx(() => [renderSlot(_ctx.$slots, "prefix")]),
+					key: "0"
+				} : void 0,
+				_ctx.$slots.clearIcon ? {
+					name: "clearIcon",
+					fn: withCtx(() => [renderSlot(_ctx.$slots, "clearIcon")]),
+					key: "1"
+				} : void 0,
+				hasSuffix.value ? {
+					name: "suffix",
+					fn: withCtx(() => [__props.visibilityToggle ? (openBlock(), createElementBlock("span", {
+						key: 0,
+						class: "am-input-password-icon",
+						role: "button",
+						tabindex: unref(disabled) ? -1 : 0,
+						"aria-pressed": unref(visible),
+						"aria-disabled": unref(disabled) || void 0,
+						onMousedown: _cache[0] || (_cache[0] = withModifiers(() => {}, ["prevent"])),
+						onClick: withModifiers(toggle, ["stop"]),
+						onKeydown: [withKeys(withModifiers(toggle, ["prevent"]), ["enter"]), withKeys(withModifiers(toggle, ["prevent"]), ["space"])]
+					}, [renderSlot(_ctx.$slots, "iconRender", { visible: unref(visible) }, () => [__props.iconRender ? (openBlock(), createBlock(unref(RenderNode_default), {
+						key: 0,
+						node: __props.iconRender,
+						params: { visible: unref(visible) }
+					}, null, 8, ["node", "params"])) : unref(visible) ? (openBlock(), createBlock(unref(EyeOutlined), { key: 1 })) : (openBlock(), createBlock(unref(EyeInvisibleOutlined), { key: 2 }))])], 40, _hoisted_1)) : createCommentVNode("", true), renderSlot(_ctx.$slots, "suffix", {}, () => [createVNode(unref(RenderNode_default), { node: __props.suffix }, null, 8, ["node"])])]),
+					key: "2"
+				} : void 0
+			]), 1040, [
+				"id",
+				"root-class",
+				"classes",
+				"styles",
+				"type",
+				"value",
+				"default-value",
+				"placeholder",
+				"disabled",
+				"read-only",
+				"maxlength",
+				"show-count",
+				"allow-clear",
+				"clear-trigger",
+				"prefix",
+				"size",
+				"status",
+				"variant",
+				"inputmode",
+				"enterkeyhint",
+				"autofocus",
+				"autocomplete",
+				"name",
+				"align"
+			]);
+		};
+	}
+});
+export { InputPassword_vue_vue_type_script_setup_true_lang_default as default };

package/dist/input/InputSearch.js

@@ -0,0 +1,4 @@
+import InputSearch_vue_vue_type_script_setup_true_lang_default from "./InputSearch.vue_vue_type_script_setup_true_lang.js";
+// src/input/InputSearch.vue
+var InputSearch_default = InputSearch_vue_vue_type_script_setup_true_lang_default;
+export { InputSearch_default as default };

package/dist/input/InputSearch.vue.d.ts

@@ -0,0 +1,63 @@
+import type { InputFocusOptions, InputSearchProps, InputSearchSlots } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = InputSearchSlots;
+declare const __VLS_base: import("vue").DefineComponent<InputSearchProps, {
+    focus: (options?: InputFocusOptions) => void | undefined;
+    blur: () => void | undefined;
+    select: () => void | undefined;
+    readonly input: HTMLInputElement | undefined;
+    readonly nativeElement: HTMLElement | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    input: (event: Event) => any;
+    search: (value: string, event?: Event | undefined, info?: import("./interface").InputSearchInfo | undefined) => any;
+    blur: (event: FocusEvent) => any;
+    cancel: () => any;
+    change: (event: Event) => any;
+    focus: (event: FocusEvent) => any;
+    clear: () => any;
+    "update:value": (value: string) => any;
+    pressEnter: (event: KeyboardEvent) => any;
+}, string, import("vue").PublicProps, Readonly<InputSearchProps> & Readonly<{
+    onInput?: ((event: Event) => any) | undefined;
+    onSearch?: ((value: string, event?: Event | undefined, info?: import("./interface").InputSearchInfo | undefined) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onCancel?: (() => any) | undefined;
+    onChange?: ((event: Event) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    "onUpdate:value"?: ((value: string) => any) | undefined;
+    onPressEnter?: ((event: KeyboardEvent) => any) | undefined;
+}>, {
+    round: boolean;
+    prefix: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+    disabled: boolean;
+    variant: import("../components.ts").FormVariant;
+    enterkeyhint: string;
+    inputmode: string;
+    value: string | number | null;
+    cancelText: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+    allowClear: boolean | import("./interface").InputAllowClearConfig;
+    suffix: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+    clearTrigger: import("./interface").InputClearTrigger;
+    enterButton: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+    searchIcon: string | number | boolean | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | import("vue").VNodeArrayChildren | (() => import("vue").VNodeChild) | null;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/input/InputSearch.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,309 @@
+import Spinner_default from "../_base/Spinner.js";
+import { provideNoCompact, useCompactItemContext } from "../_base/compact.js";
+import { isRenderable } from "../_util/index.js";
+import { useControlled } from "../_util/hooks/useControlled.js";
+import RenderNode_default from "../_util/RenderNode.js";
+import { useDisabled, useSize } from "../config-provider/context.js";
+import { useLocale } from "../locale/index.js";
+import Input_default from "./Input.js";
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createSlots, createTextVNode, createVNode, defineComponent, mergeProps, normalizeClass, normalizeStyle, openBlock, ref, renderSlot, toDisplayString, unref, useSlots, withCtx, withModifiers } from "vue";
+import { SearchOutlined } from "@antdv-next/icons";
+// src/input/InputSearch.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = {
+	key: 1,
+	class: "am-input-search-icon"
+};
+var _hoisted_2 = ["disabled"];
+var InputSearch_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmInputSearch",
+	inheritAttrs: false,
+	__name: "InputSearch",
+	props: {
+		value: { default: void 0 },
+		defaultValue: {},
+		placeholder: {},
+		disabled: {
+			type: Boolean,
+			default: void 0
+		},
+		readOnly: { type: Boolean },
+		readonly: { type: Boolean },
+		maxlength: {},
+		allowClear: {
+			type: [Boolean, Object],
+			default: true
+		},
+		clearTrigger: { default: "always" },
+		prefix: {
+			type: [
+				Object,
+				String,
+				Number,
+				Boolean,
+				null,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		suffix: {
+			type: [
+				Object,
+				String,
+				Number,
+				Boolean,
+				null,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		size: {},
+		status: {},
+		variant: { default: void 0 },
+		inputmode: { default: "search" },
+		enterkeyhint: { default: "search" },
+		autofocus: { type: Boolean },
+		autocomplete: {},
+		name: {},
+		id: {},
+		enterButton: {
+			type: [
+				Object,
+				String,
+				Number,
+				Boolean,
+				null,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		searchIcon: {
+			type: [
+				Object,
+				String,
+				Number,
+				Boolean,
+				null,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		loading: { type: Boolean },
+		showCancel: { type: Boolean },
+		cancelText: {
+			type: [
+				Object,
+				String,
+				Number,
+				Boolean,
+				null,
+				Array,
+				Function
+			],
+			default: void 0
+		},
+		round: {
+			type: Boolean,
+			default: void 0
+		},
+		rootClass: {},
+		classes: {},
+		styles: {}
+	},
+	emits: [
+		"update:value",
+		"change",
+		"input",
+		"pressEnter",
+		"focus",
+		"blur",
+		"clear",
+		"search",
+		"cancel"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const slots = useSlots();
+		const locale = useLocale("InputSearch");
+		const disabled = useDisabled(() => props.disabled);
+		const compact = useCompactItemContext();
+		provideNoCompact();
+		const size = useSize(() => props.size ?? compact.size.value);
+		const mergedVariant = computed(() => props.variant ?? (compact.inCompact.value ? "outlined" : "filled"));
+		const mergedRound = computed(() => props.round ?? !compact.inCompact.value);
+		const rootRef = ref();
+		const inputRef = ref();
+		const focused = ref(false);
+		const [rawValue, setRawValue] = useControlled(props, "value", {
+			defaultValue: () => props.defaultValue ?? "",
+			onChange: (value) => emit("update:value", String(value ?? ""))
+		});
+		const value = computed(() => String(rawValue.value ?? ""));
+		const hasEnterButton = computed(() => !!slots.enterButton || isRenderable(props.enterButton));
+		const customEnterButton = computed(() => props.enterButton === true ? void 0 : props.enterButton);
+		const cancelVisible = computed(() => props.showCancel && (focused.value || value.value !== ""));
+		function handleUpdate(next) {
+			if (next !== value.value) setRawValue(next);
+		}
+		function triggerSearch(event, source = "input", nextValue = value.value) {
+			if (disabled.value || props.loading) return;
+			emit("search", nextValue, event, { source });
+		}
+		function handlePressEnter(event) {
+			emit("pressEnter", event);
+			triggerSearch(event);
+			inputRef.value?.blur();
+		}
+		function handleClear() {
+			emit("clear");
+			triggerSearch(void 0, "clear", "");
+		}
+		function handleFocus(event) {
+			focused.value = true;
+			emit("focus", event);
+		}
+		function handleBlur(event) {
+			focused.value = false;
+			emit("blur", event);
+		}
+		function handleCancel() {
+			if (value.value !== "") setRawValue("");
+			inputRef.value?.blur();
+			emit("cancel");
+		}
+		const classNames = computed(() => [
+			"am-input-search",
+			{
+				"am-input-search-sm": size.value === "small",
+				"am-input-search-lg": size.value === "large",
+				"am-input-search-round": mergedRound.value,
+				"am-input-search-focused": focused.value,
+				"am-input-search-disabled": disabled.value
+			},
+			compact.classes.value,
+			props.rootClass,
+			props.classes?.root
+		]);
+		__expose({
+			focus: (options) => inputRef.value?.focus(options),
+			blur: () => inputRef.value?.blur(),
+			select: () => inputRef.value?.select(),
+			get input() {
+				return inputRef.value?.input;
+			},
+			get nativeElement() {
+				return rootRef.value;
+			}
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", mergeProps({
+				ref_key: "rootRef",
+				ref: rootRef
+			}, _ctx.$attrs, {
+				class: classNames.value,
+				style: __props.styles?.root,
+				role: "search"
+			}), [
+				createVNode(Input_default, {
+					id: __props.id,
+					ref_key: "inputRef",
+					ref: inputRef,
+					class: "am-input-search-input",
+					"root-class": __props.classes?.input,
+					styles: { root: __props.styles?.input },
+					type: "search",
+					value: value.value,
+					placeholder: __props.placeholder ?? unref(locale).placeholder,
+					disabled: unref(disabled),
+					"read-only": __props.readOnly || __props.readonly,
+					maxlength: __props.maxlength,
+					"allow-clear": __props.allowClear,
+					"clear-trigger": __props.clearTrigger,
+					suffix: __props.suffix,
+					size: unref(size),
+					status: __props.status,
+					variant: mergedVariant.value,
+					inputmode: __props.inputmode,
+					enterkeyhint: __props.enterkeyhint,
+					autofocus: __props.autofocus,
+					autocomplete: __props.autocomplete,
+					name: __props.name,
+					"onUpdate:value": handleUpdate,
+					onChange: _cache[0] || (_cache[0] = ($event) => emit("change", $event)),
+					onInput: _cache[1] || (_cache[1] = ($event) => emit("input", $event)),
+					onPressEnter: handlePressEnter,
+					onFocus: handleFocus,
+					onBlur: handleBlur,
+					onClear: handleClear
+				}, createSlots({
+					prefix: withCtx(() => [renderSlot(_ctx.$slots, "prefix", {}, () => [unref(isRenderable)(__props.prefix) ? (openBlock(), createBlock(unref(RenderNode_default), {
+						key: 0,
+						node: __props.prefix
+					}, null, 8, ["node"])) : (openBlock(), createElementBlock("span", _hoisted_1, [__props.loading ? (openBlock(), createBlock(unref(Spinner_default), { key: 0 })) : renderSlot(_ctx.$slots, "searchIcon", {}, () => [unref(isRenderable)(__props.searchIcon) ? (openBlock(), createBlock(unref(RenderNode_default), {
+						key: 0,
+						node: __props.searchIcon
+					}, null, 8, ["node"])) : (openBlock(), createBlock(unref(SearchOutlined), { key: 1 }))], void 0, 1)]))])]),
+					_: 2
+				}, [_ctx.$slots.suffix ? {
+					name: "suffix",
+					fn: withCtx(() => [renderSlot(_ctx.$slots, "suffix")]),
+					key: "0"
+				} : void 0, _ctx.$slots.clearIcon ? {
+					name: "clearIcon",
+					fn: withCtx(() => [renderSlot(_ctx.$slots, "clearIcon")]),
+					key: "1"
+				} : void 0]), 1032, [
+					"id",
+					"root-class",
+					"styles",
+					"value",
+					"placeholder",
+					"disabled",
+					"read-only",
+					"maxlength",
+					"allow-clear",
+					"clear-trigger",
+					"suffix",
+					"size",
+					"status",
+					"variant",
+					"inputmode",
+					"enterkeyhint",
+					"autofocus",
+					"autocomplete",
+					"name"
+				]),
+				hasEnterButton.value ? (openBlock(), createElementBlock("button", {
+					key: 0,
+					type: "button",
+					class: normalizeClass(["am-input-search-button", __props.classes?.button]),
+					style: normalizeStyle(__props.styles?.button),
+					disabled: unref(disabled) || __props.loading,
+					onMousedown: _cache[2] || (_cache[2] = withModifiers(() => {}, ["prevent"])),
+					onClick: _cache[3] || (_cache[3] = ($event) => triggerSearch($event))
+				}, [renderSlot(_ctx.$slots, "enterButton", {}, () => [customEnterButton.value !== void 0 ? (openBlock(), createBlock(unref(RenderNode_default), {
+					key: 0,
+					node: customEnterButton.value
+				}, null, 8, ["node"])) : (openBlock(), createBlock(unref(SearchOutlined), { key: 1 }))])], 46, _hoisted_2)) : createCommentVNode("", true),
+				cancelVisible.value ? (openBlock(), createElementBlock("button", {
+					key: 1,
+					type: "button",
+					class: normalizeClass(["am-input-search-cancel", __props.classes?.cancel]),
+					style: normalizeStyle(__props.styles?.cancel),
+					onMousedown: _cache[4] || (_cache[4] = withModifiers(() => {}, ["prevent"])),
+					onClick: handleCancel
+				}, [renderSlot(_ctx.$slots, "cancelText", {}, () => [unref(isRenderable)(__props.cancelText) ? (openBlock(), createBlock(unref(RenderNode_default), {
+					key: 0,
+					node: __props.cancelText
+				}, null, 8, ["node"])) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [createTextVNode(toDisplayString(unref(locale).cancelText), 1)], 64))])], 38)) : createCommentVNode("", true)
+			], 16);
+		};
+	}
+});
+export { InputSearch_vue_vue_type_script_setup_true_lang_default as default };

package/dist/input/TextArea.js

@@ -0,0 +1,4 @@
+import TextArea_vue_vue_type_script_setup_true_lang_default from "./TextArea.vue_vue_type_script_setup_true_lang.js";
+// src/input/TextArea.vue
+var TextArea_default = TextArea_vue_vue_type_script_setup_true_lang_default;
+export { TextArea_default as default };

package/dist/input/TextArea.vue.d.ts

@@ -0,0 +1,51 @@
+import type { TextAreaInstance, TextAreaProps, TextAreaSlots } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = TextAreaSlots;
+declare const __VLS_base: import("vue").DefineComponent<TextAreaProps, TextAreaInstance, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    input: (event: Event) => any;
+    blur: (event: FocusEvent) => any;
+    change: (event: Event) => any;
+    compositionend: (event: CompositionEvent) => any;
+    compositionstart: (event: CompositionEvent) => any;
+    focus: (event: FocusEvent) => any;
+    keydown: (event: KeyboardEvent) => any;
+    keyup: (event: KeyboardEvent) => any;
+    resize: (size: {
+        height: number;
+    }) => any;
+    clear: () => any;
+    "update:value": (value: string) => any;
+    pressEnter: (event: KeyboardEvent) => any;
+}, string, import("vue").PublicProps, Readonly<TextAreaProps> & Readonly<{
+    onInput?: ((event: Event) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onChange?: ((event: Event) => any) | undefined;
+    onCompositionend?: ((event: CompositionEvent) => any) | undefined;
+    onCompositionstart?: ((event: CompositionEvent) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+    onKeyup?: ((event: KeyboardEvent) => any) | undefined;
+    onResize?: ((size: {
+        height: number;
+    }) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    "onUpdate:value"?: ((value: string) => any) | undefined;
+    onPressEnter?: ((event: KeyboardEvent) => any) | undefined;
+}>, {
+    disabled: boolean;
+    value: string | number | null;
+    rows: number;
+    allowClear: boolean | import("./interface").InputAllowClearConfig;
+    showCount: boolean | import("./interface").InputShowCountConfig;
+    clearTrigger: import("./interface").InputClearTrigger;
+    autoSize: boolean | import("./interface").TextAreaAutoSize;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};