@polyv/vue-components 1.3.0 → 1.4.0

package/vue2/src/components/table/hooks/use-table/use-table-element.d.ts

@@ -0,0 +1,35 @@
+import { ComputedRef, Ref } from 'vue';
+export interface TableElementInstance {
+    /** 外层容器 */
+    wrapRef: Ref<HTMLDivElement | undefined>;
+    /** 外层容器宽度 */
+    wrapWidth: Ref<number>;
+    /** 表格头部外层容器 */
+    headerWrapRef: Ref<HTMLDivElement | undefined>;
+    /** 表格头部外层容器尺寸 */
+    headerWrapSize: ComputedRef<{
+        width: number;
+        height: number;
+    }>;
+    /** 表格主体外层容器 */
+    bodyWrapRef: Ref<HTMLDivElement | undefined>;
+    /** 表格主体外层容器尺寸 */
+    bodyWrapSize: ComputedRef<{
+        width: number;
+        height: number;
+    }>;
+    /** 表格主体 */
+    bodyRef: Ref<HTMLDivElement | undefined>;
+    /** 表格主体尺寸 */
+    bodySize: ComputedRef<{
+        width: number;
+        height: number;
+    }>;
+    /** 横向滚动条 */
+    horizontalScrollbarRef: Ref<HTMLDivElement | undefined>;
+    /** 纵向滚动条 */
+    verticalScrollbarRef: Ref<HTMLDivElement | undefined>;
+}
+/** 表格元素 */
+export declare const useTableElement: () => TableElementInstance;
+export declare const useTableElementInject: () => TableElementInstance;

package/vue2/src/components/table/hooks/use-table/use-table-pagination.d.ts

@@ -0,0 +1,12 @@
+import { VueProps } from '../../../../vue-utils';
+import { tableProps } from '../props-define';
+import { ComputedRef, Ref } from 'vue';
+import { PageContent } from '../../../../hooks/pagination/types';
+export interface TablePaginationInjectData {
+    propsData: ComputedRef<PageContent>;
+    paginationModelValue: Ref<PageContent>;
+}
+export declare const useTablePagination: (options: {
+    tableProps: VueProps<typeof tableProps>;
+}) => void;
+export declare const useTablePaginationInject: () => TablePaginationInjectData;

package/vue2/src/components/table/hooks/use-table/use-table-render-data.d.ts

@@ -0,0 +1,13 @@
+import { VueProps } from '../../../../vue-utils';
+import { tableProps } from '../props-define';
+import { ComputedRef } from 'vue';
+export interface TableRenderDataInject {
+    /** 表格渲染的数据 */
+    renderData: ComputedRef<any[]>;
+}
+export declare const useTableRenderData: (options: {
+    tableProps: VueProps<typeof tableProps>;
+}) => {
+    renderData: ComputedRef<any[]>;
+};
+export declare const useTableRenderDataInject: () => TableRenderDataInject;

package/vue2/src/components/table/hooks/use-table/use-table-scroll.d.ts

@@ -0,0 +1,28 @@
+import { ComputedRef, Ref } from 'vue';
+import { TableElementInstance } from './use-table-element';
+export interface TableScrollInjectData {
+    /**
+     * 当前横向滚动位置，left-最左侧，center-中间，right-最右侧
+     */
+    scrollXPosition: Ref<'start' | 'middle' | 'end'>;
+    /**
+     * 是否显示横向滚动
+     */
+    hasHorizontalScroll: ComputedRef<boolean>;
+    /**
+     * 是否显示纵向滚动
+     */
+    hasVerticalScroll: ComputedRef<boolean>;
+    /**
+     * 横向滚动事件
+     */
+    onHorizontalScrollEvent: (event: Event) => void;
+}
+/** 处理表格滚动 */
+export declare const useTableScroll: (options: TableElementInstance & {
+    allColumnWidth: ComputedRef<number>;
+}) => {
+    hasHorizontalScroll: ComputedRef<boolean>;
+    hasVerticalScroll: ComputedRef<boolean>;
+};
+export declare const useTableScrollInject: () => TableScrollInjectData;

package/vue2/src/components/table/hooks/use-table/use-table-status.d.ts

@@ -0,0 +1,29 @@
+import { Ref, ComputedRef } from 'vue';
+import { TableIndexData, TableSortOrder } from '../../types';
+import { tableProps } from '../props-define';
+import { VueProps } from '../../../../vue-utils';
+export interface TableStatusInjectData {
+    /**
+     * 悬停状态
+     */
+    hoverStatus: Ref<TableIndexData>;
+    /**
+     * 表格的排序名称
+     */
+    tableSortName: ComputedRef<string | undefined>;
+    /**
+     * 表格的排序顺序
+     */
+    tableSortOrder: ComputedRef<TableSortOrder | undefined>;
+}
+export declare const useTableStatus: (options: {
+    tableProps: VueProps<typeof tableProps>;
+}) => {
+    hoverStatus: Ref<{
+        rowIndex: number;
+        columnIndex: number;
+    }>;
+    tableSortName: ComputedRef<string | undefined>;
+    tableSortOrder: ComputedRef<"ascending" | "descending" | undefined>;
+};
+export declare const useTableStatusInject: () => TableStatusInjectData;

package/vue2/src/components/table/hooks/use-table/use-table.d.ts

@@ -0,0 +1,195 @@
+import { VueEmit, VueProps } from '../../../../vue-utils';
+import { ComputedRef } from 'vue';
+import { tableEmits, tableProps } from '../props-define';
+import { ColumnListInstance, ColumnListStoreInstance } from './use-column-list';
+import { TableColumnInstance } from '../use-table-column/use-table-column';
+export interface TableInjectData {
+    tableProps: VueProps<typeof tableProps>;
+    tableEmit: VueEmit<typeof tableEmits>;
+    /** 原始列 */
+    originalColumnListInstance: ColumnListStoreInstance;
+    /** 左侧列 */
+    leftColumnListInstance: ColumnListInstance;
+    /** 中间列 */
+    centerColumnListInstance: ColumnListInstance;
+    /** 右侧列 */
+    rightColumnListInstance: ColumnListInstance;
+    /** 所有列 */
+    allColumnList: ComputedRef<TableColumnInstance[]>;
+    /** 所有列宽度 */
+    allColumnWidth: ComputedRef<number>;
+}
+export declare const useTable: (options: {
+    props: VueProps<typeof tableProps>;
+    emit: VueEmit<typeof tableEmits>;
+}) => {
+    leftColumnListInstance: {
+        columnList: import('vue').Ref<{
+            columnId: string;
+            columnProps: {
+                readonly ellipsis: boolean;
+                readonly multipleMax: number;
+                readonly headerTips: string;
+                readonly sortable: boolean;
+                readonly title?: string | undefined;
+                readonly "v-model-key"?: any;
+                readonly fixed?: "left" | "right" | undefined;
+                readonly type?: import('../..').TableColumnType | undefined;
+                readonly width?: string | number | undefined;
+                readonly minWidth?: string | number | undefined;
+                readonly prop?: string | undefined;
+                readonly multipleDisabled?: ((params: import('../..').TableRowParams) => boolean) | undefined;
+                readonly singleDisabled?: ((params: import('../..').TableRowParams) => boolean) | undefined;
+                readonly sortName?: string | undefined;
+            };
+            getModelValue: () => any;
+            updateModelValue: (value: any) => void;
+            setRenderWidth: (width: number) => void;
+            getRenderWidth: () => number;
+            setColumnIndex: (index: number) => void;
+            getColumnIndex: () => number;
+            getStickyStatus: () => boolean;
+            setStickyPosition: (num: number) => void;
+            getStickyStyle: () => Record<string, string>;
+            hasSlots: (name: keyof import('../props-define').TableColumnSlots) => boolean;
+            getHeaderRenderSlot: () => import('vue/types/umd').VNode[] | undefined;
+            getCellRenderSlot: (params: import('../props-define').TableColumnCellSlotData) => import('vue/types/umd').VNode[] | undefined;
+            addChildrenColumn: (column: TableColumnInstance) => void;
+            getChildrenColumns: () => TableColumnInstance[];
+            level: number;
+            setColSpan: (num: number) => void;
+            getColSpan: () => number;
+            setRowSpan: (num: number) => void;
+            getRowSpan: () => number;
+            getColumnSortName: () => string | undefined;
+            isCurrentSort: () => boolean;
+            changeSortOrder: (order: import('../..').TableSortOrder | undefined) => void;
+            toggleSortOrder: () => import('../..').TableSortOrder | undefined;
+        }[]>;
+        addColumn: (column: TableColumnInstance) => void;
+        removeColumn: (column: TableColumnInstance) => void;
+        position: "center" | "left" | "right";
+        columnCount: ComputedRef<number>;
+        columnWidthTotal: ComputedRef<number>;
+    };
+    centerColumnListInstance: {
+        columnList: import('vue').Ref<{
+            columnId: string;
+            columnProps: {
+                readonly ellipsis: boolean;
+                readonly multipleMax: number;
+                readonly headerTips: string;
+                readonly sortable: boolean;
+                readonly title?: string | undefined;
+                readonly "v-model-key"?: any;
+                readonly fixed?: "left" | "right" | undefined;
+                readonly type?: import('../..').TableColumnType | undefined;
+                readonly width?: string | number | undefined;
+                readonly minWidth?: string | number | undefined;
+                readonly prop?: string | undefined;
+                readonly multipleDisabled?: ((params: import('../..').TableRowParams) => boolean) | undefined;
+                readonly singleDisabled?: ((params: import('../..').TableRowParams) => boolean) | undefined;
+                readonly sortName?: string | undefined;
+            };
+            getModelValue: () => any;
+            updateModelValue: (value: any) => void;
+            setRenderWidth: (width: number) => void;
+            getRenderWidth: () => number;
+            setColumnIndex: (index: number) => void;
+            getColumnIndex: () => number;
+            getStickyStatus: () => boolean;
+            setStickyPosition: (num: number) => void;
+            getStickyStyle: () => Record<string, string>;
+            hasSlots: (name: keyof import('../props-define').TableColumnSlots) => boolean;
+            getHeaderRenderSlot: () => import('vue/types/umd').VNode[] | undefined;
+            getCellRenderSlot: (params: import('../props-define').TableColumnCellSlotData) => import('vue/types/umd').VNode[] | undefined;
+            addChildrenColumn: (column: TableColumnInstance) => void;
+            getChildrenColumns: () => TableColumnInstance[];
+            level: number;
+            setColSpan: (num: number) => void;
+            getColSpan: () => number;
+            setRowSpan: (num: number) => void;
+            getRowSpan: () => number;
+            getColumnSortName: () => string | undefined;
+            isCurrentSort: () => boolean;
+            changeSortOrder: (order: import('../..').TableSortOrder | undefined) => void;
+            toggleSortOrder: () => import('../..').TableSortOrder | undefined;
+        }[]>;
+        addColumn: (column: TableColumnInstance) => void;
+        removeColumn: (column: TableColumnInstance) => void;
+        position: "center" | "left" | "right";
+        columnCount: ComputedRef<number>;
+        columnWidthTotal: ComputedRef<number>;
+    };
+    rightColumnListInstance: {
+        columnList: import('vue').Ref<{
+            columnId: string;
+            columnProps: {
+                readonly ellipsis: boolean;
+                readonly multipleMax: number;
+                readonly headerTips: string;
+                readonly sortable: boolean;
+                readonly title?: string | undefined;
+                readonly "v-model-key"?: any;
+                readonly fixed?: "left" | "right" | undefined;
+                readonly type?: import('../..').TableColumnType | undefined;
+                readonly width?: string | number | undefined;
+                readonly minWidth?: string | number | undefined;
+                readonly prop?: string | undefined;
+                readonly multipleDisabled?: ((params: import('../..').TableRowParams) => boolean) | undefined;
+                readonly singleDisabled?: ((params: import('../..').TableRowParams) => boolean) | undefined;
+                readonly sortName?: string | undefined;
+            };
+            getModelValue: () => any;
+            updateModelValue: (value: any) => void;
+            setRenderWidth: (width: number) => void;
+            getRenderWidth: () => number;
+            setColumnIndex: (index: number) => void;
+            getColumnIndex: () => number;
+            getStickyStatus: () => boolean;
+            setStickyPosition: (num: number) => void;
+            getStickyStyle: () => Record<string, string>;
+            hasSlots: (name: keyof import('../props-define').TableColumnSlots) => boolean;
+            getHeaderRenderSlot: () => import('vue/types/umd').VNode[] | undefined;
+            getCellRenderSlot: (params: import('../props-define').TableColumnCellSlotData) => import('vue/types/umd').VNode[] | undefined;
+            addChildrenColumn: (column: TableColumnInstance) => void;
+            getChildrenColumns: () => TableColumnInstance[];
+            level: number;
+            setColSpan: (num: number) => void;
+            getColSpan: () => number;
+            setRowSpan: (num: number) => void;
+            getRowSpan: () => number;
+            getColumnSortName: () => string | undefined;
+            isCurrentSort: () => boolean;
+            changeSortOrder: (order: import('../..').TableSortOrder | undefined) => void;
+            toggleSortOrder: () => import('../..').TableSortOrder | undefined;
+        }[]>;
+        addColumn: (column: TableColumnInstance) => void;
+        removeColumn: (column: TableColumnInstance) => void;
+        position: "center" | "left" | "right";
+        columnCount: ComputedRef<number>;
+        columnWidthTotal: ComputedRef<number>;
+    };
+    hasHorizontalScroll: ComputedRef<boolean>;
+    hasVerticalScroll: ComputedRef<boolean>;
+    wrapRef: import('vue').Ref<HTMLDivElement | undefined>;
+    wrapWidth: import('vue').Ref<number>;
+    headerWrapRef: import('vue').Ref<HTMLDivElement | undefined>;
+    headerWrapSize: ComputedRef<{
+        width: number;
+        height: number;
+    }>;
+    bodyWrapRef: import('vue').Ref<HTMLDivElement | undefined>;
+    bodyWrapSize: ComputedRef<{
+        width: number;
+        height: number;
+    }>;
+    bodyRef: import('vue').Ref<HTMLDivElement | undefined>;
+    bodySize: ComputedRef<{
+        width: number;
+        height: number;
+    }>;
+    horizontalScrollbarRef: import('vue').Ref<HTMLDivElement | undefined>;
+    verticalScrollbarRef: import('vue').Ref<HTMLDivElement | undefined>;
+};
+export declare const useTableInject: () => TableInjectData;

package/vue2/src/components/table/hooks/use-table-column/use-column-children.d.ts

@@ -0,0 +1,56 @@
+import { TableColumnInstance } from './use-table-column';
+export interface ColumnChildrenInstance {
+    /** 添加子列 */
+    addChildrenColumn: (column: TableColumnInstance) => void;
+    getChildrenColumns: () => TableColumnInstance[];
+    level: number;
+    setColSpan: (num: number) => void;
+    getColSpan: () => number;
+    setRowSpan: (num: number) => void;
+    getRowSpan: () => number;
+}
+export declare const useColumnChildren: (columnInstance: TableColumnInstance) => {
+    childrenColumnList: import('vue').Ref<{
+        columnId: string;
+        columnProps: {
+            readonly ellipsis: boolean;
+            readonly multipleMax: number;
+            readonly headerTips: string;
+            readonly sortable: boolean;
+            readonly title?: string | undefined;
+            readonly "v-model-key"?: any;
+            readonly fixed?: "left" | "right" | undefined;
+            readonly type?: import('../..').TableColumnType | undefined;
+            readonly width?: string | number | undefined;
+            readonly minWidth?: string | number | undefined;
+            readonly prop?: string | undefined;
+            readonly multipleDisabled?: ((params: import('../..').TableRowParams) => boolean) | undefined;
+            readonly singleDisabled?: ((params: import('../..').TableRowParams) => boolean) | undefined;
+            readonly sortName?: string | undefined;
+        };
+        getModelValue: () => any;
+        updateModelValue: (value: any) => void;
+        setRenderWidth: (width: number) => void;
+        getRenderWidth: () => number;
+        setColumnIndex: (index: number) => void;
+        getColumnIndex: () => number;
+        getStickyStatus: () => boolean;
+        setStickyPosition: (num: number) => void;
+        getStickyStyle: () => Record<string, string>;
+        hasSlots: (name: keyof import('../props-define').TableColumnSlots) => boolean;
+        getHeaderRenderSlot: () => import('vue/types/umd').VNode[] | undefined;
+        getCellRenderSlot: (params: import('../props-define').TableColumnCellSlotData) => import('vue/types/umd').VNode[] | undefined;
+        addChildrenColumn: (column: TableColumnInstance) => void;
+        getChildrenColumns: () => TableColumnInstance[];
+        level: number;
+        setColSpan: (num: number) => void;
+        getColSpan: () => number;
+        setRowSpan: (num: number) => void;
+        getRowSpan: () => number;
+        getColumnSortName: () => string | undefined;
+        isCurrentSort: () => boolean;
+        changeSortOrder: (order: import('../..').TableSortOrder | undefined) => void;
+        toggleSortOrder: () => import('../..').TableSortOrder | undefined;
+    }[]>;
+    isChildrenColmn: boolean;
+};

package/vue2/src/components/table/hooks/use-table-column/use-column-index.d.ts

@@ -0,0 +1,14 @@
+import { TableColumnInstance } from './use-table-column';
+export interface ColumnIndexInstance {
+    /** 设置列索引 */
+    setColumnIndex: (index: number) => void;
+    /** 获取列索引 */
+    getColumnIndex: () => number;
+}
+/**
+ * 处理列索引
+ */
+export declare const useColumnIndex: (columnInstance: TableColumnInstance) => {
+    setColumnIndex: (index: number) => void;
+    getColumnIndex: () => number;
+};

package/vue2/src/components/table/hooks/use-table-column/use-column-slot.d.ts

@@ -0,0 +1,16 @@
+import { TableColumnCellSlotData, TableColumnHeaderSlotData, TableColumnSlots } from '../props-define';
+import { VNode } from 'vue/types/umd';
+import { TableColumnInstance } from './use-table-column';
+export interface ColumnSlotInstance {
+    /** 是否存在插槽 */
+    hasSlots: (name: keyof TableColumnSlots) => boolean;
+    /** 获取列头插槽渲染 */
+    getHeaderRenderSlot: () => VNode[] | undefined;
+    /** 获取单元格插槽渲染 */
+    getCellRenderSlot: (params: TableColumnCellSlotData) => VNode[] | undefined;
+}
+export declare const useColumnSlot: (columnInstance: TableColumnInstance) => {
+    hasSlots: (name: keyof TableColumnSlots) => boolean;
+    getHeaderSlotData: () => TableColumnHeaderSlotData;
+    getCellSlotData: (params?: TableColumnCellSlotData) => TableColumnCellSlotData;
+};

package/vue2/src/components/table/hooks/use-table-column/use-column-sort.d.ts

@@ -0,0 +1,24 @@
+import { TableColumnInstance } from './use-table-column';
+import { TableSortOrder } from '../../types';
+export interface ColumnSortInstance {
+    /**
+     * 获取该列的排序名称
+     */
+    getColumnSortName: () => string | undefined;
+    /**
+     * 是否在当前列排序
+     */
+    isCurrentSort: () => boolean;
+    /**
+     * 修改排序
+     */
+    changeSortOrder: (order: TableSortOrder | undefined) => void;
+    /**
+     * 获取切换排序后的顺序
+     */
+    toggleSortOrder: () => TableSortOrder | undefined;
+}
+/**
+ * 处理列排序
+ */
+export declare const useColumnSort: (columnInstance: TableColumnInstance) => void;

package/vue2/src/components/table/hooks/use-table-column/use-column-sticky.d.ts

@@ -0,0 +1,17 @@
+import { TableColumnInstance } from './use-table-column';
+export interface ColumnStickyInstance {
+    /** 获取粘贴定位状态 */
+    getStickyStatus: () => boolean;
+    /** 设置列粘贴位置 */
+    setStickyPosition: (num: number) => void;
+    /** 获取列粘贴样式 */
+    getStickyStyle: () => Record<string, string>;
+}
+/**
+ * 处理列粘贴定位
+ */
+export declare const useColumnSticky: (columnInstance: TableColumnInstance) => {
+    getStickyStatus: () => boolean;
+    setStickyPosition: (num: number) => void;
+    getStickyStyle: () => Record<string, string>;
+};

package/vue2/src/components/table/hooks/use-table-column/use-column-width.d.ts

@@ -0,0 +1,14 @@
+import { TableColumnInstance } from './use-table-column';
+export interface ColumnWidthInstance {
+    /** 设置渲染宽度 */
+    setRenderWidth: (width: number) => void;
+    /** 获取渲染宽度 */
+    getRenderWidth: () => number;
+}
+/**
+ * 处理列宽度
+ */
+export declare const useColumnWidth: (columnInstance: TableColumnInstance) => {
+    setRenderWidth: (width: number) => void;
+    getRenderWidth: () => number;
+};

package/vue2/src/components/table/hooks/use-table-column/use-table-column.d.ts

@@ -0,0 +1,20 @@
+import { VueProps } from '../../../../vue-utils';
+import { tableColumnProps } from '../props-define';
+import { ColumnChildrenInstance } from './use-column-children';
+import { ColumnIndexInstance } from './use-column-index';
+import { ColumnSlotInstance } from './use-column-slot';
+import { ColumnStickyInstance } from './use-column-sticky';
+import { ColumnWidthInstance } from './use-column-width';
+import { ColumnSortInstance } from './use-column-sort';
+export interface TableColumnInstance extends ColumnWidthInstance, ColumnIndexInstance, ColumnStickyInstance, ColumnSlotInstance, ColumnChildrenInstance, ColumnSortInstance {
+    columnId: string;
+    columnProps: VueProps<typeof tableColumnProps>;
+    getModelValue: () => any;
+    updateModelValue: (value: any) => void;
+}
+export declare const useTableColumn: (options: {
+    props: VueProps<typeof tableColumnProps>;
+}) => {
+    getHeaderSlotData: () => import('../props-define').TableColumnHeaderSlotData;
+    getCellSlotData: (params?: import('../props-define').TableColumnCellSlotData) => import('../props-define').TableColumnCellSlotData;
+};

package/vue2/src/components/table/index.d.ts

@@ -0,0 +1,4 @@
+export { default as PwcTable } from './table.vue';
+export { default as PwcTableColumn } from './table-column.vue';
+export * from './types';
+export * from './hooks/props-define';

package/vue2/src/components/table/table-column.vue.d.ts

@@ -0,0 +1,80 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            rowIndex: number;
+            columnIndex: number;
+            rowData: any;
+            cellData: any;
+        }): any;
+        header?(_: {
+            renderWidth: number;
+            columnIndex: number;
+        }): any;
+        column?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{
+    "v-model-key": import('vue-types').VueTypeValidableDef<any, import('vue-types/dist/types').ValidatorFunction<any>>;
+    type: import('vue-types').VueTypeValidableDef<import('./types').TableColumnType, import('vue-types/dist/types').ValidatorFunction<import('./types').TableColumnType>>;
+    title: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>>;
+    prop: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>>;
+    width: import('vue-types').VueTypeDef<string | number>;
+    minWidth: import('vue-types').VueTypeDef<string | number>;
+    fixed: import('vue-types').VueTypeDef<"left" | "right">;
+    multipleMax: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+        default: number;
+    };
+    multipleDisabled: import('vue-types').VueTypeValidableDef<(params: import('./types').TableRowParams) => boolean, import('vue-types/dist/types').ValidatorFunction<(params: import('./types').TableRowParams) => boolean>>;
+    singleDisabled: import('vue-types').VueTypeValidableDef<(params: import('./types').TableRowParams) => boolean, import('vue-types/dist/types').ValidatorFunction<(params: import('./types').TableRowParams) => boolean>>;
+    headerTips: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
+        default: string;
+    };
+    sortable: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    sortName: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>>;
+    ellipsis: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    [x: string]: (...args: any[]) => void;
+}, string, Readonly<import('vue').ExtractPropTypes<{
+    "v-model-key": import('vue-types').VueTypeValidableDef<any, import('vue-types/dist/types').ValidatorFunction<any>>;
+    type: import('vue-types').VueTypeValidableDef<import('./types').TableColumnType, import('vue-types/dist/types').ValidatorFunction<import('./types').TableColumnType>>;
+    title: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>>;
+    prop: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>>;
+    width: import('vue-types').VueTypeDef<string | number>;
+    minWidth: import('vue-types').VueTypeDef<string | number>;
+    fixed: import('vue-types').VueTypeDef<"left" | "right">;
+    multipleMax: import('vue-types').VueTypeValidableDef<number, import('vue-types/dist/types').ValidatorFunction<number>> & {
+        default: number;
+    };
+    multipleDisabled: import('vue-types').VueTypeValidableDef<(params: import('./types').TableRowParams) => boolean, import('vue-types/dist/types').ValidatorFunction<(params: import('./types').TableRowParams) => boolean>>;
+    singleDisabled: import('vue-types').VueTypeValidableDef<(params: import('./types').TableRowParams) => boolean, import('vue-types/dist/types').ValidatorFunction<(params: import('./types').TableRowParams) => boolean>>;
+    headerTips: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>> & {
+        default: string;
+    };
+    sortable: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+    sortName: import('vue-types').VueTypeValidableDef<string, import('vue-types/dist/types').ValidatorFunction<string>>;
+    ellipsis: import('vue-types').VueTypeValidableDef<boolean, import('vue-types/dist/types').ValidatorFunction<boolean>> & {
+        default: boolean;
+    };
+}>>, {
+    ellipsis: boolean;
+    multipleMax: number;
+    headerTips: string;
+    sortable: boolean;
+}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $scopedSlots: S;
+    };
+};