antdv-next 0.0.0 → 1.0.0-alpha.1

package/dist/input/Search.js

@@ -0,0 +1,325 @@
+import { useComponentBaseConfig } from "../config-provider/context.js";
+import { getAttrStyleAndClass, useMergeSemantic, useToArr, useToProps } from "../_util/hooks/useMergeSemantic.js";
+import "../_util/hooks/index.js";
+import { toPropsRefs } from "../_util/tools.js";
+import { useSize } from "../config-provider/hooks/useSize.js";
+import { useCompactItemContext } from "../space/Compact.js";
+import button_default from "../button/index.js";
+import { SpaceCompact } from "../space/index.js";
+import Input_default from "./Input.js";
+import search_default from "./style/search.js";
+import { cloneVNode, computed, createVNode, defineComponent, isVNode, mergeProps, shallowRef } from "vue";
+import { clsx } from "@v-c/util";
+import { SearchOutlined } from "@antdv-next/icons";
+import { omit } from "es-toolkit";
+import pickAttrs from "@v-c/util/dist/pickAttrs";
+
+//#region src/input/Search.tsx
+function _isSlot(s) {
+	return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
+}
+const schema = { button: { _default: "root" } };
+const omitInputKeys = [
+	"enterButton",
+	"loading",
+	"classes",
+	"styles",
+	"rootClass",
+	"prefixCls",
+	"inputPrefixCls"
+];
+const InternalSearch = /* @__PURE__ */ defineComponent((props, { slots, attrs, emit, expose }) => {
+	const composedRef = shallowRef(false);
+	const inputRef = shallowRef();
+	const { prefixCls, direction, class: contextClassName, style: contextStyle, classes: contextClassNames, styles: contextStyles, getPrefixCls } = useComponentBaseConfig("inputSearch", props, void 0, "input-search");
+	const inputPrefixCls = computed(() => getPrefixCls("input", props.inputPrefixCls));
+	const { classes, styles, size: customizeSize, disabled: customDisabled, variant } = toPropsRefs(props, "classes", "styles", "size", "disabled", "variant");
+	const [hashId, cssVarCls] = search_default(prefixCls);
+	const { compactSize } = useCompactItemContext(prefixCls, direction);
+	const mergedSize = useSize((ctx) => customizeSize.value ?? compactSize.value ?? ctx);
+	const mergedProps = computed(() => ({
+		...props,
+		enterButton: props.enterButton
+	}));
+	const [mergedClassNames, mergedStyles] = useMergeSemantic(useToArr(contextClassNames, classes), useToArr(contextStyles, styles), useToProps(mergedProps), computed(() => schema));
+	const handleSearch = (event, info) => {
+		emit("search", inputRef.value?.input?.value ?? "", event, info ?? { source: "input" });
+	};
+	const handleChange = (e) => {
+		if (e?.type === "click" && e?.target?.value !== void 0) handleSearch(e, { source: "clear" });
+		emit("change", e);
+	};
+	const handleCompositionStart = (e) => {
+		composedRef.value = true;
+		emit("compositionstart", e);
+	};
+	const handleCompositionEnd = (e) => {
+		composedRef.value = false;
+		emit("compositionend", e);
+	};
+	const handlePressEnter = (e) => {
+		if (composedRef.value || props.loading) return;
+		emit("pressEnter", e);
+		handleSearch(e);
+	};
+	const onMouseDown = (e) => {
+		if (document.activeElement === inputRef.value?.input) e.preventDefault();
+	};
+	const onSearchClick = (e) => {
+		handleSearch(e);
+	};
+	expose({
+		focus: (...args) => inputRef.value?.focus?.(...args),
+		blur: () => inputRef.value?.blur?.(),
+		input: computed(() => inputRef.value?.input ?? null)
+	});
+	return () => {
+		const { className, style, restAttrs } = getAttrStyleAndClass(attrs);
+		const rootAttrs = pickAttrs(restAttrs, { data: true });
+		const inputAttrs = { ...restAttrs };
+		Object.keys(rootAttrs).forEach((key) => {
+			delete inputAttrs[key];
+		});
+		const restInputProps = omit(props, omitInputKeys);
+		const mergedClassName = clsx(prefixCls.value, cssVarCls.value, {
+			[`${prefixCls.value}-rtl`]: direction.value === "rtl",
+			[`${prefixCls.value}-${mergedSize.value}`]: mergedSize.value,
+			[`${prefixCls.value}-with-button`]: !!props.enterButton
+		}, className, props.rootClass, contextClassName.value, mergedClassNames.value.root, hashId.value);
+		const mergedRootStyle = {
+			...mergedStyles.value.root,
+			...contextStyle.value,
+			...style
+		};
+		const btnPrefixCls = `${prefixCls.value}-btn`;
+		const btnClassName = clsx(btnPrefixCls, { [`${btnPrefixCls}-${variant.value}`]: variant.value });
+		const enterButtonValue = props.enterButton ?? false;
+		const isBooleanEnterButton = typeof enterButtonValue === "boolean";
+		const searchIcon = isBooleanEnterButton ? createVNode(SearchOutlined, null, null) : null;
+		const buttonChildren = isBooleanEnterButton ? void 0 : enterButtonValue;
+		let buttonNode;
+		const enterButtonNode = buttonChildren;
+		const isButtonVNode = isVNode(enterButtonNode);
+		const isAntdButton = isButtonVNode && Boolean(enterButtonNode.type?.__ANT_BUTTON);
+		const isNativeButton = isButtonVNode && enterButtonNode.type === "button";
+		if (isAntdButton || isNativeButton) buttonNode = cloneVNode(enterButtonNode, {
+			onMousedown: onMouseDown,
+			onClick: (e) => {
+				enterButtonNode?.props?.onClick?.(e);
+				onSearchClick(e);
+			},
+			class: clsx(enterButtonNode?.props?.class, btnClassName),
+			...isAntdButton ? {
+				loading: props.loading,
+				size: mergedSize.value
+			} : {}
+		});
+		else buttonNode = createVNode(button_default, {
+			"classes": mergedClassNames.value.button,
+			"styles": mergedStyles.value.button,
+			"class": btnClassName,
+			"color": props.enterButton ? "primary" : "default",
+			"size": mergedSize.value,
+			"disabled": customDisabled.value,
+			"loading": props.loading,
+			"icon": searchIcon,
+			"variant": variant.value === "borderless" || variant.value === "filled" || variant.value === "underlined" ? "text" : props.enterButton ? "solid" : void 0,
+			"onMousedown": onMouseDown,
+			"onClick": onSearchClick
+		}, _isSlot(buttonChildren) ? buttonChildren : { default: () => [buttonChildren] });
+		const inputClassNames = omit(mergedClassNames.value, ["root", "button"]);
+		const inputStyles = omit(mergedStyles.value, ["root", "button"]);
+		return createVNode(SpaceCompact, mergeProps({
+			"class": mergedClassName,
+			"style": mergedRootStyle
+		}, { hidden: props.hidden }, rootAttrs, { "size": mergedSize.value }), { default: () => [createVNode(Input_default, mergeProps(inputAttrs, restInputProps, {
+			"ref": inputRef,
+			"prefixCls": inputPrefixCls.value,
+			"size": mergedSize.value,
+			"disabled": customDisabled.value,
+			"classes": inputClassNames,
+			"styles": inputStyles,
+			"variant": variant.value,
+			"onChange": handleChange,
+			"onFocus": (e) => emit("focus", e),
+			"onBlur": (e) => emit("blur", e),
+			"onKeydown": (e) => emit("keydown", e),
+			"onKeyup": (e) => emit("keyup", e),
+			"onClear": () => {
+				emit("clear");
+				handleSearch(void 0, { source: "clear" });
+			},
+			"onCompositionstart": handleCompositionStart,
+			"onCompositionend": handleCompositionEnd,
+			"onPressEnter": handlePressEnter
+		}, { "onUpdate:value": (value) => emit("update:value", value) }), slots), buttonNode] });
+	};
+}, {
+	emits: [
+		"search",
+		"pressEnter",
+		"clear",
+		"change",
+		"blur",
+		"focus",
+		"keydown",
+		"keyup",
+		"compositionstart",
+		"compositionend",
+		"update:value"
+	],
+	props: {
+		inputPrefixCls: {
+			type: String,
+			required: false
+		},
+		on: { required: false },
+		enterButton: {
+			type: [
+				Boolean,
+				Function,
+				String,
+				Number,
+				null,
+				Object
+			],
+			required: false
+		},
+		loading: {
+			type: Boolean,
+			required: false
+		},
+		size: {
+			type: [String, null],
+			required: false
+		},
+		hidden: {
+			type: Boolean,
+			required: false
+		},
+		classes: {
+			type: [Object, Function],
+			required: false
+		},
+		styles: {
+			type: [Object, Function],
+			required: false
+		},
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		status: {
+			type: String,
+			required: false
+		},
+		addonBefore: {
+			type: [
+				Function,
+				Boolean,
+				String,
+				Number,
+				null,
+				Object
+			],
+			required: false
+		},
+		addonAfter: {
+			type: [
+				Function,
+				Boolean,
+				String,
+				Number,
+				null,
+				Object
+			],
+			required: false
+		},
+		bordered: {
+			type: Boolean,
+			required: false
+		},
+		variant: {
+			type: String,
+			required: false
+		},
+		prefixCls: {
+			type: String,
+			required: false
+		},
+		value: { required: false },
+		defaultValue: { required: false },
+		type: { required: false },
+		showCount: {
+			type: [Boolean, Object],
+			required: false
+		},
+		autoComplete: {
+			type: String,
+			required: false
+		},
+		htmlSize: {
+			type: Number,
+			required: false
+		},
+		placeholder: {
+			type: String,
+			required: false
+		},
+		count: { required: false },
+		maxlength: {
+			type: Number,
+			required: false
+		},
+		readonly: {
+			type: Boolean,
+			required: false
+		},
+		dataAttrs: { required: false },
+		components: { required: false },
+		prefix: {
+			type: [
+				Function,
+				Boolean,
+				String,
+				Number,
+				null,
+				Object
+			],
+			required: false
+		},
+		suffix: {
+			type: [
+				Function,
+				Boolean,
+				String,
+				Number,
+				null,
+				Object
+			],
+			required: false
+		},
+		allowClear: {
+			type: [Boolean, Object],
+			required: false
+		},
+		autoFocus: {
+			type: Boolean,
+			required: false
+		},
+		inputMode: {
+			type: String,
+			required: false
+		},
+		rootClass: {
+			type: String,
+			required: false
+		}
+	},
+	name: "AInputSearch",
+	inheritAttrs: false
+});
+var Search_default = InternalSearch;
+
+//#endregion
+export { Search_default as default };

package/dist/input/TextArea.d.ts

@@ -0,0 +1,55 @@
+import { SemanticClassNamesType, SemanticStylesType } from "../_util/hooks/useMergeSemantic.js";
+import "../_util/hooks/index.js";
+import { SizeType } from "../config-provider/SizeContext.js";
+import { InputStatus } from "../_util/statusUtils.js";
+import { ComponentBaseProps, Variant } from "../config-provider/context.js";
+import * as vue305 from "vue";
+import { SlotsType } from "vue";
+import { InputProps } from "@v-c/input";
+import { TextAreaProps } from "@v-c/textarea";
+
+//#region src/input/TextArea.d.ts
+type SemanticName = 'root' | 'textarea' | 'count';
+type TextAreaClassNamesType = SemanticClassNamesType<TextAreaProps$1, SemanticName>;
+type TextAreaStylesType = SemanticStylesType<TextAreaProps$1, SemanticName>;
+interface TextAreaRef {
+  resizableTextArea?: any;
+  focus: (...args: any[]) => void;
+  blur: () => void;
+}
+interface TextAreaProps$1 extends ComponentBaseProps, Omit<TextAreaProps, 'classNames' | 'styles' | 'onChange' | 'onFocus' | 'onBlur' | 'onCompositionStart' | 'onCompositionEnd' | 'onKeydown' | 'onPressEnter' | 'onResize' | 'maxLength' | 'readOnly' | 'minLength'> {
+  /** @deprecated Use `variant` instead */
+  bordered?: boolean;
+  size?: SizeType;
+  status?: InputStatus;
+  /** @since 5.13.0 */
+  variant?: Variant;
+  classes?: TextAreaClassNamesType;
+  styles?: TextAreaStylesType;
+  rows?: number;
+  maxlength?: number;
+  minlength?: number;
+  readonly?: boolean;
+  showCount?: InputProps['showCount'];
+}
+interface TextAreaEmits {
+  'pressEnter': NonNullable<TextAreaProps['onPressEnter']>;
+  'change': NonNullable<TextAreaProps['onChange']>;
+  'focus': (e: FocusEvent) => void;
+  'blur': (e: FocusEvent) => void;
+  'resize': NonNullable<TextAreaProps['onResize']>;
+  'keydown': (e: KeyboardEvent) => void;
+  'compositionstart': (e: CompositionEvent) => void;
+  'compositionend': (e: CompositionEvent) => void;
+  'mousedown': (e: MouseEvent) => void;
+  'update:value': (value?: string | number) => void;
+  [key: string]: (...args: any[]) => any;
+}
+interface TextAreaSlots {
+  default?: () => any;
+}
+declare const InternalTextArea: vue305.DefineSetupFnComponent<TextAreaProps$1, TextAreaEmits, SlotsType<TextAreaSlots>, TextAreaProps$1 & {
+  [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, vue305.PublicProps>;
+//#endregion
+export { InternalTextArea, TextAreaProps$1 as TextAreaProps, TextAreaRef };

package/dist/input/TextArea.js

@@ -0,0 +1,264 @@
+import { useComponentBaseConfig } from "../config-provider/context.js";
+import { getAttrStyleAndClass, useMergeSemantic, useToArr, useToProps } from "../_util/hooks/useMergeSemantic.js";
+import { devUseWarning, isDev } from "../_util/warning.js";
+import "../_util/hooks/index.js";
+import { toPropsRefs } from "../_util/tools.js";
+import useCSSVarCls_default from "../config-provider/hooks/useCSSVarCls.js";
+import { useSize } from "../config-provider/hooks/useSize.js";
+import { useCompactItemContext } from "../space/Compact.js";
+import { useDisabledContext } from "../config-provider/DisabledContext.js";
+import { useFormItemInputContext } from "../form/context.js";
+import { getMergedStatus, getStatusClassNames } from "../_util/statusUtils.js";
+import useVariant from "../form/hooks/useVariant.js";
+import { useSharedStyle } from "./style/index.js";
+import getAllowClear_default from "../_util/getAllowClear.js";
+import textarea_default from "./style/textarea.js";
+import { computed, createVNode, defineComponent, mergeProps, onBeforeUnmount, shallowRef } from "vue";
+import { clsx } from "@v-c/util";
+import { omit } from "es-toolkit";
+import VcTextArea from "@v-c/textarea";
+
+//#region src/input/TextArea.tsx
+const omitKeys = [
+	"classes",
+	"styles",
+	"rootClass",
+	"size",
+	"status",
+	"disabled",
+	"bordered",
+	"variant",
+	"prefixCls",
+	"allowClear",
+	"onKeydown"
+];
+const InternalTextArea = /* @__PURE__ */ defineComponent((props, { attrs, emit, expose }) => {
+	if (isDev) devUseWarning("TextArea").deprecated(props.bordered === void 0, "bordered", "variant");
+	const { prefixCls, direction, allowClear: contextAllowClear, class: contextClassName, style: contextStyle, classes: contextClassNames, styles: contextStyles } = useComponentBaseConfig("textArea", props, ["allowClear"], "input");
+	const { classes, styles, rootClass, size: customizeSize, disabled: customDisabled, status: customStatus, bordered, variant: customVariant } = toPropsRefs(props, "classes", "styles", "rootClass", "size", "disabled", "status", "bordered", "variant");
+	const textAreaRef = shallowRef();
+	const rootCls = useCSSVarCls_default(prefixCls);
+	const [hashId, cssVarCls] = useSharedStyle(prefixCls, rootClass);
+	textarea_default(prefixCls, rootCls);
+	const { compactSize, compactItemClassnames } = useCompactItemContext(prefixCls, direction);
+	const mergedSize = useSize((ctx) => customizeSize.value ?? compactSize.value ?? ctx);
+	const disabledContext = useDisabledContext();
+	const mergedDisabled = computed(() => customDisabled.value ?? disabledContext.value);
+	const mergedProps = computed(() => {
+		return {
+			...props,
+			size: mergedSize.value,
+			disabled: mergedDisabled.value
+		};
+	});
+	const [mergedClassNames, mergedStyles] = useMergeSemantic(useToArr(contextClassNames, classes), useToArr(contextStyles, styles), useToProps(mergedProps));
+	const formItemInputContext = useFormItemInputContext();
+	const mergedStatus = computed(() => getMergedStatus(formItemInputContext.value.status, customStatus.value));
+	const hasFeedback = computed(() => formItemInputContext.value.hasFeedback);
+	const feedbackIcon = computed(() => formItemInputContext.value.feedbackIcon);
+	const [mergedVariant, enableVariantCls] = useVariant("textArea", customVariant, bordered);
+	const mergedAllowClear = computed(() => getAllowClear_default(props.allowClear ?? contextAllowClear.value));
+	const isMouseDown = shallowRef(false);
+	const resizeDirty = shallowRef(false);
+	const handleMouseDown = (e) => {
+		isMouseDown.value = true;
+		emit("mousedown", e);
+		const onMouseUp = () => {
+			isMouseDown.value = false;
+			document.removeEventListener("mouseup", onMouseUp);
+		};
+		document.addEventListener("mouseup", onMouseUp);
+	};
+	onBeforeUnmount(() => {
+		isMouseDown.value = false;
+	});
+	const handleResize = (size) => {
+		emit("resize", size);
+		if (isMouseDown.value && typeof getComputedStyle === "function") {
+			const ele = textAreaRef.value?.resizableTextArea?.textArea;
+			if (ele && getComputedStyle(ele).resize === "both") resizeDirty.value = true;
+		}
+	};
+	expose({
+		resizableTextArea: computed(() => textAreaRef.value?.resizableTextArea),
+		focus: () => textAreaRef.value?.focus?.(),
+		blur: () => textAreaRef.value?.blur?.()
+	});
+	const handlePressEnter = (e) => {
+		emit("pressEnter", e);
+	};
+	const handleChange = (e) => {
+		const target = e?.target;
+		emit("update:value", target?.value);
+		emit("change", e);
+	};
+	const handleFocus = (e) => emit("focus", e);
+	const handleBlur = (e) => emit("blur", e);
+	const handleKeyDown = (e) => {
+		emit("keydown", e);
+	};
+	const handleCompositionStart = (e) => emit("compositionstart", e);
+	const handleCompositionEnd = (e) => emit("compositionend", e);
+	return () => {
+		const { className, style, restAttrs } = getAttrStyleAndClass(attrs);
+		const restProps = omit(props, omitKeys);
+		const textareaAttrs = {
+			...restAttrs,
+			maxLength: props.maxlength,
+			minLength: props.minlength,
+			readOnly: props.readonly
+		};
+		const classesValue = clsx(cssVarCls.value, rootCls.value, className, rootClass.value, compactItemClassnames.value, contextClassName.value, mergedClassNames.value.root, hashId.value, { [`${prefixCls.value}-textarea-affix-wrapper-resize-dirty`]: resizeDirty.value });
+		const mergedStyle = {
+			...mergedStyles.value.root,
+			...contextStyle.value,
+			...style
+		};
+		const classNames$1 = {
+			...mergedClassNames.value,
+			textarea: clsx({
+				[`${prefixCls.value}-sm`]: mergedSize.value === "small",
+				[`${prefixCls.value}-lg`]: mergedSize.value === "large"
+			}, hashId.value, mergedClassNames.value.textarea, isMouseDown.value && `${prefixCls.value}-mouse-active`),
+			variant: clsx({ [`${prefixCls.value}-${mergedVariant.value}`]: enableVariantCls.value }, getStatusClassNames(prefixCls.value, mergedStatus.value)),
+			affixWrapper: clsx(`${prefixCls.value}-textarea-affix-wrapper`, {
+				[`${prefixCls.value}-affix-wrapper-rtl`]: direction.value === "rtl",
+				[`${prefixCls.value}-affix-wrapper-sm`]: mergedSize.value === "small",
+				[`${prefixCls.value}-affix-wrapper-lg`]: mergedSize.value === "large",
+				[`${prefixCls.value}-textarea-show-count`]: props.showCount || props.count?.show
+			}, hashId.value)
+		};
+		return createVNode(VcTextArea, mergeProps(textareaAttrs, restProps, {
+			"ref": textAreaRef,
+			"prefixCls": prefixCls.value,
+			"class": classesValue,
+			"style": mergedStyle,
+			"classNames": classNames$1,
+			"styles": mergedStyles.value,
+			"disabled": mergedDisabled.value,
+			"allowClear": mergedAllowClear.value,
+			"onPressEnter": handlePressEnter,
+			"onResize": handleResize
+		}, {
+			onMousedown: handleMouseDown,
+			onKeydown: handleKeyDown,
+			onFocus: handleFocus,
+			onBlur: handleBlur,
+			onCompositionstart: handleCompositionStart,
+			onCompositionend: handleCompositionEnd
+		}, {
+			"onChange": handleChange,
+			"suffix": hasFeedback.value ? createVNode("span", { "class": `${prefixCls.value}-textarea-suffix` }, [feedbackIcon.value]) : void 0,
+			"showCount": props.showCount
+		}), null);
+	};
+}, {
+	emits: [
+		"pressEnter",
+		"change",
+		"focus",
+		"blur",
+		"resize",
+		"keydown",
+		"compositionstart",
+		"compositionend",
+		"mousedown",
+		"update:value"
+	],
+	props: {
+		bordered: {
+			type: Boolean,
+			required: false
+		},
+		size: {
+			type: [String, null],
+			required: false
+		},
+		status: {
+			type: String,
+			required: false
+		},
+		variant: {
+			type: String,
+			required: false
+		},
+		classes: {
+			type: [Object, Function],
+			required: false
+		},
+		styles: {
+			type: [Object, Function],
+			required: false
+		},
+		rows: {
+			type: Number,
+			required: false
+		},
+		maxlength: {
+			type: Number,
+			required: false
+		},
+		minlength: {
+			type: Number,
+			required: false
+		},
+		readonly: {
+			type: Boolean,
+			required: false
+		},
+		showCount: {
+			type: [Boolean, Object],
+			required: false
+		},
+		rootClass: {
+			type: String,
+			required: false
+		},
+		prefixCls: {
+			type: String,
+			required: false
+		},
+		value: { required: false },
+		defaultValue: { required: false },
+		disabled: {
+			type: Boolean,
+			required: false
+		},
+		autoSize: {
+			type: [Boolean, Object],
+			required: false
+		},
+		allowClear: {
+			type: [Boolean, Object],
+			required: false
+		},
+		suffix: { required: false },
+		count: { required: false },
+		onClear: {
+			type: Function,
+			required: false
+		},
+		hidden: {
+			type: Boolean,
+			required: false
+		},
+		placeholder: {
+			type: String,
+			required: false
+		},
+		autoFocus: {
+			type: Boolean,
+			required: false
+		},
+		onKeyup: {
+			type: Function,
+			required: false
+		}
+	},
+	name: "ATextarea",
+	inheritAttrs: false
+});
+var TextArea_default = InternalTextArea;
+
+//#endregion
+export { TextArea_default as default };

package/dist/input/hooks/useRemovePasswordTimeout.js

@@ -0,0 +1,29 @@
+import { onBeforeUnmount, onMounted } from "vue";
+
+//#region src/input/hooks/useRemovePasswordTimeout.ts
+/**
+* Clear the `value` attribute of password inputs to avoid browser autofill flashes.
+*/
+function useRemovePasswordTimeout(inputRef, triggerOnMount = false) {
+	const timeoutIds = [];
+	const removePasswordTimeout = () => {
+		const timer = setTimeout(() => {
+			const input = inputRef.value?.input;
+			if (input && input.getAttribute("type") === "password" && input.hasAttribute("value")) input.removeAttribute("value");
+		});
+		timeoutIds.push(timer);
+	};
+	onMounted(() => {
+		if (triggerOnMount) removePasswordTimeout();
+	});
+	onBeforeUnmount(() => {
+		timeoutIds.forEach((timer) => {
+			clearTimeout(timer);
+		});
+		timeoutIds.length = 0;
+	});
+	return removePasswordTimeout;
+}
+
+//#endregion
+export { useRemovePasswordTimeout as default };

package/dist/input/index.d.ts

@@ -0,0 +1,29 @@
+import { EmptyEmit } from "../_util/type.js";
+import { InputEmits, InputProps, InputRef, InputSlots } from "./Input.js";
+import { OPTSlots, OTPEmits, OTPProps } from "./OTP/index.js";
+import { SearchEmits, SearchProps, SearchSlots } from "./Search.js";
+import { InternalTextArea, TextAreaProps, TextAreaRef } from "./TextArea.js";
+import { InputGroupProps } from "./Group.js";
+import { PasswordEmits, PasswordProps, PasswordSlots } from "./Password.js";
+import * as vue88 from "vue";
+
+//#region src/input/index.d.ts
+declare const CompoundedInput: vue88.DefineSetupFnComponent<InputProps, InputEmits, vue88.SlotsType<InputSlots>, InputProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, vue88.PublicProps>;
+declare const InputGroup: vue88.DefineSetupFnComponent<InputGroupProps, EmptyEmit, vue88.SlotsType<{
+  default?: () => any;
+}>, InputGroupProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, vue88.PublicProps>;
+declare const InputOTP: vue88.DefineSetupFnComponent<OTPProps, OTPEmits, vue88.SlotsType<OPTSlots>, OTPProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, vue88.PublicProps>;
+declare const InputPassword: vue88.DefineSetupFnComponent<PasswordProps, PasswordEmits, vue88.SlotsType<PasswordSlots>, PasswordProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, vue88.PublicProps>;
+declare const InputSearch: vue88.DefineSetupFnComponent<SearchProps, SearchEmits, vue88.SlotsType<SearchSlots>, SearchProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, vue88.PublicProps>;
+//#endregion
+export { CompoundedInput, InputGroup, InputOTP, InputPassword, InputSearch };