@univerjs/sheets-data-validation 0.1.6

package/lib/types/services/dv-cache.service.d.ts

@@ -0,0 +1,21 @@
+import { ObjectMatrix, CellValue, DataValidationStatus, IRange, ISheetDataValidationRule, Nullable } from '@univerjs/core';
+
+export interface IDataValidationResCache {
+    value: Nullable<CellValue>;
+    status: DataValidationStatus;
+    ruleId: string;
+    temp?: boolean;
+}
+export declare class DataValidationCacheService {
+    private _cacheMatrix;
+    private _ensureCache;
+    ensureCache(unitId: string, subUnitId: string): ObjectMatrix<Nullable<IDataValidationResCache>>;
+    addRule(unitId: string, subUnitId: string, rule: ISheetDataValidationRule): void;
+    removeRule(unitId: string, subUnitId: string, rule: ISheetDataValidationRule): void;
+    updateRuleRanges(unitId: string, subUnitId: string, ruleId: string, newRanges: IRange[], oldRanges: IRange[]): void;
+    markRangeDirty(unitId: string, subUnitId: string, ranges: IRange[]): void;
+    markCellDirty(unitId: string, subUnitId: string, row: number, col: number): void;
+    private _deleteRange;
+    getValue(unitId: string, subUnitId: string, row: number, col: number): Nullable<IDataValidationResCache>;
+    setValue(unitId: string, subUnitId: string, row: number, col: number, value: IDataValidationResCache): void;
+}

package/lib/types/services/dv-custom-formula.service.d.ts

@@ -0,0 +1,41 @@
+import { DataValidationCacheService } from './dv-cache.service';
+import { RegisterOtherFormulaService } from './register-formula.service';
+import { DataValidationModel } from '@univerjs/data-validation';
+import { LexerTreeBuilder } from '@univerjs/engine-formula';
+import { IRange, ISheetDataValidationRule, Disposable, IUniverInstanceService } from '@univerjs/core';
+
+interface IFormulaData {
+    formula: string;
+    originRow: number;
+    originCol: number;
+    isTransformable: boolean;
+    formulaId?: string;
+}
+export declare class DataValidationCustomFormulaService extends Disposable {
+    private _registerOtherFormulaService;
+    private _lexerTreeBuilder;
+    private readonly _univerInstanceService;
+    private readonly _dataValidationModel;
+    private readonly _dataValidationCacheService;
+    private _formulaMap;
+    /**
+     * Map of origin formula of rule
+     */
+    private _ruleFormulaMap;
+    /**
+     * reflect of formulaId to cell, only store transformable formula
+     */
+    private _formulaCellMap;
+    constructor(_registerOtherFormulaService: RegisterOtherFormulaService, _lexerTreeBuilder: LexerTreeBuilder, _univerInstanceService: IUniverInstanceService, _dataValidationModel: DataValidationModel, _dataValidationCacheService: DataValidationCacheService);
+    private _initFormulaResultHandler;
+    private _ensureMaps;
+    private _registerFormula;
+    deleteByRuleId(unitId: string, subUnitId: string, ruleId: string): void;
+    private _addFormulaByRange;
+    addRule(unitId: string, subUnitId: string, rule: ISheetDataValidationRule): void;
+    updateRuleRanges(unitId: string, subUnitId: string, ruleId: string, oldRanges: IRange[], newRanges: IRange[]): void;
+    updateRuleFormula(unitId: string, subUnitId: string, ruleId: string, ranges: IRange[], formula: string): void;
+    getCellFormulaValue(unitId: string, subUnitId: string, row: number, col: number): Promise<import('@univerjs/core').Nullable<import("./formula-common").IDataValidationFormulaResult>>;
+    getRuleFormulaInfo(unitId: string, subUnitId: string, ruleId: string): IFormulaData | undefined;
+}
+export {};

package/lib/types/services/dv-formula.service.d.ts

@@ -0,0 +1,21 @@
+import { DataValidationCacheService } from './dv-cache.service';
+import { RegisterOtherFormulaService } from './register-formula.service';
+import { IDataValidationFormulaResult, IFormulaInfo } from './formula-common';
+import { DataValidationModel } from '@univerjs/data-validation';
+import { Nullable, Disposable } from '@univerjs/core';
+
+export declare class DataValidationFormulaService extends Disposable {
+    private _registerOtherFormulaService;
+    private readonly _dataValidationCacheService;
+    private readonly _dataValidationModel;
+    private _formulaRuleMap;
+    constructor(_registerOtherFormulaService: RegisterOtherFormulaService, _dataValidationCacheService: DataValidationCacheService, _dataValidationModel: DataValidationModel);
+    private _initFormulaResultHandler;
+    private _ensureRuleFormulaMap;
+    addRule(unitId: string, subUnitId: string, ruleId: string, formula1: string | undefined, formula2: string | undefined): void;
+    removeRule(unitId: string, subUnitId: string, ruleId: string): void;
+    updateRuleFormulaText(unitId: string, subUnitId: string, ruleId: string, formula1: string | undefined, formula2: string | undefined): void;
+    getRuleFormulaResult(unitId: string, subUnitId: string, ruleId: string): Promise<Nullable<[Nullable<IDataValidationFormulaResult>, Nullable<IDataValidationFormulaResult>]>>;
+    getRuleFormulaResultSync(unitId: string, subUnitId: string, ruleId: string): Nullable<IDataValidationFormulaResult>[] | undefined;
+    getRuleFormulaInfo(unitId: string, subUnitId: string, ruleId: string): [IFormulaInfo | undefined, IFormulaInfo | undefined] | undefined;
+}

package/lib/types/services/dv.service.d.ts

@@ -0,0 +1,20 @@
+import { SheetDataValidationManager } from '../models/sheet-data-validation-manager';
+import { DataValidationModel } from '@univerjs/data-validation';
+import { Nullable } from '@univerjs/core';
+
+export interface ICurrentDataValidationManager {
+    manager: SheetDataValidationManager;
+    unitId: string;
+    subUnitId: string;
+}
+export declare class SheetDataValidationService {
+    private _dataValidationModel;
+    private _currentManager;
+    private _currentManager$;
+    get currentManager(): Nullable<ICurrentDataValidationManager>;
+    currentManager$: import('rxjs').Observable<ICurrentDataValidationManager>;
+    constructor(_dataValidationModel: DataValidationModel);
+    private _ensureManager;
+    switchCurrent(unitId: string, subUnitId: string): void;
+    get(unitId: string, subUnitId: string): SheetDataValidationManager;
+}

package/lib/types/services/dv.tips.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export declare class SheetDataValidationTipsService {
+}

package/lib/types/services/formula-common.d.ts

@@ -0,0 +1,19 @@
+import { ICellData, Nullable } from '@univerjs/core';
+
+export declare enum FormulaResultStatus {
+    NOT_REGISTER = 1,
+    SUCCESS = 2,
+    WAIT = 3,
+    ERROR = 4
+}
+export interface IDataValidationFormulaResult {
+    result?: Nullable<ICellData>[][];
+    status: FormulaResultStatus;
+    ruleId: string;
+    formulaId: string;
+    callbacks: Set<(value: Nullable<ICellData>[][]) => void>;
+}
+export interface IFormulaInfo {
+    id: string;
+    text: string;
+}

package/lib/types/services/register-formula.service.d.ts

@@ -0,0 +1,28 @@
+import { IDataValidationFormulaResult } from './formula-common';
+import { IActiveDirtyManagerService } from '@univerjs/engine-formula';
+import { Nullable, Disposable, ICommandService } from '@univerjs/core';
+
+export declare class RegisterOtherFormulaService extends Disposable {
+    private readonly _commandService;
+    private _activeDirtyManagerService;
+    private _formulaCacheMap;
+    private _formulaChange$;
+    formulaChange$: import('rxjs').Observable<{
+        unitId: string;
+        subUnitId: string;
+        ruleId: string;
+        formulaText: string;
+        formulaId: string;
+    }>;
+    private _formulaResult$;
+    formulaResult$: import('rxjs').Observable<Record<string, Record<string, IDataValidationFormulaResult[]>>>;
+    constructor(_commandService: ICommandService, _activeDirtyManagerService: IActiveDirtyManagerService);
+    private _ensureCacheMap;
+    private _createFormulaId;
+    private _initFormulaRegister;
+    private _initFormulaCalculationResultChange;
+    registerFormula(unitId: string, subUnitId: string, ruleId: string, formulaText: string): string;
+    deleteFormula(unitId: string, subUnitId: string, formulaIdList: string[]): void;
+    getFormulaValue(unitId: string, subUnitId: string, formulaId: string): Promise<Nullable<IDataValidationFormulaResult>>;
+    getFormulaValueSync(unitId: string, subUnitId: string, formulaId: string): Nullable<IDataValidationFormulaResult>;
+}

package/lib/types/types/const/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './operator-text-map';
+export * from './two-formula-operators';

package/lib/types/types/const/operator-text-map.d.ts

@@ -0,0 +1,5 @@
+import { DataValidationOperator } from '@univerjs/core';
+
+export declare const OperatorTextMap: Record<DataValidationOperator, string>;
+export declare const OperatorTitleMap: Record<DataValidationOperator, string>;
+export declare const OperatorErrorTitleMap: Record<DataValidationOperator, string>;

package/lib/types/types/const/two-formula-operators.d.ts

@@ -0,0 +1,3 @@
+import { DataValidationOperator } from '@univerjs/core';
+
+export declare const TWO_FORMULA_OPERATOR_COUNT: DataValidationOperator[];

package/lib/types/types/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './interface';
+export * from './const';

package/lib/types/types/interface/i-update-rule-formula.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export interface IUpdateDataValidationFormulaPayload {
+    type: 'formula1' | 'formula2';
+    formulaString: string;
+}

package/lib/types/types/interface/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './i-update-rule-formula';

package/lib/types/utils/date.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export declare function toYMD_1900(ord: number, leap1900?: boolean): number[];
+export declare const serialTimeToTimestamp: (value: number) => number;

package/lib/types/utils/formula.d.ts

@@ -0,0 +1,3 @@
+import { ICellData, Nullable } from '@univerjs/core';
+
+export declare function getFormulaResult(result: Nullable<Nullable<ICellData>[][]>): Nullable<import('@univerjs/core').CellValue>;

package/lib/types/utils/get-cell-data-origin.d.ts

@@ -0,0 +1,3 @@
+import { ICellData, Nullable } from '@univerjs/core';
+
+export declare function getCellValueOrigin(cell: Nullable<ICellData>): Nullable<import('@univerjs/core').CellValue>;

package/lib/types/validators/checkbox-validator.d.ts

@@ -0,0 +1,25 @@
+import { CheckboxRender } from '../widgets/checkbox-widget';
+import { ISheetLocation } from '@univerjs/sheets';
+import { BaseDataValidator, IFormulaResult, IFormulaValidResult, IValidatorCellInfo } from '@univerjs/data-validation';
+import { CellValue, DataValidationOperator, IDataValidationRule, IDataValidationRuleBase, ISheetDataValidationRule, Nullable } from '@univerjs/core';
+
+export declare const CHECKBOX_FORMULA_1 = 1;
+export declare const CHECKBOX_FORMULA_2 = 0;
+export declare class CheckboxValidator extends BaseDataValidator {
+    id: string;
+    title: string;
+    operators: DataValidationOperator[];
+    scopes: string | string[];
+    formulaInput: string;
+    canvasRender: CheckboxRender;
+    private _formulaService;
+    skipDefaultFontRender(rule: ISheetDataValidationRule, cellValue: Nullable<CellValue>, pos: ISheetLocation): boolean;
+    validatorFormula(rule: IDataValidationRuleBase): IFormulaValidResult;
+    parseFormula(rule: IDataValidationRule, unitId: string, subUnitId: string): Promise<IFormulaResult>;
+    parseFormulaSync(rule: IDataValidationRule, unitId: string, subUnitId: string): {
+        formula1: Nullable<CellValue>;
+        formula2: Nullable<CellValue>;
+    };
+    isValidType(cellInfo: IValidatorCellInfo<CellValue>, formula: IFormulaResult, rule: IDataValidationRule): Promise<boolean>;
+    generateRuleErrorMessage(rule: IDataValidationRuleBase): string;
+}

package/lib/types/validators/custom-validator.d.ts

@@ -0,0 +1,15 @@
+import { IFormulaResult, IFormulaValidResult, IValidatorCellInfo, BaseDataValidator } from '@univerjs/data-validation';
+import { CellValue, DataValidationOperator, IDataValidationRule, IDataValidationRuleBase } from '@univerjs/core';
+
+export declare class CustomFormulaValidator extends BaseDataValidator {
+    id: string;
+    title: string;
+    operators: DataValidationOperator[];
+    scopes: string | string[];
+    formulaInput: string;
+    private _customFormulaService;
+    validatorFormula(rule: IDataValidationRuleBase): IFormulaValidResult;
+    parseFormula(_rule: IDataValidationRule, _unitId: string, _subUnitId: string): Promise<IFormulaResult>;
+    isValidType(cellInfo: IValidatorCellInfo<CellValue>, _formula: IFormulaResult, _rule: IDataValidationRule): Promise<boolean>;
+    generateRuleErrorMessage(rule: IDataValidationRuleBase): string;
+}

package/lib/types/validators/date-validator.d.ts

@@ -0,0 +1,31 @@
+import { IFormulaResult, IFormulaValidResult, IValidatorCellInfo, BaseDataValidator } from '@univerjs/data-validation';
+import { Dayjs } from 'dayjs';
+import { DataValidationOperator, CellValue, IDataValidationRule, IDataValidationRuleBase, Nullable } from '@univerjs/core';
+
+export declare class DateValidator extends BaseDataValidator<Dayjs> {
+    id: string;
+    title: string;
+    operators: DataValidationOperator[];
+    scopes: string | string[];
+    formulaInput: string;
+    dropdown: string;
+    private _formulaService;
+    parseFormula(rule: IDataValidationRule, unitId: string, subUnitId: string): Promise<IFormulaResult<Dayjs | undefined>>;
+    transformDate: (value: Nullable<CellValue>) => Dayjs | undefined;
+    isValidType(info: IValidatorCellInfo): Promise<boolean>;
+    private _validatorSingleFormula;
+    validatorFormula(rule: IDataValidationRuleBase): IFormulaValidResult;
+    transform(cellInfo: IValidatorCellInfo<CellValue>, _formula: IFormulaResult, _rule: IDataValidationRule): IValidatorCellInfo<Dayjs>;
+    validatorIsEqual(info: IValidatorCellInfo<Dayjs>, formula: IFormulaResult<Dayjs | undefined>, _rule: IDataValidationRule): Promise<boolean>;
+    validatorIsNotEqual(info: IValidatorCellInfo<Dayjs>, formula: IFormulaResult<Dayjs | undefined>): Promise<boolean>;
+    validatorIsBetween(info: IValidatorCellInfo<Dayjs>, formula: IFormulaResult<Dayjs | undefined>): Promise<boolean>;
+    validatorIsNotBetween(info: IValidatorCellInfo<Dayjs>, formula: IFormulaResult<Dayjs | undefined>): Promise<boolean>;
+    validatorIsGreaterThan(info: IValidatorCellInfo<Dayjs>, formula: IFormulaResult<Dayjs | undefined>): Promise<boolean>;
+    validatorIsGreaterThanOrEqual(info: IValidatorCellInfo<Dayjs>, formula: IFormulaResult<Dayjs | undefined>): Promise<boolean>;
+    validatorIsLessThan(info: IValidatorCellInfo<Dayjs>, formula: IFormulaResult<Dayjs | undefined>): Promise<boolean>;
+    validatorIsLessThanOrEqual(info: IValidatorCellInfo<Dayjs>, formula: IFormulaResult<Dayjs | undefined>): Promise<boolean>;
+    validatorFormulaValue(rule: IDataValidationRuleBase): string | undefined;
+    get operatorNames(): string[];
+    generateRuleName(rule: IDataValidationRuleBase): string;
+    generateRuleErrorMessage(rule: IDataValidationRuleBase): string;
+}

package/lib/types/validators/decimal-validator.d.ts

@@ -0,0 +1,36 @@
+import { IFormulaResult, IFormulaValidResult, IValidatorCellInfo, BaseDataValidator } from '@univerjs/data-validation';
+import { DataValidationOperator, CellValue, IDataValidationRule, IDataValidationRuleBase } from '@univerjs/core';
+
+export declare function getCellValueNumber(cellValue: CellValue): number;
+export declare class DecimalValidator extends BaseDataValidator<number> {
+    private _formulaService;
+    id: string;
+    title: string;
+    operators: DataValidationOperator[];
+    scopes: string | string[];
+    formulaInput: string;
+    dropDownInput?: string;
+    private _isFormulaOrNumber;
+    isValidType(cellInfo: IValidatorCellInfo<CellValue>, formula: IFormulaResult, rule: IDataValidationRule): Promise<boolean>;
+    transform(cellInfo: IValidatorCellInfo<CellValue>, formula: IFormulaResult, rule: IDataValidationRule): {
+        value: number;
+        row: number;
+        column: number;
+        unitId: string;
+        subUnitId: string;
+    };
+    private _parseNumber;
+    parseFormula(rule: IDataValidationRule, unitId: string, subUnitId: string): Promise<{
+        formula1: number;
+        formula2: number;
+    }>;
+    validatorFormula(rule: IDataValidationRuleBase): IFormulaValidResult;
+    validatorIsEqual(cellInfo: IValidatorCellInfo<CellValue>, formula: IFormulaResult, rule: IDataValidationRule): Promise<boolean>;
+    validatorIsNotEqual(cellInfo: IValidatorCellInfo<number>, formula: IFormulaResult, _rule: IDataValidationRule): Promise<boolean>;
+    validatorIsBetween(cellInfo: IValidatorCellInfo<number>, formula: IFormulaResult, _rule: IDataValidationRule): Promise<boolean>;
+    validatorIsNotBetween(cellInfo: IValidatorCellInfo<number>, formula: IFormulaResult, _rule: IDataValidationRule): Promise<boolean>;
+    validatorIsGreaterThan(cellInfo: IValidatorCellInfo<number>, formula: IFormulaResult, _rule: IDataValidationRule): Promise<boolean>;
+    validatorIsGreaterThanOrEqual(cellInfo: IValidatorCellInfo<number>, formula: IFormulaResult, _rule: IDataValidationRule): Promise<boolean>;
+    validatorIsLessThan(cellInfo: IValidatorCellInfo<number>, formula: IFormulaResult, _rule: IDataValidationRule): Promise<boolean>;
+    validatorIsLessThanOrEqual(cellInfo: IValidatorCellInfo<number>, formula: IFormulaResult, _rule: IDataValidationRule): Promise<boolean>;
+}

package/lib/types/validators/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export { CheckboxValidator, CHECKBOX_FORMULA_1, CHECKBOX_FORMULA_2 } from './checkbox-validator';
+export { DateValidator } from './date-validator';
+export { ListValidator } from './list-validator';
+export { DecimalValidator } from './decimal-validator';
+export { TextLengthValidator } from './text-length-validator';

package/lib/types/validators/list-multiple-validator.d.ts

@@ -0,0 +1,27 @@
+import { DropdownMultipleWidget } from '../widgets/dropdown-multiple-widget';
+import { IFormulaResult, IFormulaValidResult, IValidatorCellInfo, BaseDataValidator } from '@univerjs/data-validation';
+import { CellValue, DataValidationOperator, IDataValidationRule, IDataValidationRuleBase, Nullable } from '@univerjs/core';
+
+export declare class ListMultipleValidator extends BaseDataValidator {
+    id: string;
+    title: string;
+    operators: DataValidationOperator[];
+    scopes: string | string[];
+    formulaInput: string;
+    private _univerInstanceService;
+    canvasRender: DropdownMultipleWidget;
+    dropdown: string | undefined;
+    skipDefaultFontRender(): boolean;
+    validatorFormula(rule: IDataValidationRuleBase): IFormulaValidResult;
+    parseCellValue(cellValue: CellValue, rule: IDataValidationRule): string[];
+    parseFormula(rule: IDataValidationRule, unitId: string, subUnitId: string): Promise<IFormulaResult<string[] | undefined>>;
+    isValidType(cellInfo: IValidatorCellInfo<Nullable<CellValue>>, formula: IFormulaResult<any>, rule: IDataValidationRule): Promise<boolean>;
+    generateRuleName(): string;
+    generateRuleErrorMessage(): string;
+    getList(rule: IDataValidationRule, propUnitId?: string, propSubUnitId?: string): string[];
+    getListWithColor(rule: IDataValidationRule, currentUnitId?: string, currentSubUnitId?: string): {
+        label: string;
+        color: string;
+    }[];
+    getListWithColorMap(rule: IDataValidationRule, currentUnitId?: string, currentSubUnitId?: string): Record<string, string>;
+}

package/lib/types/validators/list-validator.d.ts

@@ -0,0 +1,28 @@
+import { DropdownWidget } from '../widgets/dropdown-widget';
+import { IFormulaResult, IFormulaValidResult, IValidatorCellInfo, BaseDataValidator } from '@univerjs/data-validation';
+import { CellValue, DataValidationOperator, IDataValidationRule, IDataValidationRuleBase, ISheetDataValidationRule, Nullable } from '@univerjs/core';
+
+export declare class ListValidator extends BaseDataValidator {
+    id: string;
+    title: string;
+    operators: DataValidationOperator[];
+    scopes: string | string[];
+    formulaInput: string;
+    private _univerInstanceService;
+    canvasRender: DropdownWidget;
+    dropdown: string | undefined;
+    optionsInput: string | undefined;
+    skipDefaultFontRender(rule: ISheetDataValidationRule): boolean;
+    validatorFormula(rule: IDataValidationRuleBase): IFormulaValidResult;
+    private _parseCellValue;
+    parseFormula(rule: IDataValidationRule, unitId: string, subUnitId: string): Promise<IFormulaResult<string[] | undefined>>;
+    isValidType(cellInfo: IValidatorCellInfo<Nullable<CellValue>>, formula: IFormulaResult<any>, rule: IDataValidationRule): Promise<boolean>;
+    generateRuleName(): string;
+    generateRuleErrorMessage(): string;
+    getList(rule: IDataValidationRule, currentUnitId?: string, currentSubUnitId?: string): string[];
+    getListWithColor(rule: IDataValidationRule, currentUnitId?: string, currentSubUnitId?: string): {
+        label: string;
+        color: string;
+    }[];
+    getListWithColorMap(rule: IDataValidationRule, currentUnitId?: string, currentSubUnitId?: string): Record<string, string>;
+}

package/lib/types/validators/text-length-validator.d.ts

@@ -0,0 +1,32 @@
+import { IFormulaResult, IFormulaValidResult, IValidatorCellInfo, BaseDataValidator } from '@univerjs/data-validation';
+import { DataValidationOperator, CellValue, IDataValidationRule, IDataValidationRuleBase } from '@univerjs/core';
+
+export declare class TextLengthValidator extends BaseDataValidator<number> {
+    id: string;
+    title: string;
+    operators: DataValidationOperator[];
+    scopes: string | string[];
+    formulaInput: string;
+    private _formulaService;
+    private _isFormulaOrInt;
+    validatorFormula(rule: IDataValidationRuleBase): IFormulaValidResult;
+    private _parseNumber;
+    private _isValidFormula;
+    parseFormula(rule: IDataValidationRule, unitId: string, subUnitId: string): Promise<IFormulaResult<any>>;
+    transform(cellInfo: IValidatorCellInfo<CellValue>, _formula: IFormulaResult, _rule: IDataValidationRule): {
+        value: number;
+        row: number;
+        column: number;
+        unitId: string;
+        subUnitId: string;
+    };
+    isValidType(cellInfo: IValidatorCellInfo<number>, formula: IFormulaResult, rule: IDataValidationRule): Promise<boolean>;
+    validatorIsEqual(cellInfo: IValidatorCellInfo<number>, formula: IFormulaResult, rule: IDataValidationRule): Promise<boolean>;
+    validatorIsNotEqual(cellInfo: IValidatorCellInfo<number>, formula: IFormulaResult, rule: IDataValidationRule): Promise<boolean>;
+    validatorIsBetween(cellInfo: IValidatorCellInfo<number>, formula: IFormulaResult, rule: IDataValidationRule): Promise<boolean>;
+    validatorIsNotBetween(cellInfo: IValidatorCellInfo<number>, formula: IFormulaResult, rule: IDataValidationRule): Promise<boolean>;
+    validatorIsGreaterThan(cellInfo: IValidatorCellInfo<number>, formula: IFormulaResult, rule: IDataValidationRule): Promise<boolean>;
+    validatorIsGreaterThanOrEqual(cellInfo: IValidatorCellInfo<number>, formula: IFormulaResult, rule: IDataValidationRule): Promise<boolean>;
+    validatorIsLessThan(cellInfo: IValidatorCellInfo<number>, formula: IFormulaResult, rule: IDataValidationRule): Promise<boolean>;
+    validatorIsLessThanOrEqual(cellInfo: IValidatorCellInfo<number>, formula: IFormulaResult, rule: IDataValidationRule): Promise<boolean>;
+}

package/lib/types/validators/util.d.ts

@@ -0,0 +1,6 @@
+import { ICellData, IUnitRangeName, IUniverInstanceService, Nullable } from '@univerjs/core';
+
+export declare function getSheetRangeValueSet(grid: IUnitRangeName, univerInstanceService: IUniverInstanceService, currUnitId: string, currSubUnitId: string): string[];
+export declare function serializeListOptions(options: string[]): string;
+export declare function deserializeListOptions(optionsStr: string): string[];
+export declare function getDataValidationCellValue(cellData: Nullable<ICellData>): string;

package/lib/types/validators/whole-validator.d.ts

@@ -0,0 +1,35 @@
+import { IFormulaResult, IFormulaValidResult, IValidatorCellInfo, BaseDataValidator } from '@univerjs/data-validation';
+import { DataValidationOperator, CellValue, IDataValidationRule, IDataValidationRuleBase } from '@univerjs/core';
+
+export declare class WholeValidator extends BaseDataValidator<number> {
+    private _formulaService;
+    id: string;
+    title: string;
+    operators: DataValidationOperator[];
+    scopes: string | string[];
+    formulaInput: string;
+    dropDownInput?: string;
+    private _isFormulaOrInt;
+    isValidType(cellInfo: IValidatorCellInfo<CellValue>, formula: IFormulaResult, rule: IDataValidationRule): Promise<boolean>;
+    transform(cellInfo: IValidatorCellInfo<CellValue>, formula: IFormulaResult, rule: IDataValidationRule): {
+        value: number;
+        row: number;
+        column: number;
+        unitId: string;
+        subUnitId: string;
+    };
+    private _parseNumber;
+    parseFormula(rule: IDataValidationRule, unitId: string, subUnitId: string): Promise<{
+        formula1: number;
+        formula2: number;
+    }>;
+    validatorFormula(rule: IDataValidationRuleBase): IFormulaValidResult;
+    validatorIsEqual(cellInfo: IValidatorCellInfo<CellValue>, formula: IFormulaResult, rule: IDataValidationRule): Promise<boolean>;
+    validatorIsNotEqual(cellInfo: IValidatorCellInfo<number>, formula: IFormulaResult, _rule: IDataValidationRule): Promise<boolean>;
+    validatorIsBetween(cellInfo: IValidatorCellInfo<number>, formula: IFormulaResult, _rule: IDataValidationRule): Promise<boolean>;
+    validatorIsNotBetween(cellInfo: IValidatorCellInfo<number>, formula: IFormulaResult, _rule: IDataValidationRule): Promise<boolean>;
+    validatorIsGreaterThan(cellInfo: IValidatorCellInfo<number>, formula: IFormulaResult, _rule: IDataValidationRule): Promise<boolean>;
+    validatorIsGreaterThanOrEqual(cellInfo: IValidatorCellInfo<number>, formula: IFormulaResult, _rule: IDataValidationRule): Promise<boolean>;
+    validatorIsLessThan(cellInfo: IValidatorCellInfo<number>, formula: IFormulaResult, _rule: IDataValidationRule): Promise<boolean>;
+    validatorIsLessThanOrEqual(cellInfo: IValidatorCellInfo<number>, formula: IFormulaResult, _rule: IDataValidationRule): Promise<boolean>;
+}

package/lib/types/views/date-dropdown/index.d.ts

@@ -0,0 +1,4 @@
+import { IDropdownComponentProps } from '../../services/dropdown-manager.service';
+import { default as React } from 'react';
+
+export declare function DateDropdown(props: IDropdownComponentProps): React.JSX.Element | null | undefined;

package/lib/types/views/detail/index.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+
+export declare function DataValidationDetail(): React.JSX.Element | null;

package/lib/types/views/drop-down/CellDropdown.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+
+export declare function CellDropdown(): React.JSX.Element | null;

package/lib/types/views/drop-down/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export { CellDropdown } from './CellDropdown';
+declare const DROP_DOWN_KEY = "sheet.ui.dropdown";
+export { DROP_DOWN_KEY };

package/lib/types/views/formula-input/base-formula-input.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { IFormulaInputProps } from '@univerjs/data-validation';
+
+export declare const BaseFormulaInput: (props: IFormulaInputProps) => React.JSX.Element;

package/lib/types/views/formula-input/checkbox-formula-input.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { IFormulaInputProps } from '@univerjs/data-validation';
+
+export declare function CheckboxFormulaInput(props: IFormulaInputProps): React.JSX.Element;

package/lib/types/views/formula-input/custom-formula-input.d.ts

@@ -0,0 +1,4 @@
+import { IFormulaInputProps } from '@univerjs/data-validation';
+import { default as React } from 'react';
+
+export declare function CustomFormulaInput(props: IFormulaInputProps): React.JSX.Element;

package/lib/types/views/formula-input/formula-input.d.ts

@@ -0,0 +1,5 @@
+import { FormulaInputType } from '@univerjs/data-validation';
+
+export declare const BASE_FORMULA_INPUT_NAME = "data-validation.formula-input";
+export declare const LIST_FORMULA_INPUT_NAME = "data-validation.list-formula-input";
+export declare const FORMULA_INPUTS: [string, FormulaInputType][];

package/lib/types/views/formula-input/index.d.ts

@@ -0,0 +1,7 @@
+import { FormulaInputType } from '@univerjs/data-validation';
+
+export declare const CUSTOM_FORMULA_INPUT_NAME = "data-validation.custom-formula-input";
+export declare const BASE_FORMULA_INPUT_NAME = "data-validation.formula-input";
+export declare const LIST_FORMULA_INPUT_NAME = "data-validation.list-formula-input";
+export declare const CHECKBOX_FORMULA_INPUT_NAME = "data-validation.checkbox-formula-input";
+export declare const FORMULA_INPUTS: [string, FormulaInputType][];