3h1-ui 3.0.0-next.22 → 3.0.0-next.221

package/es/ui/src/ShyTable/src/types/table.d.ts

@@ -0,0 +1,422 @@
+import type { VNodeChild } from 'vue';
+import type { PaginationProps } from './pagination';
+import type { ComponentProps, ComponentType, FormProps } from '../../../ShyForm';
+import type { TableRowSelection as ITableRowSelection } from 'ant-design-vue/lib/table/interface';
+import type { ColumnProps } from 'ant-design-vue/lib/table';
+import { VueNode } from '@shy-plugins/utils';
+import { AdvancedSearchType } from '../../../ShyAdvancedSearch';
+export declare enum RoleEnum {
+    SUPER = "super",
+    TEST = "test"
+}
+export declare type SortOrder = 'ascend' | 'descend';
+export interface TableCurrentDataSource<T = Recordable> {
+    currentDataSource: T[];
+}
+export interface TableRowSelection<T = any> extends ITableRowSelection {
+    /**
+     * Callback executed when selected rows change
+     * @type Function
+     */
+    onChange?: (selectedRowKeys: Array<string | number>, selectedRows: T[]) => any;
+    /**
+     * Callback executed when select/deselect one row
+     * @type Function
+     */
+    onSelect?: (record: T, selected: boolean, selectedRows: Object[], nativeEvent: Event) => any;
+    /**
+     * Callback executed when select/deselect all rows
+     * @type Function
+     */
+    onSelectAll?: (selected: boolean, selectedRows: T[], changeRows: T[]) => any;
+    /**
+     * Callback executed when row selection is inverted
+     * @type Function
+     */
+    onSelectInvert?: (selectedRows: Array<string | number>) => any;
+}
+export interface TableCustomRecord<T> {
+    record?: T;
+    index?: number;
+}
+export interface ExpandedRowRenderRecord<T> extends TableCustomRecord<T> {
+    indent?: number;
+    expanded?: boolean;
+}
+export interface TableCustomRecord<T = Recordable> {
+    record?: T;
+    index?: number;
+}
+export interface SorterResult {
+    column: ColumnProps;
+    order: SortOrder;
+    field: string;
+    columnKey: string;
+}
+export interface FetchParams {
+    searchInfo?: Recordable;
+    page?: number;
+    sortInfo?: Recordable;
+    filterInfo?: Recordable;
+}
+export interface GetColumnsParams {
+    ignoreIndex?: boolean;
+    ignoreAction?: boolean;
+    sort?: boolean;
+}
+export type SizeType = 'default' | 'middle' | 'small' | 'large';
+export interface TableActionType {
+    reload: (opt?: FetchParams) => Promise<Recordable<any>[] | undefined>;
+    setSelectedRows: (rows: Recordable[]) => void;
+    getSelectRows: <T = Recordable>() => T[] | undefined;
+    clearSelectedRowKeys: () => void;
+    expandAll: () => void;
+    expandRows: (keys: string[]) => void;
+    collapseAll: () => void;
+    scrollTo: (pos: string) => void;
+    getSelectRowKeys: () => string[] | undefined;
+    deleteSelectRowByKey: (key: string) => void;
+    setPagination: (info: Partial<PaginationProps>) => void;
+    setTableData: (values: Recordable[]) => void;
+    updateTableDataRecord: (rowKey: string, record: Recordable) => Recordable | void;
+    deleteTableDataRecord: (rowKey: string | number | string[] | number[]) => void;
+    insertTableDataRecord: (record: Recordable, index: number) => Recordable<any> | undefined;
+    findTableDataRecord: (rowKey: string | number) => Recordable | void;
+    getColumns: (opt?: GetColumnsParams) => ShyColumn[];
+    setColumns: (columns: ShyColumn[] | string[]) => void;
+    getDataSource: () => Recordable[] | undefined;
+    getRawDataSource: () => Recordable;
+    setLoading: (loading: boolean) => void;
+    setProps: (props: Partial<ShyTableProps>) => void;
+    redoHeight: () => void;
+    setSelectedRowKeys: (rowKeys: string[]) => void;
+    getPaginationRef: () => PaginationProps | boolean | undefined;
+    getSize: () => SizeType | undefined;
+    getRowSelection: () => TableRowSelection<Recordable> | undefined;
+    getCacheColumns: () => ShyColumn[] | undefined;
+    emit?: EmitType;
+    updateTableData: (index: number, key: string, value: any) => Recordable | undefined;
+    setShowPagination: (show: boolean) => Promise<void>;
+    getShowPagination: () => boolean | undefined;
+    setCacheColumnsByField?: (dataIndex: string | undefined, value: ShyColumn) => void;
+    showAll: () => void;
+    setEditByRow?: any;
+    cancelEditByRow?: any;
+    getTableData?: any;
+    getTreeExpandRecords?: any;
+    setAllTreeExpand?: any;
+    clearTreeExpand?: any;
+    setTreeExpand?: any;
+    setSelectRowByKeys?: any;
+    getProps?: any;
+    hideColumn?: any;
+    showColumn?: any;
+    resetColumn?: any;
+    refreshColumn?: any;
+    addTableData?: any;
+}
+export interface FetchSetting {
+    pageField: string;
+    sizeField: string;
+    listField: string;
+    totalField: string;
+}
+export interface TableSetting {
+    redo?: boolean;
+    size?: boolean;
+    setting?: boolean;
+    fullScreen?: boolean;
+    advancedSearch?: boolean;
+    globalSearch?: boolean;
+    showMore?: boolean;
+}
+export interface ShyTableProps<T = any> {
+    useInfo: boolean;
+    infoConfig: InfoConfig;
+    formLayout?: 'horizontal' | 'vertical' | 'inline';
+    formLabelInInput?: boolean;
+    actionColWidth: number;
+    summaryPrecision: number;
+    isShowTitle: boolean;
+    headerAlign: 'left' | 'right';
+    isShowHeader: boolean;
+    isShowFooter: boolean;
+    isShowFooterSettings: boolean;
+    isShowPagination: boolean;
+    resizable: boolean;
+    clickToRowSelect?: boolean;
+    isTreeTable?: boolean;
+    sortFn?: (sortInfo: SorterResult) => any;
+    isSortFetch?: boolean;
+    filterFn?: (data: Partial<Recordable<string[]>>) => any;
+    inset?: boolean;
+    showTableSetting?: boolean;
+    tableSetting?: TableSetting;
+    striped?: boolean;
+    autoCreateKey?: boolean;
+    summaryFunc?: (...arg: any) => Recordable[];
+    summaryData?: Recordable[];
+    summaryTotalFields?: string[];
+    showSummary?: boolean;
+    showSummaryTotal: boolean;
+    canColDrag?: boolean;
+    api?: (...arg: any) => Promise<any>;
+    beforeFetch?: Fn;
+    afterFetch?: Fn;
+    handleSearchInfoFn?: Fn;
+    fetchSetting?: Partial<FetchSetting>;
+    immediate?: boolean;
+    emptyDataIsShowTable?: boolean;
+    searchInfo?: Recordable;
+    defSort?: Recordable;
+    useSearchForm?: boolean;
+    formConfig?: Partial<FormProps>;
+    columns: ShyColumn[];
+    showIndexColumn?: boolean;
+    indexColumnProps?: ShyColumn;
+    actionColumn?: ShyColumn;
+    ellipsis?: boolean;
+    isCanResizeParent?: boolean;
+    canResize?: boolean;
+    resizeHeightOffset?: number;
+    clearSelectOnPageChange?: boolean;
+    rowKey?: string | ((record: Recordable) => string);
+    dataSource?: Recordable[];
+    titleHelpMessage?: string | string[];
+    maxHeight?: number;
+    bordered?: boolean;
+    pagination?: PaginationProps;
+    loading?: boolean;
+    /**
+     * The column contains children to display
+     * @default 'children'
+     * @type string | string[]
+     */
+    childrenColumnName?: string;
+    /**
+     * Override default table elements
+     * @type object
+     */
+    components?: object;
+    /**
+     * Expand all rows initially
+     * @default false
+     * @type boolean
+     */
+    defaultExpandAllRows?: boolean;
+    /**
+     * Initial expanded row keys
+     * @type string[]
+     */
+    defaultExpandedRowKeys?: string[];
+    /**
+     * Current expanded row keys
+     * @type string[]
+     */
+    expandedRowKeys?: string[];
+    /**
+     * Expanded container render for each row
+     * @type Function
+     */
+    expandedRowRender?: (record?: ExpandedRowRenderRecord<T>) => VNodeChild | JSX.Element;
+    /**
+     * Customize row expand Icon.
+     * @type Function | VNodeChild
+     */
+    expandIcon?: Function | VNodeChild | JSX.Element;
+    /**
+     * Whether to expand row by clicking anywhere in the whole row
+     * @default false
+     * @type boolean
+     */
+    expandRowByClick?: boolean;
+    /**
+     * The index of `expandIcon` which column will be inserted when `expandIconAsCell` is false. default 0
+     */
+    expandIconColumnIndex?: number;
+    /**
+     * Table footer renderer
+     * @type Function | VNodeChild
+     */
+    footer?: Function | VNodeChild | JSX.Element;
+    /**
+     * Indent size in pixels of tree data
+     * @default 15
+     * @type number
+     */
+    indentSize?: number;
+    /**
+     * i18n text including filter, sort, empty text, etc
+     * @default { filterConfirm: 'Ok', filterReset: 'Reset', emptyText: 'No Data' }
+     * @type object
+     */
+    locale?: object;
+    /**
+     * Row's className
+     * @type Function
+     */
+    rowClassName?: (record: TableCustomRecord<T>, index: number) => string;
+    /**
+     * Row selection config
+     * @type object
+     */
+    rowSelection?: TableRowSelection;
+    /**
+     * Set horizontal or vertical scrolling, can also be used to specify the width and height of the scroll area.
+     * It is recommended to set a number for x, if you want to set it to true,
+     * you need to add style .ant-table td { white-space: nowrap; }.
+     * @type object
+     */
+    scroll?: {
+        x?: number | true;
+        y?: number;
+    };
+    /**
+     * Whether to show table header
+     * @default true
+     * @type boolean
+     */
+    showHeader?: boolean;
+    /**
+     * Size of table
+     * @default 'default'
+     * @type string
+     */
+    size?: SizeType;
+    /**
+     * Table title renderer
+     * @type Function | ScopedSlot
+     */
+    title?: VNodeChild | JSX.Element | string | ((data: Recordable) => string);
+    /**
+     * Set props on per header row
+     * @type Function
+     */
+    customHeaderRow?: (column: ColumnProps, index: number) => object;
+    /**
+     * Set props on per row
+     * @type Function
+     */
+    customRow?: (record: T, index: number) => object;
+    /**
+     * `table-layout` attribute of table element
+     * `fixed` when header/columns are fixed, or using `column.ellipsis`
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/CSS/table-layout
+     * @version 1.5.0
+     */
+    tableLayout?: 'auto' | 'fixed' | string;
+    /**
+     * the render container of dropdowns in table
+     * @param triggerNode
+     * @version 1.5.0
+     */
+    getPopupContainer?: (triggerNode?: HTMLElement) => HTMLElement;
+    /**
+     * Data can be changed again before rendering.
+     * The default configuration of general user empty data.
+     * You can configured globally through [ConfigProvider](https://antdv.com/components/config-provider-cn/)
+     *
+     * @version 1.5.4
+     */
+    transformCellText?: Function;
+    /**
+     * Callback executed before editable cell submit value, not for row-editor
+     *
+     * The cell will not submit data while callback return false
+     */
+    beforeEditSubmit?: (data: {
+        record: Recordable;
+        index: number;
+        key: string | number;
+        value: any;
+    }) => Promise<any>;
+    /**
+     * Callback executed when pagination, filters or sorter is changed
+     * @param pagination
+     * @param filters
+     * @param sorter
+     * @param currentDataSource
+     */
+    onChange?: (pagination: any, filters: any, sorter: any, extra: any) => void;
+    /**
+     * Callback executed when the row expand icon is clicked
+     *
+     * @param expanded
+     * @param record
+     */
+    onExpand?: (expanded: boolean, record: T) => void;
+    /**
+     * Callback executed when the expanded rows change
+     * @param expandedRows
+     */
+    onExpandedRowsChange?: (expandedRows: string[] | number[]) => void;
+    onColumnsChange?: (data: (ColumnChangeParam | ShyColumn)[]) => void;
+    onColumnsReset?: () => void;
+}
+export type AlignType = 'left' | 'center' | 'right';
+export type CellFormat = string | ((text: string, record: Recordable, index: number, tableAction: TableActionType) => string | number) | Map<string | number, any>;
+export type ShyColumn = {
+    width?: number | undefined;
+    children?: ShyColumn[];
+    filters?: {
+        text: string;
+        value: string;
+        children?: unknown[] | (((props: Record<string, unknown>) => unknown[]) & (() => unknown[]) & (() => unknown[]));
+    }[];
+    flag?: 'INDEX' | 'DEFAULT' | 'CHECKBOX' | 'RADIO' | 'ACTION';
+    customTitle?: VueNode;
+    slots?: Recordable;
+    advancedType?: AdvancedSearchType;
+    advancedComponent?: ComponentType;
+    advancedComponentProps?: ComponentProps;
+    globalShow?: boolean;
+    advancedShow?: boolean;
+    defaultHidden?: boolean;
+    helpMessage?: string | string[];
+    format?: CellFormat;
+    tag?: boolean;
+    options?: Recordable[];
+    edit?: boolean;
+    editRow?: boolean;
+    editable?: boolean;
+    editComponent?: ComponentType;
+    editComponentProps?: ((opt: {
+        text: string | number | boolean | Recordable;
+        record: Recordable;
+        column: ShyColumn;
+        index: number;
+        typeAction: TableActionType;
+    }) => Recordable) | Recordable;
+    editRule?: boolean | ((text: string, record: Recordable) => Promise<string>);
+    editValueMap?: (value: any) => string;
+    onEditRow?: () => void;
+    auth?: RoleEnum | RoleEnum[] | string | string[];
+    ifShow?: boolean | ((column: ShyColumn) => boolean);
+    editRender?: (opt: {
+        text: string | number | boolean | Recordable;
+        record: Recordable;
+        column: ShyColumn;
+        index: number;
+    }) => VNodeChild | JSX.Element;
+    editDynamicDisabled?: boolean | ((record: Recordable) => boolean);
+} & ColumnProps<Recordable>;
+export type ColumnChangeParam = {
+    title: string;
+    dataIndex: string;
+    width?: number | undefined;
+    fixed?: boolean | 'left' | 'right';
+    defaultHidden?: boolean;
+};
+export interface InnerHandlers {
+    onColumnsChange: (data: ColumnChangeParam[]) => void;
+    onColumnsReset: () => void;
+}
+export type InfoSchema = {
+    label: string;
+    field: string;
+};
+export type InfoConfig = {
+    schemas?: InfoSchema[];
+    infoData?: Recordable;
+};

package/es/ui/src/ShyTable/src/types/tableAction.d.ts

@@ -0,0 +1,26 @@
+import { ButtonProps } from 'ant-design-vue/es/button/buttonTypes';
+import { TooltipProps } from 'ant-design-vue/es/tooltip/Tooltip';
+import { RoleEnum } from './table';
+export interface ActionItem extends Omit<ButtonProps, 'type'> {
+    onClick?: Fn;
+    label?: string;
+    color?: 'success' | 'error' | 'warning';
+    icon?: string;
+    popConfirm?: PopConfirm;
+    disabled?: boolean;
+    divider?: boolean;
+    auth?: RoleEnum | RoleEnum[] | string | string[];
+    ifShow?: boolean | ((action: ActionItem) => boolean);
+    tooltip?: string | TooltipProps;
+    type?: 'primary' | 'ghost' | 'dashed' | 'link' | 'text' | 'default' | 'danger' | 'waring' | 'success' | 'message';
+}
+interface PopConfirm {
+    title: string;
+    okText?: string;
+    cancelText?: string;
+    confirm: Fn;
+    cancel?: Fn;
+    icon?: string;
+    placement?: 'top' | 'left' | 'right' | 'bottom' | 'topLeft' | 'topRight' | 'leftTop' | 'leftBottom' | 'rightTop' | 'rightBottom' | 'bottomLeft' | 'bottomRight';
+}
+export {};

package/es/ui/src/ShyTag/index.d.ts

@@ -0,0 +1,3 @@
+import { ShyTag } from './src/ShyTag';
+export { shyTagBasicProps } from './src/props';
+export { ShyTag };

package/es/ui/src/ShyTag/src/ShyTag.d.ts

@@ -0,0 +1,85 @@
+declare const ShyTag: import("vue").DefineComponent<{
+    options: {
+        type: ((new (...args: any[]) => Recordable<any>[]) | (() => Recordable<any>[])) | ((new (...args: any[]) => Recordable<any>[]) | (() => Recordable<any>[]))[];
+        default: () => any[];
+    };
+    value: {
+        type: (NumberConstructor | StringConstructor)[];
+    };
+    isTag: {
+        type: BooleanConstructor;
+    };
+    tagMode: {
+        type: ((new (...args: any[]) => "text" | "tag" | "point") | (() => "text" | "tag" | "point")) | ((new (...args: any[]) => "text" | "tag" | "point") | (() => "text" | "tag" | "point"))[];
+        default: string;
+    };
+    fieldNames: {
+        type: ((new (...args: any[]) => Partial<{
+            label: string;
+            value: string;
+            color: string;
+            css: string;
+        }>) | (() => Partial<{
+            label: string;
+            value: string;
+            color: string;
+            css: string;
+        }>)) | ((new (...args: any[]) => Partial<{
+            label: string;
+            value: string;
+            color: string;
+            css: string;
+        }>) | (() => Partial<{
+            label: string;
+            value: string;
+            color: string;
+            css: string;
+        }>))[];
+        default: () => {};
+    };
+}, () => any, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    options: {
+        type: ((new (...args: any[]) => Recordable<any>[]) | (() => Recordable<any>[])) | ((new (...args: any[]) => Recordable<any>[]) | (() => Recordable<any>[]))[];
+        default: () => any[];
+    };
+    value: {
+        type: (NumberConstructor | StringConstructor)[];
+    };
+    isTag: {
+        type: BooleanConstructor;
+    };
+    tagMode: {
+        type: ((new (...args: any[]) => "text" | "tag" | "point") | (() => "text" | "tag" | "point")) | ((new (...args: any[]) => "text" | "tag" | "point") | (() => "text" | "tag" | "point"))[];
+        default: string;
+    };
+    fieldNames: {
+        type: ((new (...args: any[]) => Partial<{
+            label: string;
+            value: string;
+            color: string;
+            css: string;
+        }>) | (() => Partial<{
+            label: string;
+            value: string;
+            color: string;
+            css: string;
+        }>)) | ((new (...args: any[]) => Partial<{
+            label: string;
+            value: string;
+            color: string;
+            css: string;
+        }>) | (() => Partial<{
+            label: string;
+            value: string;
+            color: string;
+            css: string;
+        }>))[];
+        default: () => {};
+    };
+}>>, {
+    options: Recordable<any>[];
+    fieldNames: {};
+    isTag: boolean;
+    tagMode: "text" | "tag" | "point";
+}, {}>;
+export { ShyTag };

package/es/ui/src/ShyTag/src/props.d.ts

@@ -0,0 +1,40 @@
+export declare const shyTagBasicProps: {
+    options: {
+        type: ((new (...args: any[]) => Recordable<any>[]) | (() => Recordable<any>[])) | ((new (...args: any[]) => Recordable<any>[]) | (() => Recordable<any>[]))[];
+        default: () => any[];
+    };
+    value: {
+        type: (NumberConstructor | StringConstructor)[];
+    };
+    isTag: {
+        type: BooleanConstructor;
+    };
+    tagMode: {
+        type: ((new (...args: any[]) => "text" | "tag" | "point") | (() => "text" | "tag" | "point")) | ((new (...args: any[]) => "text" | "tag" | "point") | (() => "text" | "tag" | "point"))[];
+        default: string;
+    };
+    fieldNames: {
+        type: ((new (...args: any[]) => Partial<{
+            label: string;
+            value: string;
+            color: string;
+            css: string;
+        }>) | (() => Partial<{
+            label: string;
+            value: string;
+            color: string;
+            css: string;
+        }>)) | ((new (...args: any[]) => Partial<{
+            label: string;
+            value: string;
+            color: string;
+            css: string;
+        }>) | (() => Partial<{
+            label: string;
+            value: string;
+            color: string;
+            css: string;
+        }>))[];
+        default: () => {};
+    };
+};

package/es/ui/src/StrengthMeter/index.d.ts

@@ -0,0 +1,2 @@
+import StrengthMeter from './src/StrengthMeter.vue';
+export { StrengthMeter };

package/es/ui/src/StrengthMeter/src/StrengthMeter.vue.d.ts

@@ -0,0 +1,35 @@
+declare const _sfc_main: import("vue").DefineComponent<{
+    value: {
+        type: StringConstructor;
+    };
+    showInput: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+    };
+}, {
+    getPasswordStrength: import("vue").ComputedRef<-1 | import("@zxcvbn-ts/core/dist/types").Score>;
+    handleChange: (e: ChangeEvent) => void;
+    prefixCls: string;
+    innerValueRef: import("vue").Ref<string>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "score-change")[], "change" | "score-change", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+    };
+    showInput: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+    };
+}>> & {
+    onChange?: (...args: any[]) => any;
+    "onScore-change"?: (...args: any[]) => any;
+}, {
+    disabled: boolean;
+    showInput: boolean;
+}, {}>;
+export default _sfc_main;

package/es/ui/src/TablePlus/TableColGroup.vue.d.ts

@@ -0,0 +1,52 @@
+declare const _sfc_main: import("vue").DefineComponent<{
+    column: {
+        type: any;
+        required: false;
+    };
+}, {
+    emits: (event: "handleSortChange", ...args: any[]) => void;
+    getSwitchShowText: (column: any, row: any) => any;
+    handleSortChange: (field: any, type: any) => void;
+    filterColumn: (column: any) => any;
+    readonly VxeColumn: import("vxe-table").VXEComponent<import("vxe-table").VxeColumnProps<any>, import("vxe-table").VxeColumnEventProps, import("vxe-table").VxeColumnSlots<any>>;
+    readonly VxeColgroup: import("vxe-table").VXEComponent<import("vxe-table").VxeColgroupProps, import("vxe-table").VxeColgroupEventProps, import("vxe-table").VxeColgroupSlots<any>>;
+    readonly CellComponent: import("vue").FunctionalComponent<{}, {}, any, {}>;
+    IconSort: import("vue").DefineComponent<{}, {
+        basStyle: {
+            display: string;
+            color: string;
+            fontSize: string;
+        };
+        emits: (event: "change", ...args: any[]) => void;
+        curPicker: import("vue").Ref<number>;
+        handleUpClick: () => void;
+        handleDownClick: () => void;
+        getStyleUp: import("vue").ComputedRef<{
+            transform: string;
+            color: string;
+            display: string;
+            fontSize: string;
+        }>;
+        getStyleDown: import("vue").ComputedRef<{
+            transform: string;
+            color: string;
+            display: string;
+            fontSize: string;
+        }>;
+        readonly CaretUpOutlined: import("@ant-design/icons-vue/lib/icons/CaretUpOutlined").CaretUpOutlinedIconType;
+        readonly CaretDownOutlined: import("@ant-design/icons-vue/lib/icons/CaretDownOutlined").CaretDownOutlinedIconType;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "change"[], "change", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>> & {
+        onChange?: (...args: any[]) => any;
+    }, {}, {}>;
+    readonly BasicHelp: any;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "handleSortChange"[], "handleSortChange", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    column: {
+        type: any;
+        required: false;
+    };
+}>> & {
+    onHandleSortChange?: (...args: any[]) => any;
+}, {
+    column: any;
+}, {}>;
+export default _sfc_main;