@antdv-next/mobile 0.0.0-stage → 0.1.0

package/dist/tree/style/index.css

@@ -0,0 +1,226 @@
+.am-tree {
+  /* component tokens */
+  --am-tree-item-height: 44px;
+  --am-tree-indent-size: 24px;
+  --am-tree-switcher-size: 40px;
+  --am-tree-padding-inline: 0px;
+  --am-tree-font-size: var(--am-font-size-lg);
+  --am-tree-color: var(--am-color-text);
+  --am-tree-background: var(--am-color-bg-container);
+  --am-tree-switcher-color: var(--am-color-text-tertiary);
+  --am-tree-switcher-icon-size: 12px;
+  --am-tree-icon-color: var(--am-color-text-secondary);
+  --am-tree-title-padding-inline: var(--am-padding-xs);
+  --am-tree-node-radius: var(--am-border-radius);
+  --am-tree-node-active-background: var(--am-color-fill-tertiary);
+  --am-tree-node-selected-background: var(--am-color-primary-bg);
+  --am-tree-node-selected-color: var(--am-color-text);
+  --am-tree-line-color: var(--am-color-border);
+  --am-tree-highlight-color: var(--am-color-primary);
+  --am-tree-disabled-color: var(--am-color-text-disabled);
+
+  box-sizing: border-box;
+  padding: 0 var(--am-tree-padding-inline);
+  color: var(--am-tree-color);
+  font-size: var(--am-tree-font-size);
+  font-family: var(--am-font-family);
+  line-height: var(--am-line-height);
+  background: var(--am-tree-background);
+  -webkit-tap-highlight-color: transparent;
+}
+
+/* ---------- row ---------- */
+.am-tree-treenode {
+  position: relative;
+  display: flex;
+  align-items: stretch;
+  box-sizing: border-box;
+  min-height: var(--am-tree-item-height);
+}
+
+/* one step per level; the units inside only exist to draw the guide lines */
+.am-tree-indent {
+  display: flex;
+  flex: none;
+  align-self: stretch;
+  width: calc(var(--am-tree-level, 0) * var(--am-tree-indent-size));
+  user-select: none;
+}
+
+.am-tree-indent-unit {
+  position: relative;
+  flex: none;
+  width: var(--am-tree-indent-size);
+}
+
+/* ---------- switcher ---------- */
+.am-tree-switcher {
+  position: relative;
+  display: flex;
+  flex: none;
+  align-items: center;
+  align-self: stretch;
+  justify-content: center;
+  box-sizing: border-box;
+  width: var(--am-tree-switcher-size);
+  color: var(--am-tree-switcher-color);
+  font-size: var(--am-tree-switcher-icon-size);
+  line-height: 1;
+  cursor: pointer;
+  user-select: none;
+  touch-action: manipulation;
+}
+
+.am-tree-switcher-noop {
+  cursor: default;
+}
+
+.am-tree-switcher:not(.am-tree-switcher-noop):active {
+  opacity: var(--am-opacity-active);
+}
+
+.am-tree-switcher-icon,
+.am-tree-switcher-line-icon,
+.am-tree-switcher-loading-icon {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.am-tree-switcher-icon {
+  transition: transform var(--am-motion-duration-mid);
+}
+
+.am-tree-switcher-close .am-tree-switcher-icon {
+  transform: rotate(-90deg);
+}
+
+.am-tree-switcher-line-icon,
+.am-tree-switcher-loading-icon {
+  position: relative;
+  z-index: 1;
+  font-size: calc(var(--am-tree-switcher-icon-size) + 4px);
+}
+
+.am-tree-switcher-loading-icon {
+  color: var(--am-tree-highlight-color);
+}
+
+/* ---------- checkbox (the library Checkbox, stretched to the row for a full-height touch target) ---------- */
+.am-tree .am-tree-checkbox {
+  flex: none;
+  align-self: stretch;
+  min-height: 0;
+  padding-inline: var(--am-padding-xxs);
+}
+
+/* ---------- content ---------- */
+.am-tree-node-content-wrapper {
+  position: relative;
+  display: flex;
+  gap: var(--am-padding-xs);
+  align-items: center;
+  box-sizing: border-box;
+  min-width: 0;
+  padding: var(--am-padding-xxs) var(--am-tree-title-padding-inline);
+  border-radius: var(--am-tree-node-radius);
+  cursor: pointer;
+  transition: background-color var(--am-motion-duration-mid);
+  user-select: none;
+  touch-action: manipulation;
+}
+
+.am-tree-block-node .am-tree-node-content-wrapper {
+  flex: 1;
+}
+
+.am-tree-node-content-wrapper:active {
+  background: var(--am-tree-node-active-background);
+}
+
+.am-tree-node-content-wrapper.am-tree-node-selected {
+  color: var(--am-tree-node-selected-color);
+  background: var(--am-tree-node-selected-background);
+}
+
+.am-tree-icon {
+  display: inline-flex;
+  flex: none;
+  align-items: center;
+  justify-content: center;
+  color: var(--am-tree-icon-color);
+  line-height: 1;
+}
+
+.am-tree-title {
+  flex: 1;
+  min-width: 0;
+  overflow-wrap: anywhere;
+}
+
+.am-tree-filter-node .am-tree-title {
+  color: var(--am-tree-highlight-color);
+  font-weight: var(--am-font-weight-strong);
+}
+
+/* ---------- disabled ---------- */
+.am-tree-treenode-disabled .am-tree-node-content-wrapper {
+  color: var(--am-tree-disabled-color);
+  cursor: not-allowed;
+}
+
+.am-tree-treenode-disabled .am-tree-node-content-wrapper:active {
+  background: transparent;
+}
+
+.am-tree-treenode-disabled .am-tree-icon {
+  color: inherit;
+}
+
+/* ---------- guide lines ---------- */
+
+/* the line of a level runs through the middle of the switcher column of that level */
+.am-tree-show-line .am-tree-indent-unit::before,
+.am-tree-switcher-leaf-line::before {
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  inset-inline-start: calc(var(--am-tree-switcher-size) / 2);
+  border-inline-start: var(--am-line-width) solid var(--am-tree-line-color);
+  content: '';
+}
+
+/* no more siblings below at that level */
+.am-tree-show-line .am-tree-indent-unit-end::before {
+  display: none;
+}
+
+.am-tree-switcher-leaf-line {
+  position: absolute;
+  inset: 0;
+}
+
+.am-tree-switcher-leaf-line::after {
+  position: absolute;
+  top: 50%;
+  inset-inline-start: calc(var(--am-tree-switcher-size) / 2);
+  inset-inline-end: var(--am-padding-xxs);
+  border-top: var(--am-line-width) solid var(--am-tree-line-color);
+  content: '';
+}
+
+.am-tree-treenode-leaf-last .am-tree-switcher-leaf-line::before {
+  bottom: 50%;
+}
+
+/* ---------- rtl ---------- */
+[dir='rtl'] .am-tree-switcher-close .am-tree-switcher-icon {
+  transform: rotate(90deg);
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .am-tree-switcher-icon,
+  .am-tree-node-content-wrapper {
+    transition: none;
+  }
+}

package/dist/tree/util.d.ts

@@ -0,0 +1,79 @@
+import type { Key } from '../_util/type';
+import type { TreeCheckedKeys, TreeDataNode, TreeFieldNames } from './interface';
+export interface TreeResolvedFieldNames {
+    title: string;
+    key: string;
+    children: string;
+}
+export interface TreeEntity {
+    key: Key;
+    /** the node of `treeData` */
+    node: TreeDataNode;
+    parent?: TreeEntity;
+    children: TreeEntity[];
+    /** depth, `0` for root nodes */
+    level: number;
+    /** index among its siblings */
+    index: number;
+    /** `0-1-2` */
+    pos: string;
+}
+export interface TreeEntities {
+    keyEntities: Map<Key, TreeEntity>;
+    /** entities grouped by level, in document order */
+    levelEntities: TreeEntity[][];
+}
+export interface TreeFlattenNode {
+    key: Key;
+    data: TreeDataNode;
+    level: number;
+    pos: string;
+    /** per level (ancestors, then the node itself): is it the first child */
+    isStart: boolean[];
+    /** per level (ancestors, then the node itself): is it the last child */
+    isEnd: boolean[];
+}
+export interface TreeConductResult {
+    checkedKeys: Key[];
+    halfCheckedKeys: Key[];
+}
+export interface TreeConductUncheck {
+    checked: false;
+    halfCheckedKeys: Key[];
+}
+export type TreeGetCheckDisabled = (node: TreeDataNode) => boolean;
+export declare function fillFieldNames(fieldNames?: TreeFieldNames): TreeResolvedFieldNames;
+export declare function getNodeKey(node: TreeDataNode, pos: string, fieldNames: TreeResolvedFieldNames): Key;
+export declare function getNodeChildren(node: TreeDataNode, fieldNames: TreeResolvedFieldNames): TreeDataNode[];
+export declare function arrAdd(list: Key[], key: Key): Key[];
+export declare function arrDel(list: Key[], key: Key): Key[];
+/** Indexes every node by key (with parent / children / level links). */
+export declare function convertDataToEntities(treeData: TreeDataNode[] | undefined, fieldNames?: TreeFieldNames): TreeEntities;
+/**
+ * The visible rows: every root node plus the children of expanded nodes, in display order.
+ * `expandedKeys: true` expands everything.
+ */
+export declare function flattenTreeData(treeData: TreeDataNode[] | undefined, expandedKeys: Key[] | Set<Key> | true, fieldNames?: TreeFieldNames): TreeFlattenNode[];
+/** A node whose checkbox can not be toggled stops the conduction (same rule as PC). */
+export declare function isCheckDisabled(node: TreeDataNode | undefined): boolean;
+/**
+ * Parent / child check conduction, a port of `conductCheck` of the PC tree (`@v-c/tree`).
+ *
+ * - `checked: true`: `keyList` are checked keys. Every checked node checks its enabled children;
+ *   a parent whose enabled children are all checked becomes checked, otherwise half checked
+ *   when one of them is checked / half checked.
+ * - `checked: { checked: false, halfCheckedKeys }`: `keyList` are the keys left after a node was
+ *   unchecked and `halfCheckedKeys` the previous half checked keys. Every node that is neither
+ *   checked nor half checked unchecks its enabled children; parents are derived again.
+ *
+ * Disabled nodes (`disabled`, `disableCheckbox`, `checkable: false`) keep their own state: they
+ * neither pass a change down nor take one from their children, and they are ignored when a parent
+ * counts its children. Keys that are not in the tree are dropped.
+ */
+export declare function conductCheck(keyList: Key[] | undefined, checked: true | TreeConductUncheck, entities: TreeEntities, getCheckDisabled?: TreeGetCheckDisabled): TreeConductResult;
+/** The given keys plus all their ancestors (stops above a disabled node). Unknown keys are dropped. */
+export declare function conductExpandParent(keyList: Key[] | undefined, keyEntities: Map<Key, TreeEntity>): Key[];
+/** `checkedKeys` prop -> `{ checkedKeys, halfCheckedKeys }` */
+export declare function parseCheckedKeys(keys: TreeCheckedKeys | null | undefined): TreeConductResult;
+/** single mode keeps the first key only */
+export declare function calcSelectedKeys(keys: Key[] | undefined, multiple: boolean): Key[];

package/dist/tree/util.js

@@ -0,0 +1,212 @@
+// src/tree/util.ts
+function fillFieldNames(fieldNames) {
+	return {
+		title: fieldNames?.title || "title",
+		key: fieldNames?.key || "key",
+		children: fieldNames?.children || "children"
+	};
+}
+function getNodeKey(node, pos, fieldNames) {
+	const key = node[fieldNames.key];
+	return key !== void 0 && key !== null ? key : pos;
+}
+function getNodeChildren(node, fieldNames) {
+	const children = node[fieldNames.children];
+	return Array.isArray(children) ? children : [];
+}
+function arrAdd(list, key) {
+	return list.includes(key) ? list.slice() : [...list, key];
+}
+function arrDel(list, key) {
+	return list.filter((item) => item !== key);
+}
+/** Indexes every node by key (with parent / children / level links). */
+function convertDataToEntities(treeData, fieldNames) {
+	const names = fillFieldNames(fieldNames);
+	const keyEntities = /* @__PURE__ */ new Map();
+	const levelEntities = [];
+	function dig(list, parent, level) {
+		const bucket = levelEntities[level] ?? (levelEntities[level] = []);
+		list.forEach((node, index) => {
+			if (!node || typeof node !== "object") return;
+			const pos = parent ? `${parent.pos}-${index}` : `0-${index}`;
+			const entity = {
+				key: getNodeKey(node, pos, names),
+				node,
+				parent,
+				children: [],
+				level,
+				index,
+				pos
+			};
+			keyEntities.set(entity.key, entity);
+			bucket.push(entity);
+			parent?.children.push(entity);
+			const children = getNodeChildren(node, names);
+			if (children.length) dig(children, entity, level + 1);
+		});
+	}
+	dig(treeData ?? [], void 0, 0);
+	return {
+		keyEntities,
+		levelEntities
+	};
+}
+/**
+* The visible rows: every root node plus the children of expanded nodes, in display order.
+* `expandedKeys: true` expands everything.
+*/
+function flattenTreeData(treeData, expandedKeys, fieldNames) {
+	const names = fillFieldNames(fieldNames);
+	const expanded = expandedKeys === true ? true : expandedKeys instanceof Set ? expandedKeys : new Set(expandedKeys);
+	const result = [];
+	function dig(list, parent, level) {
+		const last = list.length - 1;
+		list.forEach((data, index) => {
+			if (!data || typeof data !== "object") return;
+			const pos = parent ? `${parent.pos}-${index}` : `0-${index}`;
+			const node = {
+				key: getNodeKey(data, pos, names),
+				data,
+				level,
+				pos,
+				isStart: parent ? [...parent.isStart, index === 0] : [index === 0],
+				isEnd: parent ? [...parent.isEnd, index === last] : [index === last]
+			};
+			result.push(node);
+			if (expanded === true || expanded.has(node.key)) {
+				const children = getNodeChildren(data, names);
+				if (children.length) dig(children, node, level + 1);
+			}
+		});
+	}
+	dig(treeData ?? [], void 0, 0);
+	return result;
+}
+/** A node whose checkbox can not be toggled stops the conduction (same rule as PC). */
+function isCheckDisabled(node) {
+	if (!node) return false;
+	return !!(node.disabled || node.disableCheckbox) || node.checkable === false;
+}
+function removeFromCheckedKeys(halfCheckedKeys, checkedKeys) {
+	const filtered = [];
+	halfCheckedKeys.forEach((key) => {
+		if (!checkedKeys.has(key)) filtered.push(key);
+	});
+	return filtered;
+}
+/** bottom-up pass shared by fill and clean: derives the state of every parent from its enabled children */
+function conductUp(levelEntities, checkedKeys, halfCheckedKeys, getCheckDisabled, fill) {
+	const visited = /* @__PURE__ */ new Set();
+	for (let level = levelEntities.length - 1; level >= 0; level -= 1) {
+		const list = levelEntities[level] ?? [];
+		for (let i = 0; i < list.length; i += 1) {
+			const entity = list[i];
+			const parent = entity.parent;
+			if (getCheckDisabled(entity.node) || !parent || visited.has(parent.key)) continue;
+			if (getCheckDisabled(parent.node)) {
+				visited.add(parent.key);
+				continue;
+			}
+			let allChecked = true;
+			let partialChecked = false;
+			parent.children.forEach((child) => {
+				if (getCheckDisabled(child.node)) return;
+				const checked = checkedKeys.has(child.key);
+				if (allChecked && !checked) allChecked = false;
+				if (!partialChecked && (checked || halfCheckedKeys.has(child.key))) partialChecked = true;
+			});
+			if (fill) {
+				if (allChecked) checkedKeys.add(parent.key);
+			} else if (!allChecked) checkedKeys.delete(parent.key);
+			if (partialChecked) halfCheckedKeys.add(parent.key);
+			visited.add(parent.key);
+		}
+	}
+}
+/** checked keys conduct down to their enabled children, then up to their parents */
+function fillConductCheck(keys, levelEntities, getCheckDisabled) {
+	const checkedKeys = new Set(keys);
+	const halfCheckedKeys = /* @__PURE__ */ new Set();
+	for (let level = 0; level < levelEntities.length; level += 1) (levelEntities[level] ?? []).forEach((entity) => {
+		if (checkedKeys.has(entity.key) && !getCheckDisabled(entity.node)) entity.children.forEach((child) => {
+			if (!getCheckDisabled(child.node)) checkedKeys.add(child.key);
+		});
+	});
+	conductUp(levelEntities, checkedKeys, halfCheckedKeys, getCheckDisabled, true);
+	return {
+		checkedKeys: Array.from(checkedKeys),
+		halfCheckedKeys: removeFromCheckedKeys(halfCheckedKeys, checkedKeys)
+	};
+}
+/** unchecked keys (neither checked nor half checked) conduct down to their enabled children, then up */
+function cleanConductCheck(keys, halfKeys, levelEntities, getCheckDisabled) {
+	const checkedKeys = new Set(keys);
+	const prevHalfCheckedKeys = new Set(halfKeys);
+	for (let level = 0; level < levelEntities.length; level += 1) (levelEntities[level] ?? []).forEach((entity) => {
+		if (!checkedKeys.has(entity.key) && !prevHalfCheckedKeys.has(entity.key) && !getCheckDisabled(entity.node)) entity.children.forEach((child) => {
+			if (!getCheckDisabled(child.node)) checkedKeys.delete(child.key);
+		});
+	});
+	const halfCheckedKeys = /* @__PURE__ */ new Set();
+	conductUp(levelEntities, checkedKeys, halfCheckedKeys, getCheckDisabled, false);
+	return {
+		checkedKeys: Array.from(checkedKeys),
+		halfCheckedKeys: removeFromCheckedKeys(halfCheckedKeys, checkedKeys)
+	};
+}
+/**
+* Parent / child check conduction, a port of `conductCheck` of the PC tree (`@v-c/tree`).
+*
+* - `checked: true`: `keyList` are checked keys. Every checked node checks its enabled children;
+*   a parent whose enabled children are all checked becomes checked, otherwise half checked
+*   when one of them is checked / half checked.
+* - `checked: { checked: false, halfCheckedKeys }`: `keyList` are the keys left after a node was
+*   unchecked and `halfCheckedKeys` the previous half checked keys. Every node that is neither
+*   checked nor half checked unchecks its enabled children; parents are derived again.
+*
+* Disabled nodes (`disabled`, `disableCheckbox`, `checkable: false`) keep their own state: they
+* neither pass a change down nor take one from their children, and they are ignored when a parent
+* counts its children. Keys that are not in the tree are dropped.
+*/
+function conductCheck(keyList, checked, entities, getCheckDisabled = isCheckDisabled) {
+	const { keyEntities, levelEntities } = entities;
+	const keys = new Set((keyList ?? []).filter((key) => keyEntities.has(key)));
+	if (checked === true) return fillConductCheck(keys, levelEntities, getCheckDisabled);
+	return cleanConductCheck(keys, checked.halfCheckedKeys, levelEntities, getCheckDisabled);
+}
+/** The given keys plus all their ancestors (stops above a disabled node). Unknown keys are dropped. */
+function conductExpandParent(keyList, keyEntities) {
+	const expandedKeys = /* @__PURE__ */ new Set();
+	(keyList ?? []).forEach((key) => {
+		let entity = keyEntities.get(key);
+		while (entity && !expandedKeys.has(entity.key)) {
+			expandedKeys.add(entity.key);
+			if (entity.node.disabled) break;
+			entity = entity.parent;
+		}
+	});
+	return Array.from(expandedKeys);
+}
+/** `checkedKeys` prop -> `{ checkedKeys, halfCheckedKeys }` */
+function parseCheckedKeys(keys) {
+	if (Array.isArray(keys)) return {
+		checkedKeys: keys,
+		halfCheckedKeys: []
+	};
+	if (keys && typeof keys === "object") return {
+		checkedKeys: keys.checked ?? [],
+		halfCheckedKeys: keys.halfChecked ?? []
+	};
+	return {
+		checkedKeys: [],
+		halfCheckedKeys: []
+	};
+}
+/** single mode keeps the first key only */
+function calcSelectedKeys(keys, multiple) {
+	const list = keys ?? [];
+	if (multiple || list.length <= 1) return list;
+	return [list[0]];
+}
+export { arrAdd, arrDel, calcSelectedKeys, conductCheck, conductExpandParent, convertDataToEntities, fillFieldNames, flattenTreeData, getNodeChildren, getNodeKey, isCheckDisabled, parseCheckedKeys };

package/dist/typography/Decorate.d.ts

@@ -0,0 +1,9 @@
+import type { FunctionalComponent } from 'vue';
+/**
+ * Internal render helper: wraps the default slot with semantic tags,
+ * `['strong', 'u']` -> `<strong><u>...</u></strong>`.
+ */
+declare const Decorate: FunctionalComponent<{
+    tags: string[];
+}>;
+export default Decorate;

package/dist/typography/Decorate.js

@@ -0,0 +1,14 @@
+import { h } from "vue";
+// src/typography/Decorate.ts
+/**
+* Internal render helper: wraps the default slot with semantic tags,
+* `['strong', 'u']` -> `<strong><u>...</u></strong>`.
+*/
+var Decorate = (props, { slots }) => {
+	let content = slots.default?.();
+	for (let i = props.tags.length - 1; i >= 0; i--) content = h(props.tags[i], null, content);
+	return content;
+};
+Decorate.props = ["tags"];
+Decorate.displayName = "AmTypographyDecorate";
+export { Decorate as default };

package/dist/typography/Typography.js

@@ -0,0 +1,4 @@
+import Typography_vue_vue_type_script_setup_true_lang_default from "./Typography.vue_vue_type_script_setup_true_lang.js";
+// src/typography/Typography.vue
+var Typography_default = Typography_vue_vue_type_script_setup_true_lang_default;
+export { Typography_default as default };

package/dist/typography/Typography.vue.d.ts

@@ -0,0 +1,15 @@
+import type { TypographyProps, TypographySlots } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = TypographySlots;
+declare const __VLS_base: import("vue").DefineComponent<TypographyProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TypographyProps> & Readonly<{}>, {
+    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/typography/Typography.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,22 @@
+import "../style/index2.js";
+import './style/index.css';/* empty css            */
+import { createBlock, defineComponent, mergeProps, openBlock, renderSlot, resolveDynamicComponent, withCtx } from "vue";
+// src/typography/Typography.vue?vue&type=script&setup=true&lang.ts
+var Typography_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	name: "AmTypography",
+	inheritAttrs: false,
+	__name: "Typography",
+	props: {
+		component: { default: "article" },
+		rootClass: {}
+	},
+	setup(__props) {
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(resolveDynamicComponent(__props.component), mergeProps(_ctx.$attrs, { class: ["am-typography", __props.rootClass] }), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 16, ["class"]);
+		};
+	}
+});
+export { Typography_vue_vue_type_script_setup_true_lang_default as default };

package/dist/typography/TypographyBase.js

@@ -0,0 +1,4 @@
+import TypographyBase_vue_vue_type_script_setup_true_lang_default from "./TypographyBase.vue_vue_type_script_setup_true_lang.js";
+// src/typography/TypographyBase.vue
+var TypographyBase_default = TypographyBase_vue_vue_type_script_setup_true_lang_default;
+export { TypographyBase_default as default };

package/dist/typography/TypographyBase.vue.d.ts

@@ -0,0 +1,29 @@
+import type { TypographyBaseProps, TypographyBaseSlots, TypographyCopyConfig, TypographyEllipsisConfig, TypographyTitleLevel } from './interface';
+import '../style';
+import './style/index.css';
+type __VLS_Slots = TypographyBaseSlots;
+interface TypographyInternalProps extends TypographyBaseProps {
+    component: string;
+    kind: 'text' | 'title' | 'paragraph';
+    level?: TypographyTitleLevel;
+}
+declare const __VLS_base: import("vue").DefineComponent<TypographyInternalProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    copy: (event: MouseEvent) => any;
+    expand: (expanded: boolean, event: MouseEvent) => any;
+    "update:expanded": (expanded: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<TypographyInternalProps> & Readonly<{
+    onCopy?: ((event: MouseEvent) => any) | undefined;
+    onExpand?: ((expanded: boolean, event: MouseEvent) => any) | undefined;
+    "onUpdate:expanded"?: ((expanded: boolean) => any) | undefined;
+}>, {
+    ellipsis: boolean | TypographyEllipsisConfig;
+    copyable: boolean | TypographyCopyConfig;
+}, {}, {}, {}, 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;
+    };
+};