import { PropType } from 'vue';
import { setStyle, setColorInfo } from './utils';
import { FieldSetColumnItem } from '../../../components/field-set/src/types';
import { AnyObject } from '../../../shared/types';
declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    footerFlag: {
        type: BooleanConstructor;
        default: boolean;
    };
    isFieldColor: {
        type: BooleanConstructor;
        default: boolean;
    };
    defaultList: {
        type: PropType<AnyObject[]>;
        default: () => never[];
    };
}>, {
    props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
        footerFlag: {
            type: BooleanConstructor;
            default: boolean;
        };
        isFieldColor: {
            type: BooleanConstructor;
            default: boolean;
        };
        defaultList: {
            type: PropType<AnyObject[]>;
            default: () => never[];
        };
    }>> & Readonly<{
        onSave?: ((...args: any[]) => any) | undefined;
        onClose?: ((...args: any[]) => any) | undefined;
    }> & {}>;
    emit: (event: "close" | "save", ...args: any[]) => void;
    visible: import("vue").Ref<boolean, boolean>;
    currentRow: import("vue").Ref<AnyObject | null, AnyObject | null>;
    data: import("vue").Ref<AnyObject[], AnyObject[]>;
    readonly: import("vue").Ref<boolean, boolean>;
    isAdd: import("vue").Ref<boolean, boolean>;
    columns: import("vue").Ref<{
        [x: string]: any;
        title: string;
        type: "color" | "input" | "select" | "custom" | "text" | "checkbox" | "inputNumber";
        field: string;
        checkedAll?: boolean | undefined;
        disabledAll?: boolean | undefined;
        isHeadCheckHide?: boolean | undefined;
        isShow?: boolean | undefined;
        contentRender?: ((column: AnyObject, row: AnyObject) => import("vue").VNodeChild) | undefined;
        titleRender?: ((column: AnyObject) => import("vue").VNodeChild) | undefined;
        hide?: boolean | undefined;
        positionField?: string | undefined;
        showPrevFn?: ((column: FieldSetColumnItem, row: AnyObject) => boolean) | undefined;
    }[], FieldSetColumnItem[] | {
        [x: string]: any;
        title: string;
        type: "color" | "input" | "select" | "custom" | "text" | "checkbox" | "inputNumber";
        field: string;
        checkedAll?: boolean | undefined;
        disabledAll?: boolean | undefined;
        isHeadCheckHide?: boolean | undefined;
        isShow?: boolean | undefined;
        contentRender?: ((column: AnyObject, row: AnyObject) => import("vue").VNodeChild) | undefined;
        titleRender?: ((column: AnyObject) => import("vue").VNodeChild) | undefined;
        hide?: boolean | undefined;
        positionField?: string | undefined;
        showPrevFn?: ((column: FieldSetColumnItem, row: AnyObject) => boolean) | undefined;
    }[]>;
    rowProps: {
        columns: {
            [x: string]: any;
            title: string;
            type: "color" | "input" | "select" | "custom" | "text" | "checkbox" | "inputNumber";
            field: string;
            checkedAll?: boolean | undefined;
            disabledAll?: boolean | undefined;
            isHeadCheckHide?: boolean | undefined;
            isShow?: boolean | undefined;
            contentRender?: ((column: AnyObject, row: AnyObject) => import("vue").VNodeChild) | undefined;
            titleRender?: ((column: AnyObject) => import("vue").VNodeChild) | undefined;
            hide?: boolean | undefined;
            positionField?: string | undefined;
            showPrevFn?: ((column: FieldSetColumnItem, row: AnyObject) => boolean) | undefined;
        }[];
        data: AnyObject[];
        onEdit: ({ row, readonly: _readonly, add }: AnyObject) => void;
        isHighlightRow: boolean;
    };
    handleFieldSave: () => void;
    onCancle: () => void;
    onAdd: () => void;
    onEdit: ({ row, readonly: _readonly, add }: AnyObject) => void;
    initColumns: () => void;
    initData: () => void;
    getShowColumn: (column: FieldSetColumnItem) => boolean;
    getTableFields: () => import("lodash").Omit<AnyObject, "style" | "uuid" | "result">[];
    onConfirm: (model: AnyObject) => void;
    readonly NButton: any;
    readonly Draggable: import("vue").DefineComponent<{
        list: {
            type: ArrayConstructor;
            required: boolean;
            default: any;
        };
        modelValue: {
            type: ArrayConstructor;
            required: boolean;
            default: any;
        };
        itemKey: {
            type: (StringConstructor | FunctionConstructor)[];
            required: boolean;
        };
        clone: {
            type: FunctionConstructor;
            default: (original: any) => any;
        };
        tag: {
            type: StringConstructor;
            default: string;
        };
        move: {
            type: FunctionConstructor;
            default: any;
        };
        componentData: {
            type: ObjectConstructor;
            required: boolean;
            default: any;
        };
    }, unknown, {
        error: boolean;
    }, {
        realList(): any;
        getKey(): any;
    }, {
        getUnderlyingVm(domElement: any): any;
        getUnderlyingPotencialDraggableComponent(htmElement: any): any;
        emitChanges(evt: any): void;
        alterList(onList: any): void;
        spliceList(): void;
        updatePosition(oldIndex: any, newIndex: any): void;
        getRelatedContextFromMoveEvent({ to, related }: {
            to: any;
            related: any;
        }): any;
        getVmIndexFromDomIndex(domIndex: any): any;
        onDragStart(evt: any): void;
        onDragAdd(evt: any): void;
        onDragRemove(evt: any): void;
        onDragUpdate(evt: any): void;
        computeFutureIndex(relatedContext: any, evt: any): any;
        onDragMove(evt: any, originalEvent: any): any;
        onDragEnd(): void;
    }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, any[], any, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        move: Function;
        tag: string;
        clone: Function;
        list: unknown[];
        modelValue: unknown[];
        componentData: Record<string, any>;
    } & {
        itemKey?: string | Function | undefined;
    }>, {
        move: Function;
        tag: string;
        clone: Function;
        list: unknown[];
        modelValue: unknown[];
        componentData: Record<string, any>;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    Row: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        element: {
            type: PropType<Partial<{
                [key: string]: any;
                id: string;
                name: string;
                show: boolean;
                sort: boolean;
                sortDirection: "NONE" | "ASC" | "DESC";
                title: string;
                alias: string;
                fixedShow: boolean;
                fixedWay: "NONE" | "LEFT" | "RIGHT";
                columnWidth: number | null;
                editable: boolean;
                editableDisable: boolean;
                required: boolean;
                requiredDisable: boolean;
                hide: boolean;
            }>>;
            default: () => {};
        };
        columns: {
            type: PropType<FieldSetColumnItem[]>;
            default: () => never[];
        };
        idx: {
            type: NumberConstructor;
            default: number;
        };
        data: {
            type: PropType<Partial<{
                [key: string]: any;
                id: string;
                name: string;
                show: boolean;
                sort: boolean;
                sortDirection: "NONE" | "ASC" | "DESC";
                title: string;
                alias: string;
                fixedShow: boolean;
                fixedWay: "NONE" | "LEFT" | "RIGHT";
                columnWidth: number | null;
                editable: boolean;
                editableDisable: boolean;
                required: boolean;
                requiredDisable: boolean;
                hide: boolean;
            }>[]>;
            default: () => never[];
        };
        isHighlight: {
            type: BooleanConstructor;
        };
        index: {
            type: NumberConstructor;
            default: number;
        };
        isHighlightRow: {
            type: BooleanConstructor;
            default: boolean;
        };
        draggable: {
            type: BooleanConstructor;
            default: boolean;
        };
        isFieldSet: {
            type: BooleanConstructor;
            default: boolean;
        };
        fieldDescribeMode: {
            type: PropType<"column" | "tooltip">;
            default: string;
        };
        developMode: {
            type: BooleanConstructor;
        };
        columnWidthProps: {
            type: ObjectConstructor;
        };
        hideExpressionOption: {
            type: PropType<AnyObject[]>;
            default: () => never[];
        };
        primaryKey: {
            type: StringConstructor;
            default: string;
        };
        titleRender: {
            type: PropType<(row: AnyObject) => import("vue").VNodeChild>;
        };
    }>, {
        fixedWayOptions: {
            label: string;
            value: string;
        }[];
        sortOptions: {
            label: string;
            value: string;
        }[];
        colorScopeOptions: {
            label: string;
            value: string;
        }[];
        swatches: string[];
        props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
            element: {
                type: PropType<Partial<{
                    [key: string]: any;
                    id: string;
                    name: string;
                    show: boolean;
                    sort: boolean;
                    sortDirection: "NONE" | "ASC" | "DESC";
                    title: string;
                    alias: string;
                    fixedShow: boolean;
                    fixedWay: "NONE" | "LEFT" | "RIGHT";
                    columnWidth: number | null;
                    editable: boolean;
                    editableDisable: boolean;
                    required: boolean;
                    requiredDisable: boolean;
                    hide: boolean;
                }>>;
                default: () => {};
            };
            columns: {
                type: PropType<FieldSetColumnItem[]>;
                default: () => never[];
            };
            idx: {
                type: NumberConstructor;
                default: number;
            };
            data: {
                type: PropType<Partial<{
                    [key: string]: any;
                    id: string;
                    name: string;
                    show: boolean;
                    sort: boolean;
                    sortDirection: "NONE" | "ASC" | "DESC";
                    title: string;
                    alias: string;
                    fixedShow: boolean;
                    fixedWay: "NONE" | "LEFT" | "RIGHT";
                    columnWidth: number | null;
                    editable: boolean;
                    editableDisable: boolean;
                    required: boolean;
                    requiredDisable: boolean;
                    hide: boolean;
                }>[]>;
                default: () => never[];
            };
            isHighlight: {
                type: BooleanConstructor;
            };
            index: {
                type: NumberConstructor;
                default: number;
            };
            isHighlightRow: {
                type: BooleanConstructor;
                default: boolean;
            };
            draggable: {
                type: BooleanConstructor;
                default: boolean;
            };
            isFieldSet: {
                type: BooleanConstructor;
                default: boolean;
            };
            fieldDescribeMode: {
                type: PropType<"column" | "tooltip">;
                default: string;
            };
            developMode: {
                type: BooleanConstructor;
            };
            columnWidthProps: {
                type: ObjectConstructor;
            };
            hideExpressionOption: {
                type: PropType<AnyObject[]>;
                default: () => never[];
            };
            primaryKey: {
                type: StringConstructor;
                default: string;
            };
            titleRender: {
                type: PropType<(row: AnyObject) => import("vue").VNodeChild>;
            };
        }>> & Readonly<{
            onEdit?: ((...args: any[]) => any) | undefined;
            onUpdateChecked?: ((...args: any[]) => any) | undefined;
        }> & {}>;
        emit: (event: "edit" | "updateChecked", ...args: any[]) => void;
        onRemove: () => void;
        onEdit: (param?: AnyObject) => void;
        prevFunc: (column: AnyObject) => any;
        isRenderTooltip: (field: string) => any;
        getTooltipContent: () => any;
        getTextValue: (field: string) => any;
        isMultiple: (field: string) => boolean;
        isRender: (field: string) => boolean;
        isShow: (column: AnyObject) => any;
        showRelation: (field: string) => boolean;
        getSortPriorityOptions: () => {
            label: string;
            value: number;
        }[];
        getSelectText: (field: string) => "" | " " | "单选" | "多选" | "密码无需设置" | "主键不可设置" | "不支持脱敏设置" | undefined;
        selectProps: (field: string) => {
            valueField: string;
            labelField: string;
        };
        getOptions: (column: AnyObject) => any;
        setDisabled: (column: AnyObject) => any;
        getStyle: (column: AnyObject) => import("vue").CSSProperties;
        onUpdateChecked: (checked: boolean, column: AnyObject) => void;
        handleUpdateSelect: (value: string, column: AnyObject) => void;
        readonly NCheckbox: any;
        readonly NSelect: any;
        readonly NInput: any;
        readonly NInputNumber: any;
        readonly NTooltip: any;
        readonly NIcon: any;
        readonly NColorPicker: any;
        readonly NPopconfirm: any;
        readonly NPopover: any;
        readonly NSpace: any;
        readonly NButton: any;
        readonly setStyle: typeof setStyle;
        readonly setColorInfo: typeof setColorInfo;
        readonly ReorderTwoOutline: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        readonly TrashOutline: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        readonly CreateOutline: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        readonly HelpCircleOutline: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        readonly CaretDownOutline: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        readonly EyeOutline: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        readonly CopyOutline: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        readonly isFunction: (value: any) => value is (...args: any[]) => any;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("edit" | "updateChecked")[], "edit" | "updateChecked", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        element: {
            type: PropType<Partial<{
                [key: string]: any;
                id: string;
                name: string;
                show: boolean;
                sort: boolean;
                sortDirection: "NONE" | "ASC" | "DESC";
                title: string;
                alias: string;
                fixedShow: boolean;
                fixedWay: "NONE" | "LEFT" | "RIGHT";
                columnWidth: number | null;
                editable: boolean;
                editableDisable: boolean;
                required: boolean;
                requiredDisable: boolean;
                hide: boolean;
            }>>;
            default: () => {};
        };
        columns: {
            type: PropType<FieldSetColumnItem[]>;
            default: () => never[];
        };
        idx: {
            type: NumberConstructor;
            default: number;
        };
        data: {
            type: PropType<Partial<{
                [key: string]: any;
                id: string;
                name: string;
                show: boolean;
                sort: boolean;
                sortDirection: "NONE" | "ASC" | "DESC";
                title: string;
                alias: string;
                fixedShow: boolean;
                fixedWay: "NONE" | "LEFT" | "RIGHT";
                columnWidth: number | null;
                editable: boolean;
                editableDisable: boolean;
                required: boolean;
                requiredDisable: boolean;
                hide: boolean;
            }>[]>;
            default: () => never[];
        };
        isHighlight: {
            type: BooleanConstructor;
        };
        index: {
            type: NumberConstructor;
            default: number;
        };
        isHighlightRow: {
            type: BooleanConstructor;
            default: boolean;
        };
        draggable: {
            type: BooleanConstructor;
            default: boolean;
        };
        isFieldSet: {
            type: BooleanConstructor;
            default: boolean;
        };
        fieldDescribeMode: {
            type: PropType<"column" | "tooltip">;
            default: string;
        };
        developMode: {
            type: BooleanConstructor;
        };
        columnWidthProps: {
            type: ObjectConstructor;
        };
        hideExpressionOption: {
            type: PropType<AnyObject[]>;
            default: () => never[];
        };
        primaryKey: {
            type: StringConstructor;
            default: string;
        };
        titleRender: {
            type: PropType<(row: AnyObject) => import("vue").VNodeChild>;
        };
    }>> & Readonly<{
        onEdit?: ((...args: any[]) => any) | undefined;
        onUpdateChecked?: ((...args: any[]) => any) | undefined;
    }>, {
        data: Partial<{
            [key: string]: any;
            id: string;
            name: string;
            show: boolean;
            sort: boolean;
            sortDirection: "NONE" | "ASC" | "DESC";
            title: string;
            alias: string;
            fixedShow: boolean;
            fixedWay: "NONE" | "LEFT" | "RIGHT";
            columnWidth: number | null;
            editable: boolean;
            editableDisable: boolean;
            required: boolean;
            requiredDisable: boolean;
            hide: boolean;
        }>[];
        columns: FieldSetColumnItem[];
        primaryKey: string;
        index: number;
        developMode: boolean;
        element: Partial<{
            [key: string]: any;
            id: string;
            name: string;
            show: boolean;
            sort: boolean;
            sortDirection: "NONE" | "ASC" | "DESC";
            title: string;
            alias: string;
            fixedShow: boolean;
            fixedWay: "NONE" | "LEFT" | "RIGHT";
            columnWidth: number | null;
            editable: boolean;
            editableDisable: boolean;
            required: boolean;
            requiredDisable: boolean;
            hide: boolean;
        }>;
        draggable: boolean;
        idx: number;
        isHighlight: boolean;
        isHighlightRow: boolean;
        isFieldSet: boolean;
        fieldDescribeMode: "column" | "tooltip";
        hideExpressionOption: AnyObject[];
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    EditDialog: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        visible: {
            type: BooleanConstructor;
            default: boolean;
        };
        isFieldColor: {
            type: BooleanConstructor;
            default: boolean;
        };
        row: {
            type: PropType<AnyObject | null>;
            default: null;
        };
        readonly: {
            type: BooleanConstructor;
            default: boolean;
        };
        isAdd: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>, {
        cssVars: import("vue").ComputedRef<AnyObject>;
        message: import("naive-ui/es/message").MessageApi;
        colorOptions: {
            label: "黄色" | "绿色" | "蓝色" | "紫色" | "红色";
            value: string;
        }[];
        swatches: string[];
        fieldList: AnyObject[];
        props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
            visible: {
                type: BooleanConstructor;
                default: boolean;
            };
            isFieldColor: {
                type: BooleanConstructor;
                default: boolean;
            };
            row: {
                type: PropType<AnyObject | null>;
                default: null;
            };
            readonly: {
                type: BooleanConstructor;
                default: boolean;
            };
            isAdd: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{
            onConfirm?: ((...args: any[]) => any) | undefined;
            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
        }> & {}>;
        emit: (event: "confirm" | "update:visible", ...args: any[]) => void;
        formRef: import("vue").Ref<any, any>;
        conditionRef: import("vue").Ref<any, any>;
        filterVisible: import("vue").Ref<boolean, boolean>;
        title: import("vue").ComputedRef<"新增" | "修改" | "复制" | "过滤条件">;
        model: {
            name: string;
            color: string;
            status: boolean;
            columnName: string;
            colorScope: string;
            condition: never[];
            sqlExpression: string;
        };
        rules: import("naive-ui/es/form").FormRules;
        initModel: () => void;
        renderLabel: (option: AnyObject) => any;
        onConfirm: () => void;
        onClose: () => void;
        setFilterData: (data: AnyObject) => void;
        readonly NInput: any;
        readonly NModal: any;
        readonly NFormItem: any;
        readonly NForm: any;
        readonly NCheckbox: any;
        readonly NSelect: any;
        readonly NColorPicker: any;
        readonly NRadioGroup: any;
        readonly NRadio: any;
        readonly NSpace: any;
        Condition: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            model: {
                type: PropType<AnyObject>;
                default: null;
            };
            readonly: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>, {
            customValue: string;
            cssVars: import("vue").ComputedRef<AnyObject>;
            props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                model: {
                    type: PropType<AnyObject>;
                    default: null;
                };
                readonly: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{}> & {}>;
            fieldList: AnyObject[];
            queryWordbookData: ((params: import("../../../components/field-set/src/types").ColorSetWordbook) => Promise<{
                [key: string]: any;
                label: string;
                value: string;
            }[]>) | undefined;
            condition: import("vue").Ref<{
                field_key: string;
                con: string;
                value?: any;
                start_val?: string | undefined;
                end_val?: string | undefined;
                is_compare_field?: boolean | undefined;
                compare_field: any;
                numberValue: number | null;
                dateValue: string | [string, string] | null;
                fieldType: string;
                conOptions: AnyObject[];
                compareFieldOptions: AnyObject[];
                unit: string | null;
                multiple: boolean;
            }[], (import("../../../components/field-set/src/types").ColorSetConditionItem & {
                numberValue: number | null;
                dateValue: string | [string, string] | null;
                fieldType: string;
                conOptions: AnyObject[];
                compare_field: any;
                compareFieldOptions: AnyObject[];
                unit: string | null;
                multiple: boolean;
            })[] | {
                field_key: string;
                con: string;
                value?: any;
                start_val?: string | undefined;
                end_val?: string | undefined;
                is_compare_field?: boolean | undefined;
                compare_field: any;
                numberValue: number | null;
                dateValue: string | [string, string] | null;
                fieldType: string;
                conOptions: AnyObject[];
                compareFieldOptions: AnyObject[];
                unit: string | null;
                multiple: boolean;
            }[]>;
            sqlExpression: import("vue").Ref<string, string>;
            setConOptions: (item: import("../../../components/field-set/src/types").ColorSetConditionItem & {
                numberValue: number | null;
                dateValue: string | [string, string] | null;
                fieldType: string;
                conOptions: AnyObject[];
                compare_field: any;
                compareFieldOptions: AnyObject[];
                unit: string | null;
                multiple: boolean;
            }, isInit?: boolean) => void;
            setCompareFieldOptions: (item: import("../../../components/field-set/src/types").ColorSetConditionItem & {
                numberValue: number | null;
                dateValue: string | [string, string] | null;
                fieldType: string;
                conOptions: AnyObject[];
                compare_field: any;
                compareFieldOptions: AnyObject[];
                unit: string | null;
                multiple: boolean;
            }, isInit?: boolean) => Promise<void>;
            resetItem: (item: import("../../../components/field-set/src/types").ColorSetConditionItem & {
                numberValue: number | null;
                dateValue: string | [string, string] | null;
                fieldType: string;
                conOptions: AnyObject[];
                compare_field: any;
                compareFieldOptions: AnyObject[];
                unit: string | null;
                multiple: boolean;
            }) => void;
            showBooleanValue: (item: import("../../../components/field-set/src/types").ColorSetConditionItem & {
                numberValue: number | null;
                dateValue: string | [string, string] | null;
                fieldType: string;
                conOptions: AnyObject[];
                compare_field: any;
                compareFieldOptions: AnyObject[];
                unit: string | null;
                multiple: boolean;
            }) => boolean | "";
            showInput: (item: import("../../../components/field-set/src/types").ColorSetConditionItem & {
                numberValue: number | null;
                dateValue: string | [string, string] | null;
                fieldType: string;
                conOptions: AnyObject[];
                compare_field: any;
                compareFieldOptions: AnyObject[];
                unit: string | null;
                multiple: boolean;
            }) => boolean;
            showInputNumber: (item: import("../../../components/field-set/src/types").ColorSetConditionItem & {
                numberValue: number | null;
                dateValue: string | [string, string] | null;
                fieldType: string;
                conOptions: AnyObject[];
                compare_field: any;
                compareFieldOptions: AnyObject[];
                unit: string | null;
                multiple: boolean;
            }) => boolean;
            showUnit: (item: import("../../../components/field-set/src/types").ColorSetConditionItem & {
                numberValue: number | null;
                dateValue: string | [string, string] | null;
                fieldType: string;
                conOptions: AnyObject[];
                compare_field: any;
                compareFieldOptions: AnyObject[];
                unit: string | null;
                multiple: boolean;
            }) => boolean;
            showDatePicker: (item: import("../../../components/field-set/src/types").ColorSetConditionItem & {
                numberValue: number | null;
                dateValue: string | [string, string] | null;
                fieldType: string;
                conOptions: AnyObject[];
                compare_field: any;
                compareFieldOptions: AnyObject[];
                unit: string | null;
                multiple: boolean;
            }) => boolean;
            getDateType: (item: import("../../../components/field-set/src/types").ColorSetConditionItem & {
                numberValue: number | null;
                dateValue: string | [string, string] | null;
                fieldType: string;
                conOptions: AnyObject[];
                compare_field: any;
                compareFieldOptions: AnyObject[];
                unit: string | null;
                multiple: boolean;
            }) => "datetime" | "datetimerange";
            onAdd: () => void;
            onRemove: (index: number) => void;
            init: () => void;
            formatCondition: () => {
                field_key: string;
                fieldType: string;
                con: string;
                value: any;
                compare_field: any;
                is_compare_field: boolean;
                start_val: any;
                end_val: any;
                wordbookValueList: any;
                unit: any;
            }[];
            readonly NInput: any;
            readonly NInputNumber: any;
            readonly NSelect: any;
            readonly NIcon: any;
            readonly NButton: any;
            readonly AddCircleSharp: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            readonly RemoveCircle: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            readonly UNIT_OPTIONS: {
                label: string;
                value: string;
            }[];
            readonly BOOLEAN_OPTIONS: {
                label: string;
                value: string;
            }[];
            readonly CDatePicker: import("../../../shared/types").SFCWithInstall<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                updateUnchangedValue: {
                    type: BooleanConstructor;
                };
                onConfirm: {
                    type: FunctionConstructor;
                };
                formattedValue: {
                    type: PropType<(string | [string, string]) | null | undefined>;
                };
                placeholder: {
                    type: StringConstructor;
                };
                allowedInvalidValue: {
                    type: StringConstructor;
                };
                to: {
                    type: PropType<string | false | HTMLElement>;
                    default: string;
                };
                holidays: {
                    type: PropType<Date[]>;
                    default: () => never[];
                };
                type: {
                    type: StringConstructor;
                    default: string;
                };
                updateValueOnClose: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                isDateDisabled: {
                    type: PropType<(current: number, ...arg: any[]) => boolean>;
                };
                propKey: {
                    type: StringConstructor;
                };
                shortcutListenerConfig: {
                    type: PropType<{
                        enable: boolean;
                        callback: (value: string, propKey?: string | undefined) => void;
                    }>;
                };
            }>, {
                attrs: {
                    [x: string]: unknown;
                };
                props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                    updateUnchangedValue: {
                        type: BooleanConstructor;
                    };
                    onConfirm: {
                        type: FunctionConstructor;
                    };
                    formattedValue: {
                        type: PropType<(string | [string, string]) | null | undefined>;
                    };
                    placeholder: {
                        type: StringConstructor;
                    };
                    allowedInvalidValue: {
                        type: StringConstructor;
                    };
                    to: {
                        type: PropType<string | false | HTMLElement>;
                        default: string;
                    };
                    holidays: {
                        type: PropType<Date[]>;
                        default: () => never[];
                    };
                    type: {
                        type: StringConstructor;
                        default: string;
                    };
                    updateValueOnClose: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    isDateDisabled: {
                        type: PropType<(current: number, ...arg: any[]) => boolean>;
                    };
                    propKey: {
                        type: StringConstructor;
                    };
                    shortcutListenerConfig: {
                        type: PropType<{
                            enable: boolean;
                            callback: (value: string, propKey?: string | undefined) => void;
                        }>;
                    };
                }>> & Readonly<{
                    "onUpdate:formatted-value"?: ((...args: any[]) => any) | undefined;
                }> & {}>;
                emit: (event: "update:formatted-value", ...args: any[]) => void;
                datePickerRef: import("vue").Ref<AnyObject | null, AnyObject | null>;
                panelInstRef: import("vue").Ref<null, null>;
                placeholderRef: import("vue").Ref<any, any>;
                oldValue: (string | [string, string]) | null | undefined;
                currentFormattedValue: import("vue").WritableComputedRef<(string | [string, string]) | null | undefined, (string | [string, string]) | null | undefined>;
                isDateTime: import("vue").ComputedRef<boolean>;
                formatRef: import("vue").ComputedRef<string>;
                panelFormatRef: import("vue").ComputedRef<string | [string, string]>;
                _isDateDisabled: import("vue").ComputedRef<(current: number, ...arg: any[]) => boolean>;
                focus: () => any;
                blur: () => any;
                handleConfirm: (target: HTMLInputElement) => void;
                handleShortcutClick: (event: MouseEvent) => void;
                onUpdateShow: (show: boolean) => Promise<void>;
                watchers: import("../../../shared/types").AnyFn[];
                stopWatcher: () => void;
                setHoliday: (show: boolean) => Promise<void>;
                onConfirm: (...args: any[]) => Promise<void>;
                isAllowedInvalidValue: (value: (string | [string, string]) | null | undefined) => boolean | "" | undefined;
                setShortcutValue: (type: "month" | "week") => Promise<void>;
                readonly NDatePicker: any;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:formatted-value"[], "update:formatted-value", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                updateUnchangedValue: {
                    type: BooleanConstructor;
                };
                onConfirm: {
                    type: FunctionConstructor;
                };
                formattedValue: {
                    type: PropType<(string | [string, string]) | null | undefined>;
                };
                placeholder: {
                    type: StringConstructor;
                };
                allowedInvalidValue: {
                    type: StringConstructor;
                };
                to: {
                    type: PropType<string | false | HTMLElement>;
                    default: string;
                };
                holidays: {
                    type: PropType<Date[]>;
                    default: () => never[];
                };
                type: {
                    type: StringConstructor;
                    default: string;
                };
                updateValueOnClose: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                isDateDisabled: {
                    type: PropType<(current: number, ...arg: any[]) => boolean>;
                };
                propKey: {
                    type: StringConstructor;
                };
                shortcutListenerConfig: {
                    type: PropType<{
                        enable: boolean;
                        callback: (value: string, propKey?: string | undefined) => void;
                    }>;
                };
            }>> & Readonly<{
                "onUpdate:formatted-value"?: ((...args: any[]) => any) | undefined;
            }>, {
                type: string;
                updateUnchangedValue: boolean;
                to: string | false | HTMLElement;
                holidays: Date[];
                updateValueOnClose: boolean;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            model: {
                type: PropType<AnyObject>;
                default: null;
            };
            readonly: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{}>, {
            model: AnyObject;
            readonly: boolean;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        EditFilter: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            visible: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>, {
            props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                visible: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{
                onConfirm?: ((...args: any[]) => any) | undefined;
                "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
            }> & {}>;
            emit: (event: "confirm" | "update:visible", ...args: any[]) => void;
            conditionRef: import("vue").Ref<any, any>;
            onConfirm: () => void;
            onClose: () => void;
            readonly NModal: any;
            Condition: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                model: {
                    type: PropType<AnyObject>;
                    default: null;
                };
                readonly: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>, {
                customValue: string;
                cssVars: import("vue").ComputedRef<AnyObject>;
                props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                    model: {
                        type: PropType<AnyObject>;
                        default: null;
                    };
                    readonly: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>> & Readonly<{}> & {}>;
                fieldList: AnyObject[];
                queryWordbookData: ((params: import("../../../components/field-set/src/types").ColorSetWordbook) => Promise<{
                    [key: string]: any;
                    label: string;
                    value: string;
                }[]>) | undefined;
                condition: import("vue").Ref<{
                    field_key: string;
                    con: string;
                    value?: any;
                    start_val?: string | undefined;
                    end_val?: string | undefined;
                    is_compare_field?: boolean | undefined;
                    compare_field: any;
                    numberValue: number | null;
                    dateValue: string | [string, string] | null;
                    fieldType: string;
                    conOptions: AnyObject[];
                    compareFieldOptions: AnyObject[];
                    unit: string | null;
                    multiple: boolean;
                }[], (import("../../../components/field-set/src/types").ColorSetConditionItem & {
                    numberValue: number | null;
                    dateValue: string | [string, string] | null;
                    fieldType: string;
                    conOptions: AnyObject[];
                    compare_field: any;
                    compareFieldOptions: AnyObject[];
                    unit: string | null;
                    multiple: boolean;
                })[] | {
                    field_key: string;
                    con: string;
                    value?: any;
                    start_val?: string | undefined;
                    end_val?: string | undefined;
                    is_compare_field?: boolean | undefined;
                    compare_field: any;
                    numberValue: number | null;
                    dateValue: string | [string, string] | null;
                    fieldType: string;
                    conOptions: AnyObject[];
                    compareFieldOptions: AnyObject[];
                    unit: string | null;
                    multiple: boolean;
                }[]>;
                sqlExpression: import("vue").Ref<string, string>;
                setConOptions: (item: import("../../../components/field-set/src/types").ColorSetConditionItem & {
                    numberValue: number | null;
                    dateValue: string | [string, string] | null;
                    fieldType: string;
                    conOptions: AnyObject[];
                    compare_field: any;
                    compareFieldOptions: AnyObject[];
                    unit: string | null;
                    multiple: boolean;
                }, isInit?: boolean) => void;
                setCompareFieldOptions: (item: import("../../../components/field-set/src/types").ColorSetConditionItem & {
                    numberValue: number | null;
                    dateValue: string | [string, string] | null;
                    fieldType: string;
                    conOptions: AnyObject[];
                    compare_field: any;
                    compareFieldOptions: AnyObject[];
                    unit: string | null;
                    multiple: boolean;
                }, isInit?: boolean) => Promise<void>;
                resetItem: (item: import("../../../components/field-set/src/types").ColorSetConditionItem & {
                    numberValue: number | null;
                    dateValue: string | [string, string] | null;
                    fieldType: string;
                    conOptions: AnyObject[];
                    compare_field: any;
                    compareFieldOptions: AnyObject[];
                    unit: string | null;
                    multiple: boolean;
                }) => void;
                showBooleanValue: (item: import("../../../components/field-set/src/types").ColorSetConditionItem & {
                    numberValue: number | null;
                    dateValue: string | [string, string] | null;
                    fieldType: string;
                    conOptions: AnyObject[];
                    compare_field: any;
                    compareFieldOptions: AnyObject[];
                    unit: string | null;
                    multiple: boolean;
                }) => boolean | "";
                showInput: (item: import("../../../components/field-set/src/types").ColorSetConditionItem & {
                    numberValue: number | null;
                    dateValue: string | [string, string] | null;
                    fieldType: string;
                    conOptions: AnyObject[];
                    compare_field: any;
                    compareFieldOptions: AnyObject[];
                    unit: string | null;
                    multiple: boolean;
                }) => boolean;
                showInputNumber: (item: import("../../../components/field-set/src/types").ColorSetConditionItem & {
                    numberValue: number | null;
                    dateValue: string | [string, string] | null;
                    fieldType: string;
                    conOptions: AnyObject[];
                    compare_field: any;
                    compareFieldOptions: AnyObject[];
                    unit: string | null;
                    multiple: boolean;
                }) => boolean;
                showUnit: (item: import("../../../components/field-set/src/types").ColorSetConditionItem & {
                    numberValue: number | null;
                    dateValue: string | [string, string] | null;
                    fieldType: string;
                    conOptions: AnyObject[];
                    compare_field: any;
                    compareFieldOptions: AnyObject[];
                    unit: string | null;
                    multiple: boolean;
                }) => boolean;
                showDatePicker: (item: import("../../../components/field-set/src/types").ColorSetConditionItem & {
                    numberValue: number | null;
                    dateValue: string | [string, string] | null;
                    fieldType: string;
                    conOptions: AnyObject[];
                    compare_field: any;
                    compareFieldOptions: AnyObject[];
                    unit: string | null;
                    multiple: boolean;
                }) => boolean;
                getDateType: (item: import("../../../components/field-set/src/types").ColorSetConditionItem & {
                    numberValue: number | null;
                    dateValue: string | [string, string] | null;
                    fieldType: string;
                    conOptions: AnyObject[];
                    compare_field: any;
                    compareFieldOptions: AnyObject[];
                    unit: string | null;
                    multiple: boolean;
                }) => "datetime" | "datetimerange";
                onAdd: () => void;
                onRemove: (index: number) => void;
                init: () => void;
                formatCondition: () => {
                    field_key: string;
                    fieldType: string;
                    con: string;
                    value: any;
                    compare_field: any;
                    is_compare_field: boolean;
                    start_val: any;
                    end_val: any;
                    wordbookValueList: any;
                    unit: any;
                }[];
                readonly NInput: any;
                readonly NInputNumber: any;
                readonly NSelect: any;
                readonly NIcon: any;
                readonly NButton: any;
                readonly AddCircleSharp: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                readonly RemoveCircle: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                readonly UNIT_OPTIONS: {
                    label: string;
                    value: string;
                }[];
                readonly BOOLEAN_OPTIONS: {
                    label: string;
                    value: string;
                }[];
                readonly CDatePicker: import("../../../shared/types").SFCWithInstall<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    updateUnchangedValue: {
                        type: BooleanConstructor;
                    };
                    onConfirm: {
                        type: FunctionConstructor;
                    };
                    formattedValue: {
                        type: PropType<(string | [string, string]) | null | undefined>;
                    };
                    placeholder: {
                        type: StringConstructor;
                    };
                    allowedInvalidValue: {
                        type: StringConstructor;
                    };
                    to: {
                        type: PropType<string | false | HTMLElement>;
                        default: string;
                    };
                    holidays: {
                        type: PropType<Date[]>;
                        default: () => never[];
                    };
                    type: {
                        type: StringConstructor;
                        default: string;
                    };
                    updateValueOnClose: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    isDateDisabled: {
                        type: PropType<(current: number, ...arg: any[]) => boolean>;
                    };
                    propKey: {
                        type: StringConstructor;
                    };
                    shortcutListenerConfig: {
                        type: PropType<{
                            enable: boolean;
                            callback: (value: string, propKey?: string | undefined) => void;
                        }>;
                    };
                }>, {
                    attrs: {
                        [x: string]: unknown;
                    };
                    props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                        updateUnchangedValue: {
                            type: BooleanConstructor;
                        };
                        onConfirm: {
                            type: FunctionConstructor;
                        };
                        formattedValue: {
                            type: PropType<(string | [string, string]) | null | undefined>;
                        };
                        placeholder: {
                            type: StringConstructor;
                        };
                        allowedInvalidValue: {
                            type: StringConstructor;
                        };
                        to: {
                            type: PropType<string | false | HTMLElement>;
                            default: string;
                        };
                        holidays: {
                            type: PropType<Date[]>;
                            default: () => never[];
                        };
                        type: {
                            type: StringConstructor;
                            default: string;
                        };
                        updateValueOnClose: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        isDateDisabled: {
                            type: PropType<(current: number, ...arg: any[]) => boolean>;
                        };
                        propKey: {
                            type: StringConstructor;
                        };
                        shortcutListenerConfig: {
                            type: PropType<{
                                enable: boolean;
                                callback: (value: string, propKey?: string | undefined) => void;
                            }>;
                        };
                    }>> & Readonly<{
                        "onUpdate:formatted-value"?: ((...args: any[]) => any) | undefined;
                    }> & {}>;
                    emit: (event: "update:formatted-value", ...args: any[]) => void;
                    datePickerRef: import("vue").Ref<AnyObject | null, AnyObject | null>;
                    panelInstRef: import("vue").Ref<null, null>;
                    placeholderRef: import("vue").Ref<any, any>;
                    oldValue: (string | [string, string]) | null | undefined;
                    currentFormattedValue: import("vue").WritableComputedRef<(string | [string, string]) | null | undefined, (string | [string, string]) | null | undefined>;
                    isDateTime: import("vue").ComputedRef<boolean>;
                    formatRef: import("vue").ComputedRef<string>;
                    panelFormatRef: import("vue").ComputedRef<string | [string, string]>;
                    _isDateDisabled: import("vue").ComputedRef<(current: number, ...arg: any[]) => boolean>;
                    focus: () => any;
                    blur: () => any;
                    handleConfirm: (target: HTMLInputElement) => void;
                    handleShortcutClick: (event: MouseEvent) => void;
                    onUpdateShow: (show: boolean) => Promise<void>;
                    watchers: import("../../../shared/types").AnyFn[];
                    stopWatcher: () => void;
                    setHoliday: (show: boolean) => Promise<void>;
                    onConfirm: (...args: any[]) => Promise<void>;
                    isAllowedInvalidValue: (value: (string | [string, string]) | null | undefined) => boolean | "" | undefined;
                    setShortcutValue: (type: "month" | "week") => Promise<void>;
                    readonly NDatePicker: any;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:formatted-value"[], "update:formatted-value", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    updateUnchangedValue: {
                        type: BooleanConstructor;
                    };
                    onConfirm: {
                        type: FunctionConstructor;
                    };
                    formattedValue: {
                        type: PropType<(string | [string, string]) | null | undefined>;
                    };
                    placeholder: {
                        type: StringConstructor;
                    };
                    allowedInvalidValue: {
                        type: StringConstructor;
                    };
                    to: {
                        type: PropType<string | false | HTMLElement>;
                        default: string;
                    };
                    holidays: {
                        type: PropType<Date[]>;
                        default: () => never[];
                    };
                    type: {
                        type: StringConstructor;
                        default: string;
                    };
                    updateValueOnClose: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    isDateDisabled: {
                        type: PropType<(current: number, ...arg: any[]) => boolean>;
                    };
                    propKey: {
                        type: StringConstructor;
                    };
                    shortcutListenerConfig: {
                        type: PropType<{
                            enable: boolean;
                            callback: (value: string, propKey?: string | undefined) => void;
                        }>;
                    };
                }>> & Readonly<{
                    "onUpdate:formatted-value"?: ((...args: any[]) => any) | undefined;
                }>, {
                    type: string;
                    updateUnchangedValue: boolean;
                    to: string | false | HTMLElement;
                    holidays: Date[];
                    updateValueOnClose: boolean;
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                model: {
                    type: PropType<AnyObject>;
                    default: null;
                };
                readonly: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{}>, {
                model: AnyObject;
                readonly: boolean;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("confirm" | "update:visible")[], "confirm" | "update:visible", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            visible: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{
            onConfirm?: ((...args: any[]) => any) | undefined;
            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
        }>, {
            visible: boolean;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("confirm" | "update:visible")[], "confirm" | "update:visible", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        visible: {
            type: BooleanConstructor;
            default: boolean;
        };
        isFieldColor: {
            type: BooleanConstructor;
            default: boolean;
        };
        row: {
            type: PropType<AnyObject | null>;
            default: null;
        };
        readonly: {
            type: BooleanConstructor;
            default: boolean;
        };
        isAdd: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & Readonly<{
        onConfirm?: ((...args: any[]) => any) | undefined;
        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
    }>, {
        row: AnyObject | null;
        visible: boolean;
        readonly: boolean;
        isAdd: boolean;
        isFieldColor: boolean;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly setStyle: typeof setStyle;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("close" | "save")[], "close" | "save", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    footerFlag: {
        type: BooleanConstructor;
        default: boolean;
    };
    isFieldColor: {
        type: BooleanConstructor;
        default: boolean;
    };
    defaultList: {
        type: PropType<AnyObject[]>;
        default: () => never[];
    };
}>> & Readonly<{
    onSave?: ((...args: any[]) => any) | undefined;
    onClose?: ((...args: any[]) => any) | undefined;
}>, {
    defaultList: AnyObject[];
    footerFlag: boolean;
    isFieldColor: boolean;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
export default _default;