@czxingyu/xycomponents 0.1.0

package/dist/anchor/anchor.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,251 @@
+import { resolveSemanticClassNames as e, resolveSemanticStyles as t } from "../core/shared/index.js";
+import { useXyLocale as n } from "../core/locale/index.js";
+import { Fragment as r, computed as i, createCommentVNode as a, createElementBlock as o, createElementVNode as s, createTextVNode as c, defineComponent as l, nextTick as u, normalizeClass as d, normalizeStyle as f, onBeforeUnmount as p, onMounted as m, openBlock as h, ref as g, renderList as _, renderSlot as v, toDisplayString as y, watch as b } from "vue";
+//#region components/anchor/anchor.vue?vue&type=script&setup=true&lang.ts
+var x = ["aria-label"], S = [
+	"href",
+	"target",
+	"rel",
+	"aria-current",
+	"aria-disabled",
+	"onClick"
+], C = /*@__PURE__*/ l({
+	name: "XyAnchor",
+	__name: "anchor",
+	props: {
+		activeLink: {
+			type: String,
+			required: !1,
+			default: void 0
+		},
+		affix: {
+			type: Boolean,
+			required: !1,
+			default: !0
+		},
+		ariaLabel: {
+			type: String,
+			required: !1,
+			default: void 0
+		},
+		bounds: {
+			type: Number,
+			required: !1,
+			default: 5
+		},
+		classNames: {
+			type: null,
+			required: !1
+		},
+		defaultActiveLink: {
+			type: String,
+			required: !1,
+			default: ""
+		},
+		direction: {
+			type: String,
+			required: !1,
+			default: "vertical"
+		},
+		getContainer: {
+			type: Function,
+			required: !1,
+			default: void 0
+		},
+		getCurrentAnchor: {
+			type: Function,
+			required: !1
+		},
+		items: {
+			type: Array,
+			required: !1,
+			default: () => []
+		},
+		offsetTop: {
+			type: Number,
+			required: !1,
+			default: 0
+		},
+		replace: {
+			type: Boolean,
+			required: !1,
+			default: !1
+		},
+		scrollBehavior: {
+			type: String,
+			required: !1,
+			default: "smooth"
+		},
+		showInkInFixed: {
+			type: Boolean,
+			required: !1,
+			default: !1
+		},
+		styles: {
+			type: null,
+			required: !1
+		},
+		targetOffset: {
+			type: Number,
+			required: !1,
+			default: void 0
+		},
+		title: {
+			type: String,
+			required: !1,
+			default: void 0
+		}
+	},
+	emits: [
+		"change",
+		"click",
+		"update:activeLink"
+	],
+	setup(l, { emit: C }) {
+		let w = l, T = n(), E = C, D = g(w.defaultActiveLink), O, k = i(() => w.activeLink !== void 0), A = i(() => k.value ? w.activeLink : D.value), j = i(() => w.ariaLabel ?? w.title ?? T.value.anchor.ariaLabel), M = i(() => R(w.items)), N = i(() => ({
+			activeLink: A.value ?? "",
+			direction: w.direction,
+			hasItems: M.value.length > 0,
+			hasTitle: !!w.title
+		})), P = i(() => e(w.classNames, N.value)), F = i(() => t(w.styles, N.value)), I = i(() => w.affix ? { top: `${w.offsetTop}px` } : void 0), L = i(() => w.direction === "vertical" && (w.affix || w.showInkInFixed));
+		function R(e, t = 0, n = []) {
+			for (let r of e) n.push({
+				depth: t,
+				item: r
+			}), r.children?.length && w.direction === "vertical" && R(r.children, t + 1, n);
+			return n;
+		}
+		function z(e) {
+			return e.title ?? e.text ?? e.href;
+		}
+		function B() {
+			if (!(typeof window > "u")) return w.getContainer?.() ?? window;
+		}
+		function V(e) {
+			return typeof window < "u" && e === window;
+		}
+		function H(e) {
+			if (typeof document > "u" || !e.startsWith("#")) return null;
+			let t = decodeURIComponent(e.slice(1));
+			return t ? document.getElementById(t) : null;
+		}
+		function U(e) {
+			return e.targetOffset ?? w.targetOffset ?? w.offsetTop;
+		}
+		function W(e) {
+			let t = w.getCurrentAnchor?.(e) ?? e;
+			!t || t === A.value || (k.value || (D.value = t), E("update:activeLink", t), E("change", t));
+		}
+		function G() {
+			let e = B();
+			if (!e || !M.value.length) return;
+			let t = w.offsetTop + w.bounds, n = V(e) ? 0 : e.getBoundingClientRect().top, r = "";
+			for (let { item: e } of M.value) {
+				let i = H(e.href);
+				i && i.getBoundingClientRect().top - n <= t && (r = e.href);
+			}
+			W(r || M.value[0]?.item.href || "");
+		}
+		function K(e) {
+			let t = B(), n = H(e.href);
+			if (!t || !n) return !1;
+			let r = U(e);
+			if (V(t)) window.scrollTo({
+				behavior: w.scrollBehavior,
+				top: window.scrollY + n.getBoundingClientRect().top - r
+			});
+			else {
+				let e = t.getBoundingClientRect();
+				t.scrollTo({
+					behavior: w.scrollBehavior,
+					top: t.scrollTop + n.getBoundingClientRect().top - e.top - r
+				});
+			}
+			return W(e.href), !0;
+		}
+		function q(e) {
+			if (!e.href.startsWith("#") || typeof window > "u") return;
+			let t = e.replace ?? w.replace ? "replaceState" : "pushState";
+			window.history[t](null, "", e.href);
+		}
+		function J(e, t) {
+			if (e.disabled) {
+				t.preventDefault();
+				return;
+			}
+			e.onClick?.(t, e), E("click", t, e), !(t.defaultPrevented || !e.href.startsWith("#")) && K(e) && (t.preventDefault(), q(e));
+		}
+		function Y() {
+			O?.removeEventListener("scroll", G), O = B(), O?.addEventListener("scroll", G, { passive: !0 });
+		}
+		return m(() => {
+			Y(), u(G);
+		}), p(() => {
+			O?.removeEventListener("scroll", G);
+		}), b(() => [
+			w.items,
+			w.offsetTop,
+			w.targetOffset,
+			w.getContainer
+		], () => {
+			Y(), u(G);
+		}, { deep: !0 }), (e, t) => (h(), o("nav", {
+			class: d(["xy-anchor", [{
+				"xy-anchor--affix": l.affix,
+				"xy-anchor--horizontal": l.direction === "horizontal",
+				"xy-anchor--vertical": l.direction === "vertical"
+			}, P.value.root]]),
+			style: f([I.value, F.value.root]),
+			"aria-label": j.value
+		}, [
+			l.title ? (h(), o("h2", {
+				key: 0,
+				class: d(["xy-anchor__title", P.value.title]),
+				style: f(F.value.title)
+			}, y(l.title), 7)) : a("", !0),
+			M.value.length ? (h(), o("ul", {
+				key: 1,
+				class: d(["xy-anchor__items", [{ "xy-anchor__items--with-ink": L.value }, P.value.items]]),
+				style: f(F.value.items)
+			}, [(h(!0), o(r, null, _(M.value, ({ item: t, depth: n }, r) => (h(), o("li", {
+				key: t.key ?? t.href,
+				class: d(["xy-anchor__item", [
+					{
+						"xy-anchor__item--active": t.href === A.value,
+						"xy-anchor__item--disabled": t.disabled
+					},
+					t.className,
+					P.value.item
+				]]),
+				style: f([
+					t.style,
+					l.direction === "vertical" ? { paddingInlineStart: `${n * 16}px` } : void 0,
+					F.value.item
+				])
+			}, [s("a", {
+				class: d(["xy-anchor__link", { "xy-anchor__link--disabled": t.disabled }]),
+				href: t.href,
+				target: t.target,
+				rel: t.target === "_blank" ? "noreferrer" : void 0,
+				"aria-current": t.href === A.value ? "location" : void 0,
+				"aria-disabled": t.disabled ? "true" : void 0,
+				onClick: (e) => J(t, e)
+			}, [t.href === A.value && L.value ? (h(), o("span", {
+				key: 0,
+				class: d(["xy-anchor__indicator", P.value.indicator]),
+				style: f(F.value.indicator)
+			}, null, 6)) : a("", !0), s("span", {
+				class: d(["xy-anchor__item-title", P.value.itemTitle]),
+				style: f(F.value.itemTitle)
+			}, [v(e.$slots, "item", {
+				active: t.href === A.value,
+				depth: n,
+				index: r,
+				item: t
+			}, () => [c(y(z(t)), 1)])], 6)], 10, S)], 6))), 128))], 6)) : a("", !0),
+			v(e.$slots, "default")
+		], 14, x));
+	}
+});
+//#endregion
+export { C as default };

package/dist/anchor/index.d.ts

@@ -0,0 +1,5 @@
+import { type SFCWithInstall } from "../shared/install";
+import Anchor from "./anchor.vue";
+export declare const XyAnchor: SFCWithInstall<typeof Anchor>;
+export default XyAnchor;
+export type { XyAnchorClassNames, XyAnchorContainer, XyAnchorDirection, XyAnchorItem, XyAnchorItemSlotProps, XyAnchorProps, XyAnchorScrollBehavior, XyAnchorSemanticDom, XyAnchorSemanticProps, XyAnchorSlots, XyAnchorStyles, } from "./types";

package/dist/anchor/index.js

@@ -0,0 +1,6 @@
+import { withInstall as e } from "../shared/install.js";
+import t from "./anchor.js";
+//#region components/anchor/index.ts
+var n = e(t);
+//#endregion
+export { n as XyAnchor, n as default };

package/dist/anchor/types.d.ts

@@ -0,0 +1,57 @@
+import type { CSSProperties, VNodeChild } from "vue";
+import type { XySemanticClassNames, XySemanticStyles } from "../core";
+export type XyAnchorContainer = HTMLElement | Window;
+export type XyAnchorDirection = "horizontal" | "vertical";
+export type XyAnchorScrollBehavior = "auto" | "smooth";
+export type XyAnchorSemanticDom = "indicator" | "item" | "itemTitle" | "items" | "root" | "title";
+export interface XyAnchorSemanticProps {
+    activeLink: string;
+    direction: XyAnchorDirection;
+    hasItems: boolean;
+    hasTitle: boolean;
+}
+export type XyAnchorClassNames = XySemanticClassNames<XyAnchorSemanticDom, XyAnchorSemanticProps>;
+export type XyAnchorStyles = XySemanticStyles<XyAnchorSemanticDom, XyAnchorSemanticProps>;
+export interface XyAnchorItem {
+    children?: readonly XyAnchorItem[];
+    className?: string;
+    disabled?: boolean;
+    href: string;
+    key?: string | number;
+    onClick?: (event: MouseEvent, item: XyAnchorItem) => void;
+    replace?: boolean;
+    style?: CSSProperties;
+    target?: string;
+    targetOffset?: number;
+    text?: string;
+    title?: string;
+}
+export interface XyAnchorProps {
+    activeLink?: string;
+    affix?: boolean;
+    ariaLabel?: string;
+    bounds?: number;
+    classNames?: XyAnchorClassNames;
+    defaultActiveLink?: string;
+    direction?: XyAnchorDirection;
+    getContainer?: () => XyAnchorContainer | null | undefined;
+    getCurrentAnchor?: (activeLink: string) => string;
+    items?: readonly XyAnchorItem[];
+    offsetTop?: number;
+    replace?: boolean;
+    scrollBehavior?: XyAnchorScrollBehavior;
+    showInkInFixed?: boolean;
+    styles?: XyAnchorStyles;
+    targetOffset?: number;
+    title?: string;
+}
+export interface XyAnchorItemSlotProps {
+    active: boolean;
+    depth: number;
+    index: number;
+    item: XyAnchorItem;
+}
+export interface XyAnchorSlots {
+    default?: () => VNodeChild;
+    item?: (props: XyAnchorItemSlotProps) => VNodeChild;
+}

package/dist/app/app.js

@@ -0,0 +1,5 @@
+import e from "./app.vue_vue_type_script_setup_true_lang.js";
+//#region components/app/app.vue
+var t = e;
+//#endregion
+export { t as default };

package/dist/app/app.vue.d.ts

@@ -0,0 +1,17 @@
+import type { XyAppProps, XyAppSemanticProps, XyAppSlots } from "./types";
+type __VLS_Slots = XyAppSlots;
+declare const __VLS_base: import("vue").DefineComponent<XyAppProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<XyAppProps> & Readonly<{}>, {
+    message: import("./types").XyAppMessageConfig;
+    notification: import("./types").XyAppNotificationConfig;
+    classNames: import("../core").XySemanticResolver<Partial<Record<"root", string>>, XyAppSemanticProps> | readonly (import("../core").XySemanticResolver<Partial<Record<"root", string>>, XyAppSemanticProps> | undefined)[];
+    styles: import("../core").XySemanticResolver<Partial<Record<"root", import("vue").CSSProperties>>, XyAppSemanticProps> | readonly (import("../core").XySemanticResolver<Partial<Record<"root", import("vue").CSSProperties>>, XyAppSemanticProps> | undefined)[];
+    component: import("vue").Component | string;
+}, {}, {}, {}, 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/app/app.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,110 @@
+import { resolveSemanticClassNames as e, resolveSemanticStyles as t } from "../core/shared/index.js";
+import { getXyClassNames as n, useXyConfig as r } from "../core/config/index.js";
+import i from "../message/message-container.js";
+import { createMessageManager as a } from "../message/methods.js";
+import o from "../notification/notification-container.js";
+import { createNotificationManager as s } from "../notification/methods.js";
+import { provideXyApp as c } from "./context.js";
+import { computed as l, createBlock as u, createCommentVNode as d, defineComponent as f, normalizeClass as p, normalizeStyle as m, onBeforeUnmount as h, openBlock as g, renderSlot as _, resolveDynamicComponent as v, unref as y, withCtx as b } from "vue";
+//#region components/app/app.vue?vue&type=script&setup=true&lang.ts
+var x = /*@__PURE__*/ f({
+	name: "XyApp",
+	__name: "app",
+	props: {
+		classNames: {
+			type: [
+				Function,
+				null,
+				Array
+			],
+			required: !1,
+			skipCheck: !0,
+			default: void 0
+		},
+		component: {
+			type: [
+				Object,
+				Function,
+				String
+			],
+			required: !1,
+			default: "div"
+		},
+		message: {
+			type: Object,
+			required: !1,
+			default: void 0
+		},
+		notification: {
+			type: Object,
+			required: !1,
+			default: void 0
+		},
+		styles: {
+			type: [
+				Function,
+				null,
+				Array
+			],
+			required: !1,
+			skipCheck: !0,
+			default: void 0
+		}
+	},
+	setup(f) {
+		let x = f, S = r(), C = l(() => ({
+			...x.message,
+			zIndex: x.message?.zIndex ?? S.value.zIndex + 50
+		})), w = l(() => ({
+			...x.notification,
+			zIndex: x.notification?.zIndex ?? S.value.zIndex + 50
+		})), T = a({
+			autoMount: !1,
+			config: C
+		}), E = s({
+			autoMount: !1,
+			config: w
+		});
+		c({
+			message: T.api,
+			notification: E.api
+		});
+		let D = l(() => ({
+			messageCount: T.instances.length,
+			notificationCount: E.instances.length
+		})), O = l(() => e(x.classNames, D.value)), k = l(() => t(x.styles, D.value)), A = l(() => n(S.value, "app"));
+		return h(() => {
+			T.dispose(), E.dispose();
+		}), (e, t) => (g(), u(v(x.component), {
+			class: p([A.value, O.value.root]),
+			style: m(k.value.root)
+		}, {
+			default: b(() => [
+				_(e.$slots, "default"),
+				y(T).instances.length ? (g(), u(i, {
+					key: 0,
+					config: y(T).resolvedConfig,
+					instances: y(T).instances,
+					onRemove: y(T).api.close
+				}, null, 8, [
+					"config",
+					"instances",
+					"onRemove"
+				])) : d("", !0),
+				y(E).instances.length ? (g(), u(o, {
+					key: 1,
+					config: y(E).resolvedConfig,
+					instances: y(E).instances,
+					onRemove: y(E).api.close
+				}, null, 8, [
+					"config",
+					"instances",
+					"onRemove"
+				])) : d("", !0)
+			]),
+			_: 3
+		}, 8, ["class", "style"]));
+	}
+});
+//#endregion
+export { x as default };

package/dist/app/context.d.ts

@@ -0,0 +1,3 @@
+import type { XyAppContext } from "./types";
+export declare function provideXyApp(context: XyAppContext): XyAppContext;
+export declare function useXyApp(): XyAppContext;

package/dist/app/context.js

@@ -0,0 +1,13 @@
+import { inject as e, provide as t } from "vue";
+//#region components/app/context.ts
+var n = Symbol("xy-app-context");
+function r(e) {
+	return t(n, e), e;
+}
+function i() {
+	let t = e(n);
+	if (!t) throw Error("useXyApp() must be called inside <xy-app>.");
+	return t;
+}
+//#endregion
+export { r as provideXyApp, i as useXyApp };

package/dist/app/index.d.ts

@@ -0,0 +1,36 @@
+export declare const XyApp: import("../shared/install").SFCWithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./types").XyAppProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+        message: import("./types").XyAppMessageConfig;
+        notification: import("./types").XyAppNotificationConfig;
+        classNames: import("../index.ts").XySemanticResolver<Partial<Record<"root", string>>, import("./types").XyAppSemanticProps> | readonly (import("../index.ts").XySemanticResolver<Partial<Record<"root", string>>, import("./types").XyAppSemanticProps> | undefined)[];
+        styles: import("../index.ts").XySemanticResolver<Partial<Record<"root", import("vue").CSSProperties>>, import("./types").XyAppSemanticProps> | readonly (import("../index.ts").XySemanticResolver<Partial<Record<"root", import("vue").CSSProperties>>, import("./types").XyAppSemanticProps> | undefined)[];
+        component: import("vue").Component | string;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./types").XyAppProps> & Readonly<{}>, {}, {}, {}, {}, {
+        message: import("./types").XyAppMessageConfig;
+        notification: import("./types").XyAppNotificationConfig;
+        classNames: import("../index.ts").XySemanticResolver<Partial<Record<"root", string>>, import("./types").XyAppSemanticProps> | readonly (import("../index.ts").XySemanticResolver<Partial<Record<"root", string>>, import("./types").XyAppSemanticProps> | undefined)[];
+        styles: import("../index.ts").XySemanticResolver<Partial<Record<"root", import("vue").CSSProperties>>, import("./types").XyAppSemanticProps> | readonly (import("../index.ts").XySemanticResolver<Partial<Record<"root", import("vue").CSSProperties>>, import("./types").XyAppSemanticProps> | undefined)[];
+        component: import("vue").Component | string;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./types").XyAppProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    message: import("./types").XyAppMessageConfig;
+    notification: import("./types").XyAppNotificationConfig;
+    classNames: import("../index.ts").XySemanticResolver<Partial<Record<"root", string>>, import("./types").XyAppSemanticProps> | readonly (import("../index.ts").XySemanticResolver<Partial<Record<"root", string>>, import("./types").XyAppSemanticProps> | undefined)[];
+    styles: import("../index.ts").XySemanticResolver<Partial<Record<"root", import("vue").CSSProperties>>, import("./types").XyAppSemanticProps> | readonly (import("../index.ts").XySemanticResolver<Partial<Record<"root", import("vue").CSSProperties>>, import("./types").XyAppSemanticProps> | undefined)[];
+    component: import("vue").Component | string;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: import("./types").XyAppSlots;
+})>;
+export default XyApp;
+export { provideXyApp, useXyApp } from "./context";
+export type { XyAppClassNames, XyAppContext, XyAppMessageApi, XyAppMessageConfig, XyAppNotificationApi, XyAppNotificationConfig, XyAppProps, XyAppSemanticDom, XyAppSemanticProps, XyAppSlots, XyAppStyles, } from "./types";

package/dist/app/index.js

@@ -0,0 +1,7 @@
+import { withInstall as e } from "../shared/install.js";
+import { provideXyApp as t, useXyApp as n } from "./context.js";
+import r from "./app.js";
+//#region components/app/index.ts
+var i = e(r);
+//#endregion
+export { i as XyApp, i as default, t as provideXyApp, n as useXyApp };

package/dist/app/types.d.ts

@@ -0,0 +1,29 @@
+import type { Component, VNodeChild } from "vue";
+import type { XySemanticClassNames, XySemanticStyles } from "../core";
+import type { XyMessageApi, XyMessageGlobalConfig } from "../message";
+import type { XyNotificationApi, XyNotificationGlobalConfig } from "../notification";
+export type XyAppSemanticDom = "root";
+export interface XyAppSemanticProps {
+    messageCount: number;
+    notificationCount: number;
+}
+export type XyAppClassNames = XySemanticClassNames<XyAppSemanticDom, XyAppSemanticProps>;
+export type XyAppStyles = XySemanticStyles<XyAppSemanticDom, XyAppSemanticProps>;
+export type XyAppMessageConfig = Omit<XyMessageGlobalConfig, "getContainer">;
+export type XyAppNotificationConfig = Omit<XyNotificationGlobalConfig, "getContainer">;
+export type XyAppMessageApi = Omit<XyMessageApi, "config">;
+export type XyAppNotificationApi = Omit<XyNotificationApi, "config">;
+export interface XyAppProps {
+    classNames?: XyAppClassNames;
+    component?: Component | string;
+    message?: XyAppMessageConfig;
+    notification?: XyAppNotificationConfig;
+    styles?: XyAppStyles;
+}
+export interface XyAppSlots {
+    default?: () => VNodeChild;
+}
+export interface XyAppContext {
+    message: XyAppMessageApi;
+    notification: XyAppNotificationApi;
+}

package/dist/auto-complete/auto-complete.js

@@ -0,0 +1,7 @@
+import e from "../_virtual/_plugin-vue_export-helper.js";
+import t from "./auto-complete.vue_vue_type_script_setup_true_lang.js";
+/* empty css                                                              */
+//#region components/auto-complete/auto-complete.vue
+var n = /*#__PURE__*/ e(t, [["__scopeId", "data-v-e441f5cc"]]);
+//#endregion
+export { n as default };

package/dist/auto-complete/auto-complete.vue.d.ts

@@ -0,0 +1,48 @@
+import type { XyAutoCompleteExpose, XyAutoCompleteFilterOption, XyAutoCompleteOption, XyAutoCompleteProps, XyAutoCompleteSlots } from "./types";
+type __VLS_Slots = XyAutoCompleteSlots;
+declare const __VLS_base: import("vue").DefineComponent<XyAutoCompleteProps, XyAutoCompleteExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    search: (value: string) => any;
+    select: (value: string, option: XyAutoCompleteOption) => any;
+    clear: () => any;
+    blur: (event: FocusEvent) => any;
+    change: (value: string, detail: Event | XyAutoCompleteOption) => any;
+    focus: (event: FocusEvent) => any;
+    "update:open": (open: boolean) => any;
+    "update:modelValue": (value: string) => any;
+    "open-change": (open: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<XyAutoCompleteProps> & Readonly<{
+    onSearch?: ((value: string) => any) | undefined;
+    onSelect?: ((value: string, option: XyAutoCompleteOption) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onChange?: ((value: string, detail: Event | XyAutoCompleteOption) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    "onOpen-change"?: ((open: boolean) => any) | undefined;
+}>, {
+    disabled: boolean;
+    options: readonly XyAutoCompleteOption[];
+    variant: import("../core").XyControlVariant;
+    ariaLabel: string;
+    loading: boolean;
+    placement: import("../core").XyOverlayPlacement;
+    allowClear: boolean;
+    autocomplete: string;
+    autofocus: boolean;
+    modelValue: string;
+    readonly: boolean;
+    defaultActiveFirstOption: boolean;
+    defaultOpen: boolean;
+    filterOption: boolean | XyAutoCompleteFilterOption;
+    openOnFocus: boolean;
+    popupMatchInputWidth: boolean | number;
+}, {}, {}, {}, 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;
+    };
+};