amis 2.0.0-rc.9 → 2.0.0

package/esm/renderers/Form/ButtonToolbar.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+import { BaseSchema } from '../../Schema';
+import { ActionSchema } from '../Action';
+import { FormControlProps } from 'amis-core';
+/**
+ * Button Toolar 渲染器。
+ * 文档：https://baidu.gitee.io/amis/docs/components/button-toolbar
+ */
+export interface ButtonToolbarSchema extends BaseSchema {
+    /**
+     * 指定为按钮工具集合类型
+     */
+    type: 'button-toolbar';
+    buttons: Array<ActionSchema>;
+}
+export interface ButtonToolbarProps extends FormControlProps, Omit<ButtonToolbarSchema, 'className'> {
+}
+export default class ButtonToolbar extends React.Component<ButtonToolbarProps, object> {
+    static propsList: Array<string>;
+    /**
+     * 这个方法editor里要用作hack，所以不能删掉这个方法
+     * @returns
+     */
+    renderButtons(): JSX.Element[] | null;
+    render(): JSX.Element;
+}
+export declare class ButtonToolbarRenderer extends ButtonToolbar {
+}

package/esm/renderers/Form/ButtonToolbar.js

@@ -0,0 +1,50 @@
+/**
+ * amis v2.0.0
+ * Copyright 2018-2022 baidu
+ */
+
+import { __extends, __decorate } from 'tslib';
+import React from 'react';
+import { FormItem } from 'amis-core';
+
+var ButtonToolbar = /** @class */ (function (_super) {
+    __extends(ButtonToolbar, _super);
+    function ButtonToolbar() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /**
+     * 这个方法editor里要用作hack，所以不能删掉这个方法
+     * @returns
+     */
+    ButtonToolbar.prototype.renderButtons = function () {
+        var _a = this.props, render = _a.render; _a.classPrefix; var buttons = _a.buttons;
+        return Array.isArray(buttons)
+            ? buttons.map(function (button, key) {
+                return render("button/".concat(key), button, {
+                    key: key
+                });
+            })
+            : null;
+    };
+    ButtonToolbar.prototype.render = function () {
+        var _a = this.props; _a.buttons; var className = _a.className, cx = _a.classnames; _a.render;
+        return (React.createElement("div", { className: cx('ButtonToolbar', className) }, this.renderButtons()));
+    };
+    ButtonToolbar.propsList = ['buttons', 'className'];
+    return ButtonToolbar;
+}(React.Component));
+/** @class */ ((function (_super) {
+    __extends(ButtonToolbarRenderer, _super);
+    function ButtonToolbarRenderer() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ButtonToolbarRenderer = __decorate([
+        FormItem({
+            type: 'button-toolbar',
+            strictMode: false
+        })
+    ], ButtonToolbarRenderer);
+    return ButtonToolbarRenderer;
+})(ButtonToolbar));
+
+export { ButtonToolbar as default };

package/esm/renderers/Form/ChainedSelect.d.ts

@@ -0,0 +1,36 @@
+import React from 'react';
+import { OptionsControlProps, Option } from 'amis-core';
+import { ActionObject } from 'amis-core';
+import { FormOptionsSchema } from '../../Schema';
+/**
+ * 级联选择框
+ * 文档：https://baidu.gitee.io/amis/docs/components/form/chained-select
+ */
+export interface ChainedSelectControlSchema extends FormOptionsSchema {
+    type: 'chained-select';
+}
+export interface ChainedSelectProps extends OptionsControlProps, Omit<ChainedSelectControlSchema, 'options' | 'type' | 'source' | 'className' | 'descriptionClassName' | 'inputClassName'> {
+}
+export interface SelectState {
+    stack: Array<{
+        options: Array<Option>;
+        parentId: any;
+        loading: boolean;
+        visible?: boolean;
+    }>;
+}
+export default class ChainedSelectControl extends React.Component<ChainedSelectProps, SelectState> {
+    static defaultProps: Partial<ChainedSelectProps>;
+    state: SelectState;
+    constructor(props: ChainedSelectProps);
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: ChainedSelectProps): void;
+    doAction(action: ActionObject, data: object, throwErrors: boolean): void;
+    array2value(arr: Array<any>, isExtracted?: boolean): string | any[];
+    loadMore(): void;
+    handleChange(index: number, currentValue: any): Promise<void>;
+    reload(): void;
+    render(): JSX.Element;
+}
+export declare class ChainedSelectControlRenderer extends ChainedSelectControl {
+}

package/esm/renderers/Form/ChainedSelect.js

@@ -0,0 +1,213 @@
+/**
+ * amis v2.0.0
+ * Copyright 2018-2022 baidu
+ */
+
+import { __extends, __assign, __awaiter, __generator, __rest, __decorate } from 'tslib';
+import React from 'react';
+import cx from 'classnames';
+import { isEffectiveApi, createObject, isMobile, OptionsControl } from 'amis-core';
+import { Select } from 'amis-ui';
+
+var ChainedSelectControl = /** @class */ (function (_super) {
+    __extends(ChainedSelectControl, _super);
+    function ChainedSelectControl(props) {
+        var _this = _super.call(this, props) || this;
+        _this.state = {
+            stack: []
+        };
+        _this.handleChange = _this.handleChange.bind(_this);
+        _this.loadMore = _this.loadMore.bind(_this);
+        return _this;
+    }
+    ChainedSelectControl.prototype.componentDidMount = function () {
+        var _a, _b;
+        var formInited = this.props.formInited;
+        formInited || !this.props.addHook
+            ? this.loadMore()
+            : (_b = (_a = this.props).addHook) === null || _b === void 0 ? void 0 : _b.call(_a, this.loadMore, 'init');
+    };
+    ChainedSelectControl.prototype.componentDidUpdate = function (prevProps) {
+        var props = this.props;
+        if (prevProps.options !== props.options) {
+            this.setState({
+                stack: []
+            });
+        }
+        else if (props.formInited && props.value !== prevProps.value) {
+            this.loadMore();
+        }
+    };
+    ChainedSelectControl.prototype.doAction = function (action, data, throwErrors) {
+        var _a = this.props, resetValue = _a.resetValue, onChange = _a.onChange;
+        var actionType = action === null || action === void 0 ? void 0 : action.actionType;
+        if (actionType === 'clear') {
+            onChange('');
+        }
+        else if (actionType === 'reset') {
+            onChange(resetValue !== null && resetValue !== void 0 ? resetValue : '');
+        }
+    };
+    ChainedSelectControl.prototype.array2value = function (arr, isExtracted) {
+        if (isExtracted === void 0) { isExtracted = false; }
+        var _a = this.props, delimiter = _a.delimiter, joinValues = _a.joinValues, extractValue = _a.extractValue;
+        // 判断arr的项是否已抽取
+        return isExtracted
+            ? joinValues
+                ? arr.join(delimiter || ',')
+                : arr
+            : joinValues
+                ? arr.join(delimiter || ',')
+                : extractValue
+                    ? arr.map(function (item) { return item.value || item; })
+                    : arr;
+    };
+    ChainedSelectControl.prototype.loadMore = function () {
+        var _this = this;
+        var _a = this.props, value = _a.value, delimiter = _a.delimiter, onChange = _a.onChange, joinValues = _a.joinValues, extractValue = _a.extractValue, source = _a.source, data = _a.data, env = _a.env, dispatchEvent = _a.dispatchEvent;
+        var arr = Array.isArray(value)
+            ? value.concat()
+            : value && typeof value === 'string'
+                ? value.split(delimiter || ',')
+                : [];
+        var idx = 0;
+        var len = this.state.stack.length;
+        while (idx < len &&
+            arr[idx] &&
+            this.state.stack[idx].parentId ==
+                (joinValues || extractValue ? arr[idx] : arr[idx].value)) {
+            idx++;
+        }
+        if (!arr[idx] || !env || !isEffectiveApi(source, data)) {
+            return;
+        }
+        var parentId = joinValues || extractValue ? arr[idx] : arr[idx].value;
+        var stack = this.state.stack.concat();
+        stack.splice(idx, stack.length - idx);
+        stack.push({
+            parentId: parentId,
+            loading: true,
+            options: []
+        });
+        this.setState({
+            stack: stack
+        }, function () {
+            env
+                .fetcher(source, __assign(__assign({}, data), { value: arr, level: idx + 1, parentId: parentId, parent: arr[idx] }))
+                .then(function (ret) { return __awaiter(_this, void 0, void 0, function () {
+                var stack, remoteValue, options, valueRes, rendererEvent;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            stack = this.state.stack.concat();
+                            remoteValue = ret.data ? ret.data.value : undefined;
+                            options = (ret.data && ret.data.options) || ret.data;
+                            stack.splice(idx, stack.length - idx);
+                            if (!(typeof remoteValue !== 'undefined')) return [3 /*break*/, 2];
+                            arr.splice(idx + 1, value.length - idx - 1);
+                            arr.push(remoteValue);
+                            valueRes = this.array2value(arr, true);
+                            return [4 /*yield*/, dispatchEvent('change', createObject(data, {
+                                    value: valueRes
+                                }))];
+                        case 1:
+                            rendererEvent = _a.sent();
+                            if (rendererEvent === null || rendererEvent === void 0 ? void 0 : rendererEvent.prevented) {
+                                return [2 /*return*/];
+                            }
+                            onChange(valueRes);
+                            _a.label = 2;
+                        case 2:
+                            stack.push({
+                                options: options,
+                                parentId: parentId,
+                                loading: false,
+                                visible: !!options
+                            });
+                            this.setState({
+                                stack: stack
+                            }, this.loadMore);
+                            return [2 /*return*/];
+                    }
+                });
+            }); })
+                .catch(function (e) {
+                env.notify('error', e.message);
+            });
+        });
+    };
+    ChainedSelectControl.prototype.handleChange = function (index, currentValue) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, value, delimiter, onChange, joinValues, dispatchEvent, data, arr, valueRes, rendererEvent;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this.props, value = _a.value, delimiter = _a.delimiter, onChange = _a.onChange, joinValues = _a.joinValues, _a.extractValue, dispatchEvent = _a.dispatchEvent, data = _a.data;
+                        arr = Array.isArray(value)
+                            ? value.concat()
+                            : value && typeof value === 'string'
+                                ? value.split(delimiter || ',')
+                                : [];
+                        arr.splice(index, arr.length - index);
+                        arr.push(joinValues ? currentValue.value : currentValue);
+                        valueRes = this.array2value(arr);
+                        return [4 /*yield*/, dispatchEvent('change', createObject(data, {
+                                value: valueRes
+                            }))];
+                    case 1:
+                        rendererEvent = _b.sent();
+                        if (rendererEvent === null || rendererEvent === void 0 ? void 0 : rendererEvent.prevented) {
+                            return [2 /*return*/];
+                        }
+                        onChange(valueRes);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ChainedSelectControl.prototype.reload = function () {
+        var reload = this.props.reloadOptions;
+        reload && reload();
+    };
+    ChainedSelectControl.prototype.render = function () {
+        var _this = this;
+        var _a = this.props, options = _a.options, ns = _a.classPrefix, className = _a.className; _a.inline; var loading = _a.loading, value = _a.value, delimiter = _a.delimiter; _a.joinValues; _a.extractValue; _a.multiple; var useMobileUI = _a.useMobileUI, env = _a.env, rest = __rest(_a, ["options", "classPrefix", "className", "inline", "loading", "value", "delimiter", "joinValues", "extractValue", "multiple", "useMobileUI", "env"]);
+        var arr = Array.isArray(value)
+            ? value.concat()
+            : value && typeof value === 'string'
+                ? value.split(delimiter || ',')
+                : [];
+        var mobileUI = useMobileUI && isMobile();
+        return (React.createElement("div", { className: cx("".concat(ns, "ChainedSelectControl"), className) },
+            React.createElement(Select, __assign({}, rest, { useMobileUI: useMobileUI, popOverContainer: mobileUI && env && env.getModalContainer
+                    ? env.getModalContainer
+                    : rest.popOverContainer, classPrefix: ns, key: "base", options: options, value: arr[0], onChange: this.handleChange.bind(this, 0), loading: loading, inline: true })),
+            this.state.stack.map(function (_a, index) {
+                var options = _a.options, loading = _a.loading, visible = _a.visible;
+                return visible === false ? null : (React.createElement(Select, __assign({}, rest, { useMobileUI: useMobileUI, popOverContainer: mobileUI && env && env.getModalContainer
+                        ? env.getModalContainer
+                        : rest.popOverContainer, classPrefix: ns, key: "x-".concat(index + 1), options: options, value: arr[index + 1], onChange: _this.handleChange.bind(_this, index + 1), loading: loading, inline: true })));
+            })));
+    };
+    ChainedSelectControl.defaultProps = {
+        clearable: false,
+        searchable: false,
+        multiple: true
+    };
+    return ChainedSelectControl;
+}(React.Component));
+/** @class */ ((function (_super) {
+    __extends(ChainedSelectControlRenderer, _super);
+    function ChainedSelectControlRenderer() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ChainedSelectControlRenderer = __decorate([
+        OptionsControl({
+            type: 'chained-select',
+            sizeMutable: false
+        })
+    ], ChainedSelectControlRenderer);
+    return ChainedSelectControlRenderer;
+})(ChainedSelectControl));
+
+export { ChainedSelectControl as default };

package/esm/renderers/Form/ChartRadios.d.ts

@@ -0,0 +1,34 @@
+import React from 'react';
+import { OptionsControlProps } from 'amis-core';
+import { FormOptionsSchema } from '../../Schema';
+/**
+ * 图表 Radio 单选框。
+ * 文档：https://baidu.gitee.io/amis/docs/components/form/chart-radios
+ */
+export interface ChartRadiosControlSchema extends FormOptionsSchema {
+    type: 'chart-radios';
+    config: any;
+    showTooltipOnHighlight?: boolean;
+    chartValueField?: string;
+}
+export interface ChartRadiosProps extends OptionsControlProps {
+    placeholder?: any;
+    labelClassName?: string;
+    labelField?: string;
+    config: any;
+}
+export default class ChartRadiosControl extends React.Component<ChartRadiosProps, any> {
+    highlightIndex: number;
+    prevIndex: number;
+    chart?: any;
+    chartRef(chart?: any): void;
+    highlight(index?: number): void;
+    compoonentDidMount(): void;
+    componentDidUpdate(): void;
+    render(): JSX.Element;
+}
+export declare class RadiosControlRenderer extends ChartRadiosControl {
+    static defaultProps: {
+        multiple: boolean;
+    };
+}

package/esm/renderers/Form/ChartRadios.js

@@ -0,0 +1,121 @@
+/**
+ * amis v2.0.0
+ * Copyright 2018-2022 baidu
+ */
+
+import { __extends, __assign, __decorate, __metadata } from 'tslib';
+import React from 'react';
+import { autobind, OptionsControl } from 'amis-core';
+
+var ChartRadiosControl = /** @class */ (function (_super) {
+    __extends(ChartRadiosControl, _super);
+    function ChartRadiosControl() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.highlightIndex = -1;
+        _this.prevIndex = -1;
+        return _this;
+    }
+    ChartRadiosControl.prototype.chartRef = function (chart) {
+        var _this = this;
+        var _a;
+        this.chart = chart;
+        (_a = this.chart) === null || _a === void 0 ? void 0 : _a.on('click', 'series', function (params) {
+            _this.props.onToggle(_this.props.options[params.dataIndex]);
+        });
+        // 因为会要先 setOptions 再来。
+        setTimeout(function () { return _this.highlight(); });
+    };
+    ChartRadiosControl.prototype.highlight = function (index) {
+        if (index === void 0) { index = this.highlightIndex; }
+        this.highlightIndex = index;
+        if (!this.chart || this.prevIndex === index) {
+            return;
+        }
+        if (~this.prevIndex) {
+            this.chart.dispatchAction({
+                type: 'downplay',
+                seriesIndex: 0,
+                dataIndex: this.prevIndex
+            });
+        }
+        if (~index) {
+            this.chart.dispatchAction({
+                type: 'highlight',
+                seriesIndex: 0,
+                dataIndex: index
+            });
+            // 显示 tooltip
+            if (this.props.showTooltipOnHighlight) {
+                this.chart.dispatchAction({
+                    type: 'showTip',
+                    seriesIndex: 0,
+                    dataIndex: index
+                });
+            }
+        }
+        this.prevIndex = index;
+    };
+    ChartRadiosControl.prototype.compoonentDidMount = function () {
+        if (this.props.selectedOptions.length) {
+            this.highlight(this.props.options.indexOf(this.props.selectedOptions[0]));
+        }
+    };
+    ChartRadiosControl.prototype.componentDidUpdate = function () {
+        if (this.props.selectedOptions.length) {
+            this.highlight(this.props.options.indexOf(this.props.selectedOptions[0]));
+        }
+    };
+    ChartRadiosControl.prototype.render = function () {
+        var _a = this.props, options = _a.options, labelField = _a.labelField, chartValueField = _a.chartValueField, valueField = _a.valueField, render = _a.render;
+        var config = __assign(__assign({ legend: {
+                top: 10
+            }, tooltip: {
+                formatter: function (params) {
+                    return "".concat(params.name, "\uFF1A").concat(params.value[chartValueField || valueField || 'value'], "\uFF08").concat(params.percent, "%\uFF09");
+                }
+            }, series: [
+                {
+                    type: 'pie',
+                    top: 30,
+                    bottom: 0
+                }
+            ] }, this.props.config), { dataset: {
+                dimensions: [
+                    labelField || 'label',
+                    chartValueField || valueField || 'value'
+                ],
+                source: options
+            } });
+        return render('chart', {
+            type: 'chart'
+        }, {
+            config: config,
+            chartRef: this.chartRef
+        });
+    };
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", void 0)
+    ], ChartRadiosControl.prototype, "chartRef", null);
+    return ChartRadiosControl;
+}(React.Component));
+/** @class */ ((function (_super) {
+    __extends(RadiosControlRenderer, _super);
+    function RadiosControlRenderer() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    RadiosControlRenderer.defaultProps = {
+        multiple: false
+    };
+    RadiosControlRenderer = __decorate([
+        OptionsControl({
+            type: 'chart-radios',
+            sizeMutable: false
+        })
+    ], RadiosControlRenderer);
+    return RadiosControlRenderer;
+})(ChartRadiosControl));
+
+export { ChartRadiosControl as default };

package/esm/renderers/Form/Checkbox.d.ts

@@ -0,0 +1,47 @@
+import React from 'react';
+import { FormControlProps } from 'amis-core';
+import { BadgeObject } from 'amis-ui';
+import { ActionObject } from 'amis-core';
+import { FormBaseControlSchema } from '../../Schema';
+export interface SchemaMap {
+    checkbox: CheckboxControlSchema;
+}
+/**
+ * Checkbox 勾选框。
+ * 文档：https://baidu.gitee.io/amis/docs/components/form/checkbox
+ */
+export interface CheckboxControlSchema extends FormBaseControlSchema {
+    /**
+     * 指定为多行文本输入框
+     */
+    type: 'checkbox';
+    /**
+     * 勾选值
+     */
+    trueValue?: boolean | string | number;
+    /**
+     * 未勾选值
+     */
+    falseValue?: boolean | string | number;
+    /**
+     * 选项说明
+     */
+    option?: string;
+    /**
+     * 角标
+     */
+    badge?: BadgeObject;
+    partial?: boolean;
+    optionType?: 'default' | 'button';
+    checked?: boolean;
+}
+export interface CheckboxProps extends FormControlProps, Omit<CheckboxControlSchema, 'type' | 'className' | 'descriptionClassName' | 'inputClassName'> {
+}
+export default class CheckboxControl extends React.Component<CheckboxProps, any> {
+    static defaultProps: Partial<CheckboxProps>;
+    doAction(action: ActionObject, data: object, throwErrors: boolean): void;
+    dispatchChangeEvent(eventData?: any): Promise<void>;
+    render(): JSX.Element;
+}
+export declare class CheckboxControlRenderer extends CheckboxControl {
+}

package/esm/renderers/Form/Checkbox.js

@@ -0,0 +1,83 @@
+/**
+ * amis v2.0.0
+ * Copyright 2018-2022 baidu
+ */
+
+import { __extends, __awaiter, __generator, __decorate, __metadata } from 'tslib';
+import React from 'react';
+import { createObject, autobind, FormItem } from 'amis-core';
+import cx from 'classnames';
+import { Checkbox, withBadge } from 'amis-ui';
+
+var CheckboxControl = /** @class */ (function (_super) {
+    __extends(CheckboxControl, _super);
+    function CheckboxControl() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CheckboxControl.prototype.doAction = function (action, data, throwErrors) {
+        var _a = this.props, resetValue = _a.resetValue, onChange = _a.onChange;
+        var actionType = action === null || action === void 0 ? void 0 : action.actionType;
+        if (actionType === 'clear') {
+            onChange('');
+        }
+        else if (actionType === 'reset') {
+            onChange(resetValue !== null && resetValue !== void 0 ? resetValue : '');
+        }
+    };
+    CheckboxControl.prototype.dispatchChangeEvent = function (eventData) {
+        if (eventData === void 0) { eventData = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, dispatchEvent, data, onChange, rendererEvent;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = this.props, dispatchEvent = _a.dispatchEvent, data = _a.data, onChange = _a.onChange;
+                        return [4 /*yield*/, dispatchEvent('change', createObject(data, {
+                                value: eventData
+                            }))];
+                    case 1:
+                        rendererEvent = _b.sent();
+                        if (rendererEvent === null || rendererEvent === void 0 ? void 0 : rendererEvent.prevented) {
+                            return [2 /*return*/];
+                        }
+                        onChange && onChange(eventData);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    CheckboxControl.prototype.render = function () {
+        var _this = this;
+        var _a = this.props, className = _a.className, value = _a.value, trueValue = _a.trueValue, falseValue = _a.falseValue, option = _a.option; _a.onChange; var disabled = _a.disabled, render = _a.render, partial = _a.partial, optionType = _a.optionType, checked = _a.checked, ns = _a.classPrefix;
+        return (React.createElement("div", { className: cx("".concat(ns, "CheckboxControl"), className) },
+            React.createElement(Checkbox, { inline: true, value: value || '', trueValue: trueValue, falseValue: falseValue, disabled: disabled, onChange: function (value) { return _this.dispatchChangeEvent(value); }, partial: partial, optionType: optionType, checked: checked }, option ? render('option', option) : null)));
+    };
+    CheckboxControl.defaultProps = {
+        trueValue: true,
+        falseValue: false
+    };
+    __decorate([
+        autobind,
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", Promise)
+    ], CheckboxControl.prototype, "dispatchChangeEvent", null);
+    return CheckboxControl;
+}(React.Component));
+// @ts-ignore
+var CheckboxControlRenderer = /** @class */ (function (_super) {
+    __extends(CheckboxControlRenderer, _super);
+    function CheckboxControlRenderer() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CheckboxControlRenderer = __decorate([
+        withBadge,
+        FormItem({
+            type: 'checkbox',
+            sizeMutable: false
+        })
+    ], CheckboxControlRenderer);
+    return CheckboxControlRenderer;
+}(CheckboxControl));
+
+export { CheckboxControlRenderer, CheckboxControl as default };

package/esm/renderers/Form/Checkboxes.d.ts

@@ -0,0 +1,65 @@
+import React from 'react';
+import { OptionsControlProps, Option } from 'amis-core';
+import { ActionObject, Api } from 'amis-core';
+import { FormOptionsSchema } from '../../Schema';
+/**
+ * 复选框
+ * 文档：https://baidu.gitee.io/amis/docs/components/form/checkboxes
+ */
+export interface CheckboxesControlSchema extends FormOptionsSchema {
+    type: 'checkboxes';
+    /**
+     * 是否开启全选功能
+     */
+    checkAll?: boolean;
+    /**
+     * 是否默认全选
+     */
+    defaultCheckAll?: boolean;
+    /**
+     * 每行显示多少个
+     */
+    columnsCount?: number | number[];
+    /**
+     * 自定义选项展示
+     */
+    menuTpl?: string;
+}
+export interface CheckboxesProps extends OptionsControlProps, Omit<CheckboxesControlSchema, 'options' | 'type' | 'className' | 'descriptionClassName' | 'inputClassName'> {
+    placeholder?: any;
+    itemClassName?: string;
+    columnsCount?: number | number[];
+    labelClassName?: string;
+    onAdd?: () => void;
+    addApi?: Api;
+    creatable: boolean;
+    createBtnLabel: string;
+    editable?: boolean;
+    removable?: boolean;
+    optionType?: 'default' | 'button';
+    menuTpl?: string;
+}
+export default class CheckboxesControl extends React.Component<CheckboxesProps, any> {
+    static defaultProps: {
+        columnsCount: number;
+        multiple: boolean;
+        placeholder: string;
+        creatable: boolean;
+        inline: boolean;
+        createBtnLabel: string;
+        optionType: string;
+    };
+    doAction(action: ActionObject, data: object, throwErrors: boolean): void;
+    reload(): void;
+    handleAddClick(): void;
+    handleEditClick(e: Event, item: any): void;
+    handleDeleteClick(e: Event, item: any): void;
+    componentDidMount(): void;
+    componentWillMount(): void;
+    updateBorderStyle(): void;
+    renderGroup(option: Option, index: number): JSX.Element | null;
+    renderItem(option: Option, index: number): JSX.Element | null;
+    render(): JSX.Element;
+}
+export declare class CheckboxesControlRenderer extends CheckboxesControl {
+}