@pungfe/element 0.0.1-alpha.9 → 0.1.1

package/dist/{basic/XSelect.vue.d.ts → components/basic/Cascader.vue.d.ts}

@@ -1,27 +1,31 @@
-import { SelectProps } from 'element-plus';
-export interface XSelectOptionProps<V> {
+import { CascaderComponentProps } from 'element-plus';
+export interface XCascaderOptionProps<D, V> {
+    children?: D[];
     disabled?: boolean;
     label?: number | string;
     value: V;
+    leaf?: boolean;
 }
-export interface XSelectProps<D, V> extends Partial<Omit<SelectProps, 'modelValue'>> {
-    data: D[];
-    factory: (option: D) => XSelectOptionProps<V>;
-    identify?: (value: V) => number | string;
-    supplement?: (lacks: V[]) => D[] | PromiseLike<D[]>;
+export interface XCascaderProps<D, V> {
+    data?: D[];
+    factory?: (option: D, level: number) => XCascaderOptionProps<D, V>;
+    clearable?: CascaderComponentProps['clearable'];
+    disabled?: CascaderComponentProps['disabled'];
+    filterable?: CascaderComponentProps['filterable'];
+    size?: CascaderComponentProps['size'];
+    placeholder?: CascaderComponentProps['placeholder'];
+    props?: CascaderComponentProps['props'];
 }
 declare const _default: <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_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
         readonly "onUpdate:modelValue"?: ((value: MV) => any) | undefined;
-        readonly onBlur?: (() => any) | undefined;
-        readonly onChange?: ((value: MV) => any) | undefined;
-    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue" | "onBlur" | "onChange"> & ({
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue"> & ({
         modelValue?: MV;
-    } & XSelectProps<D, V>) & Partial<{}>> & import('vue').PublicProps;
+    } & XCascaderProps<D, V>) & Partial<{}>> & import('vue').PublicProps;
     expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
     attrs: any;
     slots: {};
-    emit: (((evt: "blur") => void) & ((evt: "change", value: MV) => void)) & ((evt: "update:modelValue", value: MV) => void);
+    emit: (evt: "update:modelValue", value: MV) => void;
 }>) => import('vue').VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };

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

@@ -0,0 +1,22 @@
+import { CheckboxProps, CheckboxValueType } from 'element-plus';
+export interface XCheckboxProps {
+    disabled?: boolean;
+    size?: CheckboxProps['size'];
+    label?: CheckboxProps['label'];
+    trueValue?: CheckboxProps['trueValue'];
+    falseValue?: CheckboxProps['falseValue'];
+}
+type __VLS_Props = XCheckboxProps;
+type __VLS_PublicProps = {
+    modelValue?: CheckboxValueType;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: CheckboxValueType) => any;
+    focus: (e: FocusEvent) => any;
+    blur: (e: FocusEvent) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: CheckboxValueType) => any) | undefined;
+    onFocus?: ((e: FocusEvent) => any) | undefined;
+    onBlur?: ((e: FocusEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,21 @@
+import { ConfigProviderProps } from 'element-plus';
+export interface XConfigProviderProps {
+    locale?: ConfigProviderProps['locale'];
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<XConfigProviderProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<XConfigProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,34 @@
+import { DatePickerProps } from 'element-plus';
+export interface XDatePickerProps {
+    disabled?: boolean;
+    disabledDate?: DatePickerProps['disabledDate'];
+    endPlaceholder?: DatePickerProps['endPlaceholder'];
+    placeholder?: DatePickerProps['placeholder'];
+    shortcuts?: DatePickerProps['shortcuts'];
+    startPlaceholder?: DatePickerProps['startPlaceholder'];
+    type?: DatePickerProps['type'];
+    valueFormat?: DatePickerProps['valueFormat'];
+}
+declare const _default: <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_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value: V) => any) | undefined;
+        readonly onFocus?: ((e: FocusEvent) => any) | undefined;
+        readonly onBlur?: ((e: FocusEvent) => any) | undefined;
+        readonly "onUpdate:start"?: ((value: V) => any) | undefined;
+        readonly "onUpdate:end"?: ((value: V) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue" | "onBlur" | "onFocus" | "onUpdate:start" | "onUpdate:end"> & ({
+        modelValue?: V;
+        start?: V;
+        end?: V;
+    } & XDatePickerProps) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: (((evt: "focus", e: FocusEvent) => void) & ((evt: "blur", e: FocusEvent) => void)) & (((evt: "update:modelValue", value: V) => void) & ((evt: "update:start", value: V) => void) & ((evt: "update:end", value: V) => void));
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/{basic/XDialog.vue.d.ts → components/basic/Dialog.vue.d.ts}

@@ -1,7 +1,15 @@
-import { Component } from 'vue';
+import { DialogProps } from 'element-plus';
+import { VNodeChild } from 'vue';
 export interface XDialogProps {
-    title?: string;
-    bodyClass?: string;
+    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'];
 }
 type __VLS_Props = XDialogProps;
 type __VLS_PublicProps = {
@@ -10,13 +18,13 @@ type __VLS_PublicProps = {
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: Readonly<{
-        default?: () => Component;
-        header?: () => Component;
-        footer?: () => Component;
+        default?: () => VNodeChild;
+        header?: () => VNodeChild;
+        footer?: () => VNodeChild;
     }> & {
-        default?: () => Component;
-        header?: () => Component;
-        footer?: () => Component;
+        default?: () => VNodeChild;
+        header?: () => VNodeChild;
+        footer?: () => VNodeChild;
     };
     refs: {};
     rootEl: any;

package/dist/{basic/XForm.vue.d.ts → components/basic/Form.vue.d.ts}

@@ -1,10 +1,4 @@
 import { VNodeChild } from 'vue';
-export interface XFormItemConfig<D> extends Omit<XFormItemProps, 'content' | 'label'> {
-    content?: (scope: {
-        data: D;
-    }) => VNodeChild;
-    label: string;
-}
 export interface XFormProps<D> {
     content?: (scope: {
         data: D;
@@ -12,33 +6,15 @@ export interface XFormProps<D> {
     data?: D;
     disabled?: boolean;
     inline?: boolean;
-    labelWidth?: number | string;
     labelPosition?: 'left' | 'right' | 'top';
-    statusIcon?: boolean;
-}
-export interface XFormItemProps {
-    content?: () => VNodeChild;
-    label?: string;
-    labelPosition?: '' | 'left' | 'right' | 'top';
+    labelSuffix?: string;
     labelWidth?: number | string;
-    required?: boolean;
-    tooltip?: {
-        type?: 'success' | 'warning';
-        content?: string;
-    };
-}
-export interface XFormItemValidation {
-    label: string;
-    required: boolean;
-    clearValidate: () => void;
-    validate: () => boolean;
-    validator?: () => string | void;
 }
-export declare const XFormItem: import('vue').DefineSetupFnComponent<XFormItemProps, {}, {}, XFormItemProps & {}, import('vue').PublicProps>;
 declare const _default: <D extends object>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, never> & XFormProps<D> & Partial<{}>> & import('vue').PublicProps;
     expose(exposed: import('vue').ShallowUnwrapRef<{
-        data: D | (() => void);
+        clearValidate: () => void;
+        data: D | undefined;
         validate: () => boolean;
         resetFields: () => void;
     }>): void;

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

@@ -0,0 +1,34 @@
+import { VNodeChild } from 'vue';
+export interface XFormItemProps {
+    content?: () => VNodeChild;
+    label?: string;
+    required?: boolean;
+    validator?: () => string | void;
+}
+export interface XFormItemValidation {
+    id?: string;
+    clearValidate: () => void;
+    label?: string;
+    required?: boolean;
+    validate: () => boolean;
+    validator?: () => string | void;
+}
+declare const _default: <D extends object>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, never> & XFormItemProps & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Readonly<{
+        default: () => VNodeChild;
+        label: () => VNodeChild;
+    }> & {
+        default: () => VNodeChild;
+        label: () => VNodeChild;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

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

@@ -0,0 +1,44 @@
+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'];
+    placeholder?: InputProps['placeholder'];
+    prefixIcon?: InputProps['prefixIcon'];
+    suffixIcon?: InputProps['suffixIcon'];
+}
+declare const _default: <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_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value: MV) => any) | undefined;
+        readonly onFocus?: ((e: FocusEvent) => any) | undefined;
+        readonly onBlur?: ((e: FocusEvent) => any) | undefined;
+        readonly onChange?: ((e: MV) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue" | "onBlur" | "onChange" | "onFocus"> & ({
+        modelValue?: MV;
+    } & XInputProps) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Readonly<{
+        append: () => VNode;
+        prefix: () => VNode;
+        prepend: () => VNode;
+        suffix: () => VNode;
+    }> & {
+        append: () => VNode;
+        prefix: () => VNode;
+        prepend: () => VNode;
+        suffix: () => VNode;
+    };
+    emit: (((evt: "focus", e: FocusEvent) => void) & ((evt: "blur", e: FocusEvent) => void) & ((evt: "change", e: MV) => void)) & ((evt: "update:modelValue", value: MV) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

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

@@ -0,0 +1,48 @@
+import { InputNumberProps } from 'element-plus';
+import { VNode } from 'vue';
+export interface XInputNumberProps {
+    align?: InputNumberProps['align'];
+    controls?: InputNumberProps['controls'];
+    disabled?: InputNumberProps['disabled'];
+    inputmode?: InputNumberProps['inputmode'];
+    max?: InputNumberProps['max'];
+    min?: InputNumberProps['min'];
+    placeholder?: InputNumberProps['placeholder'];
+    precision?: InputNumberProps['precision'];
+    size?: InputNumberProps['size'];
+    step?: InputNumberProps['step'];
+    stepStrictly?: InputNumberProps['stepStrictly'];
+}
+type __VLS_Props = XInputNumberProps;
+type __VLS_PublicProps = {
+    modelValue?: number;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        prefix: () => VNode;
+        suffix: () => VNode;
+    }> & {
+        prefix: () => VNode;
+        suffix: () => VNode;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: number) => any;
+    focus: (e: FocusEvent) => any;
+    blur: (e: FocusEvent) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+    onFocus?: ((e: FocusEvent) => any) | undefined;
+    onBlur?: ((e: FocusEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,41 @@
+import { PaginationProps } from 'element-plus';
+export interface XPaginationProps {
+    pageSizes?: PaginationProps['pageSizes'];
+    background?: PaginationProps['background'];
+    size?: PaginationProps['size'];
+    layout?: PaginationProps['layout'];
+    total?: PaginationProps['total'];
+    defaultPageSize?: PaginationProps['defaultPageSize'];
+}
+type __VLS_Props = XPaginationProps;
+type __VLS_PublicProps = {
+    'currentPage'?: number;
+    'pageSize'?: number;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    sizeChange: (size: number) => any;
+    currentChange: (current: number) => any;
+    "update:currentPage": (value: number) => any;
+    "update:pageSize": (value: number) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onSizeChange?: ((size: number) => any) | undefined;
+    onCurrentChange?: ((current: number) => any) | undefined;
+    "onUpdate:currentPage"?: ((value: number) => any) | undefined;
+    "onUpdate:pageSize"?: ((value: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,51 @@
+import { SelectProps } from 'element-plus';
+export interface XSelectOptionProps<V> {
+    disabled?: boolean;
+    label?: number | string;
+    value: V;
+}
+export interface XSelectProps<D, V> {
+    collapseTagsTooltip?: SelectProps['collapseTagsTooltip'];
+    defaultFirstOption?: SelectProps['defaultFirstOption'];
+    clearable?: SelectProps['clearable'];
+    allowCreate?: SelectProps['allowCreate'];
+    collapseTags?: SelectProps['collapseTags'];
+    data?: D[];
+    disabled?: SelectProps['disabled'];
+    factory: (option: D) => XSelectOptionProps<V>;
+    filterable?: SelectProps['filterable'];
+    identify?: (value: V) => number | string;
+    loading?: SelectProps['loading'];
+    multiple?: SelectProps['multiple'];
+    remote?: SelectProps['remote'];
+    remoteMethod?: (query: string) => void;
+    size?: SelectProps['size'];
+    supplement?: (lacks: V[]) => D[] | PromiseLike<D[]>;
+    placeholder?: SelectProps['placeholder'];
+    noDataText?: SelectProps['noDataText'];
+}
+export interface XSelectEvents<V> {
+    blur: [e: FocusEvent];
+    change: [value: V];
+    focus: [e: FocusEvent];
+}
+declare const _default: <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_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value: MV) => any) | undefined;
+        readonly onFocus?: ((e: FocusEvent) => any) | undefined;
+        readonly onBlur?: ((e: FocusEvent) => any) | undefined;
+        readonly onChange?: ((value: V) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue" | "onBlur" | "onChange" | "onFocus"> & ({
+        modelValue?: MV;
+    } & XSelectProps<D, V>) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: (((evt: "focus", e: FocusEvent) => void) & ((evt: "blur", e: FocusEvent) => void) & ((evt: "change", value: V) => void)) & ((evt: "update:modelValue", value: MV) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

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

@@ -0,0 +1,32 @@
+import { TabPaneProps } from 'element-plus';
+export interface XTabPaneConfig {
+    label?: string;
+    name?: number | string;
+}
+export interface XTabPaneProps {
+    closable?: TabPaneProps['closable'];
+    disabled?: TabPaneProps['disabled'];
+    label?: TabPaneProps['label'];
+    lazy?: TabPaneProps['lazy'];
+    name?: TabPaneProps['name'];
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<XTabPaneProps, {
+    label: string | undefined;
+    name: string | number | undefined;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<XTabPaneProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,105 @@
+import { TableColumnCtx, TableProps } from 'element-plus';
+import { CSSProperties, VNode, VNodeChild } from 'vue';
+export interface XTableConfig {
+    /**
+     * 是否隐藏额外内容并在单元格悬停时使用 Tooltip 显示它们。这将影响全部列的展示
+     * @default false
+     */
+    showOverflowTooltip?: boolean;
+    border?: boolean;
+}
+export interface XTableColumnProps<D> {
+    content?: (scope: {
+        index: number;
+        row: D;
+    }) => VNodeChild;
+    fixed?: 'left' | 'right';
+    header?: (scope: {
+        column: XTableColumnProps<D>;
+    }) => VNodeChild;
+    label?: string;
+    prop?: string;
+    selectable?: (row: D, index: number) => boolean;
+    type?: 'index' | 'selection';
+    width?: number;
+    columnKey?: string;
+}
+export interface XTableProps<D> {
+    border?: TableProps<any>['border'];
+    cellClassName?: ((scope: {
+        column: TableColumnCtx;
+        columnIndex: number;
+        row: D;
+        rowIndex: number;
+    }) => string) | string;
+    cellStyle?: ((scope: {
+        column: TableColumnCtx;
+        columnIndex: number;
+        row: D;
+        rowIndex: number;
+    }) => CSSProperties) | CSSProperties;
+    columns?: XTableColumnProps<D>[];
+    data?: D[];
+    height?: TableProps<any>['height'];
+    emptyText?: TableProps<any>['emptyText'];
+    rowClassName?: ((scope: {
+        row: D;
+        rowIndex: number;
+    }) => string) | string;
+    rowStyle?: ((scope: {
+        row: D;
+        rowIndex: number;
+    }) => CSSProperties) | CSSProperties;
+    rowKey?: (scope: {
+        row: D;
+    }) => string;
+    showOverflowTooltip?: TableProps<any>['showOverflowTooltip'];
+    showSummary?: TableProps<any>['showSummary'];
+    size?: TableProps<any>['size'];
+    fit?: TableProps<any>['fit'];
+    spanMethod?: (scope: {
+        column: TableColumnCtx;
+        columnIndex: number;
+        row: D;
+        rowIndex: number;
+    }) => number[] | undefined | {
+        colspan: number;
+        rowspan: number;
+    };
+    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 _default: <D>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onHeaderDragend?: ((newWidth: number, oldWidth: number, column: TableColumnCtx) => any) | undefined;
+        readonly onRowClick?: ((row: D) => any) | undefined;
+        readonly onRowDblclick?: ((row: D) => any) | undefined;
+        readonly onSelectionChange?: ((rows: D[]) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onHeaderDragend" | "onRowClick" | "onRowDblclick" | "onSelectionChange"> & XTableProps<D> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        clearSelection: () => void | undefined;
+        getSelectionRows: () => any[] | undefined;
+        scrollTo: (options: number | ScrollToOptions, yCoord?: number) => void | undefined;
+        setCurrentRow: (row: D) => void | undefined;
+        setScrollLeft: (left: number) => void | undefined;
+        setScrollTop: (top: number) => void | undefined;
+        toggleRowSelection: (row: D, selected?: boolean, ignoreSelectable?: boolean) => void | undefined;
+    }>): void;
+    attrs: any;
+    slots: {};
+    emit: ((evt: "headerDragend", newWidth: number, oldWidth: number, column: TableColumnCtx) => void) & ((evt: "rowClick", row: D) => void) & ((evt: "rowDblclick", row: D) => void) & ((evt: "selectionChange", rows: D[]) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/{basic/XTabs.vue.d.ts → components/basic/Tabs.vue.d.ts}

@@ -1,22 +1,20 @@
-import { TabPaneProps, TabsProps } from 'element-plus';
+import { TabsProps } from 'element-plus';
 export interface XTabsProps {
-    type?: TabsProps['type'];
-    defaultValue?: TabsProps['defaultValue'];
     addable?: TabsProps['addable'];
     editable?: TabsProps['editable'];
     tabPosition?: TabsProps['tabPosition'];
+    type?: TabsProps['type'];
 }
-export interface XTabPaneProps extends Partial<TabPaneProps> {
-}
-export interface XTabPaneInstance extends Pick<XTabPaneProps, 'label' | 'name'> {
+export interface XTabsEvents<V> {
+    change: [name: V];
+    remove: [name: V];
 }
-export declare const XTabPane: import('vue').DefineSetupFnComponent<XTabPaneProps, {}, {}, XTabPaneProps & {}, import('vue').PublicProps>;
 declare const _default: <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_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
         readonly "onUpdate:modelValue"?: ((value: V) => any) | undefined;
-        readonly onTabChange?: ((name: V) => any) | undefined;
-        readonly onTabRemove?: ((name: V) => any) | undefined;
-    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue" | "onTabChange" | "onTabRemove"> & ({
+        readonly onChange?: ((name: V) => any) | undefined;
+        readonly onRemove?: ((name: V) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:modelValue" | "onChange" | "onRemove"> & ({
         modelValue?: V;
     } & XTabsProps) & Partial<{}>> & import('vue').PublicProps;
     expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
@@ -24,7 +22,7 @@ declare const _default: <V extends string | number>(__VLS_props: NonNullable<Awa
     slots: {
         default?(_: {}): any;
     };
-    emit: (((evt: "tabChange", name: V) => void) & ((evt: "tabRemove", name: V) => void)) & ((evt: "update:modelValue", value: V) => void);
+    emit: (((evt: "change", name: V) => void) & ((evt: "remove", name: V) => void)) & ((evt: "update:modelValue", value: V) => void);
 }>) => import('vue').VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };