antdv-next 0.0.111 → 1.0.0-alpha.1

package/dist/flex/style/index.d.ts

@@ -0,0 +1,8 @@
+import "../../theme/internal.js";
+import "vue";
+
+//#region src/flex/style/index.d.ts
+/** Component only token. Which will handle additional calculation of alias token */
+interface ComponentToken {}
+//#endregion
+export { ComponentToken };

package/dist/flex/style/index.js

@@ -0,0 +1,67 @@
+import { genStyleHooks } from "../../theme/util/genStyleUtils.js";
+import { mergeToken } from "../../theme/internal.js";
+import { alignItemsValues, flexWrapValues, justifyContentValues } from "../utils.js";
+
+//#region src/flex/style/index.ts
+const genFlexStyle = (token) => {
+	const { componentCls } = token;
+	return { [componentCls]: {
+		"display": "flex",
+		"margin": 0,
+		"padding": 0,
+		"&-vertical": { flexDirection: "column" },
+		"&-rtl": { direction: "rtl" },
+		"&:empty": { display: "none" }
+	} };
+};
+const genFlexGapStyle = (token) => {
+	const { componentCls } = token;
+	return { [componentCls]: {
+		"&-gap-small": { gap: token.flexGapSM },
+		"&-gap-middle": { gap: token.flexGap },
+		"&-gap-large": { gap: token.flexGapLG }
+	} };
+};
+const genFlexWrapStyle = (token) => {
+	const { componentCls } = token;
+	const wrapStyle = {};
+	flexWrapValues.forEach((value) => {
+		wrapStyle[`${componentCls}-wrap-${value}`] = { flexWrap: value };
+	});
+	return wrapStyle;
+};
+const genAlignItemsStyle = (token) => {
+	const { componentCls } = token;
+	const alignStyle = {};
+	alignItemsValues.forEach((value) => {
+		alignStyle[`${componentCls}-align-${value}`] = { alignItems: value };
+	});
+	return alignStyle;
+};
+const genJustifyContentStyle = (token) => {
+	const { componentCls } = token;
+	const justifyStyle = {};
+	justifyContentValues.forEach((value) => {
+		justifyStyle[`${componentCls}-justify-${value}`] = { justifyContent: value };
+	});
+	return justifyStyle;
+};
+const prepareComponentToken = () => ({});
+var style_default = genStyleHooks("Flex", (token) => {
+	const { paddingXS, padding, paddingLG } = token;
+	const flexToken = mergeToken(token, {
+		flexGapSM: paddingXS,
+		flexGap: padding,
+		flexGapLG: paddingLG
+	});
+	return [
+		genFlexStyle(flexToken),
+		genFlexGapStyle(flexToken),
+		genFlexWrapStyle(flexToken),
+		genAlignItemsStyle(flexToken),
+		genJustifyContentStyle(flexToken)
+	];
+}, prepareComponentToken, { resetStyle: false });
+
+//#endregion
+export { style_default as default };

package/dist/flex/utils.js

@@ -0,0 +1,64 @@
+import { classNames } from "@v-c/util";
+
+//#region src/flex/utils.ts
+const flexWrapValues = [
+	"wrap",
+	"nowrap",
+	"wrap-reverse"
+];
+const justifyContentValues = [
+	"flex-start",
+	"flex-end",
+	"start",
+	"end",
+	"center",
+	"space-between",
+	"space-around",
+	"space-evenly",
+	"stretch",
+	"normal",
+	"left",
+	"right"
+];
+const alignItemsValues = [
+	"center",
+	"start",
+	"end",
+	"flex-start",
+	"flex-end",
+	"self-start",
+	"self-end",
+	"baseline",
+	"normal",
+	"stretch"
+];
+function genClsWrap(prefixCls, props) {
+	const wrap = props.wrap === true ? "wrap" : props.wrap;
+	return { [`${prefixCls}-wrap-${wrap}`]: wrap && flexWrapValues.includes(wrap) };
+}
+function genClsAlign(prefixCls, props) {
+	const alignCls = {};
+	alignItemsValues.forEach((cssKey) => {
+		alignCls[`${prefixCls}-align-${cssKey}`] = props.align === cssKey;
+	});
+	alignCls[`${prefixCls}-align-stretch`] = !props.align && !!props.vertical;
+	return alignCls;
+}
+function genClsJustify(prefixCls, props) {
+	const justifyCls = {};
+	justifyContentValues.forEach((cssKey) => {
+		justifyCls[`${prefixCls}-justify-${cssKey}`] = props.justify === cssKey;
+	});
+	return justifyCls;
+}
+function createFlexClassNames(prefixCls, props) {
+	return classNames({
+		...genClsWrap(prefixCls, props),
+		...genClsAlign(prefixCls, props),
+		...genClsJustify(prefixCls, props)
+	});
+}
+var utils_default = createFlexClassNames;
+
+//#endregion
+export { alignItemsValues, utils_default as default, flexWrapValues, justifyContentValues };

package/dist/float-button/BackTop.d.ts

@@ -0,0 +1,25 @@
+import { FloatButtonProps } from "./FloatButton.js";
+import { ComponentBaseProps } from "../config-provider/context.js";
+import * as vue249 from "vue";
+import { SlotsType } from "vue";
+
+//#region src/float-button/BackTop.d.ts
+interface BackTopProps extends Omit<FloatButtonProps, 'target'>, ComponentBaseProps {
+  visibilityHeight?: number;
+  target?: () => HTMLElement | Window | Document;
+  duration?: number;
+}
+interface BackTopEmits {
+  click: (e: MouseEvent) => void;
+  [key: string]: (...args: any[]) => void;
+}
+interface BackTopSlots {
+  default?: () => any;
+  icon?: () => any;
+}
+declare const BackTop: vue249.DefineSetupFnComponent<BackTopProps, BackTopEmits, SlotsType<BackTopSlots>, BackTopProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, vue249.PublicProps>;
+declare const BackTopWithInstall: typeof BackTop;
+//#endregion
+export { BackTopWithInstall };

package/dist/float-button/BackTop.js

@@ -0,0 +1,197 @@
+import throttleByAnimationFrame_default from "../_util/throttleByAnimationFrame.js";
+import { useComponentBaseConfig, useConfig } from "../config-provider/context.js";
+import { pureAttrs } from "../_util/hooks/useMergeSemantic.js";
+import "../_util/hooks/index.js";
+import { toPropsRefs } from "../_util/tools.js";
+import getScroll_default from "../_util/getScroll.js";
+import scrollTo from "../_util/scrollTo.js";
+import { getTransitionProps } from "../_util/motion.js";
+import { useGroupContext } from "./context.js";
+import FloatButton_default, { floatButtonPrefixCls } from "./FloatButton.js";
+import { Transition, computed, createVNode, defineComponent, mergeProps, onBeforeUnmount, onMounted, shallowRef, watch } from "vue";
+import { filterEmpty } from "@v-c/util/dist/props-util";
+import { VerticalAlignTopOutlined } from "@antdv-next/icons";
+import { omit } from "es-toolkit";
+
+//#region src/float-button/BackTop.tsx
+const defaultIcon = createVNode(VerticalAlignTopOutlined, null, null);
+const BackTopWithInstall = /* @__PURE__ */ defineComponent((props, { attrs, slots, emit, expose }) => {
+	const { backTopIcon } = useComponentBaseConfig("floatButton", props, ["backTopIcon"], floatButtonPrefixCls);
+	const globalConfig = useConfig();
+	const groupContext = useGroupContext();
+	const { target, visibilityHeight, duration } = toPropsRefs(props, "target", "visibilityHeight", "duration");
+	const visible = shallowRef((visibilityHeight.value ?? 400) === 0);
+	const floatButtonRef = shallowRef(null);
+	expose({ nativeElement: computed(() => floatButtonRef.value?.nativeElement ?? null) });
+	const getDefaultTarget = () => floatButtonRef.value?.nativeElement?.ownerDocument ?? (typeof window !== "undefined" ? window : void 0);
+	const container = shallowRef(null);
+	const mergedVisibility = computed(() => visibilityHeight.value ?? 400);
+	const handleScroll = throttleByAnimationFrame_default((event) => {
+		visible.value = getScroll_default(event?.target ?? container.value ?? getDefaultTarget()) >= mergedVisibility.value;
+	});
+	const bindScroll = () => {
+		const targetNode = target.value?.() ?? getDefaultTarget();
+		if (targetNode) {
+			container.value = targetNode;
+			targetNode.addEventListener?.("scroll", handleScroll);
+			handleScroll({ target: targetNode });
+		}
+	};
+	const removeScroll = () => {
+		container.value?.removeEventListener?.("scroll", handleScroll);
+		container.value = null;
+	};
+	onMounted(() => {
+		bindScroll();
+	});
+	onBeforeUnmount(() => {
+		handleScroll.cancel();
+		removeScroll();
+	});
+	watch(target, () => {
+		removeScroll();
+		bindScroll();
+	});
+	const triggerCheck = () => {
+		const node = container.value ?? getDefaultTarget();
+		if (node) handleScroll({ target: node });
+	};
+	watch(mergedVisibility, () => {
+		triggerCheck();
+	});
+	const mergedShape = computed(() => groupContext?.value?.shape ?? props.shape ?? "circle");
+	const mergedIcon = computed(() => {
+		const slotIcon = slots.icon ? filterEmpty(slots.icon()) : [];
+		if (slotIcon.length) return slotIcon;
+		return props.icon ?? backTopIcon?.value ?? defaultIcon;
+	});
+	const rootPrefixCls = computed(() => globalConfig.value?.getPrefixCls?.());
+	const transitionProps = computed(() => getTransitionProps(`${rootPrefixCls.value}-fade`));
+	const scrollToTop = (e) => {
+		scrollTo(0, {
+			getContainer: target.value || getDefaultTarget,
+			duration: duration.value ?? 450
+		});
+		emit("click", e);
+	};
+	return () => createVNode(Transition, transitionProps.value, { default: () => visible.value ? createVNode(FloatButton_default, mergeProps(pureAttrs(attrs), omit(props, [
+		"visibilityHeight",
+		"target",
+		"duration"
+	]), {
+		"ref": floatButtonRef,
+		"shape": mergedShape.value,
+		"icon": mergedIcon.value,
+		"onClick": scrollToTop
+	}), { default: slots.default }) : null });
+}, {
+	emits: ["click"],
+	props: {
+		visibilityHeight: {
+			type: Number,
+			required: false
+		},
+		target: {
+			type: Function,
+			required: false
+		},
+		duration: {
+			type: Number,
+			required: false
+		},
+		icon: {
+			type: [
+				Function,
+				Boolean,
+				String,
+				Number,
+				null,
+				Object
+			],
+			required: false
+		},
+		description: {
+			type: [
+				Function,
+				Boolean,
+				String,
+				Number,
+				null,
+				Object
+			],
+			required: false
+		},
+		content: {
+			type: [
+				Function,
+				Boolean,
+				String,
+				Number,
+				null,
+				Object
+			],
+			required: false
+		},
+		type: {
+			type: String,
+			required: false
+		},
+		shape: {
+			type: String,
+			required: false
+		},
+		tooltip: {
+			type: [
+				Function,
+				Boolean,
+				String,
+				Number,
+				null,
+				Object
+			],
+			required: false
+		},
+		href: {
+			type: String,
+			required: false
+		},
+		badge: {
+			type: Object,
+			required: false
+		},
+		htmlType: {
+			type: String,
+			required: false
+		},
+		ariaLabel: {
+			type: String,
+			required: false
+		},
+		style: {
+			type: Object,
+			required: false
+		},
+		classes: {
+			type: [Object, Function],
+			required: false
+		},
+		styles: {
+			type: [Object, Function],
+			required: false
+		},
+		rootClass: {
+			type: String,
+			required: false
+		},
+		prefixCls: {
+			type: String,
+			required: false
+		}
+	},
+	name: "AFloatBackTop",
+	inheritAttrs: false
+});
+var BackTop_default = BackTopWithInstall;
+
+//#endregion
+export { BackTop_default as default };

package/dist/float-button/FloatButton.d.ts

@@ -0,0 +1,62 @@
+import { VueNode } from "../_util/type.js";
+import { SemanticClassNamesType, SemanticStylesType } from "../_util/hooks/useMergeSemantic.js";
+import "../_util/hooks/index.js";
+import { TooltipProps } from "../tooltip/index.js";
+import { ButtonHTMLType } from "../button/buttonHelper.js";
+import { ButtonSemanticName } from "../button/Button.js";
+import "../button/index.js";
+import { BadgeProps } from "../badge/index.js";
+import { ComponentBaseProps } from "../config-provider/context.js";
+import * as vue251 from "vue";
+import { CSSProperties, SlotsType } from "vue";
+
+//#region src/float-button/FloatButton.d.ts
+type FloatButtonElement = HTMLAnchorElement | HTMLButtonElement;
+interface FloatButtonRef {
+  nativeElement: FloatButtonElement | null;
+}
+type FloatButtonType = 'default' | 'primary';
+type FloatButtonShape = 'circle' | 'square';
+type FloatButtonGroupTrigger = 'click' | 'hover';
+type FloatButtonBadgeProps = Omit<BadgeProps, 'status' | 'text' | 'title'>;
+type FloatButtonSemanticName = ButtonSemanticName;
+type FloatButtonClassNamesType = SemanticClassNamesType<FloatButtonProps, FloatButtonSemanticName>;
+type FloatButtonStylesType = SemanticStylesType<FloatButtonProps, FloatButtonSemanticName>;
+interface FloatButtonProps extends ComponentBaseProps {
+  icon?: VueNode;
+  /** @deprecated Use `content` instead */
+  description?: VueNode;
+  content?: VueNode;
+  type?: FloatButtonType;
+  shape?: FloatButtonShape;
+  tooltip?: VueNode | TooltipProps;
+  href?: string;
+  target?: '_self' | '_blank' | '_parent' | '_top' | string;
+  badge?: FloatButtonBadgeProps & {
+    class?: string;
+  };
+  htmlType?: ButtonHTMLType;
+  ariaLabel?: string;
+  style?: CSSProperties;
+  classes?: FloatButtonClassNamesType;
+  styles?: FloatButtonStylesType;
+}
+interface FloatButtonSlots {
+  default?: () => any;
+  icon?: () => any;
+  tooltip?: () => any;
+}
+interface FloatButtonEmits {
+  click: (e: MouseEvent) => void;
+  mouseenter: (e: MouseEvent) => void;
+  mouseleave: (e: MouseEvent) => void;
+  focus: (e: FocusEvent) => void;
+  blur: (e: FocusEvent) => void;
+  [key: string]: (...args: any[]) => void;
+}
+declare const InternalFloatButton: vue251.DefineSetupFnComponent<FloatButtonProps, FloatButtonEmits, SlotsType<FloatButtonSlots>, FloatButtonProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, vue251.PublicProps>;
+declare const FloatButton: typeof InternalFloatButton;
+//#endregion
+export { FloatButton, FloatButtonGroupTrigger, FloatButtonProps, FloatButtonRef };

package/dist/float-button/FloatButton.js

@@ -0,0 +1,217 @@
+import { useComponentBaseConfig } from "../config-provider/context.js";
+import { pureAttrs, useMergeSemantic, useToArr, useToProps } from "../_util/hooks/useMergeSemantic.js";
+import { useZIndex } from "../_util/hooks/useZIndex.js";
+import "../_util/hooks/index.js";
+import { getSlotPropsFnRun, toPropsRefs } from "../_util/tools.js";
+import useCSSVarCls_default from "../config-provider/hooks/useCSSVarCls.js";
+import tooltip_default from "../tooltip/index.js";
+import button_default from "../button/index.js";
+import badge_default from "../badge/index.js";
+import { useGroupContext } from "./context.js";
+import convertToTooltipProps from "../_util/convertToTooltipProps.js";
+import style_default from "./style/index.js";
+import { Fragment, computed, createVNode, defineComponent, isVNode, mergeDefaults, mergeProps, shallowRef } from "vue";
+import { classNames } from "@v-c/util";
+import { filterEmpty, removeUndefined } from "@v-c/util/dist/props-util";
+import { FileTextOutlined } from "@antdv-next/icons";
+import { omit } from "es-toolkit";
+
+//#region src/float-button/FloatButton.tsx
+function _isSlot(s) {
+	return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
+}
+const floatButtonPrefixCls = "float-btn";
+const FloatButton = /* @__PURE__ */ defineComponent((props, { slots, attrs, emit, expose }) => {
+	const { prefixCls, class: contextClassName, style: contextStyle, classes: contextClasses, styles: contextStyles, direction } = useComponentBaseConfig("floatButton", props, [], floatButtonPrefixCls);
+	const rootCls = useCSSVarCls_default(prefixCls);
+	const groupContext = useGroupContext();
+	const groupClassNames = computed(() => groupContext?.value?.classNames);
+	const groupStyles = computed(() => groupContext?.value?.styles);
+	const groupShape = computed(() => groupContext?.value?.shape);
+	const groupIndividual = computed(() => groupContext?.value?.individual);
+	const { classes, styles, badge, tooltip, style } = toPropsRefs(props, "classes", "styles", "badge", "tooltip", "style");
+	const mergedShape = computed(() => groupShape.value ?? props.shape ?? "circle");
+	const mergedType = computed(() => props.type ?? "default");
+	const mergedIndividual = computed(() => groupIndividual.value ?? true);
+	const mergedProps = computed(() => ({
+		...props,
+		type: mergedType.value,
+		shape: mergedShape.value
+	}));
+	const floatButtonClassNames = computed(() => ({
+		icon: `${prefixCls.value}-icon`,
+		content: `${prefixCls.value}-content`
+	}));
+	const [hashId, cssVarCls] = style_default(prefixCls, rootCls);
+	const [mergedClassNames, mergedStyles] = useMergeSemantic(useToArr(floatButtonClassNames, groupClassNames, contextClasses, classes), useToArr(groupStyles, contextStyles, styles), useToProps(mergedProps));
+	const buttonRef = shallowRef();
+	expose({ nativeElement: computed(() => buttonRef.value) });
+	const [zIndex] = useZIndex("FloatButton", computed(() => style.value?.zIndex));
+	const zIndexStyle = computed(() => zIndex.value === void 0 ? void 0 : { zIndex: zIndex.value });
+	return () => {
+		const slotContent = filterEmpty(slots.default?.() ?? []);
+		let contentNodes = null;
+		if (slotContent.length) contentNodes = slotContent;
+		else if (props.content !== void 0) contentNodes = props.content;
+		else if (props.description !== void 0) contentNodes = props.description;
+		const hasContent = Array.isArray(contentNodes) ? contentNodes.length > 0 : contentNodes !== null && contentNodes !== void 0 && contentNodes !== false;
+		const mergedIcon = getSlotPropsFnRun(slots, props, "icon") ?? props.icon ?? (!hasContent ? createVNode(FileTextOutlined, null, null) : null);
+		const tooltipSlotNodes = filterEmpty(slots.tooltip?.() ?? []);
+		const tooltipNode = tooltipSlotNodes.length ? tooltipSlotNodes.length === 1 ? tooltipSlotNodes[0] : tooltipSlotNodes : void 0;
+		const tooltipProps = convertToTooltipProps(tooltip.value ?? tooltipNode);
+		const badgeProps = badge.value ? omit(badge.value, [
+			"status",
+			"text",
+			"title"
+		]) : null;
+		const badgeNode = badge.value ? createVNode(badge_default, mergeProps(badgeProps, { "class": classNames(badgeProps?.class, `${prefixCls.value}-badge`, { [`${prefixCls.value}-badge-dot`]: badgeProps?.dot }) }), null) : null;
+		const buttonClass = classNames(prefixCls.value, hashId.value, cssVarCls.value, rootCls.value, `${prefixCls.value}-${mergedType.value}`, `${prefixCls.value}-${mergedShape.value}`, {
+			[`${prefixCls.value}-rtl`]: direction.value === "rtl",
+			[`${prefixCls.value}-individual`]: mergedIndividual.value,
+			[`${prefixCls.value}-icon-only`]: !hasContent
+		}, contextClassName.value, props.rootClass, attrs.class, mergedClassNames.value.root);
+		const buttonSlots = { default: () => createVNode(Fragment, null, [contentNodes, badgeNode]) };
+		const buttonNode = createVNode(button_default, mergeProps(removeUndefined(pureAttrs(attrs)), {
+			"ref": (node) => {
+				buttonRef.value = node;
+			},
+			"class": buttonClass,
+			"style": [
+				mergedStyles.value.root,
+				contextStyle.value,
+				props.style,
+				attrs.style,
+				zIndexStyle.value
+			],
+			"classes": mergedClassNames.value,
+			"styles": mergedStyles.value,
+			"size": "large",
+			"type": mergedType.value,
+			"shape": mergedShape.value,
+			"href": props.href,
+			"target": props.target,
+			"icon": mergedIcon ? () => mergedIcon : void 0,
+			"htmlType": props.htmlType,
+			"aria-label": props.ariaLabel,
+			"_skipSemantic": true,
+			"onClick": (e) => emit("click", e),
+			"onMouseenter": (e) => emit("mouseenter", e),
+			"onMouseleave": (e) => emit("mouseleave", e),
+			"onFocus": (e) => emit("focus", e),
+			"onBlur": (e) => emit("blur", e)
+		}), buttonSlots);
+		if (tooltipProps) return createVNode(tooltip_default, tooltipProps, _isSlot(buttonNode) ? buttonNode : { default: () => [buttonNode] });
+		return buttonNode;
+	};
+}, {
+	emits: [
+		"click",
+		"mouseenter",
+		"mouseleave",
+		"focus",
+		"blur"
+	],
+	props: /* @__PURE__ */ mergeDefaults({
+		icon: {
+			type: [
+				Function,
+				Boolean,
+				String,
+				Number,
+				null,
+				Object
+			],
+			required: false
+		},
+		description: {
+			type: [
+				Function,
+				Boolean,
+				String,
+				Number,
+				null,
+				Object
+			],
+			required: false
+		},
+		content: {
+			type: [
+				Function,
+				Boolean,
+				String,
+				Number,
+				null,
+				Object
+			],
+			required: false
+		},
+		type: {
+			type: String,
+			required: false
+		},
+		shape: {
+			type: String,
+			required: false
+		},
+		tooltip: {
+			type: [
+				Function,
+				Boolean,
+				String,
+				Number,
+				null,
+				Object
+			],
+			required: false
+		},
+		href: {
+			type: String,
+			required: false
+		},
+		target: {
+			type: String,
+			required: false
+		},
+		badge: {
+			type: Object,
+			required: false
+		},
+		htmlType: {
+			type: String,
+			required: false
+		},
+		ariaLabel: {
+			type: String,
+			required: false
+		},
+		style: {
+			type: Object,
+			required: false
+		},
+		classes: {
+			type: [Object, Function],
+			required: false
+		},
+		styles: {
+			type: [Object, Function],
+			required: false
+		},
+		rootClass: {
+			type: String,
+			required: false
+		},
+		prefixCls: {
+			type: String,
+			required: false
+		}
+	}, {
+		type: "default",
+		shape: "circle"
+	}),
+	name: "AFloatButton",
+	inheritAttrs: false
+});
+var FloatButton_default = FloatButton;
+
+//#endregion
+export { FloatButton_default as default, floatButtonPrefixCls };

package/dist/float-button/FloatButtonGroup.d.ts

@@ -0,0 +1,39 @@
+import { VueNode } from "../_util/type.js";
+import { SemanticClassNamesType, SemanticStylesType } from "../_util/hooks/useMergeSemantic.js";
+import "../_util/hooks/index.js";
+import { FloatButtonGroupTrigger, FloatButtonProps } from "./FloatButton.js";
+import { ComponentBaseProps } from "../config-provider/context.js";
+import * as vue253 from "vue";
+import { CSSProperties, SlotsType } from "vue";
+
+//#region src/float-button/FloatButtonGroup.d.ts
+type InternalFloatButtonGroupSemanticName = 'root' | 'list' | 'item' | 'itemIcon' | 'itemContent' | 'trigger' | 'triggerIcon' | 'triggerContent';
+type FloatButtonGroupClassNamesType = SemanticClassNamesType<FloatButtonGroupProps, InternalFloatButtonGroupSemanticName>;
+type FloatButtonGroupStylesType = SemanticStylesType<FloatButtonGroupProps, InternalFloatButtonGroupSemanticName>;
+interface FloatButtonGroupProps extends Omit<FloatButtonProps, 'classes' | 'styles'>, ComponentBaseProps {
+  classes?: FloatButtonGroupClassNamesType;
+  styles?: FloatButtonGroupStylesType;
+  trigger?: FloatButtonGroupTrigger;
+  open?: boolean;
+  defaultOpen?: boolean;
+  closeIcon?: VueNode;
+  placement?: 'top' | 'left' | 'right' | 'bottom';
+  style?: CSSProperties;
+}
+interface FloatButtonGroupSlots {
+  default?: () => any;
+  closeIcon?: () => any;
+  icon?: () => any;
+}
+interface FloatButtonGroupEmits {
+  'openChange': (open: boolean) => void;
+  'update:open': (open: boolean) => void;
+  'click': (e: MouseEvent) => void;
+  [key: string]: (...args: any[]) => void;
+}
+declare const InternalFloatButtonGroup: vue253.DefineSetupFnComponent<FloatButtonGroupProps, FloatButtonGroupEmits, SlotsType<FloatButtonGroupSlots>, FloatButtonGroupProps & {
+  [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, vue253.PublicProps>;
+declare const FloatButtonGroup: typeof InternalFloatButtonGroup;
+//#endregion
+export { FloatButtonGroup, FloatButtonGroupProps };