@aifuxi/semi-ui-vue 0.1.0-alpha.0

package/dist/modal/types.d.ts

@@ -0,0 +1,92 @@
+import { Component, HTMLAttributes, StyleValue, VNodeChild } from 'vue';
+import { ButtonProps, ButtonType } from '../button';
+import { ConfigDirection } from '../config-provider';
+export declare const MODAL_SIZES: readonly ["small", "medium", "large", "full-width"];
+export declare const MODAL_CONFIRM_TYPES: readonly ["success", "info", "warning", "error", "confirm"];
+export type ModalSize = (typeof MODAL_SIZES)[number];
+export type ModalConfirmType = (typeof MODAL_CONFIRM_TYPES)[number];
+export type ModalActionHandler = (event: MouseEvent | KeyboardEvent) => void | Promise<unknown>;
+export type ModalButtonProps = ButtonProps & Record<string, unknown>;
+export interface ModalLocale {
+    cancel: string;
+    confirm: string;
+}
+export interface ModalProps {
+    afterClose?: () => void;
+    bodyStyle?: StyleValue;
+    cancelButtonProps?: ModalButtonProps;
+    cancelLoading?: boolean;
+    cancelText?: string;
+    centered?: boolean;
+    class?: HTMLAttributes['class'];
+    className?: HTMLAttributes['class'];
+    closable?: boolean;
+    closeIcon?: VNodeChild;
+    closeOnEsc?: boolean;
+    confirmLoading?: boolean;
+    content?: VNodeChild;
+    direction?: ConfigDirection;
+    footer?: VNodeChild;
+    footerFill?: boolean;
+    fullScreen?: boolean;
+    getContainerContext?: () => unknown;
+    getPopupContainer?: () => HTMLElement;
+    hasCancel?: boolean;
+    header?: VNodeChild;
+    height?: string | number;
+    icon?: VNodeChild;
+    keepDOM?: boolean;
+    lazyRender?: boolean;
+    mask?: boolean;
+    maskClosable?: boolean;
+    maskFixed?: boolean;
+    maskStyle?: StyleValue;
+    modalContentClass?: HTMLAttributes['class'];
+    modalRender?: (dialog: VNodeChild) => VNodeChild;
+    motion?: boolean;
+    okButtonProps?: ModalButtonProps;
+    okText?: string;
+    okType?: ButtonType;
+    onAfterClose?: () => void;
+    onCancel?: ModalActionHandler;
+    onOk?: ModalActionHandler;
+    preventScroll?: boolean;
+    size?: ModalSize;
+    style?: StyleValue;
+    title?: VNodeChild;
+    visible?: boolean;
+    width?: string | number;
+    zIndex?: number;
+}
+export interface ModalSlots {
+    body?: () => VNodeChild;
+    closeIcon?: () => VNodeChild;
+    default?: () => VNodeChild;
+    footer?: () => VNodeChild;
+    header?: () => VNodeChild;
+    icon?: () => VNodeChild;
+    title?: () => VNodeChild;
+}
+export interface ModalEmits {
+    'update:visible': [visible: boolean];
+}
+export interface ModalConfirmProps extends ModalProps {
+    type?: ModalConfirmType;
+}
+export interface ModalHandle {
+    destroy: () => void;
+    update: (config: Partial<ModalConfirmProps>) => void;
+}
+export type ModalMethod = (config: ModalProps) => ModalHandle;
+export interface ModalMethods {
+    confirm: ModalMethod;
+    error: ModalMethod;
+    info: ModalMethod;
+    success: ModalMethod;
+    warning: ModalMethod;
+}
+export type ModalUseModalResult = readonly [ModalMethods, Component];
+export interface ModalStaticMethods extends ModalMethods {
+    destroyAll: () => void;
+    useModal: () => ModalUseModalResult;
+}

package/dist/modal/use-modal.d.ts

@@ -0,0 +1,2 @@
+import { ModalUseModalResult } from './types';
+export declare function useModal(): ModalUseModalResult;

package/dist/modal-YVolL7Hz.js

@@ -0,0 +1,221 @@
+import { n as e, t } from "./Modal-BhmFYVFw.js";
+import { computed as n, createApp as r, createBlock as i, defineComponent as a, h as o, markRaw as s, mergeProps as c, nextTick as l, openBlock as u, shallowReactive as d, shallowRef as f } from "vue";
+import { IconAlertCircle as p, IconAlertTriangle as m, IconHelpCircle as h, IconInfoCircle as g, IconTickCircle as _ } from "@aifuxi/semi-icons-vue";
+//#endregion
+//#region src/modal/ConfirmModal.vue
+var v = /* @__PURE__ */ a({
+	__name: "ConfirmModal",
+	props: {
+		config: {},
+		visible: { type: Boolean }
+	},
+	emits: ["closed", "update:visible"],
+	setup(r, { emit: a }) {
+		let s = r, d = a, v = f(!1), y = f(!1), b = {
+			confirm: h,
+			error: p,
+			info: g,
+			success: _,
+			warning: m
+		}, x = n(() => s.config.type ?? "confirm"), S = n(() => [
+			s.config.class,
+			s.config.className,
+			"semi-modal-confirm",
+			s.config.direction === "rtl" ? "semi-modal-confirm-rtl" : void 0
+		]), C = n(() => s.config.title == null ? void 0 : o("span", { class: "semi-modal-confirm-title-text" }, s.config.title)), w = n(() => {
+			if (s.config.icon !== void 0) return s.config.icon;
+			let e = b[x.value];
+			return o(e, {
+				class: ["semi-modal-confirm-icon", `semi-modal-${x.value}-icon`],
+				size: "extra-large"
+			});
+		}), T = n(() => o("div", {
+			class: ["semi-modal-confirm-content", { "semi-modal-confirm-content-withIcon": w.value != null }],
+			"x-semi-prop": "content"
+		}, [o(e, { content: s.config.content })])), E = n(() => ({
+			...x.value === "error" ? { type: "danger" } : {},
+			...s.config.okButtonProps
+		})), D = /* @__PURE__ */ new Set([
+			"afterClose",
+			"class",
+			"className",
+			"confirmLoading",
+			"cancelLoading",
+			"content",
+			"icon",
+			"okButtonProps",
+			"onAfterClose",
+			"onCancel",
+			"onOk",
+			"title",
+			"type",
+			"visible"
+		]), O = n(() => Object.fromEntries(Object.entries(s.config).filter(([e]) => !D.has(e))));
+		function k(e) {
+			return !!(e && typeof e.then == "function");
+		}
+		function A() {}
+		function j(e) {
+			let t = s.config.onOk?.(e);
+			if (!k(t)) {
+				d("update:visible", !1);
+				return;
+			}
+			v.value = !0, Promise.resolve(t).then(() => d("update:visible", !1), () => {
+				v.value = !1;
+			});
+		}
+		function M(e) {
+			let t = s.config.onCancel?.(e);
+			if (!k(t)) {
+				d("update:visible", !1);
+				return;
+			}
+			y.value = !0, Promise.resolve(t).then(() => d("update:visible", !1), () => {
+				y.value = !1;
+			});
+		}
+		function N() {
+			s.config.afterClose?.(), s.config.onAfterClose !== s.config.afterClose && s.config.onAfterClose?.(), l(() => d("closed"));
+		}
+		return (e, n) => (u(), i(t, c(O.value, {
+			visible: s.visible,
+			class: S.value,
+			title: C.value,
+			icon: w.value,
+			content: T.value,
+			"confirm-loading": s.config.confirmLoading ?? v.value,
+			"cancel-loading": s.config.cancelLoading ?? y.value,
+			"ok-button-props": E.value,
+			"on-ok": j,
+			"on-cancel": M,
+			"on-after-close": N,
+			"onUpdate:visible": A
+		}), null, 16, [
+			"visible",
+			"class",
+			"title",
+			"icon",
+			"content",
+			"confirm-loading",
+			"cancel-loading",
+			"ok-button-props"
+		]));
+	}
+}), y = /* @__PURE__ */ new Set();
+function b(e, t) {
+	if (typeof document > "u") throw Error("Modal imperative methods are only available in a browser.");
+	let n = document.createElement("div");
+	document.body.appendChild(n);
+	let i = d({
+		config: {
+			...t,
+			type: e
+		},
+		visible: !0
+	}), s = !1, c = () => {
+		s || (s = !0, y.delete(f), u.unmount(), n.remove());
+	}, l = a({
+		name: "ImperativeModalRoot",
+		setup: () => () => o(v, {
+			config: i.config,
+			visible: i.visible,
+			"onUpdate:visible": (e) => {
+				i.visible = e;
+			},
+			onClosed: c
+		})
+	}), u = r(l);
+	u.mount(n);
+	function f() {
+		i.visible = !1;
+	}
+	return y.add(f), {
+		destroy: f,
+		update(t) {
+			i.config = {
+				...i.config,
+				...t,
+				type: e
+			};
+		}
+	};
+}
+var x = {
+	confirm: (e) => b("confirm", e),
+	error: (e) => b("error", e),
+	info: (e) => b("info", e),
+	success: (e) => b("success", e),
+	warning: (e) => b("warning", e)
+};
+function S() {
+	for (let e of [...y]) e();
+}
+//#endregion
+//#region src/modal/use-modal.ts
+var C = 0;
+function w() {
+	let e = d([]);
+	function t(t, n) {
+		let r = d({
+			config: {
+				...n,
+				type: t
+			},
+			id: C++,
+			visible: !0
+		});
+		return e.push(r), {
+			destroy: () => {
+				r.visible = !1;
+			},
+			update: (e) => {
+				r.config = {
+					...r.config,
+					...e,
+					type: t
+				};
+			}
+		};
+	}
+	return [{
+		confirm: (e) => t("confirm", e),
+		error: (e) => t("error", e),
+		info: (e) => t("info", e),
+		success: (e) => t("success", e),
+		warning: (e) => t("warning", e)
+	}, s(a({
+		name: "ModalContextHolder",
+		setup: () => () => e.map((t) => o(v, {
+			key: t.id,
+			config: t.config,
+			visible: t.visible,
+			"onUpdate:visible": (e) => {
+				t.visible = e;
+			},
+			onClosed: () => {
+				let n = e.indexOf(t);
+				n >= 0 && e.splice(n, 1);
+			}
+		}))
+	}))];
+}
+//#endregion
+//#region src/modal/types.ts
+var T = [
+	"small",
+	"medium",
+	"large",
+	"full-width"
+], E = [
+	"success",
+	"info",
+	"warning",
+	"error",
+	"confirm"
+], D = Object.assign(t, x, {
+	destroyAll: S,
+	useModal: w
+});
+//#endregion
+export { w as i, E as n, T as r, D as t };

package/dist/navigation/CollapseButton.vue.d.ts

@@ -0,0 +1,12 @@
+import { CollapseButtonProps } from './types';
+declare const __VLS_export: import('vue').DefineComponent<CollapseButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (isCollapsed: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<CollapseButtonProps> & Readonly<{
+    onClick?: (isCollapsed: boolean) => any;
+}>, {
+    locale: import('./types').NavigationLocale;
+    prefixCls: string;
+    isCollapsed: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/navigation/NavFooter.vue.d.ts

@@ -0,0 +1,15 @@
+import { NavFooterProps, NavFooterSlots } from './types';
+type __VLS_Slots = NavFooterSlots;
+declare const __VLS_base: import('vue').DefineComponent<NavFooterProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<NavFooterProps> & Readonly<{
+    onClick?: (event: MouseEvent) => any;
+}>, {}, {}, {}, {}, 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/navigation/NavHeader.vue.d.ts

@@ -0,0 +1,13 @@
+import { NavHeaderProps, NavHeaderSlots } from './types';
+type __VLS_Slots = NavHeaderSlots;
+declare const __VLS_base: import('vue').DefineComponent<NavHeaderProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<NavHeaderProps> & Readonly<{}>, {
+    prefixCls: 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/navigation/NavItem.d.ts

@@ -0,0 +1,177 @@
+import { PropType, VNodeChild } from 'vue';
+import { ItemKey, NavigationContent, NavItemProps, NavItemSelectedData } from './types';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    class: {
+        type: PropType<NavItemProps["class"]>;
+        default: undefined;
+    };
+    className: {
+        type: PropType<NavItemProps["className"]>;
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    forwardRef: {
+        type: PropType<(element: HTMLLIElement | null) => void>;
+        default: undefined;
+    };
+    icon: {
+        type: PropType<NavigationContent>;
+        default: undefined;
+    };
+    indent: {
+        type: PropType<boolean | number>;
+        default: boolean;
+    };
+    isCollapsed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isSubNav: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    itemKey: {
+        type: PropType<ItemKey>;
+        default: undefined;
+    };
+    level: {
+        type: NumberConstructor;
+        default: number;
+    };
+    link: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    linkOptions: {
+        type: PropType<NavItemProps["linkOptions"]>;
+        default: undefined;
+    };
+    style: {
+        type: PropType<NavItemProps["style"]>;
+        default: undefined;
+    };
+    tabIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    text: {
+        type: PropType<NavigationContent>;
+        default: undefined;
+    };
+    toggleIcon: {
+        type: PropType<NavigationContent>;
+        default: undefined;
+    };
+    tooltipHideDelay: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    tooltipShowDelay: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+}>, () => VNodeChild, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (data: NavItemSelectedData) => boolean;
+    mouseenter: (event: MouseEvent) => boolean;
+    mouseleave: (event: MouseEvent) => boolean;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    class: {
+        type: PropType<NavItemProps["class"]>;
+        default: undefined;
+    };
+    className: {
+        type: PropType<NavItemProps["className"]>;
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    forwardRef: {
+        type: PropType<(element: HTMLLIElement | null) => void>;
+        default: undefined;
+    };
+    icon: {
+        type: PropType<NavigationContent>;
+        default: undefined;
+    };
+    indent: {
+        type: PropType<boolean | number>;
+        default: boolean;
+    };
+    isCollapsed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isSubNav: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    itemKey: {
+        type: PropType<ItemKey>;
+        default: undefined;
+    };
+    level: {
+        type: NumberConstructor;
+        default: number;
+    };
+    link: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    linkOptions: {
+        type: PropType<NavItemProps["linkOptions"]>;
+        default: undefined;
+    };
+    style: {
+        type: PropType<NavItemProps["style"]>;
+        default: undefined;
+    };
+    tabIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    text: {
+        type: PropType<NavigationContent>;
+        default: undefined;
+    };
+    toggleIcon: {
+        type: PropType<NavigationContent>;
+        default: undefined;
+    };
+    tooltipHideDelay: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    tooltipShowDelay: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{
+    onClick?: (data: NavItemSelectedData) => any;
+    onMouseenter?: (event: MouseEvent) => any;
+    onMouseleave?: (event: MouseEvent) => any;
+}>, {
+    text: NavigationContent;
+    className: import('vue').ClassValue;
+    style: import('vue').StyleValue;
+    icon: NavigationContent;
+    disabled: boolean;
+    link: string;
+    class: import('vue').ClassValue;
+    tabIndex: number;
+    forwardRef: (element: HTMLLIElement | null) => void;
+    isSubNav: boolean;
+    linkOptions: import('vue').AnchorHTMLAttributes | undefined;
+    indent: number | boolean;
+    isCollapsed: boolean;
+    itemKey: ItemKey;
+    level: number;
+    toggleIcon: NavigationContent;
+    tooltipHideDelay: number;
+    tooltipShowDelay: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/navigation/Navigation.vue.d.ts

@@ -0,0 +1,29 @@
+import { ItemKey, NavigationClickData, NavigationOpenChangeData, NavigationProps, NavigationSelectData, NavigationSlots } from './types';
+type __VLS_Slots = NavigationSlots;
+declare const __VLS_base: import('vue').DefineComponent<NavigationProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (data: NavigationSelectData) => any;
+    click: (data: NavigationClickData) => any;
+    deselect: (data?: unknown) => any;
+    openChange: (data: NavigationOpenChangeData) => any;
+    collapseChange: (isCollapsed: boolean) => any;
+    "update:isCollapsed": (isCollapsed: boolean) => any;
+    "update:openKeys": (openKeys: ItemKey[]) => any;
+    "update:selectedKeys": (selectedKeys: ItemKey[]) => any;
+}, string, import('vue').PublicProps, Readonly<NavigationProps> & Readonly<{
+    onSelect?: (data: NavigationSelectData) => any;
+    onClick?: (data: NavigationClickData) => any;
+    onDeselect?: (data?: unknown) => any;
+    onOpenChange?: (data: NavigationOpenChangeData) => any;
+    onCollapseChange?: (isCollapsed: boolean) => any;
+    "onUpdate:isCollapsed"?: (isCollapsed: boolean) => any;
+    "onUpdate:openKeys"?: (openKeys: ItemKey[]) => any;
+    "onUpdate:selectedKeys"?: (selectedKeys: ItemKey[]) => any;
+}>, {}, {}, {}, {}, 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/navigation/NavigationContextProvider.d.ts

@@ -0,0 +1,16 @@
+import { PropType } from 'vue';
+import { NavigationContextValue } from './navigation-context';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    value: {
+        type: PropType<NavigationContextValue>;
+        required: true;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    value: {
+        type: PropType<NavigationContextValue>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/navigation/NavigationIconRenderer.d.ts

@@ -0,0 +1,45 @@
+import { PropType } from 'vue';
+import { NavigationContent } from './types';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    animationClass: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    content: {
+        type: PropType<NavigationContent>;
+        default: undefined;
+    };
+    force: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => string | number | boolean | void | import('vue').VNodeArrayChildren | import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    animationClass: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    content: {
+        type: PropType<NavigationContent>;
+        default: undefined;
+    };
+    force: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    size: string;
+    content: NavigationContent;
+    animationClass: string;
+    force: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/navigation/NavigationItemTree.vue.d.ts

@@ -0,0 +1,8 @@
+import { NavigationItemObject } from './types';
+type __VLS_Props = {
+    item: NavigationItemObject;
+    level: number;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/navigation/NavigationNodeRenderer.d.ts

@@ -0,0 +1,18 @@
+import { PropType } from 'vue';
+import { NavigationContent } from './types';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    content: {
+        type: PropType<NavigationContent>;
+        default: undefined;
+    };
+}>, () => string | number | boolean | void | import('vue').VNodeArrayChildren | import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    content: {
+        type: PropType<NavigationContent>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    content: NavigationContent;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/navigation/SubNav.vue.d.ts

@@ -0,0 +1,18 @@
+import { SubNavProps, SubNavSlots } from './types';
+type __VLS_Slots = SubNavSlots;
+declare const __VLS_base: import('vue').DefineComponent<SubNavProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SubNavProps> & Readonly<{}>, {
+    disabled: boolean;
+    maxHeight: number;
+    isOpen: boolean;
+    indent: boolean | number;
+    isCollapsed: boolean;
+    level: 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;
+    };
+};