@pungfe/element 0.5.2 → 0.5.5

package/dist/components/advance/XRequest.vue.d.ts

@@ -1,6 +1,20 @@
 import { Ref, VNodeChild } from 'vue';
 import { Paging } from '../../types';
+export interface XRequestEvents<PT, QR> {
+    prepare: [parameters: {
+        path: PT;
+        query: QR;
+    }];
+}
 export interface XRequestProps<U, PT, QR, D> {
+    content?: (scope: {
+        data: D;
+        isFetching: boolean;
+        paging: Paging;
+        path: PT;
+        query: QR;
+        search: () => PromiseLike<unknown>;
+    }) => VNodeChild;
     request: () => {
         data: Ref<D>;
         execute: () => PromiseLike<unknown>;
@@ -10,20 +24,6 @@ export interface XRequestProps<U, PT, QR, D> {
         query: Ref<QR>;
         url: U;
     };
-    content?: (scope: {
-        data: D;
-        query: QR;
-        path: PT;
-        isFetching: boolean;
-        paging: Paging;
-        search: () => PromiseLike<unknown>;
-    }) => VNodeChild;
-}
-export interface XRequestEvents<PT, QR> {
-    prepare: [parameters: {
-        path: PT;
-        query: QR;
-    }];
 }
 declare const __VLS_export: <U, PT, QR, D>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import('vue').PublicProps & __VLS_PrettifyLocal<XRequestProps<U, PT, QR, D> & {
@@ -48,11 +48,11 @@ declare const __VLS_export: <U, PT, QR, D>(__VLS_props: NonNullable<Awaited<type
     slots: {
         default: (scope: {
             data: D;
-            search: () => PromiseLike<unknown>;
             isFetching: boolean;
             paging: Paging;
             path: PT;
             query: QR;
+            search: () => PromiseLike<unknown>;
         }) => VNodeChild;
     };
     emit: (evt: "prepare", parameters: {

package/dist/components/advance/XSelectRequest.vue.d.ts

@@ -1,5 +1,11 @@
 import { Ref } from 'vue';
 import { XSelectEvents, XSelectProps } from '../../basic';
+export interface XSelectRequestEvents<PT, QR, V> extends XSelectEvents<V> {
+    prepare: [parameters: {
+        path: PT;
+        query: QR;
+    }, input?: string];
+}
 export interface XSelectRequestProps<U, PT, QR, D, V> extends Omit<XSelectProps<D, V>, 'supplement'> {
     request: () => {
         data: Ref<D[]>;
@@ -11,12 +17,6 @@ export interface XSelectRequestProps<U, PT, QR, D, V> extends Omit<XSelectProps<
     };
     supplement?: (lacks: V[], url: U) => D[] | PromiseLike<D[]>;
 }
-export interface XSelectRequestEvents<PT, QR, V> extends XSelectEvents<V> {
-    prepare: [parameters: {
-        path: PT;
-        query: QR;
-    }, input?: string];
-}
 declare const __VLS_export: <U, PT, QR, D, V, MV extends V | V[]>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import('vue').PublicProps & __VLS_PrettifyLocal<(XSelectRequestProps<U, PT, QR, D, V> & {
         modelValue?: MV;

package/dist/components/advance/XTableConfig.vue.d.ts

@@ -4,21 +4,21 @@ import { XTableFlexEvents, XTableFlexProps } from '../../advance';
 import { XTableColumnProps } from '../../basic';
 export interface XTableConfigColumnsProps<D> extends Omit<XTableColumnProps<D>, 'content'> {
     content?: (scope: {
-        row: D;
         index: number;
+        row: D;
     }) => VNodeChild;
 }
-export interface XTableConfigProps<D> extends Omit<XTableFlexProps<D>, 'columns' | 'showOverflowTooltip' | 'data'> {
+export interface XTableConfigEvents<D> extends XTableFlexEvents<D> {
+    rowClick: [row: D];
+}
+export interface XTableConfigProps<D> extends Omit<XTableFlexProps<D>, 'columns' | 'data' | 'showOverflowTooltip'> {
+    config: Record<string, XTableConfigColumnsProps<D>>;
     data?: D[];
     fields: () => {
         data: Ref<TableColumnField[]>;
-        update: (fields: TableColumnField[]) => PromiseLike<unknown>;
         loading: Ref<boolean>;
+        update: (fields: TableColumnField[]) => PromiseLike<unknown>;
     };
-    config: Record<string, XTableConfigColumnsProps<D>>;
-}
-export interface XTableConfigEvents<D> extends XTableFlexEvents<D> {
-    rowClick: [row: D];
 }
 declare const __VLS_export: <D>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import('vue').PublicProps & __VLS_PrettifyLocal<XTableConfigProps<D> & {

package/dist/components/advance/XTableFlex.vue.d.ts

@@ -1,6 +1,7 @@
 import { TableColumnCtx } from 'element-plus';
 import { CSSProperties } from 'vue';
 import { XTableEvents, XTableProps } from '../../basic';
+export type XTableFlexEvents<D> = XTableEvents<D>;
 export interface XTableFlexProps<D> extends XTableProps<D> {
     cellClassName?: ((scope: {
         column: TableColumnCtx;
@@ -23,8 +24,6 @@ export interface XTableFlexProps<D> extends XTableProps<D> {
         rowIndex: number;
     }) => CSSProperties) | CSSProperties;
 }
-export interface XTableFlexEvents<D> extends XTableEvents<D> {
-}
 declare const __VLS_export: <D>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import('vue').PublicProps & __VLS_PrettifyLocal<XTableFlexProps<D> & {
         onHeaderDragend?: ((newWidth: number, oldWidth: number, column: TableColumnCtx) => any) | undefined;
@@ -36,7 +35,7 @@ declare const __VLS_export: <D>(__VLS_props: NonNullable<Awaited<typeof __VLS_se
     } ? P : {});
     expose: (exposed: import('vue').ShallowUnwrapRef<{
         clearSelection: () => void | undefined;
-        getSelectionRows: () => D[] | undefined;
+        getSelectionRows: () => import('../../basic').DefaultRow[] | undefined;
         scrollTo: (options: number | ScrollToOptions, yCoord?: number) => void | undefined;
         setCurrentRow: (row: D) => void | undefined;
         setScrollLeft: (left: number) => void | undefined;

package/dist/components/advance/XTableRequestConfigNext.vue.d.ts

@@ -3,44 +3,44 @@ import { Paging, TableColumnField } from '../../types';
 import { XTableFlexEvents, XTableFlexProps, XTableRequestColumnsProps } from '../../advance';
 export interface XTableRequestConfigColumnsProps<QR, D> extends Omit<XTableRequestColumnsProps<D>, 'content'> {
     content?: (scope: {
-        row: D;
         index: number;
+        row: D;
     }) => VNodeChild;
     search?: (scope: {
         query: QR;
     }) => VNodeChild;
 }
+export interface XTableRequestConfigEvents<PT, QR, D> extends XTableFlexEvents<D> {
+    prepare: [parameters: {
+        path: PT;
+        query: QR;
+    }];
+}
 export interface XTableRequestConfigProps<U, PT, QR, D> extends Omit<XTableFlexProps<D>, 'columns' | 'showOverflowTooltip'> {
-    request: () => {
-        data: Ref<D[]>;
-        execute: () => PromiseLike<unknown>;
-        isFetching: Ref<boolean>;
-        paging: Ref<Paging>;
-        path: Ref<PT>;
-        query: Ref<QR>;
-        url: U;
-    };
+    config: Record<string, XTableRequestConfigColumnsProps<QR, D>>;
     fields: () => {
         data: Ref<TableColumnField[]>;
-        update: (fields: TableColumnField[]) => PromiseLike<unknown>;
         loading: Ref<boolean>;
+        update: (fields: TableColumnField[]) => PromiseLike<unknown>;
     };
     header?: (scope: {
         data: D[];
-        query: QR;
-        path: PT;
         isFetching: boolean;
         paging: Paging;
+        path: PT;
+        query: QR;
     }) => VNodeChild;
-    config: Record<string, XTableRequestConfigColumnsProps<QR, D>>;
     pagination?: boolean;
     paginationLayout?: string;
-}
-export interface XTableRequestConfigEvents<PT, QR, D> extends XTableFlexEvents<D> {
-    prepare: [parameters: {
-        path: PT;
-        query: QR;
-    }];
+    request: () => {
+        data: Ref<D[]>;
+        execute: () => PromiseLike<unknown>;
+        isFetching: Ref<boolean>;
+        paging: Ref<Paging>;
+        path: Ref<PT>;
+        query: Ref<QR>;
+        url: U;
+    };
 }
 declare const __VLS_export: <U, PT, QR, D>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import('vue').PublicProps & __VLS_PrettifyLocal<XTableRequestConfigProps<U, PT, QR, D> & {

package/dist/components/advance/XTableRequestNext.vue.d.ts

@@ -9,24 +9,13 @@ export interface XTableRequestColumnsProps<D> extends XTableColumnProps<D> {
         row: D;
     }) => VNodeChild;
 }
-export interface XTableRequestProps<U, PT, QR, D> extends Omit<XTableFlexProps<D>, 'data' | 'columns'> {
-    request: () => {
-        data: Ref<D[]>;
-        execute: () => PromiseLike<unknown>;
-        isFetching: Ref<boolean>;
-        paging: Ref<Paging>;
-        path: Ref<PT>;
-        query: Ref<QR>;
-        url: U;
-    };
-    pagination?: boolean;
-    columns: XTableRequestColumnsProps<D>[];
-    header?: (scope: {
-        query: QR;
-    }) => VNodeChild;
-    footer?: (scope: {
+export interface XTableRequestEvents<PT, QR, D> extends XTableFlexEvents<D> {
+    prepare: [parameters: {
+        path: PT;
         query: QR;
-    }) => VNodeChild;
+    }];
+}
+export interface XTableRequestProps<U, PT, QR, D> extends Omit<XTableFlexProps<D>, 'columns' | 'data'> {
     cellClassName?: ((scope: {
         column: TableColumnCtx;
         columnIndex: number;
@@ -39,6 +28,24 @@ export interface XTableRequestProps<U, PT, QR, D> extends Omit<XTableFlexProps<D
         row: D;
         rowIndex: number;
     }) => CSSProperties) | CSSProperties;
+    columns: XTableRequestColumnsProps<D>[];
+    footer?: (scope: {
+        query: QR;
+    }) => VNodeChild;
+    header?: (scope: {
+        query: QR;
+    }) => VNodeChild;
+    pagination?: boolean;
+    paginationLayout?: string;
+    request: () => {
+        data: Ref<D[]>;
+        execute: () => PromiseLike<unknown>;
+        isFetching: Ref<boolean>;
+        paging: Ref<Paging>;
+        path: Ref<PT>;
+        query: Ref<QR>;
+        url: U;
+    };
     rowClassName?: ((scope: {
         row: D;
         rowIndex: number;
@@ -47,13 +54,6 @@ export interface XTableRequestProps<U, PT, QR, D> extends Omit<XTableFlexProps<D
         row: D;
         rowIndex: number;
     }) => CSSProperties) | CSSProperties;
-    paginationLayout?: string;
-}
-export interface XTableRequestEvents<PT, QR, D> extends XTableFlexEvents<D> {
-    prepare: [parameters: {
-        path: PT;
-        query: QR;
-    }];
 }
 declare const __VLS_export: <U, PT, QR, D>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import('vue').PublicProps & __VLS_PrettifyLocal<XTableRequestProps<U, PT, QR, D> & {

package/dist/components/advance/XUploadOssNext.vue.d.ts

@@ -1,6 +1,6 @@
 import { VNodeChild } from 'vue';
 import { XUploadProps } from '../../basic';
-export interface XUploadOssProps extends Omit<XUploadProps, 'action' | 'data' | 'fileList' | 'beforeUpload'> {
+export interface XUploadOssProps extends Omit<XUploadProps, 'action' | 'beforeUpload' | 'data' | 'fileList'> {
     /** oss 接收文件最大 大约为50兆, 超过50兆应采取oss ststoken 分片上传 */
     maxSize?: number;
 }

package/dist/components/basic/Button.vue.d.ts

@@ -8,11 +8,11 @@ export interface XButtonConfig {
 }
 export interface XButtonProps {
     disabled?: ButtonProps['disabled'];
+    icon?: ButtonProps['icon'];
     link?: ButtonProps['link'];
     size?: ButtonProps['size'];
     text?: ButtonProps['text'];
     type?: ButtonProps['type'];
-    icon?: ButtonProps['icon'];
 }
 declare var __VLS_10: {};
 type __VLS_Slots = {} & {

package/dist/components/basic/Cascader.vue.d.ts

@@ -3,18 +3,18 @@ export interface XCascaderOptionProps<D, V> {
     children?: D[];
     disabled?: boolean;
     label?: number | string;
-    value: V;
     leaf?: boolean;
+    value: V;
 }
 export interface XCascaderProps<D, V> {
-    data?: D[];
-    factory?: (option: D, level: number) => XCascaderOptionProps<D, V>;
     clearable?: CascaderComponentProps['clearable'];
+    data?: D[];
     disabled?: CascaderComponentProps['disabled'];
+    factory?: (option: D, level: number) => XCascaderOptionProps<D, V>;
     filterable?: CascaderComponentProps['filterable'];
-    size?: CascaderComponentProps['size'];
     placeholder?: CascaderComponentProps['placeholder'];
     props?: CascaderComponentProps['props'];
+    size?: CascaderComponentProps['size'];
 }
 declare const __VLS_export: <D, V, MV extends V | V[]>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import('vue').PublicProps & __VLS_PrettifyLocal<(XCascaderProps<D, V> & {

package/dist/components/basic/Checkbox.vue.d.ts

@@ -1,10 +1,10 @@
 import { CheckboxProps, CheckboxValueType } from 'element-plus';
 export interface XCheckboxProps {
     disabled?: boolean;
-    size?: CheckboxProps['size'];
+    falseValue?: CheckboxProps['falseValue'];
     label?: CheckboxProps['label'];
+    size?: CheckboxProps['size'];
     trueValue?: CheckboxProps['trueValue'];
-    falseValue?: CheckboxProps['falseValue'];
 }
 type __VLS_Props = XCheckboxProps;
 type __VLS_ModelProps = {

package/dist/components/basic/DatePicker.vue.d.ts

@@ -1,7 +1,7 @@
 import { DatePickerProps } from 'element-plus';
 export interface XDateConfig {
-    valueFormat?: DatePickerProps['valueFormat'];
     teleported?: boolean;
+    valueFormat?: DatePickerProps['valueFormat'];
 }
 export interface XDatePickerProps extends XDateConfig {
     disabled?: boolean;
@@ -9,9 +9,9 @@ export interface XDatePickerProps extends XDateConfig {
     endPlaceholder?: DatePickerProps['endPlaceholder'];
     placeholder?: DatePickerProps['placeholder'];
     shortcuts?: DatePickerProps['shortcuts'];
+    size?: DatePickerProps['size'];
     startPlaceholder?: DatePickerProps['startPlaceholder'];
     type?: DatePickerProps['type'];
-    size?: DatePickerProps['size'];
 }
 declare const __VLS_export: <V extends string>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import('vue').PublicProps & __VLS_PrettifyLocal<(XDatePickerProps & {

package/dist/components/basic/Dialog.vue.d.ts

@@ -1,21 +1,21 @@
 import { DialogProps } from 'element-plus';
 import { VNodeChild } from 'vue';
 export interface XDialogProps {
+    alignCenter?: DialogProps['alignCenter'];
     bodyClass?: DialogProps['bodyClass'];
-    width?: DialogProps['width'];
-    showClose?: DialogProps['showClose'];
-    title?: DialogProps['title'];
     center?: DialogProps['center'];
-    alignCenter?: DialogProps['alignCenter'];
-    draggable?: DialogProps['draggable'];
     closeOnClickModal?: DialogProps['closeOnClickModal'];
     closeOnPressEscape?: DialogProps['closeOnPressEscape'];
+    draggable?: DialogProps['draggable'];
+    showClose?: DialogProps['showClose'];
+    title?: DialogProps['title'];
+    width?: DialogProps['width'];
 }
 type __VLS_Props = XDialogProps;
 type __VLS_Slots = {
     default?: () => VNodeChild;
-    header?: () => VNodeChild;
     footer?: () => VNodeChild;
+    header?: () => VNodeChild;
 };
 type __VLS_ModelProps = {
     modelValue?: boolean;

package/dist/components/basic/FormItem.vue.d.ts

@@ -6,8 +6,8 @@ export interface XFormItemProps {
     validator?: () => string | void;
 }
 export interface XFormItemValidation {
-    id?: string;
     clearValidate: () => void;
+    id?: string;
     label?: string;
     required?: boolean;
     validate: () => boolean;

package/dist/components/basic/Input.vue.d.ts

@@ -1,16 +1,16 @@
 import { InputProps } from 'element-plus';
 import { VNode } from 'vue';
 export interface XInputProps {
-    clearable?: InputProps['clearable'];
-    disabled?: InputProps['disabled'];
-    size?: InputProps['size'];
-    type?: InputProps['type'];
-    showPassword?: InputProps['showPassword'];
     autocomplete?: InputProps['autocomplete'];
     autosize?: InputProps['autosize'];
+    clearable?: InputProps['clearable'];
+    disabled?: InputProps['disabled'];
     placeholder?: InputProps['placeholder'];
     prefixIcon?: InputProps['prefixIcon'];
+    showPassword?: InputProps['showPassword'];
+    size?: InputProps['size'];
     suffixIcon?: InputProps['suffixIcon'];
+    type?: InputProps['type'];
 }
 declare const __VLS_export: <MV extends string | number>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import('vue').PublicProps & __VLS_PrettifyLocal<(XInputProps & {

package/dist/components/basic/Pagination.vue.d.ts

@@ -3,12 +3,12 @@ export interface XPaginationConfig {
     layout?: XPaginationProps['layout'];
 }
 export interface XPaginationProps {
-    pageSizes?: PaginationProps['pageSizes'];
     background?: PaginationProps['background'];
-    size?: PaginationProps['size'];
+    defaultPageSize?: PaginationProps['defaultPageSize'];
     layout?: PaginationProps['layout'];
+    pageSizes?: PaginationProps['pageSizes'];
+    size?: PaginationProps['size'];
     total?: PaginationProps['total'];
-    defaultPageSize?: PaginationProps['defaultPageSize'];
 }
 type __VLS_Props = XPaginationProps;
 type __VLS_ModelProps = {
@@ -21,13 +21,13 @@ type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_11) => any;
 };
 declare const __VLS_base: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    sizeChange: (size: number) => any;
     currentChange: (current: number) => any;
+    sizeChange: (size: number) => any;
     "update:currentPage": (value: number | undefined) => any;
     "update:pageSize": (value: number | undefined) => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
-    onSizeChange?: ((size: number) => any) | undefined;
     onCurrentChange?: ((current: number) => any) | undefined;
+    onSizeChange?: ((size: number) => any) | undefined;
     "onUpdate:currentPage"?: ((value: number | undefined) => any) | undefined;
     "onUpdate:pageSize"?: ((value: number | undefined) => any) | undefined;
 }>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;

package/dist/components/basic/Select.vue.d.ts

@@ -1,34 +1,34 @@
-import { VNodeChild } from 'vue';
 import { SelectProps } from 'element-plus';
+import { VNode } from 'vue';
+export interface XSelectEvents<V> {
+    blur: [e: FocusEvent];
+    change: [value: V];
+    focus: [e: FocusEvent];
+}
 export interface XSelectOptionProps<V> {
     disabled?: boolean;
     label?: number | string;
+    render?: () => VNode;
     value: V;
-    render?: VNodeChild;
 }
 export interface XSelectProps<D, V> {
-    collapseTagsTooltip?: SelectProps['collapseTagsTooltip'];
-    defaultFirstOption?: SelectProps['defaultFirstOption'];
-    clearable?: SelectProps['clearable'];
     allowCreate?: SelectProps['allowCreate'];
+    clearable?: SelectProps['clearable'];
     collapseTags?: SelectProps['collapseTags'];
+    collapseTagsTooltip?: SelectProps['collapseTagsTooltip'];
     data?: D[];
+    defaultFirstOption?: SelectProps['defaultFirstOption'];
     disabled?: SelectProps['disabled'];
     factory: (option: D) => XSelectOptionProps<V>;
     filterable?: SelectProps['filterable'];
     identify?: (value: V) => number | string;
     loading?: SelectProps['loading'];
     multiple?: SelectProps['multiple'];
+    placeholder?: SelectProps['placeholder'];
     remote?: SelectProps['remote'];
     remoteMethod?: (query: string) => void;
     size?: SelectProps['size'];
     supplement?: (lacks: V[]) => D[] | PromiseLike<D[]>;
-    placeholder?: SelectProps['placeholder'];
-}
-export interface XSelectEvents<V> {
-    blur: [e: FocusEvent];
-    change: [value: V];
-    focus: [e: FocusEvent];
 }
 declare const __VLS_export: <D, V, MV extends V | V[]>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import('vue').PublicProps & __VLS_PrettifyLocal<(XSelectProps<D, V> & {

package/dist/components/basic/Table.vue.d.ts

@@ -1,18 +1,9 @@
 import { TableColumnCtx, TableProps } from 'element-plus';
 import { CSSProperties, VNode, VNodeChild } from 'vue';
-export interface XTableConfig {
-    /**
-     * 是否隐藏额外内容并在单元格悬停时使用 Tooltip 显示它们。这将影响全部列的展示
-     * @default false
-     */
-    showOverflowTooltip?: TableProps<any>['showOverflowTooltip'];
-    border?: TableProps<any>['border'];
-    fit?: TableProps<any>['fit'];
-    emptyText?: TableProps<any>['emptyText'];
-    headerAlign?: string;
-    align?: string;
-}
+export type DefaultRow = Record<PropertyKey, unknown>;
 export interface XTableColumnProps<D> {
+    align?: string;
+    columnKey?: string;
     content?: (scope: {
         index: number;
         row: D;
@@ -21,17 +12,33 @@ export interface XTableColumnProps<D> {
     header?: (scope: {
         column: XTableColumnProps<D>;
     }) => VNodeChild;
+    headerAlign?: string;
     label?: string;
+    minWidth?: number;
     prop?: string;
     selectable?: (row: D, index: number) => boolean;
     type?: 'index' | 'selection';
     width?: number;
-    minWidth?: number;
-    columnKey?: string;
-    headerAlign?: string;
+}
+export interface XTableConfig {
     align?: string;
+    border?: TableProps<DefaultRow>['border'];
+    emptyText?: TableProps<DefaultRow>['emptyText'];
+    fit?: TableProps<DefaultRow>['fit'];
+    headerAlign?: string;
+    /**
+     * 是否隐藏额外内容并在单元格悬停时使用 Tooltip 显示它们。这将影响全部列的展示
+     * @default false
+     */
+    showOverflowTooltip?: TableProps<DefaultRow>['showOverflowTooltip'];
 }
-export interface XTableProps<D> extends XTableConfig {
+export interface XTableEvents<D> {
+    headerDragend: [newWidth: number, oldWidth: number, column: TableColumnCtx];
+    rowClick: [row: D];
+    rowDblclick: [row: D];
+    selectionChange: [rows: D[]];
+}
+export interface XTableProps<D extends DefaultRow> extends XTableConfig {
     cellClassName?: ((scope: {
         column: TableColumnCtx;
         columnIndex: number;
@@ -46,41 +53,33 @@ export interface XTableProps<D> extends XTableConfig {
     }) => CSSProperties) | CSSProperties;
     columns?: XTableColumnProps<D>[];
     data?: D[];
-    height?: TableProps<any>['height'];
+    height?: TableProps<D>['height'];
     rowClassName?: ((scope: {
         row: D;
         rowIndex: number;
     }) => string) | string;
+    rowKey?: ((row: D) => string) | string;
     rowStyle?: ((scope: {
         row: D;
         rowIndex: number;
     }) => CSSProperties) | CSSProperties;
-    rowKey?: (scope: {
-        row: D;
-    }) => string;
-    showSummary?: TableProps<any>['showSummary'];
-    size?: TableProps<any>['size'];
+    showSummary?: TableProps<D>['showSummary'];
+    size?: TableProps<D>['size'];
     spanMethod?: (scope: {
         column: TableColumnCtx;
         columnIndex: number;
         row: D;
         rowIndex: number;
-    }) => number[] | undefined | {
+    }) => {
         colspan: number;
         rowspan: number;
-    };
+    } | number[] | undefined;
     summaryMethod?: (scope: {
         columns: TableColumnCtx[];
         data: D[];
     }) => (string | VNode)[];
 }
-export interface XTableEvents<D> {
-    headerDragend: [newWidth: number, oldWidth: number, column: TableColumnCtx];
-    rowClick: [row: D];
-    rowDblclick: [row: D];
-    selectionChange: [rows: D[]];
-}
-declare const __VLS_export: <D>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+declare const __VLS_export: <D extends DefaultRow>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import('vue').PublicProps & __VLS_PrettifyLocal<XTableProps<D> & {
         onHeaderDragend?: ((newWidth: number, oldWidth: number, column: TableColumnCtx) => any) | undefined;
         onRowClick?: ((row: D) => any) | undefined;

package/dist/components/basic/Tabs.vue.d.ts

@@ -1,16 +1,16 @@
 import { TabsProps } from 'element-plus';
 import { VNodeChild } from 'vue';
+export interface XTabsEvents<V> {
+    change: [name: V];
+    edit: [name: V, action: 'add' | 'remove'];
+    remove: [name: V];
+}
 export interface XTabsProps {
     addable?: TabsProps['addable'];
     editable?: TabsProps['editable'];
     tabPosition?: TabsProps['tabPosition'];
     type?: TabsProps['type'];
 }
-export interface XTabsEvents<V> {
-    change: [name: V];
-    remove: [name: V];
-    edit: [name: V, action: 'remove' | 'add'];
-}
 declare const __VLS_export: <V extends string | number>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import('vue').PublicProps & __VLS_PrettifyLocal<(XTabsProps & {
         modelValue?: V;
@@ -25,8 +25,8 @@ declare const __VLS_export: <V extends string | number>(__VLS_props: NonNullable
     expose: (exposed: {}) => void;
     attrs: any;
     slots: {
-        default: () => VNodeChild;
         addIcon: () => VNodeChild;
+        default: () => VNodeChild;
     };
     emit: (((evt: "change", name: V) => void) & ((evt: "remove", name: V) => void) & ((evt: "edit", name: V, action: "add" | "remove") => void)) & ((event: "update:modelValue", value: V | undefined) => void);
 }>) => import('vue').VNode & {