antdv-next 0.0.0 → 1.0.0-alpha.1

package/dist/table/style/radius.js

@@ -0,0 +1,28 @@
+import { unit } from "@antdv-next/cssinjs";
+
+//#region src/table/style/radius.ts
+const genRadiusStyle = (token) => {
+	const { componentCls, tableRadius } = token;
+	return { [`${componentCls}-wrapper`]: { [componentCls]: {
+		[`${componentCls}-title, ${componentCls}-header`]: { borderRadius: `${unit(tableRadius)} ${unit(tableRadius)} 0 0` },
+		[`${componentCls}-title + ${componentCls}-container`]: {
+			"borderStartStartRadius": 0,
+			"borderStartEndRadius": 0,
+			[`${componentCls}-header, table`]: { borderRadius: 0 },
+			"table > thead > tr:first-child": { "th:first-child, th:last-child, td:first-child, td:last-child": { borderRadius: 0 } }
+		},
+		"&-container": {
+			"borderStartStartRadius": tableRadius,
+			"borderStartEndRadius": tableRadius,
+			"table > thead > tr:first-child": {
+				"> *:first-child": { borderStartStartRadius: tableRadius },
+				"> *:last-child": { borderStartEndRadius: tableRadius }
+			}
+		},
+		"&-footer": { borderRadius: `0 0 ${unit(tableRadius)} ${unit(tableRadius)}` }
+	} } };
+};
+var radius_default = genRadiusStyle;
+
+//#endregion
+export { radius_default as default };

package/dist/table/style/rtl.js

@@ -0,0 +1,28 @@
+import { getShadowStyle } from "./fixed.js";
+
+//#region src/table/style/rtl.ts
+const genStyle = (token) => {
+	const { componentCls } = token;
+	const [leftShadowStyle, rightShadowStyle] = getShadowStyle(token);
+	return { [`${componentCls}-wrapper-rtl`]: {
+		direction: "rtl",
+		table: { direction: "rtl" },
+		[`${componentCls}-row-expand-icon`]: {
+			"float": "right",
+			"&::after": { transform: "rotate(-90deg)" },
+			"&-collapsed::before": { transform: "rotate(180deg)" },
+			"&-collapsed::after": { transform: "rotate(0deg)" }
+		},
+		[`${componentCls}-cell-fix`]: {
+			"&-start-shadow-show:after": rightShadowStyle,
+			"&-end-shadow-show:after": leftShadowStyle
+		},
+		[`${componentCls}-container`]: { [`${componentCls}-row-indent`]: { float: "right" } },
+		[`${componentCls}-fix-start-shadow-show ${componentCls}-container:before`]: rightShadowStyle,
+		[`${componentCls}-fix-end-shadow-show ${componentCls}-container:after`]: leftShadowStyle
+	} };
+};
+var rtl_default = genStyle;
+
+//#endregion
+export { rtl_default as default };

package/dist/table/style/selection.js

@@ -0,0 +1,59 @@
+import { unit } from "@antdv-next/cssinjs";
+
+//#region src/table/style/selection.ts
+const genSelectionStyle = (token) => {
+	const { componentCls, antCls, iconCls, fontSizeIcon, padding, paddingXS, headerIconColor, headerIconHoverColor, tableSelectionColumnWidth, tableSelectedRowBg, tableSelectedRowHoverBg, tableRowHoverBg, tablePaddingHorizontal, calc } = token;
+	return { [`${componentCls}-wrapper`]: {
+		[`${componentCls}-selection-col`]: {
+			width: tableSelectionColumnWidth,
+			[`&${componentCls}-selection-col-with-dropdown`]: { width: calc(tableSelectionColumnWidth).add(fontSizeIcon).add(calc(padding).div(4)).equal() }
+		},
+		[`${componentCls}-bordered ${componentCls}-selection-col`]: {
+			width: calc(tableSelectionColumnWidth).add(calc(paddingXS).mul(2)).equal(),
+			[`&${componentCls}-selection-col-with-dropdown`]: { width: calc(tableSelectionColumnWidth).add(fontSizeIcon).add(calc(padding).div(4)).add(calc(paddingXS).mul(2)).equal() }
+		},
+		[`
+        table tr th${componentCls}-selection-column,
+        table tr td${componentCls}-selection-column,
+        ${componentCls}-selection-column
+      `]: {
+			paddingInlineEnd: token.paddingXS,
+			paddingInlineStart: token.paddingXS,
+			textAlign: "center",
+			[`${antCls}-radio-wrapper`]: { marginInlineEnd: 0 }
+		},
+		[`table tr th${componentCls}-selection-column${componentCls}-cell-fix-left`]: { zIndex: calc(token.zIndexTableFixed).add(1).equal({ unit: false }) },
+		[`table tr th${componentCls}-selection-column::after`]: { backgroundColor: "transparent !important" },
+		[`${componentCls}-selection`]: {
+			position: "relative",
+			display: "inline-flex",
+			flexDirection: "column"
+		},
+		[`${componentCls}-selection-extra`]: {
+			position: "absolute",
+			top: 0,
+			zIndex: 1,
+			cursor: "pointer",
+			transition: `all ${token.motionDurationSlow}`,
+			marginInlineStart: "100%",
+			paddingInlineStart: unit(calc(tablePaddingHorizontal).div(4).equal()),
+			[iconCls]: {
+				"color": headerIconColor,
+				"fontSize": fontSizeIcon,
+				"verticalAlign": "baseline",
+				"&:hover": { color: headerIconHoverColor }
+			}
+		},
+		[`${componentCls}-tbody`]: { [`${componentCls}-row`]: {
+			[`&${componentCls}-row-selected`]: { [`> ${componentCls}-cell`]: {
+				"background": tableSelectedRowBg,
+				"&-row-hover": { background: tableSelectedRowHoverBg }
+			} },
+			[`> ${componentCls}-cell-row-hover`]: { background: tableRowHoverBg }
+		} }
+	} };
+};
+var selection_default = genSelectionStyle;
+
+//#endregion
+export { selection_default as default };

package/dist/table/style/size.js

@@ -0,0 +1,34 @@
+import { unit } from "@antdv-next/cssinjs";
+
+//#region src/table/style/size.ts
+const genSizeStyle = (token) => {
+	const { componentCls, tableExpandColumnWidth, calc } = token;
+	const getSizeStyle = (size, paddingVertical, paddingHorizontal, fontSize) => ({ [`${componentCls}${componentCls}-${size}`]: {
+		fontSize,
+		[`
+        ${componentCls}-title,
+        ${componentCls}-footer,
+        ${componentCls}-cell,
+        ${componentCls}-thead > tr > th,
+        ${componentCls}-tbody > tr > th,
+        ${componentCls}-tbody > tr > td,
+        tfoot > tr > th,
+        tfoot > tr > td
+      `]: { padding: `${unit(paddingVertical)} ${unit(paddingHorizontal)}` },
+		[`${componentCls}-filter-trigger`]: { marginInlineEnd: unit(calc(paddingHorizontal).div(2).mul(-1).equal()) },
+		[`${componentCls}-expanded-row-fixed`]: { margin: `${unit(calc(paddingVertical).mul(-1).equal())} ${unit(calc(paddingHorizontal).mul(-1).equal())}` },
+		[`${componentCls}-tbody`]: { [`${componentCls}-wrapper:only-child ${componentCls}`]: {
+			marginBlock: unit(calc(paddingVertical).mul(-1).equal()),
+			marginInline: `${unit(calc(tableExpandColumnWidth).sub(paddingHorizontal).equal())} ${unit(calc(paddingHorizontal).mul(-1).equal())}`
+		} },
+		[`${componentCls}-selection-extra`]: { paddingInlineStart: unit(calc(paddingHorizontal).div(4).equal()) }
+	} });
+	return { [`${componentCls}-wrapper`]: {
+		...getSizeStyle("middle", token.tablePaddingVerticalMiddle, token.tablePaddingHorizontalMiddle, token.tableFontSizeMiddle),
+		...getSizeStyle("small", token.tablePaddingVerticalSmall, token.tablePaddingHorizontalSmall, token.tableFontSizeSmall)
+	} };
+};
+var size_default = genSizeStyle;
+
+//#endregion
+export { size_default as default };

package/dist/table/style/sorter.js

@@ -0,0 +1,66 @@
+//#region src/table/style/sorter.ts
+const genSorterStyle = (token) => {
+	const { componentCls, marginXXS, fontSizeIcon, headerIconColor, headerIconHoverColor } = token;
+	return { [`${componentCls}-wrapper`]: {
+		[`${componentCls}-thead th${componentCls}-column-has-sorters`]: {
+			"outline": "none",
+			"cursor": "pointer",
+			"transition": `all ${token.motionDurationSlow}, left 0s`,
+			"&:hover": {
+				"background": token.tableHeaderSortHoverBg,
+				"&::before": { backgroundColor: "transparent !important" }
+			},
+			"&:focus-visible": { color: token.colorPrimary },
+			[`
+          &${componentCls}-cell-fix-left:hover,
+          &${componentCls}-cell-fix-right:hover
+        `]: { background: token.tableFixedHeaderSortActiveBg }
+		},
+		[`${componentCls}-thead th${componentCls}-column-sort`]: {
+			"background": token.tableHeaderSortBg,
+			"&::before": { backgroundColor: "transparent !important" }
+		},
+		[`td${componentCls}-column-sort`]: { background: token.tableBodySortBg },
+		[`${componentCls}-column-title`]: {
+			position: "relative",
+			zIndex: 1,
+			flex: 1,
+			minWidth: 0
+		},
+		[`${componentCls}-column-sorters`]: {
+			"display": "flex",
+			"flex": "auto",
+			"alignItems": "center",
+			"justifyContent": "space-between",
+			"&::after": {
+				position: "absolute",
+				inset: 0,
+				width: "100%",
+				height: "100%",
+				content: "\"\""
+			}
+		},
+		[`${componentCls}-column-sorters-tooltip-target-sorter`]: { "&::after": { content: "none" } },
+		[`${componentCls}-column-sorter`]: {
+			"marginInlineStart": marginXXS,
+			"color": headerIconColor,
+			"fontSize": 0,
+			"transition": `color ${token.motionDurationSlow}`,
+			"&-inner": {
+				display: "inline-flex",
+				flexDirection: "column",
+				alignItems: "center"
+			},
+			"&-up, &-down": {
+				"fontSize": fontSizeIcon,
+				"&.active": { color: token.colorPrimary }
+			},
+			[`${componentCls}-column-sorter-up + ${componentCls}-column-sorter-down`]: { marginTop: "-0.3em" }
+		},
+		[`${componentCls}-column-sorters:hover ${componentCls}-column-sorter`]: { color: headerIconHoverColor }
+	} };
+};
+var sorter_default = genSorterStyle;
+
+//#endregion
+export { sorter_default as default };

package/dist/table/style/sticky.js

@@ -0,0 +1,39 @@
+import { unit } from "@antdv-next/cssinjs";
+
+//#region src/table/style/sticky.ts
+const genStickyStyle = (token) => {
+	const { componentCls, opacityLoading, tableScrollThumbBg, tableScrollThumbBgHover, tableScrollThumbSize, tableScrollBg, stickyScrollBarBorderRadius, lineWidth, lineType, tableBorderColor, zIndexTableFixed } = token;
+	const tableBorder = `${unit(lineWidth)} ${lineType} ${tableBorderColor}`;
+	return { [`${componentCls}-wrapper`]: { [`${componentCls}-sticky`]: {
+		"&-holder": {
+			position: "sticky",
+			zIndex: `calc(var(--columns-count) * 2 + ${zIndexTableFixed} + 1)`,
+			background: token.colorBgContainer
+		},
+		"&-scroll": {
+			"position": "sticky",
+			"bottom": 0,
+			"height": `${unit(tableScrollThumbSize)} !important`,
+			"zIndex": `calc(var(--columns-count) * 2 + ${zIndexTableFixed} + 1)`,
+			"display": "flex",
+			"alignItems": "center",
+			"background": tableScrollBg,
+			"borderTop": tableBorder,
+			"opacity": opacityLoading,
+			"&:hover": { transformOrigin: "center bottom" },
+			"&-bar": {
+				"height": tableScrollThumbSize,
+				"backgroundColor": tableScrollThumbBg,
+				"borderRadius": stickyScrollBarBorderRadius,
+				"transition": `all ${token.motionDurationSlow}, transform 0s`,
+				"position": "absolute",
+				"bottom": 0,
+				"&:hover, &-active": { backgroundColor: tableScrollThumbBgHover }
+			}
+		}
+	} } };
+};
+var sticky_default = genStickyStyle;
+
+//#endregion
+export { sticky_default as default };

package/dist/table/style/summary.js

@@ -0,0 +1,20 @@
+import { unit } from "@antdv-next/cssinjs";
+
+//#region src/table/style/summary.ts
+const genSummaryStyle = (token) => {
+	const { componentCls, lineWidth, tableBorderColor, calc } = token;
+	const tableBorder = `${unit(lineWidth)} ${token.lineType} ${tableBorderColor}`;
+	return { [`${componentCls}-wrapper`]: {
+		[`${componentCls}-summary`]: {
+			"position": "relative",
+			"zIndex": token.zIndexTableFixed,
+			"background": token.tableBg,
+			"> tr": { "> th, > td": { borderBottom: tableBorder } }
+		},
+		[`div${componentCls}-summary`]: { boxShadow: `0 ${unit(calc(lineWidth).mul(-1).equal())} 0 ${tableBorderColor}` }
+	} };
+};
+var summary_default = genSummaryStyle;
+
+//#endregion
+export { summary_default as default };

package/dist/table/style/virtual.js

@@ -0,0 +1,60 @@
+import { unit } from "@antdv-next/cssinjs";
+
+//#region src/table/style/virtual.ts
+const genVirtualStyle = (token) => {
+	const { componentCls, motionDurationMid, lineWidth, lineType, tableBorderColor, calc } = token;
+	const tableBorder = `${unit(lineWidth)} ${lineType} ${tableBorderColor}`;
+	const rowCellCls = `${componentCls}-expanded-row-cell`;
+	return { [`${componentCls}-wrapper`]: {
+		[`${componentCls}-tbody-virtual`]: {
+			[`${componentCls}-tbody-virtual-holder-inner`]: { [`
+            & > ${componentCls}-row, 
+            & > div:not(${componentCls}-row) > ${componentCls}-row
+          `]: {
+				display: "flex",
+				boxSizing: "border-box",
+				width: "100%"
+			} },
+			[`${componentCls}-cell`]: {
+				borderBottom: tableBorder,
+				transition: `background ${motionDurationMid}`
+			},
+			[`${componentCls}-expanded-row`]: { [`${rowCellCls}${rowCellCls}-fixed`]: {
+				position: "sticky",
+				insetInlineStart: 0,
+				overflow: "hidden",
+				width: `calc(var(--virtual-width) - ${unit(lineWidth)})`,
+				borderInlineEnd: "none"
+			} }
+		},
+		[`${componentCls}-bordered`]: {
+			[`${componentCls}-tbody-virtual`]: {
+				"&:after": {
+					content: "\"\"",
+					insetInline: 0,
+					bottom: 0,
+					borderBottom: tableBorder,
+					position: "absolute"
+				},
+				[`${componentCls}-cell`]: {
+					borderInlineEnd: tableBorder,
+					[`&${componentCls}-cell-fix-right-first:before`]: {
+						content: "\"\"",
+						position: "absolute",
+						insetBlock: 0,
+						insetInlineStart: calc(lineWidth).mul(-1).equal(),
+						borderInlineStart: tableBorder
+					}
+				}
+			},
+			[`&${componentCls}-virtual`]: { [`${componentCls}-placeholder ${componentCls}-cell`]: {
+				borderInlineEnd: tableBorder,
+				borderBottom: tableBorder
+			} }
+		}
+	} };
+};
+var virtual_default = genVirtualStyle;
+
+//#endregion
+export { virtual_default as default };

package/dist/table/util.js

@@ -0,0 +1,26 @@
+//#region src/table/util.ts
+function getColumnKey(column, defaultKey) {
+	if ("key" in column && column.key !== void 0 && column.key !== null) return column.key;
+	if (column.dataIndex) return Array.isArray(column.dataIndex) ? column.dataIndex.join(".") : column.dataIndex;
+	return defaultKey;
+}
+function getColumnPos(index, pos) {
+	return pos ? `${pos}-${index}` : `${index}`;
+}
+function renderColumnTitle(title, props) {
+	if (typeof title === "function") return title(props);
+	return title;
+}
+/**
+* Safe get column title
+*
+* Should filter [object Object]
+*/
+function safeColumnTitle(title, props) {
+	const res = renderColumnTitle(title, props);
+	if (Object.prototype.toString.call(res) === "[object Object]") return "";
+	return res;
+}
+
+//#endregion
+export { getColumnKey, getColumnPos, renderColumnTitle, safeColumnTitle };

package/dist/table/utils.js

@@ -0,0 +1,18 @@
+import { isVNode } from "vue";
+import { flattenChildren } from "@v-c/util/dist/props-util";
+
+//#region src/table/utils.ts
+function convertColumnsToColumnProps(children) {
+	return flattenChildren(children).filter((node) => isVNode(node)).map((node) => {
+		const { key, props, children: nodeChildren } = node;
+		const column = {
+			key,
+			...props || {}
+		};
+		if (nodeChildren?.default) column.children = convertColumnsToColumnProps(nodeChildren.default());
+		return column;
+	}).filter(Boolean);
+}
+
+//#endregion
+export { convertColumnsToColumnProps };

package/dist/tabs/TabPane.d.ts

@@ -0,0 +1,23 @@
+import { EmptyEmit } from "../_util/type.js";
+import * as vue324 from "vue";
+import { CSSProperties, SlotsType } from "vue";
+import { TabPaneProps } from "@v-c/tabs";
+
+//#region src/tabs/TabPane.d.ts
+interface TabPaneProps$1 extends TabPaneProps {
+  /** @deprecated Please use `destroyOnHidden` instead */
+  destroyInactiveTabPane?: boolean;
+  class?: string;
+  style?: CSSProperties;
+}
+interface TabPaneSlots {
+  default?: () => any;
+  tab?: () => any;
+  closeIcon?: () => any;
+  icon?: () => any;
+}
+declare const TabPane: vue324.DefineSetupFnComponent<TabPaneProps$1, EmptyEmit, SlotsType<TabPaneSlots>, TabPaneProps$1 & {
+  [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, vue324.PublicProps>;
+//#endregion
+export { TabPane, TabPaneProps$1 as TabPaneProps };

package/dist/tabs/TabPane.js

@@ -0,0 +1,13 @@
+import { defineComponent } from "vue";
+
+//#region src/tabs/TabPane.ts
+const TabPane = defineComponent(() => {
+	return () => null;
+}, {
+	name: "ATabPane",
+	inheritAttrs: false
+});
+var TabPane_default = TabPane;
+
+//#endregion
+export { TabPane_default as default };

package/dist/tabs/hooks/useAnimateConfig.js

@@ -0,0 +1,26 @@
+import { getTransitionName, getTransitionProps } from "@v-c/util/dist/utils/transition";
+
+//#region src/tabs/hooks/useAnimateConfig.ts
+function useAnimateConfig(prefixCls, animated = {
+	inkBar: true,
+	tabPane: false
+}) {
+	let mergedAnimated;
+	if (animated === false) mergedAnimated = {
+		inkBar: false,
+		tabPane: false
+	};
+	else if (animated === true) mergedAnimated = {
+		inkBar: true,
+		tabPane: true
+	};
+	else mergedAnimated = {
+		inkBar: true,
+		...typeof animated === "object" ? animated : {}
+	};
+	if (mergedAnimated.tabPane) mergedAnimated.tabPaneMotion = getTransitionProps(getTransitionName(prefixCls, "switch"), { appear: false });
+	return mergedAnimated;
+}
+
+//#endregion
+export { useAnimateConfig as default };

package/dist/tabs/hooks/useLegacyItems.js

@@ -0,0 +1,54 @@
+import { getSlotPropsFnRun } from "../../_util/tools.js";
+import TabPane_default from "../TabPane.js";
+import { computed, isVNode } from "vue";
+import { filterEmpty, flattenChildren } from "@v-c/util/dist/props-util";
+
+//#region src/tabs/hooks/useLegacyItems.ts
+function convertItem(item, index, slots) {
+	const { ...rest } = item;
+	const contentRender = filterEmpty(slots?.contentRender?.({
+		item,
+		index
+	}) ?? []);
+	const labelRender = filterEmpty(slots?.labelRender?.({
+		item,
+		index
+	}) ?? []);
+	const content = contentRender.length ? contentRender : getSlotPropsFnRun(item, {}, "content");
+	const label = labelRender.length ? labelRender : getSlotPropsFnRun(item, {}, "label");
+	return {
+		...rest,
+		children: content,
+		label,
+		className: rest.class,
+		destroyOnHidden: rest.destroyOnHidden
+	};
+}
+function isTabPaneNode(node) {
+	if (!isVNode(node)) return false;
+	const type = node.type;
+	return type === TabPane_default || type?.name === "ATabPane";
+}
+function useLegacyItems(items, slots) {
+	return computed(() => {
+		const itemsValue = items();
+		if (itemsValue && itemsValue.length) return itemsValue.map((item, index) => convertItem(item, index, slots));
+		return flattenChildren(slots?.default?.() ?? []).map((node, index) => {
+			if (!isTabPaneNode(node)) return null;
+			const { tab, closeIcon, icon, destroyInactiveTabPane, destroyOnHidden, children: childrenProp, class: className, className: _className, tabKey,...restProps } = node.props || {};
+			return convertItem({
+				key: tabKey != null ? String(tabKey) : node.key != null ? String(node.key) : `${index}`,
+				label: node.children?.tab ?? tab,
+				closeIcon: node.children?.closeIcon ?? closeIcon,
+				icon: node.children?.icon ?? icon,
+				content: node.children?.default ?? childrenProp,
+				class: className ?? _className,
+				destroyOnHidden: destroyOnHidden ?? destroyInactiveTabPane,
+				...restProps
+			}, index, slots);
+		}).filter(Boolean);
+	});
+}
+
+//#endregion
+export { useLegacyItems as default };

package/dist/tabs/index.d.ts

@@ -0,0 +1,94 @@
+import { VueNode } from "../_util/type.js";
+import { SemanticClassNames, SemanticClassNamesType, SemanticStyles, SemanticStylesType } from "../_util/hooks/useMergeSemantic.js";
+import "../_util/hooks/index.js";
+import { SizeType } from "../config-provider/SizeContext.js";
+import { TabPane, TabPaneProps as TabPaneProps$1 } from "./TabPane.js";
+import { ComponentBaseProps } from "../config-provider/context.js";
+import * as vue169 from "vue";
+import { SlotsType } from "vue";
+import { GetIndicatorSize, MoreProps, Tab, TabsProps } from "@v-c/tabs";
+
+//#region src/tabs/index.d.ts
+type TabsType = 'line' | 'card' | 'editable-card';
+type TabPosition = 'top' | 'right' | 'bottom' | 'left';
+type TabPlacement = 'top' | 'end' | 'bottom' | 'start';
+type TabsSemanticName = 'root' | 'item' | 'indicator' | 'content' | 'header';
+type PopupSemantic = 'root';
+type TabsClassNamesType = SemanticClassNamesType<TabsProps$1, TabsSemanticName, {
+  popup?: SemanticClassNames<PopupSemantic>;
+}>;
+type TabsStylesType = SemanticStylesType<TabsProps$1, TabsSemanticName, {
+  popup?: SemanticStyles<PopupSemantic>;
+}>;
+interface CompatibilityProps {
+  /** @deprecated Please use `destroyOnHidden` instead */
+  destroyInactiveTabPane?: boolean;
+}
+interface Tab$1 extends Omit<Tab, 'children' | 'className'> {
+  content?: VueNode;
+  class?: string;
+}
+interface TabsRef {
+  nativeElement: any;
+}
+interface BaseTabsProps extends ComponentBaseProps {
+  type?: TabsType;
+  size?: SizeType;
+  hideAdd?: boolean;
+  centered?: boolean;
+  classes?: TabsClassNamesType;
+  styles?: TabsStylesType;
+  /** @deprecated please use `tabPlacement` instead */
+  tabPosition?: TabPosition;
+  tabPlacement?: TabPlacement;
+  /** @deprecated Please use `indicator={{ size: ... }}` instead */
+  indicatorSize?: GetIndicatorSize;
+  items?: Tab$1[];
+}
+interface TabsEmits {
+  'edit': (e: MouseEvent | KeyboardEvent | string, action: 'add' | 'remove') => void;
+  'change': NonNullable<TabsProps['onChange']>;
+  'tabClick': NonNullable<TabsProps['onTabClick']>;
+  'tabScroll': NonNullable<TabsProps['onTabScroll']>;
+  'update:activeKey': (activeKey: string) => void;
+  [key: string]: (...args: any[]) => void;
+}
+interface TabsProps$1 extends BaseTabsProps, CompatibilityProps, Omit<TabsProps, 'editable' | 'items' | 'classNames' | 'className' | 'popupClassName' | 'styles' | 'style' | 'onChange' | 'onTabScroll' | 'onTabClick' | 'renderTabBar'> {
+  addIcon?: VueNode;
+  moreIcon?: VueNode;
+  more?: MoreProps;
+  removeIcon?: VueNode;
+  styles?: TabsStylesType;
+  classes?: TabsClassNamesType;
+  /** @deprecated Please use `classNames.popup` instead */
+  popupClassName?: string;
+  renderTabBar?: (args: {
+    props: any;
+    TabNavListComponent: any;
+  }) => any;
+}
+interface TabsSlots {
+  default: () => any;
+  addIcon: () => any;
+  moreIcon: () => any;
+  removeIcon: () => any;
+  labelRender: (args: {
+    item: Tab$1;
+    index: number;
+  }) => any;
+  contentRender: (args: {
+    item: Tab$1;
+    index: number;
+  }) => any;
+  renderTabBar?: (args: {
+    props: any;
+    TabNavListComponent: any;
+  }) => any;
+  rightExtra?: () => any;
+  leftExtra?: () => any;
+}
+declare const Tabs: vue169.DefineSetupFnComponent<TabsProps$1, TabsEmits, SlotsType<TabsSlots>, TabsProps$1 & {
+  [x: `on${Capitalize<string>}`]: ((...args: any[]) => any) | undefined;
+}, vue169.PublicProps>;
+//#endregion
+export { Tab$1 as Tab, Tabs, TabsEmits, TabsProps$1 as TabsProps, TabsRef, TabsSlots };