x-sccba 0.1.2 → 0.2.4

package/types/components/XBacktop/types.d.ts

@@ -1,14 +1,16 @@
+import { ExtractPropTypes } from 'vue-demi';
 import { GlobalComponents } from 'vue';
-
+import { backtopProps, backtopEmits } from './index';
 
 // Backtop组件类型
 type elBacktopProps = GlobalComponents['ElBacktop']['$props'];
 
 // 自定义属性接口（可根据需要扩展）
-export interface BacktopProps {}
+export interface BacktopProps extends ExtractPropTypes<typeof backtopProps> {}
 
 // 合并类型（仅单层交叉，无复杂逻辑）
 export type SelfBacktopProps = BacktopProps & Partial<elBacktopProps>;
 
 // 组件 Props 类型导出
 export type XBacktopProps = SelfBacktopProps;
+export type XBacktopEmits = (typeof backtopEmits)[number];

package/types/components/XBadge/index.d.ts

@@ -0,0 +1,4 @@
+export declare const badgeProps: {};
+export declare const badgeEmits: readonly [];
+declare const _default: import('vue').DefineComponent<{}, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, never[], never, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/components/XBadge/types.d.ts

@@ -1,11 +1,13 @@
+import { ExtractPropTypes } from 'vue-demi';
 import { GlobalComponents } from 'vue';
-
+import { badgeProps, badgeEmits } from './index';
 
 // Badge组件类型
 type elBadgeProps = GlobalComponents['ElBadge']['$props'];
 
 // 自定义属性接口（可根据需要扩展）
-export interface BadgeProps {}
+export interface BadgeProps extends ExtractPropTypes<typeof badgeProps> {}
 
 // 合并类型（仅单层交叉，无复杂逻辑）
 export type SelfBadgeProps = BadgeProps & Partial<elBadgeProps>;
+export type XBadgeEmits = (typeof badgeEmits)[number];

package/types/components/XBreadcrumb/XBreadcrumbItem.d.ts

@@ -0,0 +1,4 @@
+export declare const breadcrumbItemProps: {};
+export declare const breadcrumbItemEmits: readonly [];
+declare const _default: import('vue').DefineComponent<{}, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, never[], never, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/components/XBreadcrumb/index.d.ts

@@ -0,0 +1,4 @@
+export declare const breadcrumbProps: {};
+export declare const breadcrumbEmits: readonly [];
+declare const _default: import('vue').DefineComponent<{}, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, never[], never, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/components/XBreadcrumb/types.d.ts

@@ -1,16 +1,16 @@
+import { ExtractPropTypes } from 'vue-demi';
 import { BreadcrumbItemProps, BreadcrumbProps } from 'element-plus';
-
+import { breadcrumbProps, breadcrumbEmits } from './index';
+import { breadcrumbItemProps, breadcrumbItemEmits } from './XBreadcrumbItem';
 
 // 自有 Props
-export interface Props {
-}
+export interface Props extends ExtractPropTypes<typeof breadcrumbProps> {}
 
 // 合并 Props（保留原有逻辑）
 export type SelfProps = Props & Partial<BreadcrumbProps>;
 
 // Item 自有 Props
-export interface ItemProps {
-}
+export interface ItemProps extends ExtractPropTypes<typeof breadcrumbItemProps> {}
 
 // 合并 Item Props（保留原有逻辑）
 export type SelfItemProps = ItemProps & Partial<BreadcrumbItemProps>;
@@ -18,3 +18,5 @@ export type SelfItemProps = ItemProps & Partial<BreadcrumbItemProps>;
 // 组件 Props 类型导出
 export type XBreadcrumbProps = SelfProps;
 export type XBreadcrumbItemProps = SelfItemProps;
+export type XBreadcrumbEmits = (typeof breadcrumbEmits)[number];
+export type XBreadcrumbItemEmits = (typeof breadcrumbItemEmits)[number];

package/types/components/XButton/XButtonGroup.d.ts

@@ -0,0 +1,4 @@
+export declare const buttonGroupProps: {};
+export declare const buttonGroupEmits: readonly [];
+declare const _default: import('vue').DefineComponent<{}, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, never[], never, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/components/XButton/index.d.ts

@@ -0,0 +1,169 @@
+import { PropType } from 'vue-demi';
+/**
+ * 封装层自有 props
+ *
+ * 这些字段仅服务于 XButton 自身的业务（tooltip / 防抖 / 禁用态提示 / 异步 loading / 二次确认），
+ * 大多数不会被转发到底层 el-button；特例是 `loading`（见下方注释，双重身份）。
+ * 统一将 default 写为 undefined，是为了保留「用户是否显式传入」的状态信号，
+ * 让消费侧用 `?? 默认值` 做兜底（对 Boolean 的 isDebounce 尤其必要，否则 Vue 会隐式补 false）。
+ */
+export declare const buttonProps: {
+    readonly time: {
+        readonly type: NumberConstructor;
+        readonly default: undefined;
+    };
+    readonly tip: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly placement: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly tipProps: {
+        readonly type: PropType<Record<string, any>>;
+        readonly default: undefined;
+    };
+    readonly isDebounce: {
+        readonly type: BooleanConstructor;
+        readonly default: undefined;
+    };
+    readonly disabledTip: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly asyncClick: {
+        readonly type: PropType<(e: MouseEvent) => unknown | Promise<unknown>>;
+        readonly default: undefined;
+    };
+    readonly autoLoading: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    /**
+     * P0-1：显式声明 loading 为自有 prop（default:undefined 保留“未传入”信号）。
+     * 关键：loading 不加入 SELF_PROP_KEYS，仍需透传给底层 el-button；
+     * 目的：让 useForwardProps 的末步过滤 `refProps.value[curr] !== undefined` 能读到它，
+     *      从而在 setup 中 finalLoading = forwarded.value.loading ?? autoLoadingRef.value 生效。
+     */
+    readonly loading: {
+        readonly type: BooleanConstructor;
+        readonly default: undefined;
+    };
+    readonly confirm: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+};
+export declare const buttonEmits: readonly ["click", "error", "cancel"];
+declare const _default: import('vue').DefineComponent<globalThis.ExtractPropTypes<{
+    readonly time: {
+        readonly type: NumberConstructor;
+        readonly default: undefined;
+    };
+    readonly tip: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly placement: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly tipProps: {
+        readonly type: PropType<Record<string, any>>;
+        readonly default: undefined;
+    };
+    readonly isDebounce: {
+        readonly type: BooleanConstructor;
+        readonly default: undefined;
+    };
+    readonly disabledTip: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly asyncClick: {
+        readonly type: PropType<(e: MouseEvent) => unknown | Promise<unknown>>;
+        readonly default: undefined;
+    };
+    readonly autoLoading: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    /**
+     * P0-1：显式声明 loading 为自有 prop（default:undefined 保留“未传入”信号）。
+     * 关键：loading 不加入 SELF_PROP_KEYS，仍需透传给底层 el-button；
+     * 目的：让 useForwardProps 的末步过滤 `refProps.value[curr] !== undefined` 能读到它，
+     *      从而在 setup 中 finalLoading = forwarded.value.loading ?? autoLoadingRef.value 生效。
+     */
+    readonly loading: {
+        readonly type: BooleanConstructor;
+        readonly default: undefined;
+    };
+    readonly confirm: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+}>, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("cancel" | "click" | "error")[], "cancel" | "click" | "error", import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    readonly time: {
+        readonly type: NumberConstructor;
+        readonly default: undefined;
+    };
+    readonly tip: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly placement: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly tipProps: {
+        readonly type: PropType<Record<string, any>>;
+        readonly default: undefined;
+    };
+    readonly isDebounce: {
+        readonly type: BooleanConstructor;
+        readonly default: undefined;
+    };
+    readonly disabledTip: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+    readonly asyncClick: {
+        readonly type: PropType<(e: MouseEvent) => unknown | Promise<unknown>>;
+        readonly default: undefined;
+    };
+    readonly autoLoading: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    /**
+     * P0-1：显式声明 loading 为自有 prop（default:undefined 保留“未传入”信号）。
+     * 关键：loading 不加入 SELF_PROP_KEYS，仍需透传给底层 el-button；
+     * 目的：让 useForwardProps 的末步过滤 `refProps.value[curr] !== undefined` 能读到它，
+     *      从而在 setup 中 finalLoading = forwarded.value.loading ?? autoLoadingRef.value 生效。
+     */
+    readonly loading: {
+        readonly type: BooleanConstructor;
+        readonly default: undefined;
+    };
+    readonly confirm: {
+        readonly type: StringConstructor;
+        readonly default: undefined;
+    };
+}>> & Readonly<{
+    onCancel?: ((...args: any[]) => any) | undefined;
+    onClick?: ((...args: any[]) => any) | undefined;
+    onError?: ((...args: any[]) => any) | undefined;
+}>, {
+    readonly time: number;
+    readonly loading: boolean;
+    readonly placement: string;
+    readonly confirm: string;
+    readonly tip: string;
+    readonly tipProps: Record<string, any>;
+    readonly isDebounce: boolean;
+    readonly disabledTip: string;
+    readonly asyncClick: (e: MouseEvent) => unknown | Promise<unknown>;
+    readonly autoLoading: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/components/XButton/types.d.ts

@@ -1,9 +1,22 @@
+import { ExtractPropTypes } from 'vue-demi';
 import { ButtonProps } from 'element-plus';
-export interface XButtonSelfProps {
-  time?: number;
-  tip?: string;
-  placement?: string;
-  tipProps?: Record<string, any>;
-  isDebounce?: boolean;
-}
-export type XButtonProps = XButtonSelfProps & Partial<ButtonProps>;
+import { buttonProps, buttonEmits } from './index';
+/**
+ * XButton 组件完整的 Props 类型。
+ *
+ * = 本组件自有 props（由 `buttonProps` 推导）
+ *   + element-plus `ButtonProps` 的「部分可选」形式（`Partial<ButtonProps>`）。
+ *
+ * 使用 `Partial` 是因为：element-plus 的 `ButtonProps` 在类型上可能包含必填字段，
+ * 但作为对外暴露的组件属性，这些字段通常都有默认值或允许省略，因此统一放宽为可选，
+ * 避免调用方被迫传入本不需要显式指定的属性。
+ */
+export type XButtonProps = ExtractPropTypes<typeof buttonProps> & Partial<ButtonProps>;
+
+/**
+ * XButton 组件可触发的事件名联合类型。
+ *
+ * `buttonEmits` 为一个只读字符串数组（事件名清单），通过 `[number]` 取其成员类型，
+ * 得到所有合法事件名组成的字符串字面量联合类型，便于在模板/JSX 中做事件名的精确校验。
+ */
+export type XButtonEmits = (typeof buttonEmits)[number];

package/types/components/XCalendar/index.d.ts

@@ -0,0 +1,4 @@
+export declare const calendarProps: {};
+export declare const calendarEmits: readonly [];
+declare const _default: import('vue').DefineComponent<{}, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, never[], never, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/components/XCalendar/types.d.ts

@@ -1,11 +1,13 @@
+import { ExtractPropTypes } from 'vue-demi';
 import { GlobalComponents } from 'vue';
-
+import { calendarProps, calendarEmits } from './index';
 
 // Calendar组件类型
 type elCalendarProps = GlobalComponents['ElCalendar']['$props'];
 
 // 自定义属性接口（可根据需要扩展）
-export interface CalendarProps {}
+export interface CalendarProps extends ExtractPropTypes<typeof calendarProps> {}
 
 // 合并类型（仅单层交叉，无复杂逻辑）
 export type SelfCalendarProps = CalendarProps & Partial<elCalendarProps>;
+export type XCalendarEmits = (typeof calendarEmits)[number];

package/types/components/XCard/index.d.ts

@@ -0,0 +1,4 @@
+export declare const cardProps: {};
+export declare const cardEmits: readonly [];
+declare const _default: import('vue').DefineComponent<{}, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, never[], never, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/components/XCard/types.d.ts

@@ -1,12 +1,13 @@
+import { ExtractPropTypes } from 'vue-demi';
 import { CardProps } from 'element-plus';
-
+import { cardProps, cardEmits } from './index';
 
 // 自有 Props
-export interface Props {
-}
+export interface Props extends ExtractPropTypes<typeof cardProps> {}
 
 // 合并 Props（保留原有逻辑）
 export type SelfProps = Props & Partial<CardProps>;
 
 // 组件 Props 类型导出
 export type XCardProps = SelfProps;
+export type XCardEmits = (typeof cardEmits)[number];

package/types/components/XCarousel/XCarouselItem.d.ts

@@ -0,0 +1,4 @@
+export declare const carouselItemProps: {};
+export declare const carouselItemEmits: readonly [];
+declare const _default: import('vue').DefineComponent<{}, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, never[], never, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/components/XCarousel/index.d.ts

@@ -0,0 +1,4 @@
+export declare const carouselProps: {};
+export declare const carouselEmits: readonly [];
+declare const _default: import('vue').DefineComponent<{}, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, never[], never, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/components/XCarousel/types.d.ts

@@ -1,13 +1,15 @@
+import { ExtractPropTypes } from 'vue-demi';
 import { CarouselItemProps, CarouselProps } from 'element-plus';
-
+import { carouselProps, carouselEmits } from './index';
+import { carouselItemProps, carouselItemEmits } from './XCarouselItem';
 
 // 自有 Props
-export interface Props {
-}
+export interface Props extends ExtractPropTypes<typeof carouselProps> {}
 // 合并 Props（保留原有逻辑）
 export type SelfProps = Props & Partial<CarouselProps>;
 
-export interface Props_1 {
-}
+export interface Props_1 extends ExtractPropTypes<typeof carouselItemProps> {}
 // 合并 Props（保留原有逻辑）
 export type SelfProps_1 = Props_1 & Partial<CarouselItemProps>;
+export type XCarouselEmits = (typeof carouselEmits)[number];
+export type XCarouselItemEmits = (typeof carouselItemEmits)[number];

package/types/components/XCascader/XCascaderPanel.d.ts

@@ -0,0 +1,4 @@
+export declare const cascaderPanelProps: {};
+export declare const cascaderPanelEmits: readonly [];
+declare const _default: import('vue').DefineComponent<{}, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, never[], never, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/components/XCascader/index.d.ts

@@ -0,0 +1,79 @@
+import { PropType } from 'vue-demi';
+import { AuditFieldConfig, AuditState, TrackFieldConfig, TrackState, PermissionFieldConfig } from '../../hooks/capability/types';
+export declare const cascaderProps: {
+    readonly audit: {
+        readonly type: PropType<boolean | AuditFieldConfig | undefined>;
+        readonly default: undefined;
+    };
+    readonly auditState: {
+        readonly type: PropType<AuditState | undefined>;
+        readonly default: undefined;
+    };
+    readonly track: {
+        readonly type: PropType<boolean | TrackFieldConfig | undefined>;
+        readonly default: undefined;
+    };
+    readonly trackState: {
+        readonly type: PropType<TrackState | undefined>;
+        readonly default: undefined;
+    };
+    readonly permission: {
+        readonly type: PropType<boolean | PermissionFieldConfig | undefined>;
+        readonly default: undefined;
+    };
+};
+export declare const cascaderEmits: readonly ["audit-trigger", "track-event", "permission-check"];
+declare const _default: import('vue').DefineComponent<globalThis.ExtractPropTypes<{
+    readonly audit: {
+        readonly type: PropType<boolean | AuditFieldConfig | undefined>;
+        readonly default: undefined;
+    };
+    readonly auditState: {
+        readonly type: PropType<AuditState | undefined>;
+        readonly default: undefined;
+    };
+    readonly track: {
+        readonly type: PropType<boolean | TrackFieldConfig | undefined>;
+        readonly default: undefined;
+    };
+    readonly trackState: {
+        readonly type: PropType<TrackState | undefined>;
+        readonly default: undefined;
+    };
+    readonly permission: {
+        readonly type: PropType<boolean | PermissionFieldConfig | undefined>;
+        readonly default: undefined;
+    };
+}>, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("audit-trigger" | "track-event" | "permission-check")[], "audit-trigger" | "track-event" | "permission-check", import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    readonly audit: {
+        readonly type: PropType<boolean | AuditFieldConfig | undefined>;
+        readonly default: undefined;
+    };
+    readonly auditState: {
+        readonly type: PropType<AuditState | undefined>;
+        readonly default: undefined;
+    };
+    readonly track: {
+        readonly type: PropType<boolean | TrackFieldConfig | undefined>;
+        readonly default: undefined;
+    };
+    readonly trackState: {
+        readonly type: PropType<TrackState | undefined>;
+        readonly default: undefined;
+    };
+    readonly permission: {
+        readonly type: PropType<boolean | PermissionFieldConfig | undefined>;
+        readonly default: undefined;
+    };
+}>> & Readonly<{
+    "onAudit-trigger"?: ((...args: any[]) => any) | undefined;
+    "onTrack-event"?: ((...args: any[]) => any) | undefined;
+    "onPermission-check"?: ((...args: any[]) => any) | undefined;
+}>, {
+    readonly track: boolean | TrackFieldConfig | undefined;
+    readonly audit: boolean | AuditFieldConfig | undefined;
+    readonly permission: boolean | PermissionFieldConfig | undefined;
+    readonly auditState: AuditState | undefined;
+    readonly trackState: TrackState | undefined;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/components/XCascader/types.d.ts

@@ -1,14 +1,18 @@
+import { ExtractPropTypes } from 'vue-demi';
 import { GlobalComponents } from 'vue';
-
+import { cascaderProps, cascaderEmits } from './index';
+import { cascaderPanelProps, cascaderPanelEmits } from './XCascaderPanel';
 
 // Cascader 组件类型
 type elCascaderProps = GlobalComponents['ElCascader']['$props'];
 type elCascaderPanelProps = GlobalComponents['ElCascaderPanel']['$props'];
 
 // 自定义属性接口（可根据需要扩展）
-export interface CascaderProps {}
-export interface CascaderPanelProps {}
+export interface CascaderProps extends ExtractPropTypes<typeof cascaderProps> {}
+export interface CascaderPanelProps extends ExtractPropTypes<typeof cascaderPanelProps> {}
 
 // 合并类型（仅单层交叉，无复杂逻辑）
 export type SelfCascaderProps = CascaderProps & Partial<elCascaderProps>;
 export type SelfCascaderPanelProps = CascaderPanelProps & Partial<elCascaderPanelProps>;
+export type XCascaderEmits = (typeof cascaderEmits)[number];
+export type XCascaderPanelEmits = (typeof cascaderPanelEmits)[number];

package/types/components/XCheckbox/XCheckboxButton.d.ts

@@ -0,0 +1,4 @@
+export declare const checkboxButtonProps: {};
+export declare const checkboxButtonEmits: readonly [];
+declare const _default: import('vue').DefineComponent<{}, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, never[], never, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/components/XCheckbox/XCheckboxGroup.d.ts

@@ -0,0 +1,134 @@
+import { PropType } from 'vue-demi';
+import { AuditFieldConfig, AuditState, TrackFieldConfig, TrackState, PermissionFieldConfig } from '../../hooks/capability/types';
+export declare const checkboxGroupProps: {
+    readonly textMode: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly textOptions: {
+        readonly type: PropType<Array<Record<string, any>>>;
+        readonly default: undefined;
+    };
+    readonly textOptionValueKey: {
+        readonly type: StringConstructor;
+        readonly default: "value";
+    };
+    readonly textOptionLabelKey: {
+        readonly type: StringConstructor;
+        readonly default: "label";
+    };
+    readonly audit: {
+        readonly type: PropType<boolean | AuditFieldConfig | undefined>;
+        readonly default: undefined;
+    };
+    readonly auditState: {
+        readonly type: PropType<AuditState | undefined>;
+        readonly default: undefined;
+    };
+    readonly track: {
+        readonly type: PropType<boolean | TrackFieldConfig | undefined>;
+        readonly default: undefined;
+    };
+    readonly trackState: {
+        readonly type: PropType<TrackState | undefined>;
+        readonly default: undefined;
+    };
+    /** 权限配置：控制 disabled/hidden/readonly 效果 */
+    readonly permission: {
+        readonly type: PropType<boolean | PermissionFieldConfig | undefined>;
+        readonly default: undefined;
+    };
+};
+export declare const checkboxGroupEmits: readonly ["audit-trigger", "track-event", "permission-check"];
+declare const _default: import('vue').DefineComponent<globalThis.ExtractPropTypes<{
+    readonly textMode: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly textOptions: {
+        readonly type: PropType<Array<Record<string, any>>>;
+        readonly default: undefined;
+    };
+    readonly textOptionValueKey: {
+        readonly type: StringConstructor;
+        readonly default: "value";
+    };
+    readonly textOptionLabelKey: {
+        readonly type: StringConstructor;
+        readonly default: "label";
+    };
+    readonly audit: {
+        readonly type: PropType<boolean | AuditFieldConfig | undefined>;
+        readonly default: undefined;
+    };
+    readonly auditState: {
+        readonly type: PropType<AuditState | undefined>;
+        readonly default: undefined;
+    };
+    readonly track: {
+        readonly type: PropType<boolean | TrackFieldConfig | undefined>;
+        readonly default: undefined;
+    };
+    readonly trackState: {
+        readonly type: PropType<TrackState | undefined>;
+        readonly default: undefined;
+    };
+    /** 权限配置：控制 disabled/hidden/readonly 效果 */
+    readonly permission: {
+        readonly type: PropType<boolean | PermissionFieldConfig | undefined>;
+        readonly default: undefined;
+    };
+}>, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("audit-trigger" | "track-event" | "permission-check")[], "audit-trigger" | "track-event" | "permission-check", import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    readonly textMode: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly textOptions: {
+        readonly type: PropType<Array<Record<string, any>>>;
+        readonly default: undefined;
+    };
+    readonly textOptionValueKey: {
+        readonly type: StringConstructor;
+        readonly default: "value";
+    };
+    readonly textOptionLabelKey: {
+        readonly type: StringConstructor;
+        readonly default: "label";
+    };
+    readonly audit: {
+        readonly type: PropType<boolean | AuditFieldConfig | undefined>;
+        readonly default: undefined;
+    };
+    readonly auditState: {
+        readonly type: PropType<AuditState | undefined>;
+        readonly default: undefined;
+    };
+    readonly track: {
+        readonly type: PropType<boolean | TrackFieldConfig | undefined>;
+        readonly default: undefined;
+    };
+    readonly trackState: {
+        readonly type: PropType<TrackState | undefined>;
+        readonly default: undefined;
+    };
+    /** 权限配置：控制 disabled/hidden/readonly 效果 */
+    readonly permission: {
+        readonly type: PropType<boolean | PermissionFieldConfig | undefined>;
+        readonly default: undefined;
+    };
+}>> & Readonly<{
+    "onAudit-trigger"?: ((...args: any[]) => any) | undefined;
+    "onTrack-event"?: ((...args: any[]) => any) | undefined;
+    "onPermission-check"?: ((...args: any[]) => any) | undefined;
+}>, {
+    readonly track: boolean | TrackFieldConfig | undefined;
+    readonly audit: boolean | AuditFieldConfig | undefined;
+    readonly permission: boolean | PermissionFieldConfig | undefined;
+    readonly auditState: AuditState | undefined;
+    readonly trackState: TrackState | undefined;
+    readonly textMode: boolean;
+    readonly textOptions: Record<string, any>[];
+    readonly textOptionValueKey: string;
+    readonly textOptionLabelKey: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/components/XCheckbox/index.d.ts

@@ -0,0 +1,4 @@
+export declare const checkboxProps: {};
+export declare const checkboxEmits: readonly [];
+declare const _default: import('vue').DefineComponent<{}, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, never[], never, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/components/XCheckbox/types.d.ts

@@ -1,3 +1,7 @@
+import { ExtractPropTypes } from 'vue-demi';
+import { checkboxProps, checkboxEmits } from './index';
+import { checkboxGroupProps, checkboxGroupEmits } from './XCheckboxGroup';
+import { checkboxButtonProps, checkboxButtonEmits } from './XCheckboxButton';
 import { GlobalComponents } from 'vue';
 
 
@@ -6,17 +10,17 @@ type elProps1 = GlobalComponents['ElCheckboxGroup']['$props'];
 type elProps2 = GlobalComponents['ElCheckboxButton']['$props'];
 
 // 自有 Props
-export interface Props {
-}
+export interface Props extends ExtractPropTypes<typeof checkboxProps> {}
 // 合并 Props（保留原有逻辑）
 export type SelfProps = Props & Partial<elProps>;
 
-export interface Props_1 {
-}
+export interface Props_1 extends ExtractPropTypes<typeof checkboxGroupProps> {}
 // 合并 Props（保留原有逻辑）
 export type SelfProps_1 = Props_1 & Partial<elProps1>;
 
-export interface Props_2 {
-}
+export interface Props_2 extends ExtractPropTypes<typeof checkboxButtonProps> {}
 // 合并 Props（保留原有逻辑）
 export type SelfProps_2 = Props_1 & Partial<elProps2>;
+export type XCheckboxEmits = (typeof checkboxEmits)[number];
+export type XCheckboxGroupEmits = (typeof checkboxGroupEmits)[number];
+export type XCheckboxButtonEmits = (typeof checkboxButtonEmits)[number];