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

package/dist/popover-hD77YpUM.js

@@ -0,0 +1,292 @@
+import "./src-DNBBthjO.js";
+import { t as e } from "./env-BeIzjQx7.js";
+import { n as t, t as n } from "./Tooltip-Bq7HZwnS.js";
+import { t as r } from "./constants-BF9bZJyc.js";
+import { t as i } from "./config-context-CyynTtDb.js";
+import { n as a } from "./config-provider-VMfNNSF1.js";
+import { computed as o, createBlock as s, createElementBlock as c, createElementVNode as l, createSlots as u, createVNode as d, defineComponent as f, getCurrentInstance as p, inject as m, mergeProps as h, normalizeClass as g, normalizeStyle as _, openBlock as v, renderSlot as y, unref as b, useTemplateRef as x, withCtx as S } from "vue";
+`${e}`, `${e}`;
+var C = {
+	POSITION_SET: [
+		"top",
+		"topLeft",
+		"topRight",
+		"left",
+		"leftTop",
+		"leftBottom",
+		"right",
+		"rightTop",
+		"rightBottom",
+		"bottom",
+		"bottomLeft",
+		"bottomRight",
+		"leftTopOver",
+		"rightTopOver"
+	],
+	TRIGGER_SET: [
+		"hover",
+		"focus",
+		"click",
+		"custom",
+		"contextMenu"
+	],
+	DEFAULT_ARROW_STYLE: {
+		borderOpacity: "1",
+		backgroundColor: "var(--semi-color-bg-3)",
+		borderColor: "var(--semi-color-border)"
+	}
+}, w = {
+	ARROW_BOUNDING: {
+		...r.ARROW_BOUNDING,
+		offsetY: 6,
+		offsetX: 0,
+		height: 8
+	},
+	SPACING: 4,
+	SPACING_WITH_ARROW: 10,
+	DEFAULT_Z_INDEX: 1030
+}, T = {
+	key: 0,
+	"aria-hidden": "true",
+	class: "semi-popover-icon-arrow",
+	width: "24",
+	height: "8",
+	xmlns: "http://www.w3.org/2000/svg"
+}, E = {
+	key: 1,
+	"aria-hidden": "true",
+	class: "semi-popover-icon-arrow",
+	width: "24",
+	height: "8",
+	xmlns: "http://www.w3.org/2000/svg"
+}, D = /* @__PURE__ */ f({
+	__name: "PopoverArrow",
+	props: {
+		arrowStyle: {},
+		popStyle: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] },
+		position: {}
+	},
+	setup(e) {
+		let t = e, n = o(() => t.position?.startsWith("top") || t.position?.startsWith("bottom")), r = o(() => {
+			if (!(!t.popStyle || typeof t.popStyle != "object" || Array.isArray(t.popStyle))) return t.popStyle;
+		}), i = o(() => ({
+			fill: t.arrowStyle?.borderColor ?? r.value?.borderColor,
+			opacity: t.arrowStyle?.borderOpacity
+		})), a = o(() => ({ fill: t.arrowStyle?.backgroundColor ?? r.value?.backgroundColor }));
+		return (e, t) => n.value ? (v(), c("svg", T, [l("path", {
+			d: "M0 0.5L0 1.5C4 1.5, 5.5 3, 7.5 5S10,8 12,8S14.5 7, 16.5 5S20,1.5 24,1.5L24 0.5L0 0.5z",
+			style: _(i.value)
+		}, null, 4), l("path", {
+			d: "M0 0L0 1C4 1, 5.5 2, 7.5 4S10,7 12,7S14.5 6, 16.5 4S20,1 24,1L24 0L0 0z",
+			style: _(a.value)
+		}, null, 4)])) : (v(), c("svg", E, [l("path", {
+			d: "M0.5 0L1.5 0C1.5 4, 3 5.5, 5 7.5S8,10 8,12S7 14.5, 5 16.5S1.5,20 1.5,24L0.5 24L0.5 0z",
+			style: _(i.value)
+		}, null, 4), l("path", {
+			d: "M0 0L1 0C1 4, 2 5.5, 4 7.5S7,10 7,12S6 14.5, 4 16.5S1,20 1,24L0 24L0 0z",
+			style: _(a.value)
+		}, null, 4)]));
+	}
+}), O = /* @__PURE__ */ f({
+	name: "Popover",
+	inheritAttrs: !1,
+	__name: "Popover",
+	props: {
+		arrowStyle: {},
+		class: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] },
+		className: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] },
+		content: { type: [
+			Object,
+			String,
+			Number,
+			Boolean,
+			null,
+			Array
+		] },
+		contentClassName: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] },
+		prefixCls: {},
+		showArrow: { type: Boolean },
+		style: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] },
+		zIndex: {},
+		arrowBounding: {},
+		arrowPointAtCenter: { type: Boolean },
+		autoAdjustOverflow: { type: Boolean },
+		clickToHide: { type: Boolean },
+		clickTriggerToHide: { type: Boolean },
+		closeOnEsc: { type: Boolean },
+		condition: { type: Boolean },
+		disableArrowKeyDown: { type: Boolean },
+		disableFocusListener: { type: Boolean },
+		getPopupContainer: { type: Function },
+		guardFocus: { type: Boolean },
+		keepDOM: { type: Boolean },
+		margin: {},
+		motion: { type: Boolean },
+		mouseEnterDelay: {},
+		mouseLeaveDelay: {},
+		position: {},
+		preventScroll: { type: Boolean },
+		rePosKey: {},
+		returnFocusOnClose: { type: Boolean },
+		spacing: {},
+		stopPropagation: { type: Boolean },
+		transformFromCenter: { type: Boolean },
+		trigger: {},
+		visible: { type: Boolean },
+		wrapWhenSpecial: { type: Boolean },
+		wrapperClassName: { type: [
+			Boolean,
+			null,
+			String,
+			Object,
+			Array
+		] },
+		wrapperId: {}
+	},
+	emits: [
+		"afterClose",
+		"clickOutside",
+		"escKeydown",
+		"visibleChange",
+		"update:visible"
+	],
+	setup(e, { expose: r, emit: c }) {
+		let f = e, _ = c, C = p(), T = x("tooltip"), E = m(i, void 0), O = o(() => E ? E.value : {
+			direction: "ltr",
+			getPopupContainer: void 0
+		});
+		function k(e) {
+			let t = String(e).replace(/[A-Z]/g, (e) => `-${e.toLowerCase()}`), n = C?.vnode.props;
+			return !!(n && (Object.prototype.hasOwnProperty.call(n, e) || Object.prototype.hasOwnProperty.call(n, t)));
+		}
+		function A(e, t) {
+			let n = f[e];
+			if (k(e) && n !== void 0) return n;
+			let r = a.config.overrideDefaultProps?.Popover?.[e];
+			return r === void 0 ? t : r;
+		}
+		let j = o(() => A("showArrow", !1)), M = o(() => ({
+			arrowBounding: A("arrowBounding", { ...w.ARROW_BOUNDING }),
+			arrowPointAtCenter: A("arrowPointAtCenter", !0),
+			autoAdjustOverflow: A("autoAdjustOverflow", !0),
+			clickToHide: A("clickToHide", !1),
+			closeOnEsc: A("closeOnEsc", !0),
+			condition: A("condition", !0),
+			disableArrowKeyDown: A("disableArrowKeyDown", !1),
+			disableFocusListener: A("disableFocusListener", !0),
+			guardFocus: A("guardFocus", !0),
+			keepDOM: A("keepDOM", !1),
+			margin: A("margin", 0),
+			motion: A("motion", !0),
+			mouseEnterDelay: A("mouseEnterDelay", 50),
+			mouseLeaveDelay: A("mouseLeaveDelay", 50),
+			position: A("position", "bottom"),
+			prefixCls: A("prefixCls", "semi-popover"),
+			preventScroll: A("preventScroll", !1),
+			returnFocusOnClose: A("returnFocusOnClose", !0),
+			spacing: A("spacing", j.value ? w.SPACING_WITH_ARROW : w.SPACING),
+			stopPropagation: A("stopPropagation", !1),
+			trigger: A("trigger", "hover"),
+			wrapWhenSpecial: A("wrapWhenSpecial", !0),
+			zIndex: A("zIndex", w.DEFAULT_Z_INDEX)
+		})), N = o(() => M.value.trigger === "click" || M.value.trigger === "custom" ? "dialog" : "tooltip"), P = o(() => [f.class, f.className]), F = o(() => [
+			M.value.prefixCls,
+			f.contentClassName,
+			{ [`${M.value.prefixCls}-rtl`]: O.value.direction === "rtl" }
+		]), I = o(() => ({
+			...f.getPopupContainer ? { getPopupContainer: f.getPopupContainer } : {},
+			...f.rePosKey === void 0 ? {} : { rePosKey: f.rePosKey },
+			...k("visible") ? { visible: f.visible } : {},
+			...f.wrapperClassName === void 0 ? {} : { wrapperClassName: f.wrapperClassName },
+			...f.wrapperId === void 0 ? {} : { wrapperId: f.wrapperId }
+		}));
+		function L() {
+			T.value?.focusTrigger();
+		}
+		return r({ focusTrigger: L }), (e, r) => (v(), s(b(n), h({ ref: "tooltip" }, I.value, {
+			"arrow-bounding": M.value.arrowBounding,
+			"arrow-point-at-center": M.value.arrowPointAtCenter,
+			"auto-adjust-overflow": M.value.autoAdjustOverflow,
+			class: P.value,
+			"click-to-hide": M.value.clickToHide,
+			"close-on-esc": M.value.closeOnEsc,
+			condition: M.value.condition,
+			"disable-arrow-key-down": M.value.disableArrowKeyDown,
+			"disable-focus-listener": M.value.disableFocusListener,
+			"guard-focus": M.value.guardFocus,
+			"keep-d-o-m": M.value.keepDOM,
+			margin: M.value.margin,
+			motion: M.value.motion,
+			"mouse-enter-delay": M.value.mouseEnterDelay,
+			"mouse-leave-delay": M.value.mouseLeaveDelay,
+			position: M.value.position,
+			"prefix-cls": M.value.prefixCls,
+			"prevent-scroll": M.value.preventScroll,
+			"return-focus-on-close": M.value.returnFocusOnClose,
+			role: N.value,
+			"show-arrow": j.value,
+			spacing: M.value.spacing,
+			"stop-propagation": M.value.stopPropagation,
+			style: f.style,
+			trigger: M.value.trigger,
+			"wrap-when-special": M.value.wrapWhenSpecial,
+			"z-index": M.value.zIndex,
+			onAfterClose: r[0] ||= (e) => _("afterClose"),
+			onClickOutside: r[1] ||= (e) => _("clickOutside", e),
+			onEscKeydown: r[2] ||= (e) => _("escKeydown", e),
+			"onUpdate:visible": r[3] ||= (e) => _("update:visible", e),
+			onVisibleChange: r[4] ||= (e) => _("visibleChange", e)
+		}), u({
+			content: S(({ initialFocusRef: n }) => [l("div", { class: g(F.value) }, [l("div", { class: g(`${M.value.prefixCls}-content`) }, [e.$slots.content ? y(e.$slots, "content", { initialFocusRef: n }, void 0, void 0, 0) : (v(), s(b(t), {
+				key: 1,
+				content: f.content
+			}, null, 8, ["content"]))], 2)], 2)]),
+			default: S(() => [y(e.$slots, "default")]),
+			_: 2
+		}, [j.value ? {
+			name: "arrow",
+			fn: S(() => [d(D, {
+				"arrow-style": f.arrowStyle,
+				"pop-style": f.style,
+				position: M.value.position
+			}, null, 8, [
+				"arrow-style",
+				"pop-style",
+				"position"
+			])]),
+			key: "0"
+		} : void 0]), 1040, /* @__PURE__ */ "arrow-bounding.arrow-point-at-center.auto-adjust-overflow.class.click-to-hide.close-on-esc.condition.disable-arrow-key-down.disable-focus-listener.guard-focus.keep-d-o-m.margin.motion.mouse-enter-delay.mouse-leave-delay.position.prefix-cls.prevent-scroll.return-focus-on-close.role.show-arrow.spacing.stop-propagation.style.trigger.wrap-when-special.z-index".split(".")));
+	}
+}), k = O;
+//#endregion
+export { C as i, O as n, w as r, k as t };

package/dist/progress/Progress.vue.d.ts

@@ -0,0 +1,24 @@
+import { VNodeChild } from 'vue';
+import { ProgressProps, ProgressSlots } from './types';
+type __VLS_Slots = ProgressSlots;
+declare const __VLS_base: import('vue').DefineComponent<ProgressProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ProgressProps> & Readonly<{}>, {
+    className: import('vue').HTMLAttributes["class"];
+    size: import('./types').ProgressSize;
+    type: import('./types').ProgressType;
+    direction: import('./types').ProgressDirection;
+    strokeLinecap: import('./types').ProgressStrokeLinecap;
+    strokeWidth: number;
+    motion: import('./types').ProgressMotion;
+    percent: number;
+    format: (percent: number) => VNodeChild;
+    showInfo: boolean;
+    strokeGradient: 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/progress/ProgressCircle.vue.d.ts

@@ -0,0 +1,26 @@
+import { HTMLAttributes, StyleValue, VNodeChild } from 'vue';
+import { ProgressSize, ProgressStrokeLinecap } from './types';
+type __VLS_Props = {
+    ariaLabel?: string | undefined;
+    ariaLabelledby?: string | undefined;
+    ariaValuetext?: string | undefined;
+    content: VNodeChild;
+    dataAttrs: Record<string, unknown>;
+    id?: string | undefined;
+    nativeClass?: HTMLAttributes['class'] | undefined;
+    nativeStyle?: StyleValue | undefined;
+    orbitStroke?: string | undefined;
+    percent: number;
+    percentNumber: number;
+    rootClass?: HTMLAttributes['class'] | undefined;
+    rootStyle?: StyleValue | undefined;
+    showInfo: boolean;
+    size: ProgressSize;
+    stroke?: string | undefined;
+    strokeLinecap: ProgressStrokeLinecap;
+    strokeWidth: number;
+    width?: number | undefined;
+};
+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/progress/ProgressLine.vue.d.ts

@@ -0,0 +1,23 @@
+import { HTMLAttributes, StyleValue, VNodeChild } from 'vue';
+import { ProgressDirection, ProgressSize } from './types';
+type __VLS_Props = {
+    ariaLabel?: string | undefined;
+    ariaLabelledby?: string | undefined;
+    ariaValuetext?: string | undefined;
+    content: VNodeChild;
+    dataAttrs: Record<string, unknown>;
+    direction: ProgressDirection;
+    id?: string | undefined;
+    nativeClass?: HTMLAttributes['class'] | undefined;
+    nativeStyle?: StyleValue | undefined;
+    orbitStroke?: string | undefined;
+    percent: number;
+    rootClass?: HTMLAttributes['class'] | undefined;
+    rootStyle?: StyleValue | undefined;
+    size: ProgressSize;
+    stroke?: string | undefined;
+    showInfo: boolean;
+};
+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/progress/ProgressNodeRenderer.d.ts

@@ -0,0 +1,15 @@
+import { PropType, VNodeChild } from 'vue';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    content: {
+        type: PropType<VNodeChild>;
+        default: undefined;
+    };
+}>, () => VNodeChild, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    content: {
+        type: PropType<VNodeChild>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    content: VNodeChild;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/progress/index.d.ts

@@ -0,0 +1,6 @@
+import { DefineComponent } from 'vue';
+import { ProgressProps } from './types';
+export declare const Progress: DefineComponent<ProgressProps>;
+export { PROGRESS_DIRECTIONS, PROGRESS_SIZES, PROGRESS_STROKE_LINECAPS, PROGRESS_TYPES, } from './types';
+export type { ProgressDirection, ProgressMotion, ProgressMotionObject, ProgressProps, ProgressSize, ProgressSlots, ProgressStrokeLinecap, ProgressStrokePoint, ProgressType, } from './types';
+export default Progress;

package/dist/progress/index.js

@@ -0,0 +1,2 @@
+import { a as e, i as t, n, r, t as i } from "../progress-DIIyWKKD.js";
+export { n as PROGRESS_DIRECTIONS, r as PROGRESS_SIZES, t as PROGRESS_STROKE_LINECAPS, e as PROGRESS_TYPES, i as Progress, i as default };

package/dist/progress/types.d.ts

@@ -0,0 +1,44 @@
+import { HTMLAttributes, StyleValue, VNodeChild } from 'vue';
+export declare const PROGRESS_DIRECTIONS: readonly ["horizontal", "vertical"];
+export declare const PROGRESS_SIZES: readonly ["default", "small", "large"];
+export declare const PROGRESS_STROKE_LINECAPS: readonly ["round", "square"];
+export declare const PROGRESS_TYPES: readonly ["line", "circle"];
+export type ProgressDirection = (typeof PROGRESS_DIRECTIONS)[number];
+export type ProgressSize = (typeof PROGRESS_SIZES)[number];
+export type ProgressStrokeLinecap = (typeof PROGRESS_STROKE_LINECAPS)[number];
+export type ProgressType = (typeof PROGRESS_TYPES)[number];
+export interface ProgressStrokePoint {
+    percent: number;
+    color: string;
+}
+export interface ProgressMotionObject {
+    [key: string]: unknown;
+}
+export type ProgressMotion = boolean | ProgressMotionObject | ((props: Record<string, unknown>) => ProgressMotionObject);
+export interface ProgressProps {
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+    ariaValuetext?: string;
+    class?: HTMLAttributes['class'];
+    className?: HTMLAttributes['class'];
+    direction?: ProgressDirection;
+    format?: (percent: number) => VNodeChild;
+    id?: string;
+    motion?: ProgressMotion;
+    orbitStroke?: string;
+    percent?: number;
+    showInfo?: boolean;
+    size?: ProgressSize;
+    stroke?: string | ProgressStrokePoint[];
+    strokeGradient?: boolean;
+    strokeLinecap?: ProgressStrokeLinecap;
+    strokeWidth?: number;
+    style?: StyleValue;
+    type?: ProgressType;
+    width?: number;
+}
+export interface ProgressSlots {
+    format?: (props: {
+        percent: number;
+    }) => VNodeChild;
+}

package/dist/progress-DIIyWKKD.js

@@ -0,0 +1,9 @@
+import { t as e } from "./Progress-BulSV_JR.js";
+//#region src/progress/types.ts
+var t = ["horizontal", "vertical"], n = [
+	"default",
+	"small",
+	"large"
+], r = ["round", "square"], i = ["line", "circle"], a = e;
+//#endregion
+export { i as a, r as i, t as n, n as r, a as t };

package/dist/radio/Radio.vue.d.ts

@@ -0,0 +1,30 @@
+import { RadioChangeEvent, RadioExposed, RadioProps, RadioSlots } from './types';
+type __VLS_Slots = RadioSlots;
+declare const __VLS_base: import('vue').DefineComponent<RadioProps, RadioExposed, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (event: RadioChangeEvent) => any;
+    mouseenter: (event: MouseEvent) => any;
+    mouseleave: (event: MouseEvent) => any;
+    "update:modelValue": (checked: boolean) => any;
+    "update:checked": (checked: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<RadioProps> & Readonly<{
+    onChange?: (event: RadioChangeEvent) => any;
+    onMouseenter?: (event: MouseEvent) => any;
+    onMouseleave?: (event: MouseEvent) => any;
+    "onUpdate:modelValue"?: (checked: boolean) => any;
+    "onUpdate:checked"?: (checked: boolean) => any;
+}>, {
+    disabled: boolean;
+    type: import('./types').RadioType;
+    mode: import('./types').RadioMode;
+    autoFocus: boolean;
+    defaultChecked: boolean;
+    displayMode: import('./types').RadioDisplayMode;
+}, {}, {}, {}, 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/radio/RadioGroup.d.ts

@@ -0,0 +1,201 @@
+import { PropType, VNode } from 'vue';
+import { RadioButtonSize, RadioDirection, RadioGroupProps, RadioMode, RadioOption, RadioType, RadioValue } from './types';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    ariaDescribedby: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    ariaErrormessage: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    ariaInvalid: {
+        type: PropType<RadioGroupProps["ariaInvalid"]>;
+        default: undefined;
+    };
+    ariaLabel: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    ariaLabelledby: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    ariaRequired: {
+        type: PropType<RadioGroupProps["ariaRequired"]>;
+        default: undefined;
+    };
+    buttonSize: {
+        type: PropType<RadioButtonSize>;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+    className: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultValue: {
+        type: PropType<RadioValue | undefined>;
+        default: undefined;
+    };
+    direction: {
+        type: PropType<RadioDirection>;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    mode: {
+        type: PropType<RadioMode>;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+    modelValue: {
+        type: PropType<RadioValue | undefined>;
+        default: undefined;
+    };
+    name: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    options: {
+        type: PropType<Array<string | RadioOption> | undefined>;
+        default: undefined;
+    };
+    prefixCls: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    style: {
+        type: PropType<RadioGroupProps["style"]>;
+        default: undefined;
+    };
+    type: {
+        type: PropType<RadioType>;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+    value: {
+        type: PropType<RadioValue | undefined>;
+        default: undefined;
+    };
+}>, () => VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("change" | "update:modelValue" | "update:value")[], "change" | "update:modelValue" | "update:value", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    ariaDescribedby: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    ariaErrormessage: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    ariaInvalid: {
+        type: PropType<RadioGroupProps["ariaInvalid"]>;
+        default: undefined;
+    };
+    ariaLabel: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    ariaLabelledby: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    ariaRequired: {
+        type: PropType<RadioGroupProps["ariaRequired"]>;
+        default: undefined;
+    };
+    buttonSize: {
+        type: PropType<RadioButtonSize>;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+    className: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    defaultValue: {
+        type: PropType<RadioValue | undefined>;
+        default: undefined;
+    };
+    direction: {
+        type: PropType<RadioDirection>;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    mode: {
+        type: PropType<RadioMode>;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+    modelValue: {
+        type: PropType<RadioValue | undefined>;
+        default: undefined;
+    };
+    name: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    options: {
+        type: PropType<Array<string | RadioOption> | undefined>;
+        default: undefined;
+    };
+    prefixCls: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    style: {
+        type: PropType<RadioGroupProps["style"]>;
+        default: undefined;
+    };
+    type: {
+        type: PropType<RadioType>;
+        default: string;
+        validator: (value: string) => boolean;
+    };
+    value: {
+        type: PropType<RadioValue | undefined>;
+        default: undefined;
+    };
+}>> & Readonly<{
+    onChange?: (...args: any[]) => any;
+    "onUpdate:modelValue"?: (...args: any[]) => any;
+    "onUpdate:value"?: (...args: any[]) => any;
+}>, {
+    className: string;
+    style: import('vue').CSSProperties | undefined;
+    disabled: boolean;
+    type: "default" | "button" | "card" | "pureCard";
+    name: string;
+    value: RadioValue | undefined;
+    mode: "" | "advanced";
+    prefixCls: string;
+    defaultValue: RadioValue | undefined;
+    id: string;
+    modelValue: RadioValue | undefined;
+    ariaDescribedby: string;
+    ariaErrormessage: string;
+    ariaInvalid: boolean | "true" | "false" | "grammar" | "spelling" | undefined;
+    ariaLabel: string;
+    ariaLabelledby: string;
+    ariaRequired: boolean | "true" | "false" | undefined;
+    direction: "horizontal" | "vertical";
+    options: (string | RadioOption)[] | undefined;
+    buttonSize: "small" | "middle" | "large";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;