@pungfe/element 0.6.6 → 0.6.7

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

@@ -0,0 +1,91 @@
+import { Ref, VNodeChild } from 'vue';
+import { Paging, TableColumnField } from '../../types';
+import { XTableFlexEvents, XTableFlexProps, XTableRequestColumnsProps } from '../../advance';
+import { DefaultRow } from '../../basic';
+export interface XTableRequestConfigColumnsProps<QR, D> extends Omit<XTableRequestColumnsProps<D>, 'content'> {
+    content?: (scope: {
+        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 DefaultRow> extends Omit<XTableFlexProps<D>, 'columns' | 'showOverflowTooltip'> {
+    config: Record<string, XTableRequestConfigColumnsProps<QR, D>>;
+    fields: () => {
+        data: Ref<TableColumnField[]>;
+        loading: Ref<boolean>;
+        update: (fields: TableColumnField[]) => PromiseLike<unknown>;
+    };
+    header?: (scope: {
+        data: D[];
+        isFetching: boolean;
+        paging: Paging;
+        path: PT;
+        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;
+    };
+}
+declare const __VLS_export: <U, PT, QR, 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<XTableRequestConfigProps<U, PT, QR, D> & {
+        onHeaderDragend?: ((newWidth: number, oldWidth: number, column: import('element-plus').TableColumnCtx) => any) | undefined;
+        onRowClick?: ((row: D) => any) | undefined;
+        onRowDblclick?: ((row: D) => any) | undefined;
+        onScroll?: ((data: {
+            scrollLeft: number;
+            scrollTop: number;
+        }) => any) | undefined;
+        onSelectionChange?: ((rows: D[]) => any) | undefined;
+        onPrepare?: ((parameters: {
+            path: PT;
+            query: QR;
+        }) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        data: Ref<D[], D[]>;
+        isFetching: Ref<boolean, boolean>;
+        paging: Ref<Paging, Paging>;
+        path: Ref<PT, PT>;
+        query: Ref<QR, QR>;
+        reset: import('@vueuse/core').UseDebounceFnReturn<() => Promise<void>>;
+        search: import('@vueuse/core').UseDebounceFnReturn<() => Promise<void>>;
+        url: U;
+    }>) => void;
+    attrs: any;
+    slots: {};
+    emit: ((evt: "headerDragend", newWidth: number, oldWidth: number, column: import('element-plus').TableColumnCtx) => void) & ((evt: "rowClick", row: D) => void) & ((evt: "rowDblclick", row: D) => void) & ((evt: "scroll", data: {
+        scrollLeft: number;
+        scrollTop: number;
+    }) => void) & ((evt: "selectionChange", rows: D[]) => void) & ((evt: "prepare", parameters: {
+        path: PT;
+        query: QR;
+    }) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

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

@@ -0,0 +1,31 @@
+import { VNodeChild } from 'vue';
+import { XUploadProps } from '../../basic';
+export interface XUploadOssProps extends Omit<XUploadProps, 'action' | 'beforeUpload' | 'data' | 'fileList'> {
+    /** oss 接收文件最大 大约为50兆, 超过50兆应采取oss ststoken 分片上传 */
+    maxSize?: number;
+}
+declare const __VLS_export: <V extends string, 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<(XUploadOssProps & {
+        modelValue?: MV;
+    }) & {
+        "onUpdate:modelValue"?: ((value: MV | undefined) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default: () => VNodeChild;
+        tip: () => VNodeChild;
+    };
+    emit: (event: "update:modelValue", value: MV | undefined) => void;
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

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

@@ -0,0 +1,33 @@
+import { ButtonProps } from 'element-plus';
+export interface XButtonConfig {
+    /**
+     * 两个中文字符之间自动插入空格(仅当文本长度为 2 且所有字符均为中文时才生效)
+     * @default false
+     */
+    autoInsertSpace?: boolean;
+}
+export interface XButtonProps {
+    disabled?: ButtonProps['disabled'];
+    icon?: ButtonProps['icon'];
+    link?: ButtonProps['link'];
+    size?: ButtonProps['size'];
+    text?: ButtonProps['text'];
+    type?: ButtonProps['type'];
+}
+declare var __VLS_10: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_10) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<XButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (e: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<XButtonProps> & Readonly<{
+    onClick?: ((e: MouseEvent) => any) | undefined;
+}>, {}, {}, {}, {}, 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/components/basic/Cascader.vue.d.ts

@@ -0,0 +1,40 @@
+import { CascaderComponentProps } from 'element-plus';
+export interface XCascaderOptionProps<D, V> {
+    children?: D[];
+    disabled?: boolean;
+    label?: number | string;
+    leaf?: boolean;
+    value: V;
+}
+export interface XCascaderProps<D, V> {
+    clearable?: CascaderComponentProps['clearable'];
+    data?: D[];
+    disabled?: CascaderComponentProps['disabled'];
+    factory?: (option: D, level: number) => XCascaderOptionProps<D, V>;
+    filterable?: CascaderComponentProps['filterable'];
+    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> & {
+        modelValue?: MV;
+    }) & {
+        "onUpdate:modelValue"?: ((value: MV | undefined) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {};
+    emit: (event: "update:modelValue", value: MV | undefined) => void;
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

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

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

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

@@ -0,0 +1,17 @@
+import { ConfigProviderProps } from 'element-plus';
+export interface XConfigProviderProps {
+    locale?: ConfigProviderProps['locale'];
+}
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: 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 __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/components/basic/DatePicker.vue.d.ts

@@ -0,0 +1,43 @@
+import { DatePickerProps } from 'element-plus';
+export interface XDateConfig {
+    teleported?: boolean;
+    valueFormat?: DatePickerProps['valueFormat'];
+}
+export interface XDatePickerProps extends XDateConfig {
+    disabled?: boolean;
+    disabledDate?: DatePickerProps['disabledDate'];
+    endPlaceholder?: DatePickerProps['endPlaceholder'];
+    placeholder?: DatePickerProps['placeholder'];
+    shortcuts?: DatePickerProps['shortcuts'];
+    size?: DatePickerProps['size'];
+    startPlaceholder?: DatePickerProps['startPlaceholder'];
+    type?: DatePickerProps['type'];
+}
+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 & {
+        modelValue?: V;
+        start?: V;
+        end?: V;
+    }) & {
+        "onUpdate:modelValue"?: ((value: V | undefined) => any) | undefined;
+        onFocus?: ((e: FocusEvent) => any) | undefined;
+        onBlur?: ((e: FocusEvent) => any) | undefined;
+        "onUpdate:start"?: ((value: V | undefined) => any) | undefined;
+        "onUpdate:end"?: ((value: V | undefined) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {};
+    emit: (((evt: "focus", e: FocusEvent) => void) & ((evt: "blur", e: FocusEvent) => void)) & (((event: "update:modelValue", value: V | undefined) => void) & ((event: "update:start", value: V | undefined) => void) & ((event: "update:end", value: V | undefined) => void));
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

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

@@ -0,0 +1,36 @@
+import { DialogProps } from 'element-plus';
+import { VNodeChild } from 'vue';
+export interface XDialogProps {
+    alignCenter?: DialogProps['alignCenter'];
+    bodyClass?: DialogProps['bodyClass'];
+    center?: DialogProps['center'];
+    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;
+    footer?: () => VNodeChild;
+    header?: () => VNodeChild;
+};
+type __VLS_ModelProps = {
+    modelValue?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, 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/components/basic/Form.vue.d.ts

@@ -0,0 +1,37 @@
+import { VNodeChild } from 'vue';
+import { FormProps } from 'element-plus';
+export interface XFormProps<D> {
+    content?: (scope: {
+        data: D;
+    }) => VNodeChild;
+    data?: D;
+    disabled?: boolean;
+    inline?: boolean;
+    labelPosition?: 'left' | 'right' | 'top';
+    labelSuffix?: string;
+    labelWidth?: number | string;
+    size?: FormProps['size'];
+}
+declare const __VLS_export: <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_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<XFormProps<D>> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import('vue').ShallowUnwrapRef<{
+        clearValidate: () => void;
+        data: D | undefined;
+        resetFields: () => void;
+        validate: () => boolean;
+    }>) => void;
+    attrs: any;
+    slots: {};
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

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

@@ -0,0 +1,36 @@
+import { VNodeChild } from 'vue';
+export interface XFormItemProps {
+    content?: () => VNodeChild;
+    label?: string;
+    required?: boolean;
+    validator?: () => string | void;
+}
+export interface XFormItemValidation {
+    clearValidate: () => void;
+    id?: string;
+    label?: string;
+    required?: boolean;
+    validate: () => boolean;
+    validator?: () => string | void;
+}
+declare const __VLS_export: <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_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<XFormItemProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default: () => VNodeChild;
+        label: () => VNodeChild;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: 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 {
+    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 & {
+        modelValue?: MV;
+    }) & {
+        "onUpdate:modelValue"?: ((value: MV | undefined) => any) | undefined;
+        onFocus?: ((e: FocusEvent) => any) | undefined;
+        onBlur?: ((e: FocusEvent) => any) | undefined;
+        onChange?: ((e: MV) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        append: () => VNode;
+        prefix: () => VNode;
+        prepend: () => VNode;
+        suffix: () => VNode;
+    };
+    emit: (((evt: "focus", e: FocusEvent) => void) & ((evt: "blur", e: FocusEvent) => void) & ((evt: "change", e: MV) => void)) & ((event: "update:modelValue", value: MV | undefined) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

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

@@ -0,0 +1,41 @@
+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_Slots = {
+    prefix: () => VNode;
+    suffix: () => VNode;
+};
+type __VLS_ModelProps = {
+    modelValue?: number;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: number | undefined) => any;
+    focus: (e: FocusEvent) => any;
+    blur: (e: FocusEvent) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: number | undefined) => any) | undefined;
+    onFocus?: ((e: FocusEvent) => any) | undefined;
+    onBlur?: ((e: FocusEvent) => any) | undefined;
+}>, {}, {}, {}, {}, 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/components/basic/Pagination.vue.d.ts

@@ -0,0 +1,41 @@
+import { PaginationProps } from 'element-plus';
+export interface XPaginationConfig {
+    defaultPageSize?: PaginationProps['defaultPageSize'];
+    layout?: XPaginationProps['layout'];
+}
+export interface XPaginationProps extends XPaginationConfig {
+    background?: PaginationProps['background'];
+    layout?: PaginationProps['layout'];
+    pageSizes?: PaginationProps['pageSizes'];
+    size?: PaginationProps['size'];
+    total?: PaginationProps['total'];
+}
+type __VLS_Props = XPaginationProps;
+type __VLS_ModelProps = {
+    'currentPage'?: number;
+    'pageSize'?: number;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_11: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_11) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    currentChange: (value: number) => any;
+    sizeChange: (value: number) => any;
+    "update:currentPage": (value: number | undefined) => any;
+    "update:pageSize": (value: number | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onCurrentChange?: ((value: number) => any) | undefined;
+    onSizeChange?: ((value: number) => any) | undefined;
+    "onUpdate:currentPage"?: ((value: number | undefined) => any) | undefined;
+    "onUpdate:pageSize"?: ((value: number | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, 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/components/basic/Select.vue.d.ts

@@ -0,0 +1,57 @@
+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;
+}
+export interface XSelectProps<D, V> {
+    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[]>;
+}
+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> & {
+        modelValue?: MV;
+    }) & {
+        "onUpdate:modelValue"?: ((value: MV | undefined) => any) | undefined;
+        onFocus?: ((e: FocusEvent) => any) | undefined;
+        onBlur?: ((e: FocusEvent) => any) | undefined;
+        onChange?: ((value: V) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {};
+    emit: (((evt: "focus", e: FocusEvent) => void) & ((evt: "blur", e: FocusEvent) => void) & ((evt: "change", value: V) => void)) & ((event: "update:modelValue", value: MV | undefined) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

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

@@ -0,0 +1,28 @@
+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 var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: 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 __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;
+    };
+};