ideaz-element/dist/element/table/src/props.d.ts

<p align="center"> <a href="" target="_blank" rel="noopener noreferrer"> <img src="./docs/public/logo.svg" alt="Ideaz Element" width="180" style="width: 180px;" /> </a> </p>

import { CSSProperties, ExtractPropTypes, PropType, VNode } from 'vue';
import { watermarkProps } from 'element-plus';
import { EditableTableEventParams, Pagination, TableCol, ToolBar } from '../../types';

export interface TableEdit {
    type?: 'multiple' | 'single';
    position?: 'bottom' | 'top';
    maxLength?: number;
    deleteConfirm?: boolean;
    onEdit?: ({ row, $index, column, formRef }: EditableTableEventParams) => void;
    onSave?: ({ row, $index, column, formRef }: EditableTableEventParams) => void;
    onDelete?: ({ row, $index, column, formRef }: EditableTableEventParams) => void;
    onCancel?: ({ row, $index, column, formRef }: EditableTableEventParams) => void;
}
export interface TableSticky {
    top?: string;
    parent?: string;
    zIndex?: number;
    style?: CSSProperties;
}
export declare const tableProps: {
    data: {
        type: PropType<any[]>;
        default: () => never[];
    };
    height: (StringConstructor | NumberConstructor)[];
    maxHeight: (StringConstructor | NumberConstructor)[];
    fit: {
        type: BooleanConstructor;
        default: boolean;
    };
    stripe: BooleanConstructor;
    border: BooleanConstructor;
    rowKey: PropType<string | ((row: any) => string) | undefined>;
    showHeader: {
        type: BooleanConstructor;
        default: boolean;
    };
    showSummary: BooleanConstructor;
    sumText: StringConstructor;
    summaryMethod: PropType<import('element-plus').SummaryMethod<any> | undefined>;
    rowClassName: PropType<import('element-plus').ColumnCls<any> | undefined>;
    rowStyle: PropType<import('element-plus').ColumnStyle<any> | undefined>;
    cellClassName: PropType<import('element-plus').CellCls<any> | undefined>;
    cellStyle: PropType<import('element-plus').CellStyle<any> | undefined>;
    headerRowClassName: PropType<import('element-plus').ColumnCls<any> | undefined>;
    headerRowStyle: PropType<import('element-plus').ColumnStyle<any> | undefined>;
    headerCellClassName: PropType<import('element-plus').CellCls<any> | undefined>;
    headerCellStyle: PropType<import('element-plus').CellStyle<any> | undefined>;
    highlightCurrentRow: BooleanConstructor;
    currentRowKey: (StringConstructor | NumberConstructor)[];
    emptyText: StringConstructor;
    expandRowKeys: PropType<string[] | undefined>;
    defaultExpandAll: BooleanConstructor;
    defaultSort: PropType<import('element-plus').Sort | undefined>;
    tooltipEffect: StringConstructor;
    spanMethod: PropType<((data: {
        row: any;
        rowIndex: number;
        column: import('element-plus').TableColumnCtx<any>;
        columnIndex: number;
    }) => number[] | {
        rowspan: number;
        colspan: number;
    } | undefined) | undefined>;
    selectOnIndeterminate: {
        type: BooleanConstructor;
        default: boolean;
    };
    indent: {
        type: NumberConstructor;
        default: number;
    };
    treeProps: {
        type: PropType<import('element-plus/es/components/table/src/table/defaults').TreeProps | undefined>;
        default: () => {
            hasChildren: string;
            children: string;
        };
    };
    lazy: BooleanConstructor;
    load: PropType<((row: any, treeNode: import('element-plus').TreeNode, resolve: (data: any[]) => void) => void) | undefined>;
    style: {
        type: PropType<CSSProperties>;
        default: () => {};
    };
    className: {
        type: StringConstructor;
        default: string;
    };
    tableLayout: {
        type: PropType<"auto" | "fixed">;
        default: string;
    };
    scrollbarAlwaysOn: BooleanConstructor;
    flexible: BooleanConstructor;
    showOverflowTooltip: BooleanConstructor;
    align: PropType<"left" | "center" | "right">;
    headerAlign: PropType<"left" | "center" | "right">;
    size: PropType<"" | "small" | "default" | "large">;
    loading: BooleanConstructor;
    columns: {
        type: PropType<TableCol<any>[]>;
        default: () => never[];
    };
    pagination: {
        type: PropType<boolean | Pagination>;
        default: () => {
            page: number;
            pageSize: number;
            total: number;
            align: string;
        };
    };
    toolBar: {
        type: PropType<boolean | ToolBar>;
        default: boolean;
    };
    draggable: {
        type: BooleanConstructor;
        default: boolean;
    };
    editable: {
        type: PropType<boolean | TableEdit>;
    };
    options: {
        type: ObjectConstructor;
        default: () => void;
    };
    watermark: {
        type: PropType<string | boolean | ElWatermarkProps>;
        default: boolean;
    };
    fullScreenElement: {
        type: PropType<() => HTMLElement | HTMLElement>;
    };
    totalData: {
        type: ArrayConstructor;
        default: () => never[];
    };
    title: {
        type: PropType<string | (() => VNode)>;
        default: string;
    };
    sticky: {
        type: PropType<boolean | TableSticky>;
        default: boolean;
    };
    mergeCells: {
        type: PropType<{
            direction: 'row' | 'column' | 'both';
            props?: string[] | undefined;
        }>;
    };
};
export declare const tableColumnProps: {
    column: {
        type: PropType<TableCol<any>>;
        default: () => {};
    };
    size: {
        type: PropType<"" | "small" | "default" | "large">;
        default: string;
    };
    tableProps: {
        type: PropType<ITableProps>;
        default: () => {};
    };
    columnIndex: {
        type: NumberConstructor;
    };
    columnsLength: {
        type: NumberConstructor;
        default: number;
    };
};
export declare const radioColumnProps: {
    column: {
        type: PropType<TableCol<any>>;
        default: () => {};
    };
    tableProps: {
        type: PropType<ITableProps>;
        default: () => {};
    };
};
export declare const toolBarProps: {
    formatTableCols: {
        type: PropType<TableCol<any>[]>;
        default: () => never[];
    };
    sortTableCols: {
        type: PropType<TableCol<any>[]>;
        default: () => never[];
    };
    middleTableCols: {
        type: PropType<TableCol<any>[]>;
        default: () => never[];
    };
    originFormatTableCols: {
        type: PropType<TableCol<any>[]>;
        default: () => never[];
    };
    size: {
        type: StringConstructor;
        default: string;
    };
    toolBar: {
        type: (ObjectConstructor | BooleanConstructor)[];
        default: undefined;
    };
    tableProps: {
        type: PropType<ITableProps>;
    };
};
export type ElWatermarkProps = ExtractPropTypes<typeof watermarkProps>;
export type ITableProps = ExtractPropTypes<typeof tableProps>;
export type TableColumnProps = ExtractPropTypes<typeof tableColumnProps>;
export type ToolBarProps = ExtractPropTypes<typeof toolBarProps>;
export declare const tableProvideKey: unique symbol;