@czxingyu/xycomponents 0.1.0

package/dist/card/types.d.ts

@@ -0,0 +1,17 @@
+import type { XySemanticClassNames, XySemanticStyles } from "../core";
+export type XyCardSize = "default" | "large" | "md" | "lg" | "small" | "sm";
+export type XyCardResolvedSize = "lg" | "md" | "sm";
+export type XyCardType = "default" | "inner";
+export type XyCardSemanticDom = "actions" | "body" | "cover" | "extra" | "header" | "loading" | "root" | "title";
+export interface XyCardSemanticProps {
+    bordered: boolean;
+    hasActions: boolean;
+    hasCover: boolean;
+    hasHeader: boolean;
+    hoverable: boolean;
+    loading: boolean;
+    size: XyCardResolvedSize;
+    type: XyCardType;
+}
+export type XyCardClassNames = XySemanticClassNames<XyCardSemanticDom, XyCardSemanticProps>;
+export type XyCardStyles = XySemanticStyles<XyCardSemanticDom, XyCardSemanticProps>;

package/dist/carousel/carousel.js

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

package/dist/carousel/carousel.vue.d.ts

@@ -0,0 +1,47 @@
+import type { XyCarouselDotPlacement, XyCarouselEffect, XyCarouselExpose, XyCarouselSlots } from "./types";
+type __VLS_Props = {
+    arrows?: boolean;
+    autoplay?: boolean;
+    autoplaySpeed?: number;
+    adaptiveHeight?: boolean;
+    current?: number;
+    defaultCurrent?: number;
+    dotPlacement?: XyCarouselDotPlacement;
+    dots?: boolean;
+    draggable?: boolean;
+    effect?: XyCarouselEffect;
+    infinite?: boolean;
+    speed?: number;
+};
+type __VLS_Slots = XyCarouselSlots;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, XyCarouselExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (current: number) => any;
+    afterChange: (current: number) => any;
+    beforeChange: (current: number, next: number) => any;
+    "update:current": (current: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((current: number) => any) | undefined;
+    onAfterChange?: ((current: number) => any) | undefined;
+    onBeforeChange?: ((current: number, next: number) => any) | undefined;
+    "onUpdate:current"?: ((current: number) => any) | undefined;
+}>, {
+    speed: number;
+    infinite: boolean;
+    effect: XyCarouselEffect;
+    draggable: boolean;
+    arrows: boolean;
+    autoplay: boolean;
+    autoplaySpeed: number;
+    adaptiveHeight: boolean;
+    defaultCurrent: number;
+    dotPlacement: XyCarouselDotPlacement;
+    dots: boolean;
+}, {}, {}, {}, 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/carousel/carousel.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,282 @@
+import { useXyLocale as e } from "../core/locale/index.js";
+import t from "../icon/icon.js";
+import { flattenSlideVNodes as n, normalizeIndex as r } from "./utils.js";
+import { Fragment as i, computed as a, createCommentVNode as o, createElementBlock as s, createElementVNode as c, createVNode as l, defineComponent as u, nextTick as d, normalizeClass as f, normalizeStyle as p, onBeforeUnmount as ee, openBlock as m, ref as h, renderList as g, renderSlot as _, unref as v, useSlots as te, watch as y } from "vue";
+//#region components/carousel/carousel.vue?vue&type=script&setup=true&lang.ts
+var ne = ["aria-roledescription"], re = ["aria-label", "disabled"], ie = ["aria-hidden"], ae = ["aria-label", "disabled"], oe = ["aria-label"], se = [
+	"aria-label",
+	"aria-selected",
+	"onClick"
+], b = /*@__PURE__*/ u({
+	name: "XyCarousel",
+	__name: "carousel",
+	props: {
+		arrows: {
+			type: Boolean,
+			required: !1,
+			default: !1
+		},
+		autoplay: {
+			type: Boolean,
+			required: !1,
+			default: !1
+		},
+		autoplaySpeed: {
+			type: Number,
+			required: !1,
+			default: 3e3
+		},
+		adaptiveHeight: {
+			type: Boolean,
+			required: !1,
+			default: !1
+		},
+		current: {
+			type: Number,
+			required: !1
+		},
+		defaultCurrent: {
+			type: Number,
+			required: !1,
+			default: 0
+		},
+		dotPlacement: {
+			type: String,
+			required: !1,
+			default: "bottom"
+		},
+		dots: {
+			type: Boolean,
+			required: !1,
+			default: !0
+		},
+		draggable: {
+			type: Boolean,
+			required: !1,
+			default: !1
+		},
+		effect: {
+			type: String,
+			required: !1,
+			default: "scrollx"
+		},
+		infinite: {
+			type: Boolean,
+			required: !1,
+			default: !0
+		},
+		speed: {
+			type: Number,
+			required: !1,
+			default: 500
+		}
+	},
+	emits: [
+		"afterChange",
+		"beforeChange",
+		"change",
+		"update:current"
+	],
+	setup(b, { expose: ce, emit: le }) {
+		let ue = u({
+			name: "XyCarouselSlideHost",
+			props: { vnode: {
+				required: !0,
+				type: Object
+			} },
+			setup(e) {
+				return () => e.vnode;
+			}
+		}), x = b, S = le, C = te(), w = e(), T = h(), E = h(), D = h(x.defaultCurrent), O = h(0), k = h(!1), A = h(!0), j = h(0), M = h(!1), N = h(0), P = h(0), F, I, L, R = a(() => n(C.default?.() ?? [])), z = a(() => R.value.length), B = a(() => x.current === void 0 ? D.value : x.current), V = a(() => x.effect === "scrollx"), H = a(() => x.infinite && V.value && z.value > 1), U = a(() => {
+			if (!H.value) return R.value;
+			let e = R.value;
+			return [
+				e.at(-1),
+				...e,
+				e[0]
+			];
+		}), W = a(() => U.value.length), G = a(() => H.value ? O.value : B.value), de = a(() => {
+			if (!V.value) return { "--xy-carousel-slide-count": String(W.value || 1) };
+			let e = G.value, t = W.value || 1, n = M.value ? j.value : 0;
+			return {
+				"--xy-carousel-slide-count": String(t),
+				transform: `translate3d(calc(-${e} * 100% / ${t} + ${n}px), 0, 0)`,
+				transitionDuration: A.value ? `${x.speed}ms` : "0ms"
+			};
+		}), fe = a(() => ({ "--xy-carousel-speed": `${x.speed}ms` })), pe = a(() => {
+			if (!x.adaptiveHeight) return;
+			let e = V.value ? G.value : B.value, t = E.value?.children.item(e)?.offsetHeight;
+			return t ? { height: `${t}px` } : void 0;
+		}), me = a(() => x.arrows || !!C.prevArrow), K = a(() => x.arrows || !!C.nextArrow), he = a(() => me.value || K.value), q = a(() => !x.infinite && B.value <= 0), J = a(() => !x.infinite && B.value >= Math.max(z.value - 1, 0));
+		function Y(e, t = !1) {
+			let n = r(e, z.value, x.infinite);
+			H.value ? O.value = n + 1 : O.value = n, t && (A.value = !1, d(() => {
+				A.value = !0;
+			}));
+		}
+		function X(e) {
+			x.current === void 0 && (D.value = e), S("update:current", e), S("change", e);
+		}
+		function ge() {
+			if (!k.value || L === void 0) return;
+			let e = L;
+			L = void 0, k.value = !1, S("afterChange", e), _e();
+		}
+		function Z(e, t = !1) {
+			if (z.value === 0) return;
+			let n = B.value, i = r(e, z.value, x.infinite);
+			if (i !== n) {
+				if (S("beforeChange", n, i), window.clearTimeout(I), k.value = !1, L = void 0, t) {
+					A.value = !1, Y(i, !0), X(i), S("afterChange", i), d(() => {
+						A.value = !0;
+					});
+					return;
+				}
+				k.value = !0, L = i, H.value && n === z.value - 1 && e === z.value ? O.value = z.value + 1 : H.value && n === 0 && e === -1 ? O.value = 0 : Y(i), X(i), I = window.setTimeout(ge, x.speed);
+			}
+		}
+		function _e() {
+			if (!(!H.value || z.value <= 1)) {
+				if (O.value === 0) {
+					A.value = !1, O.value = z.value, d(() => {
+						A.value = !0;
+					});
+					return;
+				}
+				O.value === z.value + 1 && (A.value = !1, O.value = 1, d(() => {
+					A.value = !0;
+				}));
+			}
+		}
+		function Q() {
+			z.value !== 0 && (!x.infinite && B.value >= z.value - 1 || Z(B.value + 1));
+		}
+		function $() {
+			z.value !== 0 && (!x.infinite && B.value <= 0 || Z(B.value - 1));
+		}
+		function ve() {
+			F &&= (window.clearInterval(F), void 0);
+		}
+		function ye() {
+			ve(), !(!x.autoplay || z.value <= 1) && (F = window.setInterval(() => {
+				M.value || k.value || Q();
+			}, x.autoplaySpeed));
+		}
+		function be(e) {
+			if (!k.value) return;
+			let t = e.target;
+			V.value && t !== E.value || !V.value && (!(t instanceof HTMLElement) || !t.classList.contains("xy-carousel__slide")) || ge();
+		}
+		function xe(e) {
+			Z(e);
+		}
+		function Se(e) {
+			return H.value ? e === 0 ? z.value - 1 : e === W.value - 1 ? 0 : e - 1 : e;
+		}
+		function Ce(e) {
+			!x.draggable || z.value <= 1 || (M.value = !0, N.value = e.clientX, P.value = j.value, T.value?.setPointerCapture(e.pointerId));
+		}
+		function we(e) {
+			M.value && (j.value = P.value + (e.clientX - N.value));
+		}
+		function Te(e) {
+			if (!M.value) return;
+			M.value = !1, T.value?.releasePointerCapture(e.pointerId);
+			let t = (T.value?.clientWidth || 1) * .15;
+			j.value <= -t ? Q() : j.value >= t && $(), j.value = 0;
+		}
+		return y(() => x.current, (e) => {
+			e !== void 0 && Y(e, !1);
+		}, { immediate: !0 }), y(z, (e) => {
+			let t = r(B.value, e, x.infinite);
+			Y(t, !0), x.current === void 0 && (D.value = t);
+		}, { immediate: !0 }), y(() => [
+			x.autoplay,
+			x.autoplaySpeed,
+			z.value
+		], () => ye(), { immediate: !0 }), ee(() => {
+			ve(), window.clearTimeout(I), L = void 0;
+		}), ce({
+			goTo: Z,
+			next: Q,
+			prev: $
+		}), (e, n) => (m(), s("section", {
+			class: f(["xy-carousel", [
+				`xy-carousel--dots-${b.dotPlacement}`,
+				`xy-carousel--effect-${b.effect}`,
+				{ "xy-carousel--has-arrows": he.value }
+			]]),
+			style: p(fe.value),
+			"aria-roledescription": v(w).carousel.roleDescription
+		}, [
+			me.value ? _(e.$slots, "prevArrow", {
+				key: 0,
+				current: B.value,
+				disabled: q.value,
+				prev: $,
+				total: z.value
+			}, () => [c("button", {
+				"aria-label": v(w).carousel.previousSlideAriaLabel,
+				class: "xy-carousel__arrow xy-carousel__arrow--prev",
+				type: "button",
+				disabled: q.value,
+				onClick: $
+			}, [l(t, {
+				"aria-hidden": "true",
+				name: "left-outlined"
+			})], 8, re)], !0) : o("", !0),
+			c("div", {
+				ref_key: "viewportRef",
+				ref: T,
+				class: f(["xy-carousel__viewport", { "xy-carousel__viewport--dragging": M.value }]),
+				style: p(pe.value),
+				onPointercancel: Te,
+				onPointerdown: Ce,
+				onPointermove: we,
+				onPointerup: Te
+			}, [c("div", {
+				ref_key: "trackRef",
+				ref: E,
+				class: "xy-carousel__track",
+				style: p(de.value),
+				onTransitionend: be
+			}, [(m(!0), s(i, null, g(U.value, (e, t) => (m(), s("div", {
+				key: `${t}-${String(e.key ?? t)}`,
+				class: f(["xy-carousel__slide", { "xy-carousel__slide--active": !V.value && Se(t) === B.value }]),
+				"aria-hidden": V.value ? void 0 : Se(t) !== B.value
+			}, [l(v(ue), { vnode: e }, null, 8, ["vnode"])], 10, ie))), 128))], 36)], 38),
+			K.value ? _(e.$slots, "nextArrow", {
+				key: 1,
+				current: B.value,
+				disabled: J.value,
+				next: Q,
+				total: z.value
+			}, () => [c("button", {
+				"aria-label": v(w).carousel.nextSlideAriaLabel,
+				class: "xy-carousel__arrow xy-carousel__arrow--next",
+				type: "button",
+				disabled: J.value,
+				onClick: Q
+			}, [l(t, {
+				"aria-hidden": "true",
+				name: "right-outlined"
+			})], 8, ae)], !0) : o("", !0),
+			b.dots && z.value > 0 ? (m(), s("div", {
+				key: 2,
+				"aria-label": v(w).carousel.paginationAriaLabel,
+				class: "xy-carousel__dots",
+				role: "tablist"
+			}, [(m(!0), s(i, null, g(z.value, (e, t) => (m(), s("button", {
+				key: t,
+				"aria-label": v(w).carousel.goToSlideAriaLabel(t + 1),
+				"aria-selected": t === B.value,
+				class: f(["xy-carousel__dot", { "xy-carousel__dot--active": t === B.value }]),
+				role: "tab",
+				type: "button",
+				onClick: (e) => xe(t)
+			}, null, 10, se))), 128))], 8, oe)) : o("", !0)
+		], 14, ne));
+	}
+});
+//#endregion
+export { b as default };

package/dist/carousel/index.d.ts

@@ -0,0 +1,118 @@
+export declare const XyCarousel: import("../shared/install").SFCWithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+        arrows?: boolean;
+        autoplay?: boolean;
+        autoplaySpeed?: number;
+        adaptiveHeight?: boolean;
+        current?: number;
+        defaultCurrent?: number;
+        dotPlacement?: import("./types").XyCarouselDotPlacement;
+        dots?: boolean;
+        draggable?: boolean;
+        effect?: import("./types").XyCarouselEffect;
+        infinite?: boolean;
+        speed?: number;
+    }> & Readonly<{
+        onChange?: ((current: number) => any) | undefined;
+        onAfterChange?: ((current: number) => any) | undefined;
+        onBeforeChange?: ((current: number, next: number) => any) | undefined;
+        "onUpdate:current"?: ((current: number) => any) | undefined;
+    }>, import("./types").XyCarouselExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        change: (current: number) => any;
+        afterChange: (current: number) => any;
+        beforeChange: (current: number, next: number) => any;
+        "update:current": (current: number) => any;
+    }, import("vue").PublicProps, {
+        speed: number;
+        infinite: boolean;
+        effect: import("./types").XyCarouselEffect;
+        draggable: boolean;
+        arrows: boolean;
+        autoplay: boolean;
+        autoplaySpeed: number;
+        adaptiveHeight: boolean;
+        defaultCurrent: number;
+        dotPlacement: import("./types").XyCarouselDotPlacement;
+        dots: boolean;
+    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        arrows?: boolean;
+        autoplay?: boolean;
+        autoplaySpeed?: number;
+        adaptiveHeight?: boolean;
+        current?: number;
+        defaultCurrent?: number;
+        dotPlacement?: import("./types").XyCarouselDotPlacement;
+        dots?: boolean;
+        draggable?: boolean;
+        effect?: import("./types").XyCarouselEffect;
+        infinite?: boolean;
+        speed?: number;
+    }> & Readonly<{
+        onChange?: ((current: number) => any) | undefined;
+        onAfterChange?: ((current: number) => any) | undefined;
+        onBeforeChange?: ((current: number, next: number) => any) | undefined;
+        "onUpdate:current"?: ((current: number) => any) | undefined;
+    }>, import("./types").XyCarouselExpose, {}, {}, {}, {
+        speed: number;
+        infinite: boolean;
+        effect: import("./types").XyCarouselEffect;
+        draggable: boolean;
+        arrows: boolean;
+        autoplay: boolean;
+        autoplaySpeed: number;
+        adaptiveHeight: boolean;
+        defaultCurrent: number;
+        dotPlacement: import("./types").XyCarouselDotPlacement;
+        dots: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<{
+    arrows?: boolean;
+    autoplay?: boolean;
+    autoplaySpeed?: number;
+    adaptiveHeight?: boolean;
+    current?: number;
+    defaultCurrent?: number;
+    dotPlacement?: import("./types").XyCarouselDotPlacement;
+    dots?: boolean;
+    draggable?: boolean;
+    effect?: import("./types").XyCarouselEffect;
+    infinite?: boolean;
+    speed?: number;
+}> & Readonly<{
+    onChange?: ((current: number) => any) | undefined;
+    onAfterChange?: ((current: number) => any) | undefined;
+    onBeforeChange?: ((current: number, next: number) => any) | undefined;
+    "onUpdate:current"?: ((current: number) => any) | undefined;
+}>, import("./types").XyCarouselExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (current: number) => any;
+    afterChange: (current: number) => any;
+    beforeChange: (current: number, next: number) => any;
+    "update:current": (current: number) => any;
+}, string, {
+    speed: number;
+    infinite: boolean;
+    effect: import("./types").XyCarouselEffect;
+    draggable: boolean;
+    arrows: boolean;
+    autoplay: boolean;
+    autoplaySpeed: number;
+    adaptiveHeight: boolean;
+    defaultCurrent: number;
+    dotPlacement: import("./types").XyCarouselDotPlacement;
+    dots: boolean;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: import("./types").XyCarouselSlots;
+})>;
+export default XyCarousel;
+export type { XyCarouselDotPlacement, XyCarouselEffect, XyCarouselExpose, XyCarouselProps, XyCarouselSlots, } from "./types";
+export { flattenSlideVNodes, normalizeIndex } from "./utils";

package/dist/carousel/index.js

@@ -0,0 +1,7 @@
+import { withInstall as e } from "../shared/install.js";
+import { flattenSlideVNodes as t, normalizeIndex as n } from "./utils.js";
+import r from "./carousel.js";
+//#region components/carousel/index.ts
+var i = e(r);
+//#endregion
+export { i as XyCarousel, i as default, t as flattenSlideVNodes, n as normalizeIndex };

package/dist/carousel/types.d.ts

@@ -0,0 +1,38 @@
+import type { VNodeChild } from "vue";
+export type XyCarouselDotPlacement = "bottom" | "end" | "start" | "top";
+export type XyCarouselEffect = "fade" | "scrollx";
+export interface XyCarouselProps {
+    adaptiveHeight?: boolean;
+    arrows?: boolean;
+    autoplay?: boolean;
+    autoplaySpeed?: number;
+    current?: number;
+    defaultCurrent?: number;
+    dotPlacement?: XyCarouselDotPlacement;
+    dots?: boolean;
+    draggable?: boolean;
+    effect?: XyCarouselEffect;
+    infinite?: boolean;
+    speed?: number;
+}
+export interface XyCarouselArrowSlotProps {
+    current: number;
+    disabled: boolean;
+    total: number;
+}
+export interface XyCarouselPrevArrowSlotProps extends XyCarouselArrowSlotProps {
+    prev: () => void;
+}
+export interface XyCarouselNextArrowSlotProps extends XyCarouselArrowSlotProps {
+    next: () => void;
+}
+export interface XyCarouselSlots {
+    default?: () => VNodeChild;
+    nextArrow?: (props: XyCarouselNextArrowSlotProps) => VNodeChild;
+    prevArrow?: (props: XyCarouselPrevArrowSlotProps) => VNodeChild;
+}
+export interface XyCarouselExpose {
+    goTo: (index: number, dontAnimate?: boolean) => void;
+    next: () => void;
+    prev: () => void;
+}

package/dist/carousel/utils.d.ts

@@ -0,0 +1,3 @@
+import { type VNode, type VNodeChild } from "vue";
+export declare function flattenSlideVNodes(children: VNodeChild): VNode[];
+export declare function normalizeIndex(index: number, count: number, infinite: boolean): number;

package/dist/carousel/utils.js

@@ -0,0 +1,29 @@
+import { Comment as e, Fragment as t, Text as n, isVNode as r } from "vue";
+//#region components/carousel/utils.ts
+function i(e) {
+	return e.type === n && typeof e.children == "string" && !e.children.trim();
+}
+function a(n) {
+	let o = [];
+	for (let s of Array.isArray(n) ? n : [n]) {
+		if (Array.isArray(s)) {
+			o.push(...a(s));
+			continue;
+		}
+		if (!r(s)) continue;
+		let n = s;
+		if (!(n.type === e || i(n))) {
+			if (n.type === t && Array.isArray(n.children)) {
+				o.push(...a(n.children));
+				continue;
+			}
+			o.push(n);
+		}
+	}
+	return o;
+}
+function o(e, t, n) {
+	return t <= 0 ? 0 : n ? (e % t + t) % t : Math.min(Math.max(e, 0), t - 1);
+}
+//#endregion
+export { a as flattenSlideVNodes, o as normalizeIndex };

package/dist/cascader/cascader.js

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

package/dist/cascader/cascader.vue.d.ts

@@ -0,0 +1,59 @@
+import type { XyCascaderExpose, XyCascaderOption, XyCascaderPath, XyCascaderProps, XyCascaderSlots, XyCascaderValue } from "./types";
+type __VLS_Slots = XyCascaderSlots;
+declare const __VLS_base: import("vue").DefineComponent<XyCascaderProps, XyCascaderExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    search: (value: string) => any;
+    select: (path: XyCascaderPath, selectedOptions: XyCascaderOption[]) => any;
+    clear: () => any;
+    blur: (event: FocusEvent) => any;
+    change: (value: XyCascaderValue, selectedOptions: XyCascaderOption[] | XyCascaderOption[][]) => any;
+    focus: (event: FocusEvent) => any;
+    "update:open": (open: boolean) => any;
+    "update:modelValue": (value: XyCascaderValue) => any;
+    "open-change": (open: boolean) => any;
+    deselect: (path: XyCascaderPath, selectedOptions: XyCascaderOption[]) => any;
+    "load-error": (error: unknown, option: XyCascaderOption, path: XyCascaderOption[]) => any;
+}, string, import("vue").PublicProps, Readonly<XyCascaderProps> & Readonly<{
+    onSearch?: ((value: string) => any) | undefined;
+    onSelect?: ((path: XyCascaderPath, selectedOptions: XyCascaderOption[]) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onChange?: ((value: XyCascaderValue, selectedOptions: XyCascaderOption[] | XyCascaderOption[][]) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: XyCascaderValue) => any) | undefined;
+    "onOpen-change"?: ((open: boolean) => any) | undefined;
+    onDeselect?: ((path: XyCascaderPath, selectedOptions: XyCascaderOption[]) => any) | undefined;
+    "onLoad-error"?: ((error: unknown, option: XyCascaderOption, path: XyCascaderOption[]) => any) | undefined;
+}>, {
+    label: string;
+    separator: string;
+    multiple: boolean;
+    error: string;
+    options: XyCascaderOption[];
+    variant: import("../core").XyControlVariant;
+    ariaLabel: string;
+    loading: boolean;
+    maxCount: number;
+    placement: import("../core").XyOverlayPlacement;
+    allowClear: boolean;
+    autofocus: boolean;
+    modelValue: XyCascaderValue;
+    defaultOpen: boolean;
+    filterOption: boolean | import("./types").XyCascaderFilterOption;
+    autoClearSearchValue: boolean;
+    maxTagCount: number;
+    popupMatchSelectWidth: boolean | number;
+    searchable: boolean;
+    showSearch: boolean;
+    changeOnSelect: boolean;
+    expandTrigger: import("./types").XyCascaderExpandTrigger;
+    searchLimit: false | 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;
+    };
+};