import { SFCWithInstall } from '../../shared/types';
declare const CClassification: SFCWithInstall<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
    tableId: {
        type: StringConstructor;
        default: string;
    };
    searchFieldList: {
        type: import("vue").PropType<any[]>;
        default: () => never[];
    };
    conditionMap: {
        type: import("vue").PropType<import("..").IConditionMapType>;
        default: () => {};
    };
    conditionSid: {
        type: import("vue").PropType<string[]>;
        default: () => string[];
    };
    curClassificationIndex: {
        type: NumberConstructor;
        default: number;
    };
    showClassificationIndexs: {
        type: import("vue").PropType<number[]>;
        default: () => number[];
    };
    curClassificationWidth: {
        type: NumberConstructor;
    };
    hideConditionChangeBtn: {
        type: NumberConstructor;
        default: number;
    };
    hideConditionChangeSetting: {
        type: NumberConstructor;
        default: number;
    };
    hideClearConditionChange: {
        type: NumberConstructor;
        default: number;
    };
    isShowResetButton: {
        type: BooleanConstructor;
        default: boolean;
    };
    filterApiConfig: {
        type: ObjectConstructor;
        default: () => {};
    };
    condiTionDigital: {
        type: ObjectConstructor;
        default: () => {};
    };
    filterType: {
        type: StringConstructor;
        default: string;
    };
}>, {
    handleGetConfigApi: (params: any, key: string, config: {} | undefined, filterApiConfigVal: any) => Promise<any>;
    transformClassifyChild: (conObjList: any, searchFieldList: any[]) => any;
    attrs: any;
    $message: import("naive-ui/es/message").MessageApi;
    props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
        tableId: {
            type: StringConstructor;
            default: string;
        };
        searchFieldList: {
            type: import("vue").PropType<any[]>;
            default: () => never[];
        };
        conditionMap: {
            type: import("vue").PropType<import("..").IConditionMapType>;
            default: () => {};
        };
        conditionSid: {
            type: import("vue").PropType<string[]>;
            default: () => string[];
        };
        curClassificationIndex: {
            type: NumberConstructor;
            default: number;
        };
        showClassificationIndexs: {
            type: import("vue").PropType<number[]>;
            default: () => number[];
        };
        curClassificationWidth: {
            type: NumberConstructor;
        };
        hideConditionChangeBtn: {
            type: NumberConstructor;
            default: number;
        };
        hideConditionChangeSetting: {
            type: NumberConstructor;
            default: number;
        };
        hideClearConditionChange: {
            type: NumberConstructor;
            default: number;
        };
        isShowResetButton: {
            type: BooleanConstructor;
            default: boolean;
        };
        filterApiConfig: {
            type: ObjectConstructor;
            default: () => {};
        };
        condiTionDigital: {
            type: ObjectConstructor;
            default: () => {};
        };
        filterType: {
            type: StringConstructor;
            default: string;
        };
    }>> & Readonly<{
        onChangeSearch?: ((...args: any[]) => any) | undefined;
        onSetClassificationIndex?: ((...args: any[]) => any) | undefined;
        onGetQuickSearchListObj?: ((...args: any[]) => any) | undefined;
    }> & {}>;
    emit: (event: "changeSearch" | "setClassificationIndex" | "getQuickSearchListObj", ...args: any[]) => void;
    selectType: import("vue").Ref<any, any>;
    classificationWidth: import("vue").Ref<number, number>;
    selectShow: import("vue").Ref<boolean, boolean>;
    treeData: import("vue").Ref<{
        [x: string]: any;
        name: string;
        sid: string;
        children: {
            [x: string]: any;
            displayCategory: string;
            isDefault: boolean;
            isEdit: boolean;
            isShow: boolean;
            name: string;
            sid: string;
            isPublic?: string | undefined;
            classifyId?: string | undefined;
            conObj?: any;
            digital?: number | undefined;
            checked?: boolean | undefined;
            id?: string | undefined;
            isCommon?: boolean | undefined;
            selected?: boolean | undefined;
            sqlExpression?: string | undefined;
            createdByName?: string | undefined;
            from?: string | undefined;
        }[];
        digital?: number | undefined;
        open?: boolean | undefined;
        selected?: boolean | undefined;
    }[], import("..").ITreeDataType[] | {
        [x: string]: any;
        name: string;
        sid: string;
        children: {
            [x: string]: any;
            displayCategory: string;
            isDefault: boolean;
            isEdit: boolean;
            isShow: boolean;
            name: string;
            sid: string;
            isPublic?: string | undefined;
            classifyId?: string | undefined;
            conObj?: any;
            digital?: number | undefined;
            checked?: boolean | undefined;
            id?: string | undefined;
            isCommon?: boolean | undefined;
            selected?: boolean | undefined;
            sqlExpression?: string | undefined;
            createdByName?: string | undefined;
            from?: string | undefined;
        }[];
        digital?: number | undefined;
        open?: boolean | undefined;
        selected?: boolean | undefined;
    }[]>;
    conditionLists: import("vue").Ref<{
        [x: string]: any;
        displayCategory: string;
        isDefault: boolean;
        isEdit: boolean;
        isShow: boolean;
        name: string;
        sid: string;
        isPublic?: string | undefined;
        classifyId?: string | undefined;
        conObj?: any;
        digital?: number | undefined;
        checked?: boolean | undefined;
        id?: string | undefined;
        isCommon?: boolean | undefined;
        selected?: boolean | undefined;
        sqlExpression?: string | undefined;
        createdByName?: string | undefined;
        from?: string | undefined;
    }[], import("..").IClassifyListType[] | {
        [x: string]: any;
        displayCategory: string;
        isDefault: boolean;
        isEdit: boolean;
        isShow: boolean;
        name: string;
        sid: string;
        isPublic?: string | undefined;
        classifyId?: string | undefined;
        conObj?: any;
        digital?: number | undefined;
        checked?: boolean | undefined;
        id?: string | undefined;
        isCommon?: boolean | undefined;
        selected?: boolean | undefined;
        sqlExpression?: string | undefined;
        createdByName?: string | undefined;
        from?: string | undefined;
    }[]>;
    originConditionList: import("vue").Ref<{
        [x: string]: any;
        displayCategory: string;
        isDefault: boolean;
        isEdit: boolean;
        isShow: boolean;
        name: string;
        sid: string;
        isPublic?: string | undefined;
        classifyId?: string | undefined;
        conObj?: any;
        digital?: number | undefined;
        checked?: boolean | undefined;
        id?: string | undefined;
        isCommon?: boolean | undefined;
        selected?: boolean | undefined;
        sqlExpression?: string | undefined;
        createdByName?: string | undefined;
        from?: string | undefined;
    }[], import("..").IClassifyListType[] | {
        [x: string]: any;
        displayCategory: string;
        isDefault: boolean;
        isEdit: boolean;
        isShow: boolean;
        name: string;
        sid: string;
        isPublic?: string | undefined;
        classifyId?: string | undefined;
        conObj?: any;
        digital?: number | undefined;
        checked?: boolean | undefined;
        id?: string | undefined;
        isCommon?: boolean | undefined;
        selected?: boolean | undefined;
        sqlExpression?: string | undefined;
        createdByName?: string | undefined;
        from?: string | undefined;
    }[]>;
    classificationIndex: import("vue").Ref<number, number>;
    allObj: import("vue").Ref<any, any>;
    displayCategoryLists: import("vue").Ref<string[], string[]>;
    settingId: import("vue").Ref<string, string>;
    classifyModal: import("vue").Ref<boolean, boolean>;
    showTitleName: import("vue").Ref<string, string>;
    dynamicStyle: import("vue").ComputedRef<{
        marginRight: string;
        display?: undefined;
    } | {
        display: string;
        marginRight?: undefined;
    } | {
        marginRight?: undefined;
        display?: undefined;
    }>;
    titleName: import("vue").ComputedRef<string>;
    tooltipTilte: import("vue").ComputedRef<(item: any) => string>;
    handleFold: (item: import("..").ITreeDataType) => void;
    handleItemClick: (child: import("..").IClassifyItemType, i?: number | undefined, p?: import("..").ITreeDataType | undefined) => void;
    initTree: (conditionSidTemp: string[]) => import("..").IClassifyListType[];
    getConditionSid: (sid: string, conditionSidVal: string[], p?: import("..").ITreeDataType | undefined) => string[];
    handleModeChange: () => void;
    saveListPersonaSetting: (classificationIndexVal: number, classificationWidthVal?: number | undefined) => Promise<void>;
    handleSettingShow: () => void;
    setClassifyModal: (val: boolean) => void;
    toggleSelect: (flag?: boolean | undefined) => void;
    initTableCondiTionList: () => import("naive-ui/es/message").MessageReactive | undefined;
    setOpenStatus: (value: boolean) => void;
    tableCondiTionPromise: () => Promise<void>;
    changeWidth: ({ distance }: any) => void;
    saveWidth: () => void;
    updateTableCondiTion: () => Promise<void>;
    saveGetTableCondiTionList: (options: any) => Promise<void>;
    getTableCondiTionListRequest: (first?: boolean | undefined) => void;
    handleGetTableCondiTionList: (first?: boolean | undefined, conditionMapVal?: {}) => Promise<unknown>;
    getTableCondiTionListNew: (tableIdVal: any) => Promise<any>;
    fmtChildName: (name: string, isPublic?: string | undefined) => string;
    mergeDigitalMapToTreeData: (list: any[], digitalObj: import("../../shared/types").AnyObject) => void;
    handlePathClick: (e: Event) => void;
    readonly NIcon: any;
    readonly NTooltip: any;
    readonly SettingsOutline: 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 Repeat: 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 Checkmark: 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 ChevronUp: 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 ChevronDown: 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 ChevronForward: 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 Close: 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>;
    SetClassification: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
        searchFieldList: {
            type: ArrayConstructor;
            default: () => never[];
        };
        conditionList: {
            type: ArrayConstructor;
            default: () => never[];
        };
        settingId: StringConstructor;
        classifyModal: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>, {
        props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
            searchFieldList: {
                type: ArrayConstructor;
                default: () => never[];
            };
            conditionList: {
                type: ArrayConstructor;
                default: () => never[];
            };
            settingId: StringConstructor;
            classifyModal: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{
            onCondiTionListInit?: ((...args: any[]) => any) | undefined;
            onSaveGetTableCondiTionList?: ((...args: any[]) => any) | undefined;
            onSetClassifyModal?: ((...args: any[]) => any) | undefined;
        }> & {}>;
        emit: (event: "CondiTionListInit" | "saveGetTableCondiTionList" | "setClassifyModal", ...args: any[]) => void;
        $message: import("naive-ui/es/message").MessageApi;
        handleGetConfigApi: (params: any, key: string, config: {} | undefined, filterApiConfigVal: any) => Promise<any>;
        conditionList: import("vue").Ref<unknown[], unknown[]>;
        addVisible: import("vue").Ref<boolean, boolean>;
        actionList_prop: import("vue").Ref<{}, {}>;
        newSearchFieldList: import("vue").Ref<any, any>;
        saveLoading: import("vue").Ref<boolean, boolean>;
        searchFilter: import("vue").Ref<any, any>;
        filterApiConfig: import("../../shared/types").AnyObject;
        attrs: {
            [x: string]: unknown;
        };
        oneSave: (value: any) => Promise<void>;
        oneCancel: () => void;
        hanleAdd: () => void;
        edit: (item: import("..").IClassifyListType) => void;
        copy: (item: import("..").IClassifyListType) => void;
        saveAdd: (params: any) => Promise<void>;
        cancelSaveAdd: () => void;
        delItem: (checkedItemVal: any) => Promise<void>;
        setOneVisible: (flag: boolean) => void;
        resetPopconfirm: () => Promise<void>;
        oneVisible: import("vue").ComputedRef<boolean>;
        readonly NButton: any;
        TableModal: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            visibleIn: {
                type: BooleanConstructor;
            };
            loading: {
                type: BooleanConstructor;
            };
            confirm: {
                type: FunctionConstructor;
            };
            edit: {
                type: FunctionConstructor;
                defdault: () => {};
            };
            copy: {
                type: FunctionConstructor;
                defdault: () => {};
            };
            delItem: {
                type: FunctionConstructor;
                defdault: () => {};
            };
            dataSource: {
                type: ArrayConstructor;
                default: () => never[];
            };
            type: {
                type: StringConstructor;
                default: string;
            };
            transitionName: {
                type: StringConstructor;
            };
            getContainer: {
                type: FunctionConstructor;
                default: () => HTMLElement;
            };
        }>, {
            props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                visibleIn: {
                    type: BooleanConstructor;
                };
                loading: {
                    type: BooleanConstructor;
                };
                confirm: {
                    type: FunctionConstructor;
                };
                edit: {
                    type: FunctionConstructor;
                    defdault: () => {};
                };
                copy: {
                    type: FunctionConstructor;
                    defdault: () => {};
                };
                delItem: {
                    type: FunctionConstructor;
                    defdault: () => {};
                };
                dataSource: {
                    type: ArrayConstructor;
                    default: () => never[];
                };
                type: {
                    type: StringConstructor;
                    default: string;
                };
                transitionName: {
                    type: StringConstructor;
                };
                getContainer: {
                    type: FunctionConstructor;
                    default: () => HTMLElement;
                };
            }>> & Readonly<{
                onClose?: ((...args: any[]) => any) | undefined;
                onHandleOk?: ((...args: any[]) => any) | undefined;
                onResetPopconfirm?: ((...args: any[]) => any) | undefined;
                onFinishSubmit?: ((...args: any[]) => any) | undefined;
            }> & {}>;
            emits: (event: "close" | "handleOk" | "resetPopconfirm" | "finishSubmit", ...args: any[]) => void;
            homeList: any;
            visible: import("vue").Ref<boolean, boolean>;
            isChangeWindow: import("vue").Ref<boolean, boolean>;
            modalWidth: import("vue").Ref<string, string>;
            modalHeight: import("vue").Ref<string, string>;
            isShowResetButton: boolean;
            handleOk: () => void;
            close: () => void;
            resetChangeWindow: () => void;
            clickli: (item: import("..").IClassifyListType) => void;
            clickChecked: (item: import("..").IClassifyListType) => void;
            changeSwitch: (item: import("..").IClassifyListType) => void;
            formatParams: (type: string) => {
                id: string;
                tableId: string;
                setting: string;
            } | undefined;
            changeModalWindow: () => void;
            popconfirm: (e: any) => void;
            handleOperationItem: (option: string, item: import("..").IClassifyListType, name?: string | undefined) => void;
            readonly NModal: any;
            readonly NCard: any;
            readonly NIcon: any;
            readonly NButton: any;
            readonly NTooltip: any;
            readonly NSwitch: any;
            readonly NPopconfirm: any;
            readonly DocumentOutline: 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 Brush: 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 ReorderTwo: 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 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>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("close" | "handleOk" | "resetPopconfirm" | "finishSubmit")[], "close" | "handleOk" | "resetPopconfirm" | "finishSubmit", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            visibleIn: {
                type: BooleanConstructor;
            };
            loading: {
                type: BooleanConstructor;
            };
            confirm: {
                type: FunctionConstructor;
            };
            edit: {
                type: FunctionConstructor;
                defdault: () => {};
            };
            copy: {
                type: FunctionConstructor;
                defdault: () => {};
            };
            delItem: {
                type: FunctionConstructor;
                defdault: () => {};
            };
            dataSource: {
                type: ArrayConstructor;
                default: () => never[];
            };
            type: {
                type: StringConstructor;
                default: string;
            };
            transitionName: {
                type: StringConstructor;
            };
            getContainer: {
                type: FunctionConstructor;
                default: () => HTMLElement;
            };
        }>> & Readonly<{
            onClose?: ((...args: any[]) => any) | undefined;
            onHandleOk?: ((...args: any[]) => any) | undefined;
            onResetPopconfirm?: ((...args: any[]) => any) | undefined;
            onFinishSubmit?: ((...args: any[]) => any) | undefined;
        }>, {
            loading: boolean;
            type: string;
            visibleIn: boolean;
            dataSource: unknown[];
            getContainer: Function;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        SearchFilter: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
            visible: {
                type: BooleanConstructor;
                default: boolean;
            };
            modalTitle: {
                type: StringConstructor;
                default: string;
            };
            conditionList: {
                type: ArrayConstructor;
                default: () => never[];
            };
            searchFieldList: {
                type: ArrayConstructor;
                default: () => never[];
            };
        }>, {
            props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                visible: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                modalTitle: {
                    type: StringConstructor;
                    default: string;
                };
                conditionList: {
                    type: ArrayConstructor;
                    default: () => never[];
                };
                searchFieldList: {
                    type: ArrayConstructor;
                    default: () => never[];
                };
            }>> & Readonly<{
                onCancelSaveAdd?: ((...args: any[]) => any) | undefined;
            }> & {}>;
            emits: (event: "cancelSaveAdd", ...args: any[]) => void;
            addVisible: import("vue").Ref<boolean, boolean>;
            isChangeWindow: import("vue").Ref<boolean, boolean>;
            modalWidth: import("vue").Ref<string, string>;
            bodyStyle: import("vue").Ref<{
                maxHeight: string;
                height: string;
            }, {
                maxHeight: string;
                height: string;
            } | {
                maxHeight: string;
                height: string;
            }>;
            conditionApiRef: import("vue").Ref<any, any>;
            filterTimer: any;
            classifyfilterType: String;
            init: () => void;
            clearTimer: () => void;
            handleInitConditions: () => void;
            saveAdd: () => void;
            cancelSaveAdd: () => void;
            clearConditions: () => void;
            resetChangeWindow: () => void;
            changeModalWindow: () => void;
            readonly NModal: any;
            readonly NCard: any;
            readonly NButton: any;
            ClassifyFilterConditionByApi: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                actionList_prop: {
                    type: import("vue").PropType<import("..").IClassifyListType>;
                    default: () => {};
                };
                conditionList: {
                    type: ArrayConstructor;
                    default: () => never[];
                };
                tableId: {
                    type: StringConstructor;
                    default: string;
                };
                searchFieldList: {
                    type: ArrayConstructor;
                    default: () => never[];
                };
                showItemName: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                hideAddBtn: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>, {
                $message: import("naive-ui/es/message").MessageApi;
                menuProps: {
                    class: string;
                };
                specialDateRange: string[];
                specialCustomDateRange: string[];
                props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                    actionList_prop: {
                        type: import("vue").PropType<import("..").IClassifyListType>;
                        default: () => {};
                    };
                    conditionList: {
                        type: ArrayConstructor;
                        default: () => never[];
                    };
                    tableId: {
                        type: StringConstructor;
                        default: string;
                    };
                    searchFieldList: {
                        type: ArrayConstructor;
                        default: () => never[];
                    };
                    showItemName: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    hideAddBtn: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>> & Readonly<{
                    onCancelSaveAdd?: ((...args: any[]) => any) | undefined;
                    onSaveAdd?: ((...args: any[]) => any) | undefined;
                }> & {}>;
                emit: (event: "cancelSaveAdd" | "saveAdd", ...args: any[]) => void;
                $attrs: {
                    [x: string]: unknown;
                };
                FormState: {
                    className: string;
                    displayCategory: string;
                    filterConditions: {
                        condition: string;
                        key: string;
                        presetVal: string;
                        value: string;
                        isAccurateSearch?: boolean | undefined;
                        accurateSearchKey?: string | undefined;
                        customDate?: string | undefined;
                    }[];
                };
                loading: import("vue").Ref<boolean, boolean>;
                parentInputRef: import("vue").Ref<any, any>;
                parentInputAddRef: import("vue").Ref<any, any>;
                DisplayCategoryState: {
                    addDisplayCategory: string;
                    displayCategories: {
                        disabled: boolean;
                        value: string;
                    }[];
                    displayCategoryOriginLen: number;
                    showAdd: boolean;
                };
                isEnableAddDisplayCategory: import("vue").ComputedRef<boolean>;
                editDisplayCategory: (item: import("..").ICategoryItemType, cb?: any) => void;
                handleDisplayCategorySelect: (item: import("..").ICategoryItemType) => void;
                handleDisplayCategoryRemove: (index: number, item: import("..").ICategoryItemType) => void;
                handleDisplayCategoryAdd: (cb?: any) => void;
                handlerBlur: () => void;
                initDisplayCategories: (rawDataDisplayCategories: any, displayCategory: any) => void;
                FilterConditionsState: any;
                paramOptions: import("vue").ComputedRef<any>;
                addFilterCondition: () => void;
                delFilterCondition: (index: number) => void;
                updateKey: (index: number, val: any) => void;
                updateCondition: (index: number, val: any) => void;
                getParamCfg: (key: string) => any;
                initFilterConditions: (tableId: string, rawConditions: import("..").ISearchConfigType) => Promise<void>;
                getRawFilterConditions: () => any[];
                dateTypeList: string[];
                getOptions: (key: string) => {
                    label: string;
                    value: string;
                }[];
                handleEditDisplayCategory: (item: import("..").ICategoryItemType) => void;
                handleDisplayCategoryAddState: () => void;
                findConditionByDisplayCategory: (sid: string) => unknown;
                handleDisplayCategorySelectProxy: (item: import("..").ICategoryItemType) => void;
                clearFormData: () => void;
                handleInitConditions: () => Promise<void>;
                validate: () => Promise<unknown>;
                saveAdd: () => void;
                cancelSaveAdd: () => void;
                checkActionList: () => boolean;
                readonly NSpin: any;
                readonly NIcon: any;
                readonly NInput: any;
                readonly NButton: any;
                readonly NTooltip: any;
                readonly NSelect: any;
                readonly AddOutline: 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 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 CloseOutline: 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>;
                ValueCfg: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    item: {
                        type: ObjectConstructor;
                        default: null;
                    };
                    paramCfg: {
                        type: ObjectConstructor;
                        default: null;
                    };
                    modelValue: {
                        type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                        default: null;
                    };
                    presetVal: {
                        type: StringConstructor;
                        default: null;
                    };
                    isAccurate: {
                        type: BooleanConstructor;
                    };
                    customDate: {
                        type: StringConstructor;
                        default: null;
                    };
                }>, {
                    props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                        item: {
                            type: ObjectConstructor;
                            default: null;
                        };
                        paramCfg: {
                            type: ObjectConstructor;
                            default: null;
                        };
                        modelValue: {
                            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                            default: null;
                        };
                        presetVal: {
                            type: StringConstructor;
                            default: null;
                        };
                        isAccurate: {
                            type: BooleanConstructor;
                        };
                        customDate: {
                            type: StringConstructor;
                            default: null;
                        };
                    }>> & Readonly<{
                        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                        "onUpdate:isAccurate"?: ((...args: any[]) => any) | undefined;
                        "onUpdate:presetVal"?: ((...args: any[]) => any) | undefined;
                        "onUpdate:customDate"?: ((...args: any[]) => any) | undefined;
                    }> & {}>;
                    emit: (event: "update:modelValue" | "update:isAccurate" | "update:presetVal" | "update:customDate", ...args: any[]) => void;
                    valueCp: import("vue").WritableComputedRef<any, any>;
                    presetValCp: import("vue").WritableComputedRef<string, string>;
                    isAccurateCp: import("vue").WritableComputedRef<boolean, boolean>;
                    customDateCp: import("vue").WritableComputedRef<string, string>;
                    widgetType: import("vue").ComputedRef<any>;
                    readonly Date: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        componentCfg: {
                            type: ObjectConstructor;
                        };
                        item: {
                            type: ObjectConstructor;
                            required: true;
                        };
                        paramCfg: {
                            type: ObjectConstructor;
                            default: null;
                        };
                        modelValue: {
                            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                            default: null;
                        };
                        presetVal: {
                            type: StringConstructor;
                            default: null;
                        };
                        customDate: {
                            type: StringConstructor;
                            default: null;
                        };
                    }>, {
                        props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                            componentCfg: {
                                type: ObjectConstructor;
                            };
                            item: {
                                type: ObjectConstructor;
                                required: true;
                            };
                            paramCfg: {
                                type: ObjectConstructor;
                                default: null;
                            };
                            modelValue: {
                                type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                                default: null;
                            };
                            presetVal: {
                                type: StringConstructor;
                                default: null;
                            };
                            customDate: {
                                type: StringConstructor;
                                default: null;
                            };
                        }>> & Readonly<{
                            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                            "onUpdate:presetVal"?: ((...args: any[]) => any) | undefined;
                            "onUpdate:customDate"?: ((...args: any[]) => any) | undefined;
                        }> & {}>;
                        emit: (event: "update:modelValue" | "update:presetVal" | "update:customDate", ...args: any[]) => void;
                        filterType: import("vue").ComputedRef<"1" | "3" | "2">;
                        valueCp: import("vue").WritableComputedRef<any, any>;
                        presetValCp: import("vue").WritableComputedRef<string, string>;
                        dateType: any;
                        valueFormat: import("vue").ComputedRef<string>;
                        compType: import("vue").ComputedRef<any>;
                        optionSetting: import("vue").ComputedRef<any>;
                        widgetOptions: import("vue").ComputedRef<{
                            label: string;
                            value: string;
                        }[]>;
                        isDateDisabled: (ts: number) => boolean;
                        timeDisabled: (ts: number) => {
                            isHourDisabled(hour: number): boolean | undefined;
                            isMinuteDisabled(minute: number, hour: number | null): boolean | undefined;
                            isSecondDisabled(second: number, minute: number | null, hour: number | null): boolean | undefined;
                        };
                        readonly CDatePicker: SFCWithInstall<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                            updateUnchangedValue: {
                                type: BooleanConstructor;
                            };
                            onConfirm: {
                                type: FunctionConstructor;
                            };
                            formattedValue: {
                                type: import("vue").PropType<(string | [string, string]) | null | undefined>;
                            };
                            placeholder: {
                                type: StringConstructor;
                            };
                            allowedInvalidValue: {
                                type: StringConstructor;
                            };
                            to: {
                                type: import("vue").PropType<string | false | HTMLElement>;
                                default: string;
                            };
                            holidays: {
                                type: import("vue").PropType<Date[]>;
                                default: () => never[];
                            };
                            type: {
                                type: StringConstructor;
                                default: string;
                            };
                            updateValueOnClose: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            isDateDisabled: {
                                type: import("vue").PropType<(current: number, ...arg: any[]) => boolean>;
                            };
                            propKey: {
                                type: StringConstructor;
                            };
                            shortcutListenerConfig: {
                                type: import("vue").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: import("vue").PropType<(string | [string, string]) | null | undefined>;
                                };
                                placeholder: {
                                    type: StringConstructor;
                                };
                                allowedInvalidValue: {
                                    type: StringConstructor;
                                };
                                to: {
                                    type: import("vue").PropType<string | false | HTMLElement>;
                                    default: string;
                                };
                                holidays: {
                                    type: import("vue").PropType<Date[]>;
                                    default: () => never[];
                                };
                                type: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                updateValueOnClose: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                isDateDisabled: {
                                    type: import("vue").PropType<(current: number, ...arg: any[]) => boolean>;
                                };
                                propKey: {
                                    type: StringConstructor;
                                };
                                shortcutListenerConfig: {
                                    type: import("vue").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<import("../../shared/types").AnyObject | null, import("../../shared/types").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: import("vue").PropType<(string | [string, string]) | null | undefined>;
                            };
                            placeholder: {
                                type: StringConstructor;
                            };
                            allowedInvalidValue: {
                                type: StringConstructor;
                            };
                            to: {
                                type: import("vue").PropType<string | false | HTMLElement>;
                                default: string;
                            };
                            holidays: {
                                type: import("vue").PropType<Date[]>;
                                default: () => never[];
                            };
                            type: {
                                type: StringConstructor;
                                default: string;
                            };
                            updateValueOnClose: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            isDateDisabled: {
                                type: import("vue").PropType<(current: number, ...arg: any[]) => boolean>;
                            };
                            propKey: {
                                type: StringConstructor;
                            };
                            shortcutListenerConfig: {
                                type: import("vue").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>>;
                        readonly NSelect: any;
                        DateOption: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                            filterType: {
                                type: StringConstructor;
                                required: true;
                            };
                            modelValue: {
                                type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                                default: null;
                            };
                            presetVal: {
                                type: StringConstructor;
                                default: null;
                            };
                            dateType: {
                                type: StringConstructor;
                            };
                            isDateDisabled: {
                                type: FunctionConstructor;
                            };
                            timeDisabled: {
                                type: FunctionConstructor;
                            };
                            valueFormat: {
                                type: StringConstructor;
                            };
                        }>, {
                            widgetOptions: {
                                label: string;
                                value: string;
                            }[];
                            widgetRangeOptions: {
                                label: string;
                                value: string;
                            }[];
                            startDateNum: import("vue").Ref<any, any>;
                            endDateNum: import("vue").Ref<any, any>;
                            props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                                filterType: {
                                    type: StringConstructor;
                                    required: true;
                                };
                                modelValue: {
                                    type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                                    default: null;
                                };
                                presetVal: {
                                    type: StringConstructor;
                                    default: null;
                                };
                                dateType: {
                                    type: StringConstructor;
                                };
                                isDateDisabled: {
                                    type: FunctionConstructor;
                                };
                                timeDisabled: {
                                    type: FunctionConstructor;
                                };
                                valueFormat: {
                                    type: StringConstructor;
                                };
                            }>> & Readonly<{
                                "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                                "onUpdate:presetVal"?: ((...args: any[]) => any) | undefined;
                            }> & {}>;
                            emit: (event: "update:modelValue" | "update:presetVal", ...args: any[]) => void;
                            valueCp: import("vue").WritableComputedRef<any, any>;
                            presetValCp: import("vue").WritableComputedRef<string, string>;
                            handleChange: (val: any, type: "start" | "end") => void;
                            readonly NSelect: any;
                            readonly NInputNumber: any;
                        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "update:presetVal")[], "update:modelValue" | "update:presetVal", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                            filterType: {
                                type: StringConstructor;
                                required: true;
                            };
                            modelValue: {
                                type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                                default: null;
                            };
                            presetVal: {
                                type: StringConstructor;
                                default: null;
                            };
                            dateType: {
                                type: StringConstructor;
                            };
                            isDateDisabled: {
                                type: FunctionConstructor;
                            };
                            timeDisabled: {
                                type: FunctionConstructor;
                            };
                            valueFormat: {
                                type: StringConstructor;
                            };
                        }>> & Readonly<{
                            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                            "onUpdate:presetVal"?: ((...args: any[]) => any) | undefined;
                        }>, {
                            modelValue: string | number | unknown[];
                            presetVal: string;
                        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                        readonly WidgetValEnums: {
                            CUSTOM: string;
                            FIRST_VAL: string;
                            WHOLE: string;
                            NOW: string;
                            TODAY: string;
                            TODAY_START: string;
                            TODAY_END: string;
                            TOMORROW: string;
                            TOMORROW_START: string;
                            TOMORROW_END: string;
                            YESTERDAY: string;
                            YESTERDAY_START: string;
                            YESTERDAY_END: string;
                            THIS_WEEK: string;
                            WEEK_START: string;
                            WEEK_END: string;
                            NEXT_WEEK: string;
                            LAST_WEEK: string;
                            THIS_MONTH: string;
                            MONTH_START: string;
                            MONTH_END: string;
                            NEXT_MONTH: string;
                            LAST_MONTH: string;
                            THIS_QUARTER: string;
                            NEXT_QUARTER: string;
                            LAST_QUARTER: string;
                            THIS_YEAR: string;
                            NEXT_YEAR: string;
                            LAST_YEAR: string;
                        };
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "update:presetVal" | "update:customDate")[], "update:modelValue" | "update:presetVal" | "update:customDate", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        componentCfg: {
                            type: ObjectConstructor;
                        };
                        item: {
                            type: ObjectConstructor;
                            required: true;
                        };
                        paramCfg: {
                            type: ObjectConstructor;
                            default: null;
                        };
                        modelValue: {
                            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                            default: null;
                        };
                        presetVal: {
                            type: StringConstructor;
                            default: null;
                        };
                        customDate: {
                            type: StringConstructor;
                            default: null;
                        };
                    }>> & Readonly<{
                        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                        "onUpdate:presetVal"?: ((...args: any[]) => any) | undefined;
                        "onUpdate:customDate"?: ((...args: any[]) => any) | undefined;
                    }>, {
                        modelValue: string | number | unknown[];
                        paramCfg: Record<string, any>;
                        presetVal: string;
                        customDate: string;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                    readonly InputFilter: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        paramCfg: {
                            type: ObjectConstructor;
                            default: null;
                        };
                        modelValue: {
                            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                            default: null;
                        };
                        isAccurateFilter: {
                            type: BooleanConstructor;
                        };
                    }>, {
                        props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                            paramCfg: {
                                type: ObjectConstructor;
                                default: null;
                            };
                            modelValue: {
                                type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                                default: null;
                            };
                            isAccurateFilter: {
                                type: BooleanConstructor;
                            };
                        }>> & Readonly<{
                            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                            "onUpdate:isAccurateFilter"?: ((...args: any[]) => any) | undefined;
                        }> & {}>;
                        emit: (event: "update:modelValue" | "update:isAccurateFilter", ...args: any[]) => void;
                        optionList: import("vue").Ref<{
                            label: string;
                            value: number;
                        }[], {
                            label: string;
                            value: number;
                        }[] | {
                            label: string;
                            value: number;
                        }[]>;
                        valueCp: import("vue").WritableComputedRef<any, any>;
                        isAccurateFilterCp: import("vue").WritableComputedRef<number, number>;
                        isShowSearch: import("vue").ComputedRef<any>;
                        readonly NInput: any;
                        readonly NSelect: any;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "update:isAccurateFilter")[], "update:modelValue" | "update:isAccurateFilter", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        paramCfg: {
                            type: ObjectConstructor;
                            default: null;
                        };
                        modelValue: {
                            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                            default: null;
                        };
                        isAccurateFilter: {
                            type: BooleanConstructor;
                        };
                    }>> & Readonly<{
                        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                        "onUpdate:isAccurateFilter"?: ((...args: any[]) => any) | undefined;
                    }>, {
                        modelValue: string | number | unknown[];
                        paramCfg: Record<string, any>;
                        isAccurateFilter: boolean;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                    readonly InputNumber: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        modelValue: {
                            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                            default: null;
                        };
                    }>, {
                        props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                            modelValue: {
                                type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                                default: null;
                            };
                        }>> & Readonly<{
                            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                        }> & {}>;
                        emit: (event: "update:modelValue", ...args: any[]) => void;
                        valueCp: import("vue").WritableComputedRef<any, any>;
                        readonly NInputNumber: any;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        modelValue: {
                            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                            default: null;
                        };
                    }>> & Readonly<{
                        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                    }>, {
                        modelValue: string | number | unknown[];
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                    readonly SelectFilter: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        paramCfg: {
                            type: ObjectConstructor;
                            default: null;
                        };
                        modelValue: {
                            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                            default: null;
                        };
                        widgetType: {
                            type: StringConstructor;
                            default: string;
                        };
                    }>, {
                        props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                            paramCfg: {
                                type: ObjectConstructor;
                                default: null;
                            };
                            modelValue: {
                                type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                                default: null;
                            };
                            widgetType: {
                                type: StringConstructor;
                                default: string;
                            };
                        }>> & Readonly<{
                            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                        }> & {}>;
                        emit: (event: "update:modelValue", ...args: any[]) => void;
                        valueCp: import("vue").WritableComputedRef<any, any>;
                        optionSetting: import("vue").ComputedRef<any>;
                        widgetOptions: import("vue").ComputedRef<any>;
                        readonly NSelect: any;
                        readonly WidgetOptionEnums: {
                            RADIO: string;
                            MULTIPLE: string;
                            ALL: string;
                            SELECT_TIME: string;
                            PAST_TIME: string;
                            FUTURE_TIME: string;
                            CUSTOM_TIME: string;
                        };
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        paramCfg: {
                            type: ObjectConstructor;
                            default: null;
                        };
                        modelValue: {
                            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                            default: null;
                        };
                        widgetType: {
                            type: StringConstructor;
                            default: string;
                        };
                    }>> & Readonly<{
                        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                    }>, {
                        modelValue: string | number | unknown[];
                        widgetType: string;
                        paramCfg: Record<string, any>;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                    readonly SelectDynamic: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        paramCfg: {
                            type: ObjectConstructor;
                            default: null;
                        };
                        modelValue: {
                            type: import("vue").PropType<import("../../shared/types").AnyObject[]>;
                            default: null;
                        };
                    }>, {
                        message: import("naive-ui/es/message").MessageApi;
                        props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                            paramCfg: {
                                type: ObjectConstructor;
                                default: null;
                            };
                            modelValue: {
                                type: import("vue").PropType<import("../../shared/types").AnyObject[]>;
                                default: null;
                            };
                        }>> & Readonly<{
                            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                        }> & {}>;
                        getDynamicSelectData: (params: any, filterApiConfig: any) => Promise<any>;
                        emit: (event: "update:modelValue", ...args: any[]) => void;
                        selectDynamicRef: import("vue").Ref<any, any>;
                        isLoading: import("vue").Ref<boolean, boolean>;
                        filterApiConfig: import("../../shared/types").AnyObject;
                        classifyFilterList: import("vue").Ref<import("../../shared/types").AnyObject[], import("../../shared/types").AnyObject[]>;
                        totalPage: import("vue").Ref<number, number>;
                        menuProps: {
                            class: string;
                        };
                        curPage: import("vue").Ref<number, number>;
                        fieldTitleList: import("vue").Ref<any, any>;
                        selectOptions: import("vue").Ref<any[], any[]>;
                        keywordVal: import("vue").Ref<any, any>;
                        optionSetting: import("vue").ComputedRef<any>;
                        isMultiple: import("vue").ComputedRef<boolean>;
                        dynamicOptionInfos: import("vue").ComputedRef<any>;
                        isLastPage: import("vue").ComputedRef<boolean>;
                        originList: import("vue").ComputedRef<any[]>;
                        valueCp: import("vue").ComputedRef<string | any[]>;
                        isInitRequest: import("vue").ComputedRef<boolean>;
                        setOptionActive: (selectIds: string[]) => void;
                        handleUpdateSelect: (value: string[] | null) => void;
                        handleUpdatePage: (page: number) => Promise<void>;
                        getOptionsData: (keyword: string, curPage: number) => Promise<any>;
                        isWhole: (value: string) => boolean;
                        _handleSearch: (query: string) => Promise<void>;
                        handleSearch: (query: string) => Promise<void>;
                        handleInitData: () => Promise<void>;
                        handleClear: () => Promise<void>;
                        handleUpdateShow: (show: boolean) => void;
                        renderTag: ({ option, handleClose }: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>;
                        init: () => void;
                        saveDynamicBaseList: (selectValue: any[] | null) => void;
                        readonly NSelect: any;
                        SelectDynamicOption: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                            oldValue: {
                                type: import("vue").PropType<import("../../shared/types").AnyObject[]>;
                                default: () => never[];
                            };
                            dynamicOptionInfo: {
                                type: import("vue").PropType<import("../../shared/types").AnyObject>;
                                default: () => {};
                            };
                            fieldTitleList: {
                                type: import("vue").PropType<import("../../shared/types").AnyObject[]>;
                                default: () => never[];
                            };
                            optionList: {
                                type: import("vue").PropType<import("../../shared/types").AnyObject[]>;
                                default: () => never[];
                            };
                            isMultiple: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            curPage: {
                                type: NumberConstructor;
                                default: number;
                            };
                            isLastPage: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            isShowWhole: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            loading: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                        }>, {
                            selectMinWidth: number;
                            props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                                oldValue: {
                                    type: import("vue").PropType<import("../../shared/types").AnyObject[]>;
                                    default: () => never[];
                                };
                                dynamicOptionInfo: {
                                    type: import("vue").PropType<import("../../shared/types").AnyObject>;
                                    default: () => {};
                                };
                                fieldTitleList: {
                                    type: import("vue").PropType<import("../../shared/types").AnyObject[]>;
                                    default: () => never[];
                                };
                                optionList: {
                                    type: import("vue").PropType<import("../../shared/types").AnyObject[]>;
                                    default: () => never[];
                                };
                                isMultiple: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                curPage: {
                                    type: NumberConstructor;
                                    default: number;
                                };
                                isLastPage: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                isShowWhole: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                loading: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                            }>> & Readonly<{
                                onUpdatePage?: ((...args: any[]) => any) | undefined;
                                onUpdateSelect?: ((...args: any[]) => any) | undefined;
                            }> & {}>;
                            emit: (event: "updateSelect" | "updatePage", ...args: any[]) => void;
                            dragEndWidth: import("vue").Ref<number, number>;
                            showKeys: import("vue").ComputedRef<any>;
                            titleList: import("vue").ComputedRef<string[]>;
                            isOptionsNull: import("vue").ComputedRef<boolean>;
                            handleSelect: (option: any) => void;
                            searchByPage: (onePage: number) => void;
                            changeWidth: ({ distance }: any) => void;
                            saveWidth: () => void;
                            readonly NEmpty: any;
                            readonly NButtonGroup: any;
                            readonly NButton: any;
                            readonly NIcon: any;
                            readonly NPopover: any;
                            readonly vFlexibleResize: {
                                mounted(el: any, { value }: any): void;
                                beforeUnmount(el: any): void;
                            };
                            readonly WidgetValEnums: {
                                CUSTOM: string;
                                FIRST_VAL: string;
                                WHOLE: string;
                                NOW: string;
                                TODAY: string;
                                TODAY_START: string;
                                TODAY_END: string;
                                TOMORROW: string;
                                TOMORROW_START: string;
                                TOMORROW_END: string;
                                YESTERDAY: string;
                                YESTERDAY_START: string;
                                YESTERDAY_END: string;
                                THIS_WEEK: string;
                                WEEK_START: string;
                                WEEK_END: string;
                                NEXT_WEEK: string;
                                LAST_WEEK: string;
                                THIS_MONTH: string;
                                MONTH_START: string;
                                MONTH_END: string;
                                NEXT_MONTH: string;
                                LAST_MONTH: string;
                                THIS_QUARTER: string;
                                NEXT_QUARTER: string;
                                LAST_QUARTER: string;
                                THIS_YEAR: string;
                                NEXT_YEAR: string;
                                LAST_YEAR: string;
                            };
                            readonly ArrowBack: 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 ArrowForward: 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>;
                        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("updateSelect" | "updatePage")[], "updateSelect" | "updatePage", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                            oldValue: {
                                type: import("vue").PropType<import("../../shared/types").AnyObject[]>;
                                default: () => never[];
                            };
                            dynamicOptionInfo: {
                                type: import("vue").PropType<import("../../shared/types").AnyObject>;
                                default: () => {};
                            };
                            fieldTitleList: {
                                type: import("vue").PropType<import("../../shared/types").AnyObject[]>;
                                default: () => never[];
                            };
                            optionList: {
                                type: import("vue").PropType<import("../../shared/types").AnyObject[]>;
                                default: () => never[];
                            };
                            isMultiple: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            curPage: {
                                type: NumberConstructor;
                                default: number;
                            };
                            isLastPage: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            isShowWhole: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            loading: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                        }>> & Readonly<{
                            onUpdatePage?: ((...args: any[]) => any) | undefined;
                            onUpdateSelect?: ((...args: any[]) => any) | undefined;
                        }>, {
                            loading: boolean;
                            isMultiple: boolean;
                            oldValue: import("../../shared/types").AnyObject[];
                            optionList: import("../../shared/types").AnyObject[];
                            isShowWhole: boolean;
                            dynamicOptionInfo: import("../../shared/types").AnyObject;
                            fieldTitleList: import("../../shared/types").AnyObject[];
                            curPage: number;
                            isLastPage: boolean;
                        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        paramCfg: {
                            type: ObjectConstructor;
                            default: null;
                        };
                        modelValue: {
                            type: import("vue").PropType<import("../../shared/types").AnyObject[]>;
                            default: null;
                        };
                    }>> & Readonly<{
                        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                    }>, {
                        modelValue: import("../../shared/types").AnyObject[];
                        paramCfg: Record<string, any>;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                    readonly InputNumberGroup: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        paramCfg: {
                            type: ObjectConstructor;
                            default: null;
                        };
                        modelValue: {
                            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                            default: null;
                        };
                    }>, {
                        props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                            paramCfg: {
                                type: ObjectConstructor;
                                default: null;
                            };
                            modelValue: {
                                type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                                default: null;
                            };
                        }>> & Readonly<{
                            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                        }> & {}>;
                        startNumber: import("vue").Ref<any, any>;
                        endNumber: import("vue").Ref<any, any>;
                        emit: (event: "update:modelValue", ...args: any[]) => void;
                        handleChange: (val: number | null, key: string) => void;
                        readonly NInputGroup: any;
                        readonly NInputNumber: any;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        paramCfg: {
                            type: ObjectConstructor;
                            default: null;
                        };
                        modelValue: {
                            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                            default: null;
                        };
                    }>> & Readonly<{
                        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                    }>, {
                        modelValue: string | number | unknown[];
                        paramCfg: Record<string, any>;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                    readonly DateRange: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        item: {
                            type: ObjectConstructor;
                            required: true;
                        };
                        paramCfg: {
                            type: ObjectConstructor;
                            default: null;
                        };
                        modelValue: {
                            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                            default: null;
                        };
                        presetVal: {
                            type: StringConstructor;
                            default: null;
                        };
                        customDate: {
                            type: StringConstructor;
                            default: null;
                        };
                    }>, {
                        props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                            item: {
                                type: ObjectConstructor;
                                required: true;
                            };
                            paramCfg: {
                                type: ObjectConstructor;
                                default: null;
                            };
                            modelValue: {
                                type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                                default: null;
                            };
                            presetVal: {
                                type: StringConstructor;
                                default: null;
                            };
                            customDate: {
                                type: StringConstructor;
                                default: null;
                            };
                        }>> & Readonly<{
                            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                            "onUpdate:presetVal"?: ((...args: any[]) => any) | undefined;
                            "onUpdate:customDate"?: ((...args: any[]) => any) | undefined;
                        }> & {}>;
                        emit: (event: "update:modelValue" | "update:presetVal" | "update:customDate", ...args: any[]) => void;
                        startDate: import("vue").Ref<any, any>;
                        endDate: import("vue").Ref<any, any>;
                        filterType: import("vue").ComputedRef<"1" | "3" | "2">;
                        valueFormat: import("vue").ComputedRef<string>;
                        dateFormat: import("vue").ComputedRef<string>;
                        compType: import("vue").ComputedRef<any>;
                        optionSetting: import("vue").ComputedRef<any>;
                        isPastTime: import("vue").ComputedRef<boolean>;
                        isFutureTime: import("vue").ComputedRef<boolean>;
                        startPlaceholder: import("vue").ComputedRef<"初始日期" | "初始时间">;
                        endPlaceholder: import("vue").ComputedRef<"截止日期" | "截止时间">;
                        startDefault: import("vue").ComputedRef<string>;
                        endDefault: import("vue").ComputedRef<string>;
                        startDateFormat: import("vue").ComputedRef<string | null>;
                        endDateFormat: import("vue").ComputedRef<string | null>;
                        dateType: any;
                        widgetOptions: import("vue").ComputedRef<{
                            label: string;
                            value: string;
                        }[]>;
                        presetValCp: import("vue").WritableComputedRef<string, string>;
                        valueDateCp: import("vue").WritableComputedRef<string | number | unknown[] | null, unknown>;
                        handleChange: (val: any, type: "start" | "end") => void;
                        isStartDateDisabled: (ts: number) => boolean;
                        timeStartDisabled: (ts: number) => {
                            isHourDisabled(hour: number): boolean | 0;
                            isMinuteDisabled(minute: number, hour: number | null): boolean | 0;
                            isSecondDisabled(second: number, minute: number | null, hour: number | null): boolean | 0;
                        };
                        isEndDateDisabled: (ts: number) => boolean;
                        timeEndDisabled: (ts: number) => {
                            isHourDisabled(hour: number): boolean | 0;
                            isMinuteDisabled(minute: number, hour: number | null): boolean | 0;
                            isSecondDisabled(second: number, minute: number | null, hour: number | null): boolean | 0;
                        };
                        readonly NSelect: any;
                        readonly NPopover: any;
                        readonly CDatePicker: SFCWithInstall<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                            updateUnchangedValue: {
                                type: BooleanConstructor;
                            };
                            onConfirm: {
                                type: FunctionConstructor;
                            };
                            formattedValue: {
                                type: import("vue").PropType<(string | [string, string]) | null | undefined>;
                            };
                            placeholder: {
                                type: StringConstructor;
                            };
                            allowedInvalidValue: {
                                type: StringConstructor;
                            };
                            to: {
                                type: import("vue").PropType<string | false | HTMLElement>;
                                default: string;
                            };
                            holidays: {
                                type: import("vue").PropType<Date[]>;
                                default: () => never[];
                            };
                            type: {
                                type: StringConstructor;
                                default: string;
                            };
                            updateValueOnClose: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            isDateDisabled: {
                                type: import("vue").PropType<(current: number, ...arg: any[]) => boolean>;
                            };
                            propKey: {
                                type: StringConstructor;
                            };
                            shortcutListenerConfig: {
                                type: import("vue").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: import("vue").PropType<(string | [string, string]) | null | undefined>;
                                };
                                placeholder: {
                                    type: StringConstructor;
                                };
                                allowedInvalidValue: {
                                    type: StringConstructor;
                                };
                                to: {
                                    type: import("vue").PropType<string | false | HTMLElement>;
                                    default: string;
                                };
                                holidays: {
                                    type: import("vue").PropType<Date[]>;
                                    default: () => never[];
                                };
                                type: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                updateValueOnClose: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                isDateDisabled: {
                                    type: import("vue").PropType<(current: number, ...arg: any[]) => boolean>;
                                };
                                propKey: {
                                    type: StringConstructor;
                                };
                                shortcutListenerConfig: {
                                    type: import("vue").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<import("../../shared/types").AnyObject | null, import("../../shared/types").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: import("vue").PropType<(string | [string, string]) | null | undefined>;
                            };
                            placeholder: {
                                type: StringConstructor;
                            };
                            allowedInvalidValue: {
                                type: StringConstructor;
                            };
                            to: {
                                type: import("vue").PropType<string | false | HTMLElement>;
                                default: string;
                            };
                            holidays: {
                                type: import("vue").PropType<Date[]>;
                                default: () => never[];
                            };
                            type: {
                                type: StringConstructor;
                                default: string;
                            };
                            updateValueOnClose: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            isDateDisabled: {
                                type: import("vue").PropType<(current: number, ...arg: any[]) => boolean>;
                            };
                            propKey: {
                                type: StringConstructor;
                            };
                            shortcutListenerConfig: {
                                type: import("vue").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>>;
                        DateOption: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                            filterType: {
                                type: StringConstructor;
                                required: true;
                            };
                            modelValue: {
                                type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                                default: null;
                            };
                            presetVal: {
                                type: StringConstructor;
                                default: null;
                            };
                            dateType: {
                                type: StringConstructor;
                            };
                            isDateDisabled: {
                                type: FunctionConstructor;
                            };
                            timeDisabled: {
                                type: FunctionConstructor;
                            };
                            valueFormat: {
                                type: StringConstructor;
                            };
                        }>, {
                            widgetOptions: {
                                label: string;
                                value: string;
                            }[];
                            widgetRangeOptions: {
                                label: string;
                                value: string;
                            }[];
                            startDateNum: import("vue").Ref<any, any>;
                            endDateNum: import("vue").Ref<any, any>;
                            props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                                filterType: {
                                    type: StringConstructor;
                                    required: true;
                                };
                                modelValue: {
                                    type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                                    default: null;
                                };
                                presetVal: {
                                    type: StringConstructor;
                                    default: null;
                                };
                                dateType: {
                                    type: StringConstructor;
                                };
                                isDateDisabled: {
                                    type: FunctionConstructor;
                                };
                                timeDisabled: {
                                    type: FunctionConstructor;
                                };
                                valueFormat: {
                                    type: StringConstructor;
                                };
                            }>> & Readonly<{
                                "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                                "onUpdate:presetVal"?: ((...args: any[]) => any) | undefined;
                            }> & {}>;
                            emit: (event: "update:modelValue" | "update:presetVal", ...args: any[]) => void;
                            valueCp: import("vue").WritableComputedRef<any, any>;
                            presetValCp: import("vue").WritableComputedRef<string, string>;
                            handleChange: (val: any, type: "start" | "end") => void;
                            readonly NSelect: any;
                            readonly NInputNumber: any;
                        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "update:presetVal")[], "update:modelValue" | "update:presetVal", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                            filterType: {
                                type: StringConstructor;
                                required: true;
                            };
                            modelValue: {
                                type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                                default: null;
                            };
                            presetVal: {
                                type: StringConstructor;
                                default: null;
                            };
                            dateType: {
                                type: StringConstructor;
                            };
                            isDateDisabled: {
                                type: FunctionConstructor;
                            };
                            timeDisabled: {
                                type: FunctionConstructor;
                            };
                            valueFormat: {
                                type: StringConstructor;
                            };
                        }>> & Readonly<{
                            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                            "onUpdate:presetVal"?: ((...args: any[]) => any) | undefined;
                        }>, {
                            modelValue: string | number | unknown[];
                            presetVal: string;
                        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                        readonly WidgetValEnums: {
                            CUSTOM: string;
                            FIRST_VAL: string;
                            WHOLE: string;
                            NOW: string;
                            TODAY: string;
                            TODAY_START: string;
                            TODAY_END: string;
                            TOMORROW: string;
                            TOMORROW_START: string;
                            TOMORROW_END: string;
                            YESTERDAY: string;
                            YESTERDAY_START: string;
                            YESTERDAY_END: string;
                            THIS_WEEK: string;
                            WEEK_START: string;
                            WEEK_END: string;
                            NEXT_WEEK: string;
                            LAST_WEEK: string;
                            THIS_MONTH: string;
                            MONTH_START: string;
                            MONTH_END: string;
                            NEXT_MONTH: string;
                            LAST_MONTH: string;
                            THIS_QUARTER: string;
                            NEXT_QUARTER: string;
                            LAST_QUARTER: string;
                            THIS_YEAR: string;
                            NEXT_YEAR: string;
                            LAST_YEAR: string;
                        };
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "update:presetVal" | "update:customDate")[], "update:modelValue" | "update:presetVal" | "update:customDate", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        item: {
                            type: ObjectConstructor;
                            required: true;
                        };
                        paramCfg: {
                            type: ObjectConstructor;
                            default: null;
                        };
                        modelValue: {
                            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                            default: null;
                        };
                        presetVal: {
                            type: StringConstructor;
                            default: null;
                        };
                        customDate: {
                            type: StringConstructor;
                            default: null;
                        };
                    }>> & Readonly<{
                        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                        "onUpdate:presetVal"?: ((...args: any[]) => any) | undefined;
                        "onUpdate:customDate"?: ((...args: any[]) => any) | undefined;
                    }>, {
                        modelValue: string | number | unknown[];
                        paramCfg: Record<string, any>;
                        presetVal: string;
                        customDate: string;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                    readonly SelectLabel: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        paramCfg: {
                            type: ObjectConstructor;
                            default: null;
                        };
                        modelValue: {
                            type: StringConstructor;
                            default: null;
                        };
                    }>, {
                        getDynamicLabelData: (params: any, filterApiConfig: any) => Promise<any>;
                        message: import("naive-ui/es/message").MessageApi;
                        props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                            paramCfg: {
                                type: ObjectConstructor;
                                default: null;
                            };
                            modelValue: {
                                type: StringConstructor;
                                default: null;
                            };
                        }>> & Readonly<{
                            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                        }> & {}>;
                        emit: (event: "update:modelValue", ...args: any[]) => void;
                        tagList: import("vue").Ref<never[], never[]>;
                        filterApiConfig: import("../../shared/types").AnyObject;
                        valueCp: import("vue").WritableComputedRef<string[], string[]>;
                        optionList: import("vue").ComputedRef<import("naive-ui").SelectOption[]>;
                        initTagList: () => Promise<void>;
                        renderOption: ({ node, option }: {
                            node: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                                [key: string]: any;
                            }>;
                            option: import("naive-ui").SelectOption;
                        }) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                            [key: string]: any;
                        }>;
                        renderLabel: (option: any) => any;
                        readonly NSelect: any;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        paramCfg: {
                            type: ObjectConstructor;
                            default: null;
                        };
                        modelValue: {
                            type: StringConstructor;
                            default: null;
                        };
                    }>> & Readonly<{
                        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                    }>, {
                        modelValue: string;
                        paramCfg: Record<string, any>;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                    readonly SelectTreeDynamic: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        paramCfg: {
                            type: ObjectConstructor;
                            default: null;
                        };
                        modelValue: {
                            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                            default: null;
                        };
                    }>, {
                        message: import("naive-ui/es/message").MessageApi;
                        props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                            paramCfg: {
                                type: ObjectConstructor;
                                default: null;
                            };
                            modelValue: {
                                type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                                default: null;
                            };
                        }>> & Readonly<{
                            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                        }> & {}>;
                        getDynamicSelectData: (params: any, filterApiConfig: any) => Promise<any>;
                        emit: (event: "update:modelValue", ...args: any[]) => void;
                        options: import("vue").Ref<any[], any[]>;
                        filterApiConfig: import("../../shared/types").AnyObject;
                        classifyFilterList: import("vue").Ref<import("../../shared/types").AnyObject[], import("../../shared/types").AnyObject[]>;
                        optionSetting: import("vue").ComputedRef<any>;
                        isMultiple: import("vue").ComputedRef<boolean>;
                        dynamicOptionInfos: import("vue").ComputedRef<any>;
                        valueCp: import("vue").WritableComputedRef<any, any>;
                        transformOptions: (list: any[], showKeys: string[], valueKey: string) => any[];
                        getOptionsData: (keyword: string) => Promise<void>;
                        readonly NTreeSelect: any;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        paramCfg: {
                            type: ObjectConstructor;
                            default: null;
                        };
                        modelValue: {
                            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                            default: null;
                        };
                    }>> & Readonly<{
                        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                    }>, {
                        modelValue: string | number | unknown[];
                        paramCfg: Record<string, any>;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                    readonly WidgetTypeEnums: {
                        INPUT_NUMBER: string;
                        INPUT: string;
                        SELECT: string;
                        DATE: string;
                        DATE_OUT: string;
                        DATE_TIME: string;
                        DATETIME_OUT: string;
                        CHECKBOX_GROUP: string;
                        INPUTNUMBER_RANGE: string;
                        DATE_RANGE_OUT: string;
                        DATE_RANGE_INNER: string;
                        DATETIME_RANGE_OUT: string;
                        DATETIME_RANGE_INNER: string;
                        LABEL: string;
                        SELECTLABEL: string;
                        SELECTDYNAMIC: string;
                        SELECTTREE: string;
                        SELECTTREEDYNAMIC: string;
                    };
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "update:isAccurate" | "update:presetVal" | "update:customDate")[], "update:modelValue" | "update:isAccurate" | "update:presetVal" | "update:customDate", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    item: {
                        type: ObjectConstructor;
                        default: null;
                    };
                    paramCfg: {
                        type: ObjectConstructor;
                        default: null;
                    };
                    modelValue: {
                        type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                        default: null;
                    };
                    presetVal: {
                        type: StringConstructor;
                        default: null;
                    };
                    isAccurate: {
                        type: BooleanConstructor;
                    };
                    customDate: {
                        type: StringConstructor;
                        default: null;
                    };
                }>> & Readonly<{
                    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                    "onUpdate:isAccurate"?: ((...args: any[]) => any) | undefined;
                    "onUpdate:presetVal"?: ((...args: any[]) => any) | undefined;
                    "onUpdate:customDate"?: ((...args: any[]) => any) | undefined;
                }>, {
                    modelValue: string | number | unknown[];
                    item: Record<string, any>;
                    paramCfg: Record<string, any>;
                    presetVal: string;
                    isAccurate: boolean;
                    customDate: string;
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                readonly ConditionEnums: {
                    NULL: string;
                    EQUAL: string;
                    CUSTOM_RANGE: string;
                    IN_THE_PAST: string;
                    IN_THE_FUTURE: string;
                    IN_THE_PAST_DI: string;
                    IN_THE_FUTURE_DI: string;
                };
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("cancelSaveAdd" | "saveAdd")[], "cancelSaveAdd" | "saveAdd", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                actionList_prop: {
                    type: import("vue").PropType<import("..").IClassifyListType>;
                    default: () => {};
                };
                conditionList: {
                    type: ArrayConstructor;
                    default: () => never[];
                };
                tableId: {
                    type: StringConstructor;
                    default: string;
                };
                searchFieldList: {
                    type: ArrayConstructor;
                    default: () => never[];
                };
                showItemName: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                hideAddBtn: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{
                onCancelSaveAdd?: ((...args: any[]) => any) | undefined;
                onSaveAdd?: ((...args: any[]) => any) | undefined;
            }>, {
                searchFieldList: unknown[];
                tableId: string;
                conditionList: unknown[];
                actionList_prop: import("..").IClassifyListType;
                showItemName: boolean;
                hideAddBtn: boolean;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            BiFilterConditionByApi: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                actionList_prop: {
                    type: import("vue").PropType<import("..").IClassifyListType>;
                    default: () => {};
                };
                conditionList: {
                    type: ArrayConstructor;
                    default: () => never[];
                };
                tableId: {
                    type: StringConstructor;
                    default: string;
                };
                searchFieldList: {
                    type: ArrayConstructor;
                    default: () => never[];
                };
                showItemName: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                hideAddBtn: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>, {
                $message: import("naive-ui/es/message").MessageApi;
                menuProps: {
                    class: string;
                };
                dateCons: string[];
                textCons: string[];
                numberCons: string[];
                props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                    actionList_prop: {
                        type: import("vue").PropType<import("..").IClassifyListType>;
                        default: () => {};
                    };
                    conditionList: {
                        type: ArrayConstructor;
                        default: () => never[];
                    };
                    tableId: {
                        type: StringConstructor;
                        default: string;
                    };
                    searchFieldList: {
                        type: ArrayConstructor;
                        default: () => never[];
                    };
                    showItemName: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                    hideAddBtn: {
                        type: BooleanConstructor;
                        default: boolean;
                    };
                }>> & Readonly<{
                    onCancelSaveAdd?: ((...args: any[]) => any) | undefined;
                    onSaveAdd?: ((...args: any[]) => any) | undefined;
                }> & {}>;
                emit: (event: "cancelSaveAdd" | "saveAdd", ...args: any[]) => void;
                $attrs: {
                    [x: string]: unknown;
                };
                FormState: any;
                loading: import("vue").Ref<boolean, boolean>;
                parentInputRef: import("vue").Ref<any, any>;
                parentInputAddRef: import("vue").Ref<any, any>;
                sqlExpression: import("vue").Ref<any, any>;
                DisplayCategoryState: {
                    addDisplayCategory: string;
                    displayCategories: {
                        disabled: boolean;
                        value: string;
                    }[];
                    displayCategoryOriginLen: number;
                    showAdd: boolean;
                };
                isEnableAddDisplayCategory: import("vue").ComputedRef<boolean>;
                editDisplayCategory: (item: import("..").ICategoryItemType, cb?: any) => void;
                handleDisplayCategorySelect: (item: import("..").ICategoryItemType) => void;
                handleDisplayCategoryRemove: (index: number, item: import("..").ICategoryItemType) => void;
                handleDisplayCategoryAdd: (cb?: any) => void;
                handlerBlur: () => void;
                initDisplayCategories: (rawDataDisplayCategories: any, displayCategory: any) => void;
                FilterConditionsState: any;
                paramOptions: import("vue").ComputedRef<any>;
                addFilterCondition: () => void;
                delFilterCondition: (index: number) => void;
                updateKey: (index: number, val: any) => void;
                updateCondition: (index: number, val: any) => void;
                getParamCfg: (key: string) => any;
                initFilterConditions: (tableId: string, rawConditions: import("..").ISearchConfigType[]) => Promise<void>;
                getRawFilterConditions: () => any;
                isShowValueCfg: (con: string) => boolean;
                handleEditDisplayCategory: (item: import("..").ICategoryItemType) => void;
                handleDisplayCategoryAddState: () => void;
                findConditionByDisplayCategory: (sid: string) => unknown;
                handleDisplayCategorySelectProxy: (item: import("..").ICategoryItemType) => void;
                clearFormData: () => void;
                handleInitConditions: () => Promise<void>;
                validate: () => Promise<unknown>;
                saveAdd: () => void;
                cancelSaveAdd: () => void;
                checkActionList: () => any;
                readonly NSpin: any;
                readonly NIcon: any;
                readonly NInput: any;
                readonly NButton: any;
                readonly NTooltip: any;
                readonly NSelect: any;
                readonly AddOutline: 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 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 CloseOutline: 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>;
                ValueCfg: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                    paramCfg: {
                        type: ObjectConstructor;
                        default: null;
                    };
                    modelValue: {
                        type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                        default: null;
                    };
                    modelValues: {
                        type: ArrayConstructor;
                        default: () => never[];
                    };
                }>, {
                    props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                        paramCfg: {
                            type: ObjectConstructor;
                            default: null;
                        };
                        modelValue: {
                            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                            default: null;
                        };
                        modelValues: {
                            type: ArrayConstructor;
                            default: () => never[];
                        };
                    }>> & Readonly<{
                        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                        "onUpdate:modelValues"?: ((...args: any[]) => any) | undefined;
                    }> & {}>;
                    emit: (event: "update:modelValue" | "update:modelValues", ...args: any[]) => void;
                    valueCp: import("vue").WritableComputedRef<any, any>;
                    valuesCp: import("vue").WritableComputedRef<any, any>;
                    isSelectMode: import("vue").ComputedRef<boolean>;
                    isSelectMultiple: import("vue").ComputedRef<boolean>;
                    biType: import("vue").ComputedRef<any>;
                    readonly Date: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        componentCfg: {
                            type: ObjectConstructor;
                        };
                        paramCfg: {
                            type: ObjectConstructor;
                            default: null;
                        };
                        modelValue: {
                            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                            default: null;
                        };
                    }>, {
                        props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                            componentCfg: {
                                type: ObjectConstructor;
                            };
                            paramCfg: {
                                type: ObjectConstructor;
                                default: null;
                            };
                            modelValue: {
                                type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                                default: null;
                            };
                        }>> & Readonly<{
                            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                        }> & {}>;
                        emit: (event: "update:modelValue", ...args: any[]) => void;
                        valueCp: import("vue").WritableComputedRef<any, any>;
                        dateType: any;
                        valueFormat: import("vue").ComputedRef<string>;
                        compType: import("vue").ComputedRef<any>;
                        readonly CDatePicker: SFCWithInstall<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                            updateUnchangedValue: {
                                type: BooleanConstructor;
                            };
                            onConfirm: {
                                type: FunctionConstructor;
                            };
                            formattedValue: {
                                type: import("vue").PropType<(string | [string, string]) | null | undefined>;
                            };
                            placeholder: {
                                type: StringConstructor;
                            };
                            allowedInvalidValue: {
                                type: StringConstructor;
                            };
                            to: {
                                type: import("vue").PropType<string | false | HTMLElement>;
                                default: string;
                            };
                            holidays: {
                                type: import("vue").PropType<Date[]>;
                                default: () => never[];
                            };
                            type: {
                                type: StringConstructor;
                                default: string;
                            };
                            updateValueOnClose: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            isDateDisabled: {
                                type: import("vue").PropType<(current: number, ...arg: any[]) => boolean>;
                            };
                            propKey: {
                                type: StringConstructor;
                            };
                            shortcutListenerConfig: {
                                type: import("vue").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: import("vue").PropType<(string | [string, string]) | null | undefined>;
                                };
                                placeholder: {
                                    type: StringConstructor;
                                };
                                allowedInvalidValue: {
                                    type: StringConstructor;
                                };
                                to: {
                                    type: import("vue").PropType<string | false | HTMLElement>;
                                    default: string;
                                };
                                holidays: {
                                    type: import("vue").PropType<Date[]>;
                                    default: () => never[];
                                };
                                type: {
                                    type: StringConstructor;
                                    default: string;
                                };
                                updateValueOnClose: {
                                    type: BooleanConstructor;
                                    default: boolean;
                                };
                                isDateDisabled: {
                                    type: import("vue").PropType<(current: number, ...arg: any[]) => boolean>;
                                };
                                propKey: {
                                    type: StringConstructor;
                                };
                                shortcutListenerConfig: {
                                    type: import("vue").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<import("../../shared/types").AnyObject | null, import("../../shared/types").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: import("vue").PropType<(string | [string, string]) | null | undefined>;
                            };
                            placeholder: {
                                type: StringConstructor;
                            };
                            allowedInvalidValue: {
                                type: StringConstructor;
                            };
                            to: {
                                type: import("vue").PropType<string | false | HTMLElement>;
                                default: string;
                            };
                            holidays: {
                                type: import("vue").PropType<Date[]>;
                                default: () => never[];
                            };
                            type: {
                                type: StringConstructor;
                                default: string;
                            };
                            updateValueOnClose: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            isDateDisabled: {
                                type: import("vue").PropType<(current: number, ...arg: any[]) => boolean>;
                            };
                            propKey: {
                                type: StringConstructor;
                            };
                            shortcutListenerConfig: {
                                type: import("vue").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, "update:modelValue"[], "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        componentCfg: {
                            type: ObjectConstructor;
                        };
                        paramCfg: {
                            type: ObjectConstructor;
                            default: null;
                        };
                        modelValue: {
                            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                            default: null;
                        };
                    }>> & Readonly<{
                        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                    }>, {
                        modelValue: string | number | unknown[];
                        paramCfg: Record<string, any>;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                    readonly InputFilter: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        paramCfg: {
                            type: ObjectConstructor;
                            default: null;
                        };
                        modelValue: {
                            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                            default: null;
                        };
                    }>, {
                        props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                            paramCfg: {
                                type: ObjectConstructor;
                                default: null;
                            };
                            modelValue: {
                                type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                                default: null;
                            };
                        }>> & Readonly<{
                            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                        }> & {}>;
                        emit: (event: "update:modelValue", ...args: any[]) => void;
                        valueCp: import("vue").WritableComputedRef<any, any>;
                        readonly NInput: any;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        paramCfg: {
                            type: ObjectConstructor;
                            default: null;
                        };
                        modelValue: {
                            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                            default: null;
                        };
                    }>> & Readonly<{
                        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                    }>, {
                        modelValue: string | number | unknown[];
                        paramCfg: Record<string, any>;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                    readonly InputNumber: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        modelValue: {
                            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                            default: null;
                        };
                    }>, {
                        props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                            modelValue: {
                                type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                                default: null;
                            };
                        }>> & Readonly<{
                            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                        }> & {}>;
                        emit: (event: "update:modelValue", ...args: any[]) => void;
                        valueCp: import("vue").WritableComputedRef<any, any>;
                        readonly NInputNumber: any;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        modelValue: {
                            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                            default: null;
                        };
                    }>> & Readonly<{
                        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                    }>, {
                        modelValue: string | number | unknown[];
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                    readonly SelectFilter: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                        paramCfg: {
                            type: ObjectConstructor;
                            default: null;
                        };
                        modelValue: {
                            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                            default: null;
                        };
                    }>, {
                        props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                            paramCfg: {
                                type: ObjectConstructor;
                                default: null;
                            };
                            modelValue: {
                                type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                                default: null;
                            };
                        }>> & Readonly<{
                            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                        }> & {}>;
                        emit: (event: "update:modelValue", ...args: any[]) => void;
                        valueCp: import("vue").WritableComputedRef<any, any>;
                        optionSetting: import("vue").ComputedRef<any>;
                        widgetOptions: import("vue").ComputedRef<any>;
                        readonly NSelect: any;
                        readonly WidgetOptionEnums: {
                            RADIO: string;
                            MULTIPLE: string;
                            ALL: string;
                            SELECT_TIME: string;
                            PAST_TIME: string;
                            FUTURE_TIME: string;
                            CUSTOM_TIME: string;
                        };
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                        paramCfg: {
                            type: ObjectConstructor;
                            default: null;
                        };
                        modelValue: {
                            type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                            default: null;
                        };
                    }>> & Readonly<{
                        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                    }>, {
                        modelValue: string | number | unknown[];
                        paramCfg: Record<string, any>;
                    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                    readonly WidgetTypeEnums: {
                        INPUT_NUMBER: string;
                        INPUT: string;
                        SELECT: string;
                        DATE: string;
                        DATE_OUT: string;
                        DATE_TIME: string;
                        DATETIME_OUT: string;
                        CHECKBOX_GROUP: string;
                        INPUTNUMBER_RANGE: string;
                        DATE_RANGE_OUT: string;
                        DATE_RANGE_INNER: string;
                        DATETIME_RANGE_OUT: string;
                        DATETIME_RANGE_INNER: string;
                        LABEL: string;
                        SELECTLABEL: string;
                        SELECTDYNAMIC: string;
                        SELECTTREE: string;
                        SELECTTREEDYNAMIC: string;
                    };
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "update:modelValues")[], "update:modelValue" | "update:modelValues", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                    paramCfg: {
                        type: ObjectConstructor;
                        default: null;
                    };
                    modelValue: {
                        type: (ArrayConstructor | NumberConstructor | StringConstructor)[];
                        default: null;
                    };
                    modelValues: {
                        type: ArrayConstructor;
                        default: () => never[];
                    };
                }>> & Readonly<{
                    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
                    "onUpdate:modelValues"?: ((...args: any[]) => any) | undefined;
                }>, {
                    modelValue: string | number | unknown[];
                    paramCfg: Record<string, any>;
                    modelValues: unknown[];
                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("cancelSaveAdd" | "saveAdd")[], "cancelSaveAdd" | "saveAdd", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
                actionList_prop: {
                    type: import("vue").PropType<import("..").IClassifyListType>;
                    default: () => {};
                };
                conditionList: {
                    type: ArrayConstructor;
                    default: () => never[];
                };
                tableId: {
                    type: StringConstructor;
                    default: string;
                };
                searchFieldList: {
                    type: ArrayConstructor;
                    default: () => never[];
                };
                showItemName: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                hideAddBtn: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{
                onCancelSaveAdd?: ((...args: any[]) => any) | undefined;
                onSaveAdd?: ((...args: any[]) => any) | undefined;
            }>, {
                searchFieldList: unknown[];
                tableId: string;
                conditionList: unknown[];
                actionList_prop: import("..").IClassifyListType;
                showItemName: boolean;
                hideAddBtn: boolean;
            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "cancelSaveAdd"[], "cancelSaveAdd", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
            visible: {
                type: BooleanConstructor;
                default: boolean;
            };
            modalTitle: {
                type: StringConstructor;
                default: string;
            };
            conditionList: {
                type: ArrayConstructor;
                default: () => never[];
            };
            searchFieldList: {
                type: ArrayConstructor;
                default: () => never[];
            };
        }>> & Readonly<{
            onCancelSaveAdd?: ((...args: any[]) => any) | undefined;
        }>, {
            visible: boolean;
            searchFieldList: unknown[];
            conditionList: unknown[];
            modalTitle: string;
        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("CondiTionListInit" | "saveGetTableCondiTionList" | "setClassifyModal")[], "CondiTionListInit" | "saveGetTableCondiTionList" | "setClassifyModal", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
        searchFieldList: {
            type: ArrayConstructor;
            default: () => never[];
        };
        conditionList: {
            type: ArrayConstructor;
            default: () => never[];
        };
        settingId: StringConstructor;
        classifyModal: {
            type: BooleanConstructor;
            default: boolean;
        };
    }>> & Readonly<{
        onCondiTionListInit?: ((...args: any[]) => any) | undefined;
        onSaveGetTableCondiTionList?: ((...args: any[]) => any) | undefined;
        onSetClassifyModal?: ((...args: any[]) => any) | undefined;
    }>, {
        searchFieldList: unknown[];
        conditionList: unknown[];
        classifyModal: boolean;
    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    readonly vFlexibleResize: {
        mounted(el: any, { value }: any): void;
        beforeUnmount(el: any): void;
    };
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("changeSearch" | "setClassificationIndex" | "getQuickSearchListObj")[], "changeSearch" | "setClassificationIndex" | "getQuickSearchListObj", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
    tableId: {
        type: StringConstructor;
        default: string;
    };
    searchFieldList: {
        type: import("vue").PropType<any[]>;
        default: () => never[];
    };
    conditionMap: {
        type: import("vue").PropType<import("..").IConditionMapType>;
        default: () => {};
    };
    conditionSid: {
        type: import("vue").PropType<string[]>;
        default: () => string[];
    };
    curClassificationIndex: {
        type: NumberConstructor;
        default: number;
    };
    showClassificationIndexs: {
        type: import("vue").PropType<number[]>;
        default: () => number[];
    };
    curClassificationWidth: {
        type: NumberConstructor;
    };
    hideConditionChangeBtn: {
        type: NumberConstructor;
        default: number;
    };
    hideConditionChangeSetting: {
        type: NumberConstructor;
        default: number;
    };
    hideClearConditionChange: {
        type: NumberConstructor;
        default: number;
    };
    isShowResetButton: {
        type: BooleanConstructor;
        default: boolean;
    };
    filterApiConfig: {
        type: ObjectConstructor;
        default: () => {};
    };
    condiTionDigital: {
        type: ObjectConstructor;
        default: () => {};
    };
    filterType: {
        type: StringConstructor;
        default: string;
    };
}>> & Readonly<{
    onChangeSearch?: ((...args: any[]) => any) | undefined;
    onSetClassificationIndex?: ((...args: any[]) => any) | undefined;
    onGetQuickSearchListObj?: ((...args: any[]) => any) | undefined;
}>, {
    searchFieldList: any[];
    filterApiConfig: Record<string, any>;
    tableId: string;
    conditionMap: import("..").IConditionMapType;
    conditionSid: string[];
    curClassificationIndex: number;
    showClassificationIndexs: number[];
    hideConditionChangeBtn: number;
    hideConditionChangeSetting: number;
    hideClearConditionChange: number;
    isShowResetButton: boolean;
    condiTionDigital: Record<string, any>;
    filterType: string;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
export default CClassification;