amis 2.0.0-rc.9 → 2.0.0

package/esm/renderers/Table-v2/ColumnToggler.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import { ColumnTogglerProps } from '../Table/ColumnToggler';
+import { BaseSchema } from '../../Schema';
+export interface ColumnTogglerSchema extends BaseSchema {
+    label?: string;
+    tooltip?: string;
+    size?: string;
+    icon?: string;
+    draggable?: boolean;
+    align?: string;
+}
+export interface ColumnTogglerRendererProps extends ColumnTogglerProps {
+    toggleAllColumns?: Function;
+    toggleToggle?: Function;
+    cols: Array<any>;
+}
+export declare class ColumnTogglerRenderer extends React.Component<ColumnTogglerRendererProps> {
+    render(): JSX.Element | null;
+}

package/esm/renderers/Table-v2/ColumnToggler.js

@@ -0,0 +1,88 @@
+/**
+ * amis v2.0.0
+ * Copyright 2018-2022 baidu
+ */
+
+import { __extends, __rest, __assign, __awaiter, __generator, __decorate } from 'tslib';
+import React from 'react';
+import { isVisible, createObject, Renderer } from 'amis-core';
+import { Checkbox } from 'amis-ui';
+import ColumnToggler from '../Table/ColumnToggler.js';
+
+/** @class */ ((function (_super) {
+    __extends(ColumnTogglerRenderer, _super);
+    function ColumnTogglerRenderer() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ColumnTogglerRenderer.prototype.render = function () {
+        var _this = this;
+        var _a = this.props; _a.className; _a.store; var render = _a.render, ns = _a.classPrefix, cx = _a.classnames, tooltip = _a.tooltip, align = _a.align, cols = _a.cols, toggleAllColumns = _a.toggleAllColumns, toggleToggle = _a.toggleToggle, data = _a.data, rest = __rest(_a, ["className", "store", "render", "classPrefix", "classnames", "tooltip", "align", "cols", "toggleAllColumns", "toggleToggle", "data"]);
+        var __ = rest.translate;
+        var env = rest.env;
+        if (!cols) {
+            return null;
+        }
+        var toggableColumns = cols.filter(function (item) { return isVisible(item.pristine || item, data) && item.toggable !== false; });
+        var activeToggaleColumns = toggableColumns.filter(function (item) { return item.toggled !== false; });
+        return (React.createElement(ColumnToggler, __assign({}, rest, { render: render, tooltip: tooltip || __('Table.columnsVisibility'), tooltipContainer: env && env.getModalContainer ? env.getModalContainer : undefined, isActived: cols.findIndex(function (column) { return !column.toggled; }) !== -1, align: align !== null && align !== void 0 ? align : 'right', classnames: cx, classPrefix: ns, key: "columns-toggable", columns: cols, activeToggaleColumns: activeToggaleColumns, data: data }),
+            (toggableColumns === null || toggableColumns === void 0 ? void 0 : toggableColumns.length) ? (React.createElement("li", { className: cx('ColumnToggler-menuItem'), key: 'selectAll', onClick: function () { return __awaiter(_this, void 0, void 0, function () {
+                    var _a, data, dispatchEvent, allToggled, rendererEvent;
+                    return __generator(this, function (_b) {
+                        switch (_b.label) {
+                            case 0:
+                                _a = this.props, data = _a.data, dispatchEvent = _a.dispatchEvent;
+                                allToggled = !((activeToggaleColumns === null || activeToggaleColumns === void 0 ? void 0 : activeToggaleColumns.length) ===
+                                    (toggableColumns === null || toggableColumns === void 0 ? void 0 : toggableColumns.length));
+                                return [4 /*yield*/, dispatchEvent('columnToggled', createObject(data, {
+                                        columns: allToggled
+                                            ? toggableColumns === null || toggableColumns === void 0 ? void 0 : toggableColumns.map(function (column) { return column; })
+                                            : []
+                                    }))];
+                            case 1:
+                                rendererEvent = _b.sent();
+                                if (rendererEvent === null || rendererEvent === void 0 ? void 0 : rendererEvent.prevented) {
+                                    return [2 /*return*/];
+                                }
+                                toggleAllColumns && toggleAllColumns(allToggled);
+                                return [2 /*return*/];
+                        }
+                    });
+                }); } },
+                React.createElement(Checkbox, { size: "sm", classPrefix: ns, key: "checkall", checked: !!(activeToggaleColumns === null || activeToggaleColumns === void 0 ? void 0 : activeToggaleColumns.length), partial: !!((activeToggaleColumns === null || activeToggaleColumns === void 0 ? void 0 : activeToggaleColumns.length) &&
+                        (activeToggaleColumns === null || activeToggaleColumns === void 0 ? void 0 : activeToggaleColumns.length) !== (toggableColumns === null || toggableColumns === void 0 ? void 0 : toggableColumns.length)) }, __('Checkboxes.selectAll')))) : null, toggableColumns === null || toggableColumns === void 0 ? void 0 :
+            toggableColumns.map(function (column, index) { return (React.createElement("li", { className: cx('ColumnToggler-menuItem'), key: 'item' + (column.index || index), onClick: function () { return __awaiter(_this, void 0, void 0, function () {
+                    var _a, data, dispatchEvent, columns, rendererEvent;
+                    return __generator(this, function (_b) {
+                        switch (_b.label) {
+                            case 0:
+                                _a = this.props, data = _a.data, dispatchEvent = _a.dispatchEvent;
+                                columns = activeToggaleColumns.map(function (item) { return item; });
+                                if (column.toggled !== false) {
+                                    columns.push(column);
+                                }
+                                else {
+                                    columns = columns.filter(function (c) { return c.key !== column.key; });
+                                }
+                                return [4 /*yield*/, dispatchEvent('columnToggled', createObject(data, {
+                                        columns: columns
+                                    }))];
+                            case 1:
+                                rendererEvent = _b.sent();
+                                if (rendererEvent === null || rendererEvent === void 0 ? void 0 : rendererEvent.prevented) {
+                                    return [2 /*return*/];
+                                }
+                                toggleToggle && toggleToggle(!(column.toggled !== false), index);
+                                return [2 /*return*/];
+                        }
+                    });
+                }); } },
+                React.createElement(Checkbox, { size: "sm", classPrefix: ns, checked: column.toggled !== false }, column.title ? render('tpl', column.title) : null))); })));
+    };
+    ColumnTogglerRenderer = __decorate([
+        Renderer({
+            type: 'column-toggler',
+            name: 'column-toggler'
+        })
+    ], ColumnTogglerRenderer);
+    return ColumnTogglerRenderer;
+})(React.Component));

package/esm/renderers/Table-v2/HeadCellSearchDropdown.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+import { RendererProps } from 'amis-core';
+import { ActionObject } from 'amis-core';
+import { ITableStoreV2 } from 'amis-core';
+export interface QuickSearchConfig {
+    type?: string;
+    controls?: any;
+    tabs?: any;
+    fieldSet?: any;
+    [propName: string]: any;
+}
+export interface HeadCellSearchProps extends RendererProps {
+    name: string;
+    searchable: boolean | QuickSearchConfig;
+    classPrefix: string;
+    onSearch?: (values: object) => void;
+    onAction?: Function;
+    store: ITableStoreV2;
+}
+export declare class HeadCellSearchDropDown extends React.Component<HeadCellSearchProps, any> {
+    formItems: Array<string>;
+    constructor(props: HeadCellSearchProps);
+    buildSchema(): any;
+    handleAction(e: any, action: ActionObject, ctx: object, confirm: Function): Promise<void>;
+    handleReset(): Promise<void>;
+    handleSubmit(values: any, confirm: Function): Promise<void>;
+    isActive(): any;
+    render(): JSX.Element;
+}

package/esm/renderers/Table-v2/HeadCellSearchDropdown.js

@@ -0,0 +1,206 @@
+/**
+ * amis v2.0.0
+ * Copyright 2018-2022 baidu
+ */
+
+import { __extends, __assign, __awaiter, __generator } from 'tslib';
+import React from 'react';
+import { findDOMNode } from 'react-dom';
+import { HeadCellDropDown, Icon } from 'amis-ui';
+import { setVariable, createObject } from 'amis-core';
+
+var HeadCellSearchDropDown = /** @class */ (function (_super) {
+    __extends(HeadCellSearchDropDown, _super);
+    function HeadCellSearchDropDown(props) {
+        var _this = _super.call(this, props) || this;
+        _this.formItems = [];
+        _this.handleSubmit = _this.handleSubmit.bind(_this);
+        _this.handleAction = _this.handleAction.bind(_this);
+        return _this;
+    }
+    HeadCellSearchDropDown.prototype.buildSchema = function () {
+        var _a;
+        var _b = this.props, searchable = _b.searchable, sortable = _b.sortable, name = _b.name, label = _b.label, __ = _b.translate;
+        var schema;
+        if (searchable === true) {
+            schema = {
+                title: '',
+                controls: [
+                    {
+                        type: 'text',
+                        name: name,
+                        placeholder: label,
+                        clearable: true
+                    }
+                ]
+            };
+        }
+        else if (searchable) {
+            if (searchable.controls || searchable.tabs || searchable.fieldSet) {
+                schema = __assign(__assign({ title: '' }, searchable), { controls: Array.isArray(searchable.controls)
+                        ? searchable.controls.concat()
+                        : undefined });
+            }
+            else {
+                schema = {
+                    title: '',
+                    className: searchable.formClassName,
+                    controls: [
+                        __assign({ type: searchable.type || 'text', name: searchable.name || name, placeholder: label }, searchable)
+                    ]
+                };
+            }
+        }
+        if (schema && schema.controls && sortable) {
+            schema.controls.unshift({
+                type: 'hidden',
+                name: 'orderBy',
+                value: name
+            }, {
+                type: 'button-group',
+                name: 'order',
+                label: __('sort'),
+                options: [
+                    {
+                        label: __('asc'),
+                        value: 'asc'
+                    },
+                    {
+                        label: __('desc'),
+                        value: 'desc'
+                    }
+                ]
+            });
+        }
+        if (schema) {
+            var formItems_1 = [];
+            (_a = schema.controls) === null || _a === void 0 ? void 0 : _a.forEach(function (item) {
+                return item.name &&
+                    item.name !== 'orderBy' &&
+                    item.name !== 'order' &&
+                    formItems_1.push(item.name);
+            });
+            this.formItems = formItems_1;
+            schema = __assign(__assign({}, schema), { type: 'form', wrapperComponent: 'div', actions: [
+                    {
+                        type: 'button',
+                        label: __('reset'),
+                        actionType: 'clear-and-submit'
+                    },
+                    {
+                        type: 'button',
+                        label: __('cancel'),
+                        actionType: 'cancel'
+                    },
+                    {
+                        label: __('search'),
+                        type: 'submit',
+                        primary: true
+                    }
+                ] });
+        }
+        return schema || 'error';
+    };
+    HeadCellSearchDropDown.prototype.handleAction = function (e, action, ctx, confirm) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, onAction, data, dispatchEvent, name, values, rendererEvent;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this.props, onAction = _a.onAction, data = _a.data, dispatchEvent = _a.dispatchEvent, name = _a.name;
+                        if (action.actionType === 'cancel' || action.actionType === 'close') {
+                            confirm();
+                            return [2 /*return*/];
+                        }
+                        if (action.actionType === 'reset') {
+                            confirm();
+                            this.handleReset();
+                            return [2 /*return*/];
+                        }
+                        values = __assign({}, data);
+                        this.formItems.forEach(function (key) { return setVariable(values, key, undefined); });
+                        return [4 /*yield*/, dispatchEvent('columnSearch', createObject(data, {
+                                searchName: name,
+                                searchValue: values
+                            }))];
+                    case 1:
+                        rendererEvent = _b.sent();
+                        if (rendererEvent === null || rendererEvent === void 0 ? void 0 : rendererEvent.prevented) {
+                            return [2 /*return*/];
+                        }
+                        onAction && onAction(e, action, ctx);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    HeadCellSearchDropDown.prototype.handleReset = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, onSearch, data, name, store, values;
+            return __generator(this, function (_b) {
+                _a = this.props, onSearch = _a.onSearch, data = _a.data, name = _a.name, store = _a.store;
+                values = __assign({}, data);
+                this.formItems.forEach(function (key) { return setVariable(values, key, undefined); });
+                if (values.orderBy === name) {
+                    values.orderBy = '';
+                    values.order = 'asc';
+                }
+                store.updateQuery(values);
+                onSearch && onSearch(values);
+                return [2 /*return*/];
+            });
+        });
+    };
+    HeadCellSearchDropDown.prototype.handleSubmit = function (values, confirm) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, onSearch, name, store, dispatchEvent, data, rendererEvent;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this.props, onSearch = _a.onSearch, name = _a.name, store = _a.store, dispatchEvent = _a.dispatchEvent, data = _a.data;
+                        if (values.order) {
+                            values = __assign(__assign({}, values), { orderBy: name });
+                        }
+                        return [4 /*yield*/, dispatchEvent('columnSearch', createObject(data, {
+                                searchName: name,
+                                searchValue: values
+                            }))];
+                    case 1:
+                        rendererEvent = _b.sent();
+                        if (rendererEvent === null || rendererEvent === void 0 ? void 0 : rendererEvent.prevented) {
+                            return [2 /*return*/];
+                        }
+                        store.updateQuery(values);
+                        onSearch && onSearch(values);
+                        confirm();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    HeadCellSearchDropDown.prototype.isActive = function () {
+        var _a = this.props, data = _a.data, name = _a.name, orderBy = _a.orderBy;
+        return ((orderBy && orderBy === name) || this.formItems.some(function (key) { return data === null || data === void 0 ? void 0 : data[key]; }));
+    };
+    HeadCellSearchDropDown.prototype.render = function () {
+        var _this = this;
+        var _a = this.props, render = _a.render, name = _a.name, data = _a.data, searchable = _a.searchable, store = _a.store, orderBy = _a.orderBy, popOverContainer = _a.popOverContainer, ns = _a.classPrefix, cx = _a.classnames;
+        var formSchema = this.buildSchema();
+        var isActive = this.isActive();
+        return (React.createElement(HeadCellDropDown, { className: "".concat(ns, "TableCell-searchBtn"), layerClassName: cx("".concat(ns, "TableCell-searchPopOver"), searchable.className), active: isActive, filterIcon: React.createElement(Icon, { icon: "search", className: "icon" }), popOverContainer: popOverContainer ? popOverContainer : function () { return findDOMNode(_this); }, filterDropdown: function (_a) {
+                _a.setSelectedKeys; _a.selectedKeys; var confirm = _a.confirm; _a.clearFilters;
+                return render('quick-search-form', formSchema, {
+                    data: __assign(__assign({}, data), { orderBy: orderBy, order: orderBy && orderBy === name
+                            ? store.order
+                            : '' }),
+                    onSubmit: function (values) { return _this.handleSubmit(values, confirm); },
+                    onAction: function (e, action, ctx) {
+                        _this.handleAction(e, action, ctx, confirm);
+                    }
+                });
+            } }));
+    };
+    return HeadCellSearchDropDown;
+}(React.Component));
+
+export { HeadCellSearchDropDown };

package/esm/renderers/Table-v2/TableCell.d.ts

@@ -0,0 +1,6 @@
+import { TableCell } from '../Table';
+export declare class CellFieldRenderer extends TableCell {
+    static defaultProps: {
+        wrapperComponent: string;
+    };
+}

package/esm/renderers/Table-v2/TableCell.js

@@ -0,0 +1,30 @@
+/**
+ * amis v2.0.0
+ * Copyright 2018-2022 baidu
+ */
+
+import { __extends, __assign, __decorate } from 'tslib';
+import { Renderer } from 'amis-core';
+import '../Table/index.js';
+import { HocQuickEdit } from '../QuickEdit.js';
+import { HocCopyable } from '../Copyable.js';
+import { HocPopOver } from '../PopOver.js';
+import { TableCell } from '../Table/TableCell.js';
+
+/** @class */ ((function (_super) {
+    __extends(CellFieldRenderer, _super);
+    function CellFieldRenderer() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CellFieldRenderer.defaultProps = __assign(__assign({}, TableCell.defaultProps), { wrapperComponent: 'div' });
+    CellFieldRenderer = __decorate([
+        Renderer({
+            type: 'cell-field',
+            name: 'cell-field'
+        }),
+        HocPopOver(),
+        HocCopyable(),
+        HocQuickEdit()
+    ], CellFieldRenderer);
+    return CellFieldRenderer;
+})(TableCell));

package/esm/renderers/Table-v2/index.d.ts

@@ -0,0 +1,285 @@
+import React from 'react';
+import { IScopedContext } from 'amis-core';
+import { RendererProps } from 'amis-core';
+import { ActionObject } from 'amis-core';
+import { BaseSchema, SchemaObject, SchemaTokenizeableString } from '../../Schema';
+import { BadgeObject } from 'amis-ui';
+import { ITableStoreV2, IRowV2 } from 'amis-core';
+import './TableCell';
+import './ColumnToggler';
+import type { SortProps } from 'amis-ui/lib/components/table';
+import { Action } from '../../types';
+/**
+ * Table 表格v2渲染器。
+ * 文档：https://baidu.gitee.io/amis/docs/components/table-v2
+ */
+export interface CellSpan {
+    colIndex: number;
+    rowIndex: number;
+    colSpan?: number;
+    rowSpan?: number;
+}
+export interface RenderProps {
+    colSpan?: number;
+    rowSpan?: number;
+}
+export interface ColumnSchema {
+    /**
+     * 指定列唯一标识
+     */
+    key: string;
+    /**
+     * 指定列标题
+     */
+    title: string | SchemaObject;
+    /**
+     * 指定列内容渲染器
+     */
+    type?: string;
+    /**
+     * 指定行合并表达式
+     */
+    rowSpanExpr?: string;
+    /**
+     * 指定列合并表达式
+     */
+    colSpanExpr?: string;
+    /**
+     * 表头分组
+     */
+    children?: Array<ColumnSchema>;
+    /**
+     * 可复制
+     */
+    copyable?: boolean;
+    /**
+     * 列表头提示
+     */
+    remark?: string;
+    /**
+     * 快速搜索
+     */
+    searchable?: boolean | SchemaObject;
+    /**
+     * 快速排序
+     */
+    sorter?: boolean;
+    /**
+     * 内容居左、居中、居右
+     */
+    align?: string;
+    /**
+     * 是否固定在左侧/右侧
+     */
+    fixed?: boolean | string;
+    /**
+     * 当前列是否展示
+     */
+    toggled?: boolean;
+    /**
+     * 列样式
+     */
+    className?: string;
+    /**
+     * 表头单元格样式
+     */
+    titleClassName?: string;
+    /**
+     * 单元格样式
+     */
+    classNameExpr?: string;
+}
+export interface RowSelectionOptionsSchema {
+    /**
+     * 选择类型 选择全部
+     */
+    key: string;
+    /**
+     * 选项显示文本
+     */
+    text: string;
+}
+export interface RowSelectionSchema {
+    /**
+     * 选择类型 单选/多选
+     */
+    type: string;
+    /**
+     * 对应数据源的key值
+     */
+    keyField?: string;
+    /**
+     * 行是否禁用表达式
+     */
+    disableOn?: string;
+    /**
+     * 自定义选择菜单
+     */
+    selections?: Array<RowSelectionOptionsSchema>;
+    /**
+     * 已选择的key值
+     */
+    selectedRowKeys?: Array<string | number>;
+    /**
+     * 已选择的key值表达式
+     */
+    selectedRowKeysExpr?: string;
+    /**
+     * 已选择的key值表达式
+     */
+    columnWidth?: number;
+    /**
+     * 是否点击行触发选中或取消选中
+     */
+    rowClick?: boolean;
+}
+export interface ExpandableSchema {
+    /**
+     * 对应渲染器类型
+     */
+    type: string;
+    /**
+     * 对应数据源的key值
+     */
+    keyField: string;
+    /**
+     * 行是否可展开表达式
+     */
+    expandableOn: string;
+    /**
+     * 展开行自定义样式表达式
+     */
+    expandedRowClassNameExpr: string;
+    /**
+     * 已展开的key值
+     */
+    expandedRowKeys: Array<string | number>;
+    /**
+     * 已展开的key值表达式
+     */
+    expandedRowKeysExpr: string;
+}
+export interface TableSchemaV2 extends BaseSchema {
+    /**
+     * 指定为表格类型
+     */
+    type: 'table-v2';
+    /**
+     * 表格标题
+     */
+    title?: string | SchemaObject | Array<SchemaObject>;
+    /**
+     * 表格数据源
+     */
+    source: SchemaTokenizeableString;
+    /**
+     * 表格可自定义列
+     */
+    columnsTogglable?: boolean | string | SchemaObject;
+    /**
+     * 表格列配置
+     */
+    columns: Array<ColumnSchema>;
+    /**
+     * 表格可选择配置
+     */
+    rowSelection?: RowSelectionSchema;
+    /**
+     * 表格行可展开配置
+     */
+    expandable?: ExpandableSchema;
+    /**
+     * 粘性头部
+     */
+    sticky?: boolean;
+    /**
+     * 加载中
+     */
+    loading?: boolean | string | SchemaObject;
+    /**
+     * 行角标
+     */
+    itemBadge?: BadgeObject;
+    /**
+     * 指定挂载dom
+     */
+    popOverContainer?: any;
+    /**
+     * 嵌套展开记录的唯一标识
+     */
+    keyField?: string;
+    /**
+     * 数据源嵌套自定义字段名
+     */
+    childrenColumnName?: string;
+    /**
+     * 自定义行样式
+     */
+    rowClassNameExpr?: string;
+    /**
+     * 是否固定内容行高度
+     */
+    lineHeight?: string;
+    /**
+     * 是否展示边框
+     */
+    bordered?: boolean;
+    /**
+     * 是否展示表头
+     */
+    showHeader?: boolean;
+    /**
+     * 自定义表格样式
+     */
+    className?: string;
+    /**
+     * 指定表尾
+     */
+    footer?: string | SchemaObject | Array<SchemaObject>;
+}
+export declare type TableV2RendererEvent = 'selected' | 'columnSort' | 'columnFilter' | 'columnSearch' | 'columnToggled' | 'dragOver';
+export declare type TableV2RendererAction = 'selectAll' | 'clearAll' | 'select';
+export interface TableV2Props extends RendererProps {
+    title?: string;
+    source?: string;
+    store: ITableStoreV2;
+    togglable: boolean;
+}
+export default class TableV2 extends React.Component<TableV2Props, object> {
+    static contextType: React.Context<IScopedContext>;
+    renderedToolbars: Array<string>;
+    control: any;
+    constructor(props: TableV2Props, context: IScopedContext);
+    componentWillUnmount(): void;
+    controlRef(control: any): void;
+    syncSelected(): void;
+    static syncRows(store: ITableStoreV2, props: TableV2Props, prevProps?: TableV2Props): boolean;
+    componentDidUpdate(prevProps: TableV2Props): void;
+    getPopOverContainer(): Element | Text | null;
+    renderCellSchema(schema: any, props: any): any;
+    renderSchema(key: string, schema: any, props?: any): any;
+    buildColumns(columns: Array<any>): any[];
+    buildSummary(key: string, summary: Array<any>): any[] | null;
+    reloadTarget(target: string, data: any): void;
+    handleSave(rows: Array<object> | object, diff: Array<object> | object, indexes: Array<string>, unModifiedItems?: Array<any>, rowsOrigin?: Array<object> | object, resetOnFailed?: boolean): void;
+    handleQuickChange(item: IRowV2, values: object, saveImmediately?: boolean | any, savePristine?: boolean, resetOnFailed?: boolean): void;
+    handleAction(e: React.UIEvent<any>, action: Action, ctx: object): void;
+    renderActions(region: string): JSX.Element | null;
+    handleSelected(selectedRows: Array<any>, selectedRowKeys: Array<string | number>, unSelectedRows: Array<string | number>): Promise<any>;
+    handleSort(payload: SortProps): Promise<any>;
+    handleFilter(payload: {
+        filterName: string;
+        filterValue: string;
+    }): Promise<any>;
+    handleRowClick(event: React.ChangeEvent<any>, rowItem: any, rowIndex?: number): Promise<any>;
+    handleOrderChange(oldIndex: number, newIndex: number, levels: Array<string>): Promise<void>;
+    handleSaveOrder(): Promise<void>;
+    reset(): void;
+    doAction(action: ActionObject, args: any, throwErrors: boolean): any;
+    renderTable(): JSX.Element | null;
+    renderHeading(): JSX.Element | null;
+    render(): JSX.Element;
+}
+export declare class TableRenderer extends TableV2 {
+    receive(values: any, subPath?: string): void;
+}