@univerjs/sheets-data-validation 0.5.0 → 0.5.1-nightly.202411301606

package/lib/types/controllers/config.schema.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export declare const PLUGIN_CONFIG_KEY = "sheets-data-validation.config";
+export declare const SHEETS_DATA_VALIDATION_PLUGIN_CONFIG_KEY = "sheets-data-validation.config";
 export declare const configSymbol: unique symbol;
 export interface IUniverSheetsDataValidationConfig {
 }

package/lib/types/controllers/dv-formula-ref-range.controller.d.ts

@@ -1,11 +1,13 @@
 import { ISheetDataValidationRule, Disposable } from '@univerjs/core';
+import { DataValidatorRegistryService } from '@univerjs/data-validation';
 import { FormulaRefRangeService } from '@univerjs/sheets-formula';
 import { SheetDataValidationModel } from '../models/sheet-data-validation-model';
 export declare class DataValidationFormulaRefRangeController extends Disposable {
     private _dataValidationModel;
     private _formulaRefRangeService;
+    private _validatorRegistryService;
     private _disposableMap;
-    constructor(_dataValidationModel: SheetDataValidationModel, _formulaRefRangeService: FormulaRefRangeService);
+    constructor(_dataValidationModel: SheetDataValidationModel, _formulaRefRangeService: FormulaRefRangeService, _validatorRegistryService: DataValidatorRegistryService);
     private _getIdWithUnitId;
     registerRule: (unitId: string, subUnitId: string, rule: ISheetDataValidationRule) => void;
     register(unitId: string, subUnitId: string, rule: ISheetDataValidationRule): void;

package/lib/types/controllers/dv-ref-range.controller.d.ts

@@ -1,18 +1,18 @@
 import { ISheetDataValidationRule, Disposable, Injector } from '@univerjs/core';
+import { DataValidatorRegistryService } from '@univerjs/data-validation';
 import { RefRangeService } from '@univerjs/sheets';
 import { FormulaRefRangeService } from '@univerjs/sheets-formula';
 import { SheetDataValidationModel } from '../models/sheet-data-validation-model';
-import { DataValidationCustomFormulaService } from '../services/dv-custom-formula.service';
 import { DataValidationFormulaService } from '../services/dv-formula.service';
 export declare class DataValidationRefRangeController extends Disposable {
     private _dataValidationModel;
     private _injector;
     private _refRangeService;
-    private _dataValidationCustomFormulaService;
     private _dataValidationFormulaService;
     private _formulaRefRangeService;
+    private _validatorRegistryService;
     private _disposableMap;
-    constructor(_dataValidationModel: SheetDataValidationModel, _injector: Injector, _refRangeService: RefRangeService, _dataValidationCustomFormulaService: DataValidationCustomFormulaService, _dataValidationFormulaService: DataValidationFormulaService, _formulaRefRangeService: FormulaRefRangeService);
+    constructor(_dataValidationModel: SheetDataValidationModel, _injector: Injector, _refRangeService: RefRangeService, _dataValidationFormulaService: DataValidationFormulaService, _formulaRefRangeService: FormulaRefRangeService, _validatorRegistryService: DataValidatorRegistryService);
     private _getIdWithUnitId;
     registerRule: (unitId: string, subUnitId: string, rule: ISheetDataValidationRule) => void;
     registerFormula(unitId: string, subUnitId: string, rule: ISheetDataValidationRule): void;

package/lib/types/facade/f-data-validation-builder.d.ts

@@ -34,7 +34,7 @@ export declare class FDataValidationBuilder {
      *
      * @returns {DataValidationType} The data validation type
      */
-    getCriteriaType(): DataValidationType;
+    getCriteriaType(): DataValidationType | string;
     /**
      * Gets the values used for criteria evaluation
      *
@@ -235,7 +235,7 @@ export declare class FDataValidationBuilder {
      * operator is a DataValidationOperator enum value, formula1 is the first formula, and formula2 is the second formula.
      * @return The current instance of the FDataValidationBuilder class, allowing for method chaining.
      */
-    withCriteriaValues(type: DataValidationType, values: [DataValidationOperator, string, string]): this;
+    withCriteriaValues(type: DataValidationType | string, values: [DataValidationOperator, string, string]): this;
     /**
      * Sets the options for the data validation rule.
      * For details of options, please refer to https://univer.ai/typedoc/@univerjs/core/interfaces/IDataValidationRuleOptions

package/lib/types/facade/f-data-validation.d.ts

@@ -16,7 +16,7 @@ export declare class FDataValidation {
      *
      * @returns The data validation type
      */
-    getCriteriaType(): DataValidationType;
+    getCriteriaType(): DataValidationType | string;
     /**
      * Gets the values used for criteria evaluation
      *

package/lib/types/models/rule-matrix.d.ts

@@ -25,8 +25,10 @@ export declare class RuleMatrix {
     private _buildTree;
     private _debonceBuildTree;
     get _worksheet(): import('@univerjs/core').Nullable<import('@univerjs/core').Worksheet>;
+    private _addRule;
     addRule(rule: ISheetDataValidationRule): void;
     removeRange(_ranges: IRange[]): void;
+    private _removeRule;
     removeRule(rule: ISheetDataValidationRule): void;
     updateRange(ruleId: string, _newRanges: IRange[]): void;
     addRangeRules(rules: {

package/lib/types/models/sheet-data-validation-model.d.ts

@@ -34,7 +34,7 @@ export declare class SheetDataValidationModel extends Disposable {
     private _addRule;
     private _updateRule;
     private _removeRule;
-    getValidator(type: DataValidationType): import('@univerjs/data-validation').BaseDataValidator<import('@univerjs/core').CellValue> | undefined;
+    getValidator(type: DataValidationType | string): import('@univerjs/data-validation').BaseDataValidator | undefined;
     getRuleIdByLocation(unitId: string, subUnitId: string, row: number, col: number): string | undefined;
     getRuleByLocation(unitId: string, subUnitId: string, row: number, col: number): ISheetDataValidationRule | undefined;
     validator(rule: ISheetDataValidationRule, pos: ISheetLocation, _onCompete?: (status: DataValidationStatus, changed: boolean) => void): DataValidationStatus;

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

@@ -1,6 +1,7 @@
-import { DataValidationStatus, IRange, ISheetDataValidationRule, Nullable, Disposable, ICommandService, ObjectMatrix } from '@univerjs/core';
+import { DataValidationStatus, IRange, ISheetDataValidationRule, Nullable, Disposable, ICommandService, IUniverInstanceService, ObjectMatrix } from '@univerjs/core';
 export declare class DataValidationCacheService extends Disposable {
     private readonly _commandService;
+    private readonly _univerInstanceService;
     private _cacheMatrix;
     private _dirtyRanges$;
     readonly dirtyRanges$: import('rxjs').Observable<{
@@ -8,15 +9,14 @@ export declare class DataValidationCacheService extends Disposable {
         subUnitId: string;
         ranges: IRange[];
     }>;
-    constructor(_commandService: ICommandService);
+    constructor(_commandService: ICommandService, _univerInstanceService: IUniverInstanceService);
     private _initDirtyRanges;
+    private _initSheetRemove;
     private _ensureCache;
     ensureCache(unitId: string, subUnitId: string): ObjectMatrix<Nullable<DataValidationStatus>>;
     addRule(unitId: string, subUnitId: string, rule: ISheetDataValidationRule): void;
     removeRule(unitId: string, subUnitId: string, rule: ISheetDataValidationRule): 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<Nullable<DataValidationStatus>>;
-    setValue(unitId: string, subUnitId: string, row: number, col: number, value: DataValidationStatus): void;
 }

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

@@ -1,5 +1,5 @@
 import { ISheetDataValidationRule, Disposable, IUniverInstanceService } from '@univerjs/core';
-import { DataValidationModel } from '@univerjs/data-validation';
+import { DataValidationModel, DataValidatorRegistryService } from '@univerjs/data-validation';
 import { RegisterOtherFormulaService } from '@univerjs/sheets-formula';
 import { DataValidationCacheService } from './dv-cache.service';
 interface IFormulaData {
@@ -13,12 +13,13 @@ export declare class DataValidationCustomFormulaService extends Disposable {
     private _registerOtherFormulaService;
     private readonly _dataValidationModel;
     private readonly _dataValidationCacheService;
+    private readonly _validatorRegistryService;
     /**
      * Map of origin formula of rule
      */
     private _ruleFormulaMap;
     private _ruleFormulaMap2;
-    constructor(_instanceSrv: IUniverInstanceService, _registerOtherFormulaService: RegisterOtherFormulaService, _dataValidationModel: DataValidationModel, _dataValidationCacheService: DataValidationCacheService);
+    constructor(_instanceSrv: IUniverInstanceService, _registerOtherFormulaService: RegisterOtherFormulaService, _dataValidationModel: DataValidationModel, _dataValidationCacheService: DataValidationCacheService, _validatorRegistryService: DataValidatorRegistryService);
     private _initFormulaResultHandler;
     private _ensureMaps;
     private _registerFormula;

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

@@ -1,14 +1,15 @@
 import { ISheetDataValidationRule, Nullable, Disposable, IUniverInstanceService } from '@univerjs/core';
 import { IFormulaInfo, IOtherFormulaResult, RegisterOtherFormulaService } from '@univerjs/sheets-formula';
-import { DataValidationModel } from '@univerjs/data-validation';
+import { DataValidationModel, DataValidatorRegistryService } from '@univerjs/data-validation';
 import { DataValidationCacheService } from './dv-cache.service';
 export declare class DataValidationFormulaService extends Disposable {
     private readonly _instanceService;
     private _registerOtherFormulaService;
     private readonly _dataValidationCacheService;
     private readonly _dataValidationModel;
+    private readonly _validatorRegistryService;
     private _formulaRuleMap;
-    constructor(_instanceService: IUniverInstanceService, _registerOtherFormulaService: RegisterOtherFormulaService, _dataValidationCacheService: DataValidationCacheService, _dataValidationModel: DataValidationModel);
+    constructor(_instanceService: IUniverInstanceService, _registerOtherFormulaService: RegisterOtherFormulaService, _dataValidationCacheService: DataValidationCacheService, _dataValidationModel: DataValidationModel, _validatorRegistryService: DataValidatorRegistryService);
     private _initFormulaResultHandler;
     private _ensureRuleFormulaMap;
     private _registerSingleFormula;

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

@@ -1,8 +1,9 @@
 import { DataValidationType, ICellData, Nullable } from '@univerjs/core';
+import { DataValidatorRegistryService } from '@univerjs/data-validation';
 export declare function getFormulaResult(result: Nullable<Nullable<ICellData>[][]>): Nullable<import('@univerjs/core').CellValue>;
 export declare function getFormulaCellData(result: Nullable<Nullable<ICellData>[][]>): Nullable<ICellData>;
 export declare function isLegalFormulaResult(res: string): boolean;
 /**
  * Judge if the data-validation's formula need to be offseted by ranges
  */
-export declare function isCustomFormulaType(type: DataValidationType): type is DataValidationType.CUSTOM | DataValidationType.NONE | DataValidationType.TEXT_LENGTH | DataValidationType.DATE | DataValidationType.TIME | DataValidationType.WHOLE | DataValidationType.DECIMAL;
+export declare function shouldOffsetFormulaByRange(type: DataValidationType | string, validatorRegistryService: DataValidatorRegistryService): boolean;

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

@@ -5,6 +5,7 @@ export declare class AnyValidator extends BaseDataValidator {
     title: string;
     operators: DataValidationOperator[];
     scopes: string | string[];
+    readonly offsetFormulaByRange = false;
     parseFormula(rule: IDataValidationRule, unitId: string, subUnitId: string): Promise<IFormulaResult>;
     validatorFormula(rule: IDataValidationRule, unitId: string, subUnitId: string): IFormulaValidResult;
     isValidType(cellInfo: IValidatorCellInfo<CellValue>, formula: IFormulaResult, rule: IDataValidationRule): Promise<boolean>;

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

@@ -12,6 +12,7 @@ export declare class CheckboxValidator extends BaseDataValidator {
     title: string;
     operators: DataValidationOperator[];
     scopes: string | string[];
+    readonly offsetFormulaByRange = false;
     private _formulaService;
     skipDefaultFontRender: (rule: ISheetDataValidationRule, cellValue: Nullable<CellValue>, pos: {
         unitId: string;

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

@@ -1,7 +1,7 @@
 import { CellValue, IDataValidationRule, IDataValidationRuleBase, DataValidationOperator } from '@univerjs/core';
 import { IFormulaResult, IFormulaValidResult, IValidatorCellInfo, BaseDataValidator } from '@univerjs/data-validation';
 import { ISheetLocationBase } from '@univerjs/sheets';
-export declare class DateValidator extends BaseDataValidator<number> {
+export declare class DateValidator extends BaseDataValidator {
     id: string;
     title: string;
     operators: DataValidationOperator[];
@@ -17,14 +17,6 @@ export declare class DateValidator extends BaseDataValidator<number> {
         formula2: string | undefined;
     };
     transform(cellInfo: IValidatorCellInfo<CellValue>, _formula: IFormulaResult, _rule: IDataValidationRule): IValidatorCellInfo<number>;
-    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>;
     get operatorNames(): string[];
     generateRuleName(rule: IDataValidationRuleBase): string;
     generateRuleErrorMessage(rule: IDataValidationRuleBase, pos: ISheetLocationBase): string;

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

@@ -2,7 +2,7 @@ import { CellValue, IDataValidationRule, IDataValidationRuleBase, Nullable, Data
 import { IFormulaResult, IFormulaValidResult, IValidatorCellInfo, BaseDataValidator } from '@univerjs/data-validation';
 import { ISheetLocationBase } from '@univerjs/sheets';
 export declare function getCellValueNumber(cellValue: CellValue): number;
-export declare class DecimalValidator extends BaseDataValidator<number> {
+export declare class DecimalValidator extends BaseDataValidator {
     private readonly _customFormulaService;
     id: string;
     private readonly _lexerTreeBuilder;
@@ -25,13 +25,5 @@ export declare class DecimalValidator extends BaseDataValidator<number> {
     private _parseNumber;
     parseFormula(rule: IDataValidationRule, unitId: string, subUnitId: string, row: number, column: number): Promise<IFormulaResult>;
     validatorFormula(rule: IDataValidationRule, unitId: string, subUnitId: string): 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>;
     generateRuleErrorMessage(rule: IDataValidationRuleBase, position: ISheetLocationBase): string;
 }

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

@@ -2,5 +2,6 @@ import { ListValidator } from './list-validator';
 export declare class ListMultipleValidator extends ListValidator {
     id: string;
     title: string;
+    readonly offsetFormulaByRange = false;
     skipDefaultFontRender: () => boolean;
 }

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

@@ -8,6 +8,7 @@ export declare class ListValidator extends BaseDataValidator {
     protected formulaService: DataValidationFormulaService;
     private _lexer;
     private _univerInstanceService;
+    readonly offsetFormulaByRange = false;
     id: string;
     title: string;
     operators: DataValidationOperator[];
@@ -18,7 +19,7 @@ export declare class ListValidator extends BaseDataValidator {
         style: IStyleData;
     }): Nullable<IStyleData>;
     parseCellValue(cellValue: CellValue): string[];
-    parseFormula(rule: IDataValidationRule, unitId: string, subUnitId: string): Promise<IFormulaResult<string[] | undefined>>;
+    parseFormula(rule: IDataValidationRule, unitId: string, subUnitId: string): Promise<IFormulaResult<number | undefined>>;
     isValidType(cellInfo: IValidatorCellInfo<Nullable<CellValue>>, formula: IFormulaResult<string[] | undefined>, rule: IDataValidationRule): Promise<boolean>;
     generateRuleName(): string;
     generateRuleErrorMessage(): string;

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

@@ -1,7 +1,7 @@
 import { CellValue, IDataValidationRule, IDataValidationRuleBase, Nullable, DataValidationOperator } from '@univerjs/core';
 import { IFormulaResult, IFormulaValidResult, IValidatorCellInfo, BaseDataValidator } from '@univerjs/data-validation';
 import { ISheetLocationBase } from '@univerjs/sheets';
-export declare class TextLengthValidator extends BaseDataValidator<number> {
+export declare class TextLengthValidator extends BaseDataValidator {
     id: string;
     title: string;
     private readonly _lexerTreeBuilder;
@@ -9,10 +9,9 @@ export declare class TextLengthValidator extends BaseDataValidator<number> {
     scopes: string | string[];
     private readonly _customFormulaService;
     private _isFormulaOrInt;
-    validatorFormula(rule: IDataValidationRule, unitId: string, subUnitId: string): IFormulaValidResult;
+    validatorFormula(rule: IDataValidationRule, _unitId: string, _subUnitId: string): IFormulaValidResult;
     private _parseNumber;
-    private _isValidFormula;
-    parseFormula(rule: IDataValidationRule, unitId: string, subUnitId: string, row: number, column: number): Promise<IFormulaResult<any>>;
+    parseFormula(rule: IDataValidationRule, unitId: string, subUnitId: string, row: number, column: number): Promise<IFormulaResult<number | undefined>>;
     transform(cellInfo: IValidatorCellInfo<CellValue>, _formula: IFormulaResult, _rule: IDataValidationRule): {
         value: number;
         interceptValue: Nullable<CellValue>;
@@ -24,14 +23,6 @@ export declare class TextLengthValidator extends BaseDataValidator<number> {
         workbook: import('@univerjs/core').Workbook;
         t: Nullable<import('@univerjs/protocol').CellValueType>;
     };
-    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>;
+    isValidType(cellInfo: IValidatorCellInfo<number>, _formula: IFormulaResult, _rule: IDataValidationRule): Promise<boolean>;
     generateRuleErrorMessage(rule: IDataValidationRuleBase, pos: ISheetLocationBase): string;
 }

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

@@ -1,7 +1,7 @@
 import { CellValue, IDataValidationRule, IDataValidationRuleBase, Nullable, DataValidationOperator } from '@univerjs/core';
 import { IFormulaResult, IFormulaValidResult, IValidatorCellInfo, BaseDataValidator } from '@univerjs/data-validation';
 import { ISheetLocationBase } from '@univerjs/sheets';
-export declare class WholeValidator extends BaseDataValidator<number> {
+export declare class WholeValidator extends BaseDataValidator {
     private readonly _customFormulaService;
     private readonly _lexerTreeBuilder;
     id: string;
@@ -9,8 +9,8 @@ export declare class WholeValidator extends BaseDataValidator<number> {
     operators: DataValidationOperator[];
     scopes: string | string[];
     private _isFormulaOrInt;
-    isValidType(cellInfo: IValidatorCellInfo<CellValue>, formula: IFormulaResult, rule: IDataValidationRule): Promise<boolean>;
-    transform(cellInfo: IValidatorCellInfo<CellValue>, formula: IFormulaResult, rule: IDataValidationRule): {
+    isValidType(cellInfo: IValidatorCellInfo<CellValue>, _formula: IFormulaResult, _rule: IDataValidationRule): Promise<boolean>;
+    transform(cellInfo: IValidatorCellInfo<CellValue>, _formula: IFormulaResult, _rule: IDataValidationRule): {
         value: number;
         interceptValue: Nullable<CellValue>;
         row: number;
@@ -23,14 +23,6 @@ export declare class WholeValidator extends BaseDataValidator<number> {
     };
     private _parseNumber;
     parseFormula(rule: IDataValidationRule, unitId: string, subUnitId: string, row: number, column: number): Promise<IFormulaResult>;
-    validatorFormula(rule: IDataValidationRuleBase, unitId: string, subUnitId: string): 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>;
+    validatorFormula(rule: IDataValidationRuleBase, _unitId: string, _subUnitId: string): IFormulaValidResult;
     generateRuleErrorMessage(rule: IDataValidationRuleBase, position: ISheetLocationBase): string;
 }