@univerjs/sheets-data-validation 0.5.4 → 0.5.5-experimental.20250122-3362a4a

package/lib/es/facade.js

@@ -1,769 +1,1012 @@
-var j = Object.defineProperty;
-var q = (c, e, t) => e in c ? j(c, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : c[e] = t;
-var f = (c, e, t) => q(c, typeof e != "symbol" ? e + "" : e, t);
-import { UpdateSheetDataValidationSettingCommand as U, UpdateSheetDataValidationOptionsCommand as v, UpdateSheetDataValidationRangeCommand as C, RemoveSheetDataValidationCommand as T, ClearRangeDataValidationCommand as W, AddSheetDataValidationCommand as A, SheetsDataValidationValidatorService as S, SheetDataValidationModel as V, RemoveSheetAllDataValidationCommand as O } from "@univerjs/sheets-data-validation";
-import { FRange as y, FWorkbook as M, FWorksheet as x } from "@univerjs/sheets/facade";
-import { generateRandomId as B, DataValidationType as o, DataValidationErrorStyle as w, DataValidationOperator as d, IUniverInstanceService as H, ICommandService as p, FUniver as N, CanceledError as _, toDisposable as g, FEventName as $ } from "@univerjs/core";
-import { DataValidationModel as b, getRuleOptions as F } from "@univerjs/data-validation";
-import { serializeRangeToRefString as P } from "@univerjs/engine-formula";
-import { filter as R } from "rxjs";
-class D {
-  constructor(e) {
-    f(this, "_rule");
-    this._rule = e != null ? e : {
-      uid: B(),
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: !0 });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key != "symbol" ? key + "" : key, value);
+import { UpdateSheetDataValidationSettingCommand, UpdateSheetDataValidationOptionsCommand, UpdateSheetDataValidationRangeCommand, RemoveSheetDataValidationCommand, ClearRangeDataValidationCommand, AddSheetDataValidationCommand, SheetsDataValidationValidatorService, SheetDataValidationModel, RemoveSheetAllDataValidationCommand } from "@univerjs/sheets-data-validation";
+import { FRange, FWorkbook, FWorksheet } from "@univerjs/sheets/facade";
+import { generateRandomId, DataValidationType, DataValidationErrorStyle, DataValidationOperator, IUniverInstanceService, ICommandService, FUniver, CanceledError, toDisposable, FEventName } from "@univerjs/core";
+import { DataValidationModel, getRuleOptions } from "@univerjs/data-validation";
+import { serializeRangeToRefString } from "@univerjs/engine-formula";
+import { filter } from "rxjs";
+const _FDataValidationBuilder = class _FDataValidationBuilder {
+  constructor(rule) {
+    __publicField(this, "_rule");
+    this._rule = rule != null ? rule : {
+      uid: generateRandomId(),
       ranges: void 0,
-      type: o.CUSTOM
+      type: DataValidationType.CUSTOM
     };
   }
   /**
    * Builds an FDataValidation instance based on the _rule property of the current class
-   *
    * @returns {FDataValidation} A new instance of the FDataValidation class
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const validation = builder.requireNumberBetween(1, 10).build();
+   * ```
    */
   build() {
-    return new m(this._rule);
+    return new FDataValidation(this._rule);
   }
   /**
    * Creates a duplicate of the current DataValidationBuilder object
-   *
-   * @return {FDataValidationBuilder} A new instance of the DataValidationBuilder class
+   * @returns {FDataValidationBuilder} A new instance of the DataValidationBuilder class
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const copy = builder.requireNumberBetween(1, 10).copy();
+   * ```
    */
   copy() {
-    return new D({
+    return new _FDataValidationBuilder({
       ...this._rule,
-      uid: B()
+      uid: generateRandomId()
     });
   }
   /**
    * Determines whether invalid data is allowed
-   *
    * @returns {boolean} True if invalid data is allowed, False otherwise
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const allowsInvalid = builder.getAllowInvalid();
+   * ```
    */
   getAllowInvalid() {
-    return this._rule.errorStyle !== w.STOP;
+    return this._rule.errorStyle !== DataValidationErrorStyle.STOP;
   }
   /**
    * Gets the data validation type of the rule
-   *
-   * @returns {DataValidationType} The data validation type
+   * @returns {DataValidationType | string} The data validation type
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const type = builder.getCriteriaType();
+   * ```
    */
   getCriteriaType() {
     return this._rule.type;
   }
   /**
    * Gets the values used for criteria evaluation
-   *
-   * @returns {[string, string, string]} An array containing the operator, formula1, and formula2 values
+   * @returns {[string | undefined, string | undefined, string | undefined]} An array containing the operator, formula1, and formula2 values
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const [operator, formula1, formula2] = builder.getCriteriaValues();
+   * ```
    */
   getCriteriaValues() {
     return [this._rule.operator, this._rule.formula1, this._rule.formula2];
   }
   /**
    * Gets the help text information, which is used to provide users with guidance and support
-   *
-   * @returns {string | undefined} Returns the help text information. If there is no error message, it returns an undefined value.
+   * @returns {string | undefined} Returns the help text information. If there is no error message, it returns an undefined value
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const helpText = builder.getHelpText();
+   * ```
    */
   getHelpText() {
     return this._rule.error;
   }
   /**
    * Sets the data validation type to CHECKBOX and sets the checked and unchecked values
-   *
-   * @param checkedValue The value when the checkbox is checked (Optional)
-   * @param uncheckedValue The value when the checkbox is unchecked (Optional)
-   * @returns The current instance of the FDataValidationBuilder class to allow for method chaining
+   * @param {string} [checkedValue] - The value when the checkbox is checked
+   * @param {string} [uncheckedValue] - The value when the checkbox is unchecked
+   * @returns {FDataValidationBuilder} The current instance for method chaining
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const rule = builder.requireCheckbox('Yes', 'No').build();
+   * ```
    */
-  requireCheckbox(e, t) {
-    return this._rule.type = o.CHECKBOX, this._rule.formula1 = e, this._rule.formula2 = t, this;
+  requireCheckbox(checkedValue, uncheckedValue) {
+    return this._rule.type = DataValidationType.CHECKBOX, this._rule.formula1 = checkedValue, this._rule.formula2 = uncheckedValue, this;
   }
   /**
    * Set the data validation type to DATE and configure the validation rules to be after a specific date
-   *
-   * @param date The date to compare against. The formatted date string will be set as formula1
-   * @return The current instance of the FDataValidationBuilder class to allow for method chaining
+   * @param {Date} date - The date to compare against
+   * @returns {FDataValidationBuilder} The current instance for method chaining
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const rule = builder.requireDateAfter(new Date('2024-01-01')).build();
+   * ```
    */
-  requireDateAfter(e) {
-    return this._rule.type = o.DATE, this._rule.formula1 = e.toLocaleDateString(), this._rule.operator = d.GREATER_THAN, this;
+  requireDateAfter(date) {
+    return this._rule.type = DataValidationType.DATE, this._rule.formula1 = date.toLocaleDateString(), this._rule.operator = DataValidationOperator.GREATER_THAN, this;
   }
   /**
    * Set the data validation type to DATE and configure the validation rules to be before a specific date
-   *
-   * @param date The date to compare against. The formatted date string will be set as formula1
-   * @return The current instance of the FDataValidationBuilder class to allow for method chaining
+   * @param {Date} date - The date to compare against
+   * @returns {FDataValidationBuilder} The current instance for method chaining
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const rule = builder.requireDateBefore(new Date('2024-12-31')).build();
+   * ```
    */
-  requireDateBefore(e) {
-    return this._rule.type = o.DATE, this._rule.formula1 = e.toLocaleDateString(), this._rule.formula2 = void 0, this._rule.operator = d.LESS_THAN, this;
+  requireDateBefore(date) {
+    return this._rule.type = DataValidationType.DATE, this._rule.formula1 = date.toLocaleDateString(), this._rule.formula2 = void 0, this._rule.operator = DataValidationOperator.LESS_THAN, this;
   }
   /**
    * Set the data validation type to DATE and configure the validation rules to be within a specific date range
-   *
-   * @param start The starting date of the range. The formatted date string will be set as formula1
-   * @param end The ending date of the range. The formatted date string will be set as formula2
-   * @return The current instance of the FDataValidationBuilder class to allow for method chaining
+   * @param {Date} start - The starting date of the range
+   * @param {Date} end - The ending date of the range
+   * @returns {FDataValidationBuilder} The current instance for method chaining
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const rule = builder
+   *   .requireDateBetween(new Date('2024-01-01'), new Date('2024-12-31'))
+   *   .build();
+   * ```
    */
-  requireDateBetween(e, t) {
-    return this._rule.type = o.DATE, this._rule.formula1 = e.toLocaleDateString(), this._rule.formula2 = t.toLocaleDateString(), this._rule.operator = d.BETWEEN, this;
+  requireDateBetween(start, end) {
+    return this._rule.type = DataValidationType.DATE, this._rule.formula1 = start.toLocaleDateString(), this._rule.formula2 = end.toLocaleDateString(), this._rule.operator = DataValidationOperator.BETWEEN, this;
   }
   /**
    * Set the data validation type to DATE and configure the validation rules to be equal to a specific date
-   *
-   * @param date The date to compare against. The formatted date string will be set as formula1
-   * @return The current instance of the FDataValidationBuilder class to allow for method chaining
+   * @param {Date} date - The date to compare against
+   * @returns {FDataValidationBuilder} The current instance for method chaining
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const rule = builder.requireDateEqualTo(new Date('2024-01-01')).build();
+   * ```
    */
-  requireDateEqualTo(e) {
-    return this._rule.type = o.DATE, this._rule.formula1 = e.toLocaleDateString(), this._rule.formula2 = void 0, this._rule.operator = d.EQUAL, this;
+  requireDateEqualTo(date) {
+    return this._rule.type = DataValidationType.DATE, this._rule.formula1 = date.toLocaleDateString(), this._rule.formula2 = void 0, this._rule.operator = DataValidationOperator.EQUAL, this;
   }
   /**
    * Set the data validation type to DATE and configure the validation rules to be not within a specific date range
-   *
-   * @param start The starting date of the date range
-   * @param end The ending date of the date range
-   * @return The current instance of the FDataValidationBuilder class to allow for method chaining
+   * @param {Date} start - The starting date of the date range
+   * @param {Date} end - The ending date of the date range
+   * @returns {FDataValidationBuilder} The current instance for method chaining
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const rule = builder
+   *   .requireDateNotBetween(new Date('2024-01-01'), new Date('2024-12-31'))
+   *   .build();
+   * ```
    */
-  requireDateNotBetween(e, t) {
-    return this._rule.type = o.DATE, this._rule.formula1 = e.toLocaleDateString(), this._rule.formula2 = t.toLocaleDateString(), this._rule.operator = d.NOT_BETWEEN, this;
+  requireDateNotBetween(start, end) {
+    return this._rule.type = DataValidationType.DATE, this._rule.formula1 = start.toLocaleDateString(), this._rule.formula2 = end.toLocaleDateString(), this._rule.operator = DataValidationOperator.NOT_BETWEEN, this;
   }
   /**
    * Set the data validation type to DATE and configure the validation rules to be on or after a specific date
-   *
-   * @param date The date to compare against. The formatted date string will be set as formula1
-   * @return The current instance of the FDataValidationBuilder class to allow for method chaining
+   * @param {Date} date - The date to compare against
+   * @returns {FDataValidationBuilder} The current instance for method chaining
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const rule = builder.requireDateOnOrAfter(new Date('2024-01-01')).build();
+   * ```
    */
-  requireDateOnOrAfter(e) {
-    return this._rule.type = o.DATE, this._rule.formula1 = e.toLocaleDateString(), this._rule.formula2 = void 0, this._rule.operator = d.GREATER_THAN_OR_EQUAL, this;
+  requireDateOnOrAfter(date) {
+    return this._rule.type = DataValidationType.DATE, this._rule.formula1 = date.toLocaleDateString(), this._rule.formula2 = void 0, this._rule.operator = DataValidationOperator.GREATER_THAN_OR_EQUAL, this;
   }
   /**
    * Set the data validation type to DATE and configure the validation rules to be on or before a specific date
-   *
-   * @param date The date to compare against. The formatted date string will be set as formula1
-   * @return The current instance of the FDataValidationBuilder class to allow for method chaining
+   * @param {Date} date - The date to compare against
+   * @returns {FDataValidationBuilder} The current instance for method chaining
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const rule = builder.requireDateOnOrBefore(new Date('2024-12-31')).build();
+   * ```
    */
-  requireDateOnOrBefore(e) {
-    return this._rule.type = o.DATE, this._rule.formula1 = e.toLocaleDateString(), this._rule.formula2 = void 0, this._rule.operator = d.LESS_THAN_OR_EQUAL, this;
+  requireDateOnOrBefore(date) {
+    return this._rule.type = DataValidationType.DATE, this._rule.formula1 = date.toLocaleDateString(), this._rule.formula2 = void 0, this._rule.operator = DataValidationOperator.LESS_THAN_OR_EQUAL, this;
   }
   /**
-   * Requires that a custom formula be satisfied.
-   * Sets the data validation type to CUSTOM and configures the validation rule based on the provided formula string.
-   *
-   * @param formula The formula string that needs to be satisfied.
-   * @return The current instance of the FDataValidationBuilder class to allow for method chaining.
+   * Requires that a custom formula be satisfied
+   * @param {string} formula - The formula string that needs to be satisfied
+   * @returns {FDataValidationBuilder} The current instance for method chaining
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const rule = builder.requireFormulaSatisfied('=A1>0').build();
+   * ```
    */
-  requireFormulaSatisfied(e) {
-    return this._rule.type = o.CUSTOM, this._rule.formula1 = e, this._rule.formula2 = void 0, this;
+  requireFormulaSatisfied(formula) {
+    return this._rule.type = DataValidationType.CUSTOM, this._rule.formula1 = formula, this._rule.formula2 = void 0, this;
   }
   /**
-   * Requires the user to enter a number within a specific range, which can be integer or decimal.
-   * Sets the data validation type based on the isInteger parameter and configures the validation rules for the specified number range.
-   *
-   * @param start The starting value of the number range.
-   * @param end The ending value of the number range.
-   * @param isInteger Indicates whether the required number is an integer. Default is undefined, meaning it can be an integer or decimal.
-   * @return The current instance of the FDataValidationBuilder class to allow for method chaining.
+   * Requires the user to enter a number within a specific range, which can be integer or decimal
+   * @param {number} start - The starting value of the number range
+   * @param {number} end - The ending value of the number range
+   * @param {boolean} [isInteger] - Indicates whether the required number is an integer
+   * @returns {FDataValidationBuilder} The current instance for method chaining
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const rule = builder.requireNumberBetween(1, 10).build();
+   * ```
    */
-  requireNumberBetween(e, t, r) {
-    return this._rule.formula1 = `${e}`, this._rule.formula2 = `${t}`, this._rule.operator = d.BETWEEN, this._rule.type = r ? o.WHOLE : o.DECIMAL, this;
+  requireNumberBetween(start, end, isInteger) {
+    return this._rule.formula1 = `${start}`, this._rule.formula2 = `${end}`, this._rule.operator = DataValidationOperator.BETWEEN, this._rule.type = isInteger ? DataValidationType.WHOLE : DataValidationType.DECIMAL, this;
   }
   /**
-   * Requires the user to enter a number that is equal to a specific value, which can be an integer or a decimal.
-   * Sets the data validation type based on the isInteger parameter and configures the validation rules for the specified number.
-   *
-   * @param num The number to which the entered number should be equal.
-   * @param isInteger Indicates whether the required number is an integer. Default is undefined, meaning it can be an integer or a decimal.
-   * @return The current instance of the FDataValidationBuilder class to allow for method chaining.
+   * Requires the user to enter a number that is equal to a specific value, which can be an integer or a decimal
+   * @param {number} num - The number to which the entered number should be equal
+   * @param {boolean} [isInteger] - Indicates whether the required number is an integer
+   * @returns {FDataValidationBuilder} The current instance for method chaining
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const rule = builder.requireNumberEqualTo(10).build();
+   * ```
    */
-  requireNumberEqualTo(e, t) {
-    return this._rule.formula1 = `${e}`, this._rule.formula2 = void 0, this._rule.operator = d.EQUAL, this._rule.type = t ? o.WHOLE : o.DECIMAL, this;
+  requireNumberEqualTo(num, isInteger) {
+    return this._rule.formula1 = `${num}`, this._rule.formula2 = void 0, this._rule.operator = DataValidationOperator.EQUAL, this._rule.type = isInteger ? DataValidationType.WHOLE : DataValidationType.DECIMAL, this;
   }
   /**
-   * Requires the user to enter a number that is greater than a specific value, which can be an integer or a decimal.
-   * Sets the data validation type based on the isInteger parameter and configures the validation rules for the specified number.
-   *
-   * @param num The number to which the entered number should be greater.
-   * @param isInteger Indicates whether the required number is an integer. Default is undefined, meaning it can be an integer or a decimal.
-   * @return The current instance of the FDataValidationBuilder class to allow for method chaining.
+   * Requires the user to enter a number that is greater than a specific value, which can be an integer or a decimal
+   * @param {number} num - The number to which the entered number should be greater
+   * @param {boolean} [isInteger] - Indicates whether the required number is an integer
+   * @returns {FDataValidationBuilder} The current instance for method chaining
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const rule = builder.requireNumberGreaterThan(10).build();
+   * ```
    */
-  requireNumberGreaterThan(e, t) {
-    return this._rule.formula1 = `${e}`, this._rule.formula2 = void 0, this._rule.operator = d.GREATER_THAN, this._rule.type = t ? o.WHOLE : o.DECIMAL, this;
+  requireNumberGreaterThan(num, isInteger) {
+    return this._rule.formula1 = `${num}`, this._rule.formula2 = void 0, this._rule.operator = DataValidationOperator.GREATER_THAN, this._rule.type = isInteger ? DataValidationType.WHOLE : DataValidationType.DECIMAL, this;
   }
   /**
-   * Requires the user to enter a number that is greater than or equal to a specific value, which can be an integer or a decimal.
-   * Sets the data validation type based on the isInteger parameter and configures the validation rules for the specified number.
-   *
-   * @param num The number to which the entered number should be greater than or equal.
-   * @param isInteger Indicates whether the required number is an integer. Default is undefined, meaning it can be an integer or a decimal.
-   * @return The current instance of the FDataValidationBuilder class to allow for method chaining.
+   * Requires the user to enter a number that is greater than or equal to a specific value, which can be an integer or a decimal
+   * @param {number} num - The number to which the entered number should be greater than or equal
+   * @param {boolean} [isInteger] - Indicates whether the required number is an integer
+   * @returns {FDataValidationBuilder} The current instance for method chaining
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const rule = builder.requireNumberGreaterThanOrEqualTo(10).build();
+   * ```
    */
-  requireNumberGreaterThanOrEqualTo(e, t) {
-    return this._rule.formula1 = `${e}`, this._rule.formula2 = void 0, this._rule.operator = d.GREATER_THAN_OR_EQUAL, this._rule.type = t ? o.WHOLE : o.DECIMAL, this;
+  requireNumberGreaterThanOrEqualTo(num, isInteger) {
+    return this._rule.formula1 = `${num}`, this._rule.formula2 = void 0, this._rule.operator = DataValidationOperator.GREATER_THAN_OR_EQUAL, this._rule.type = isInteger ? DataValidationType.WHOLE : DataValidationType.DECIMAL, this;
   }
   /**
-   * Requires the user to enter a number that is less than a specific value, which can be an integer or a decimal.
-   * Sets the data validation type based on the isInteger parameter and configures the validation rules for the specified number.
-   *
-   * @param num The number to which the entered number should be less.
-   * @param isInteger Indicates whether the required number is an integer. Default is undefined, meaning it can be an integer or a decimal.
-   * @return The current instance of the FDataValidationBuilder class to allow for method chaining.
+   * Requires the user to enter a number that is less than a specific value, which can be an integer or a decimal
+   * @param {number} num - The number to which the entered number should be less
+   * @param {boolean} [isInteger] - Indicates whether the required number is an integer
+   * @returns {FDataValidationBuilder} The current instance for method chaining
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const rule = builder.requireNumberLessThan(10).build();
+   * ```
    */
-  requireNumberLessThan(e, t) {
-    return this._rule.formula1 = `${e}`, this._rule.formula2 = void 0, this._rule.operator = d.LESS_THAN, this._rule.type = t ? o.WHOLE : o.DECIMAL, this;
+  requireNumberLessThan(num, isInteger) {
+    return this._rule.formula1 = `${num}`, this._rule.formula2 = void 0, this._rule.operator = DataValidationOperator.LESS_THAN, this._rule.type = isInteger ? DataValidationType.WHOLE : DataValidationType.DECIMAL, this;
   }
   /**
    * Sets the data validation rule to require a number less than or equal to a specified value
    * The specified value can be an integer or a decimal
-   *
-   * @param num The number to which the entered number should be less than or equal
-   * @param isInteger Indicates whether the required number is an integer
-   * @return The current instance of the DataValidationBuilder class, allowing for method chaining
+   * @param {number} num - The number to which the entered number should be less than or equal
+   * @param {boolean} [isInteger] - Indicates whether the required number is an integer
+   * @returns {FDataValidationBuilder} The current instance for method chaining
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const rule = builder.requireNumberLessThanOrEqualTo(10).build();
+   * ```
    */
-  requireNumberLessThanOrEqualTo(e, t) {
-    return this._rule.formula1 = `${e}`, this._rule.formula2 = void 0, this._rule.operator = d.LESS_THAN_OR_EQUAL, this._rule.type = t ? o.WHOLE : o.DECIMAL, this;
+  requireNumberLessThanOrEqualTo(num, isInteger) {
+    return this._rule.formula1 = `${num}`, this._rule.formula2 = void 0, this._rule.operator = DataValidationOperator.LESS_THAN_OR_EQUAL, this._rule.type = isInteger ? DataValidationType.WHOLE : DataValidationType.DECIMAL, this;
   }
   /**
    * Sets a data validation rule that requires the user to enter a number outside a specified range
    * The specified range includes all integers and decimals
-   *
-   * @param start The starting point of the specified range
-   * @param end The end point of the specified range
-   * @param isInteger Optional parameter, indicating whether the number to be verified is an integer. Default value is false
-   * @return An instance of the FDataValidationBuilder class, allowing for method chaining
+   * @param {number} start - The starting point of the specified range
+   * @param {number} end - The end point of the specified range
+   * @param {boolean} [isInteger] - Optional parameter, indicating whether the number to be verified is an integer
+   * @returns {FDataValidationBuilder} The current instance for method chaining
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const rule = builder.requireNumberNotBetween(1, 10).build();
+   * ```
    */
-  requireNumberNotBetween(e, t, r) {
-    return this._rule.formula1 = `${e}`, this._rule.formula2 = `${t}`, this._rule.operator = d.NOT_BETWEEN, this._rule.type = r ? o.WHOLE : o.DECIMAL, this;
+  requireNumberNotBetween(start, end, isInteger) {
+    return this._rule.formula1 = `${start}`, this._rule.formula2 = `${end}`, this._rule.operator = DataValidationOperator.NOT_BETWEEN, this._rule.type = isInteger ? DataValidationType.WHOLE : DataValidationType.DECIMAL, this;
   }
   /**
    * Creates a data validation rule that requires the user to enter a number that is not equal to a specific value
    * The specific value can be an integer or a decimal
-   *
-   * @param num The number to which the entered number should not be equal
-   * @param isInteger Indicates whether the required number is an integer. Default is undefined, meaning it can be an integer or a decimal
-   * @return The current instance of the FDataValidationBuilder class to allow for method chaining
+   * @param {number} num - The number to which the entered number should not be equal
+   * @param {boolean} [isInteger] - Indicates whether the required number is an integer
+   * @returns {FDataValidationBuilder} The current instance for method chaining
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const rule = builder.requireNumberNotEqualTo(10).build();
+   * ```
    */
-  requireNumberNotEqualTo(e, t) {
-    return this._rule.formula1 = `${e}`, this._rule.formula2 = void 0, this._rule.operator = d.NOT_EQUAL, this._rule.type = t ? o.WHOLE : o.DECIMAL, this;
+  requireNumberNotEqualTo(num, isInteger) {
+    return this._rule.formula1 = `${num}`, this._rule.formula2 = void 0, this._rule.operator = DataValidationOperator.NOT_EQUAL, this._rule.type = isInteger ? DataValidationType.WHOLE : DataValidationType.DECIMAL, this;
   }
   /**
-   * Sets a data validation rule that requires the user to enter a value from a list of specific values.
-   * The list can be displayed in a dropdown, and the user can choose multiple values according to the settings.
-   *
-   * @param values An array containing the specific values that the user can enter.
-   * @param multiple Optional parameter indicating whether the user can select multiple values. Default is false, meaning only one value can be selected.
-   * @param showDropdown Optional parameter indicating whether to display the list in a dropdown. Default is true, meaning the list will be displayed as a dropdown.
-   * @return An instance of the FDataValidationBuilder class, allowing for method chaining.
+   * Sets a data validation rule that requires the user to enter a value from a list of specific values
+   * The list can be displayed in a dropdown, and the user can choose multiple values according to the settings
+   * @param {string[]} values - An array containing the specific values that the user can enter
+   * @param {boolean} [multiple] - Optional parameter indicating whether the user can select multiple values
+   * @param {boolean} [showDropdown] - Optional parameter indicating whether to display the list in a dropdown
+   * @returns {FDataValidationBuilder} The current instance for method chaining
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const rule = builder.requireValueInList(['Yes', 'No']).build();
+   * ```
    */
-  requireValueInList(e, t, r) {
-    return this._rule.type = t ? o.LIST_MULTIPLE : o.LIST, this._rule.formula1 = e.join(","), this._rule.formula2 = void 0, this._rule.showDropDown = r != null ? r : !0, this;
+  requireValueInList(values, multiple, showDropdown) {
+    return this._rule.type = multiple ? DataValidationType.LIST_MULTIPLE : DataValidationType.LIST, this._rule.formula1 = values.join(","), this._rule.formula2 = void 0, this._rule.showDropDown = showDropdown != null ? showDropdown : !0, this;
   }
   /**
-   * Sets a data validation rule that requires the user to enter a value within a specific range.
-   * The range is defined by an FRange object, which contains the unit ID, sheet name, and cell range.
-   *
-   * @param range An FRange object representing the range of values that the user can enter.
-   * @param multiple Optional parameter indicating whether the user can select multiple values. Default is false, meaning only one value can be selected.
-   * @param showDropdown Optional parameter indicating whether to display the list in a dropdown. Default is true, meaning the list will be displayed as a dropdown.
-   * @return The current instance of the FDataValidationBuilder class to allow for method chaining.
+   * Sets a data validation rule that requires the user to enter a value within a specific range
+   * The range is defined by an FRange object, which contains the unit ID, sheet name, and cell range
+   * @param {FRange} range - An FRange object representing the range of values that the user can enter
+   * @param {boolean} [multiple] - Optional parameter indicating whether the user can select multiple values
+   * @param {boolean} [showDropdown] - Optional parameter indicating whether to display the list in a dropdown
+   * @returns {FDataValidationBuilder} The current instance for method chaining
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const range = FRange.create('Sheet1', 'B1:B10');
+   * const rule = builder.requireValueInRange(range).build();
+   * ```
    */
-  requireValueInRange(e, t, r) {
-    return this._rule.type = t ? o.LIST_MULTIPLE : o.LIST, this._rule.formula1 = `=${P({
-      unitId: e.getUnitId(),
-      sheetName: e.getSheetName(),
-      range: e.getRange()
-    })}`, this._rule.formula2 = void 0, this._rule.showDropDown = r != null ? r : !0, this;
+  requireValueInRange(range, multiple, showDropdown) {
+    return this._rule.type = multiple ? DataValidationType.LIST_MULTIPLE : DataValidationType.LIST, this._rule.formula1 = `=${serializeRangeToRefString({
+      unitId: range.getUnitId(),
+      sheetName: range.getSheetName(),
+      range: range.getRange()
+    })}`, this._rule.formula2 = void 0, this._rule.showDropDown = showDropdown != null ? showDropdown : !0, this;
   }
   /**
-   * Sets whether to allow invalid data and configures the error style for data validation.
-   * If invalid data is not allowed, the error style will be set to STOP, indicating that data entry must stop upon encountering an error.
-   * If invalid data is allowed, the error style will be set to WARNING, indicating that a warning will be displayed when invalid data is entered, but data entry can continue.
-   *
-   * @param allowInvalidData A boolean value indicating whether to allow invalid data.
-   * @return The current instance of the FDataValidationBuilder class to allow for method chaining.
+   * Sets whether to allow invalid data and configures the error style
+   * If invalid data is not allowed, the error style will be set to STOP, indicating that data entry must stop upon encountering an error
+   * If invalid data is allowed, the error style will be set to WARNING, indicating that a warning will be displayed when invalid data is entered, but data entry can continue
+   * @param {boolean} allowInvalidData - Whether to allow invalid data
+   * @returns {FDataValidationBuilder} The current instance for method chaining
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const rule = builder.setAllowInvalid(true).build();
+   * ```
    */
-  setAllowInvalid(e) {
-    return this._rule.errorStyle = e ? w.WARNING : w.STOP, this;
+  setAllowInvalid(allowInvalidData) {
+    return this._rule.errorStyle = allowInvalidData ? DataValidationErrorStyle.WARNING : DataValidationErrorStyle.STOP, this;
   }
   /**
-   * Sets the help text and enables the display of error messages for data validation.
-   * This method allows you to set a custom help text that will be displayed when the user enters invalid data.
-   *
-   * @param helpText The text to display as help information.
-   * @return The current instance of the FDataValidationBuilder class to allow for method chaining.
+   * Sets whether to allow blank values
+   * @param {boolean} allowBlank - Whether to allow blank values
+   * @returns {FDataValidationBuilder} The current instance for method chaining
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const rule = builder.setAllowBlank(true).build();
+   * ```
    */
-  setHelpText(e) {
-    return this._rule.error = e, this._rule.showErrorMessage = !0, this;
+  setAllowBlank(allowBlank) {
+    return this._rule.allowBlank = allowBlank, this;
   }
   /**
-   * Sets the criteria values for data validation.
-   * This method is used to configure the validation rules based on specific criteria values.
-   *
-   * @param type The type of data validation.
-   * @param values An array containing the criteria values.
-   * The array should have three elements: [operator, formula1, formula2].
-   * 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.
+   * Sets the options for the data validation rule
+   * @param {Partial<IDataValidationRuleOptions>} options - The options to set for the data validation rule
+   * @returns {FDataValidationBuilder} The current instance for method chaining
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * const rule = builder.setOptions({
+   *   allowBlank: true,
+   *   showErrorMessage: true,
+   *   error: 'Please enter a valid value'
+   * }).build();
+   * ```
    */
-  withCriteriaValues(e, t) {
-    return this._rule.type = e, this._rule.operator = t[0], this._rule.formula1 = t[1], this._rule.formula2 = t[2], this;
+  setOptions(options) {
+    return Object.assign(this._rule, options), this;
   }
-  setAllowBlank(e) {
-    return this._rule.allowBlank = e, this;
-  }
-  /**
-   * Sets the options for the data validation rule.
-   * For details of options, please refer to https://univer.ai/typedoc/@univerjs/core/interfaces/IDataValidationRuleOptions
-   *
-   * @param options The options to set for the data validation rule.
-   * @returns The current instance of the FDataValidationBuilder class to allow for method chaining.
-   */
-  setOptions(e) {
-    return Object.assign(this._rule, e), this;
-  }
-}
-class m {
-  constructor(e, t, r) {
-    f(this, "rule");
-    f(this, "_worksheet");
-    f(this, "_injector");
-    this._injector = r, this.rule = e, this._worksheet = t;
+};
+__name(_FDataValidationBuilder, "FDataValidationBuilder");
+let FDataValidationBuilder = _FDataValidationBuilder;
+const _FDataValidation = class _FDataValidation {
+  constructor(rule, worksheet, _injector) {
+    __publicField(this, "rule");
+    __publicField(this, "_worksheet");
+    __publicField(this, "_injector");
+    this._injector = _injector, this.rule = rule, this._worksheet = worksheet;
   }
   /**
-   * Gets whether invalid data is allowed based on the error style value.
-   *
-   * @return true if invalid data is allowed, false otherwise.
+   * Gets whether invalid data is allowed based on the error style value
+   * @returns {boolean} true if invalid data is allowed, false otherwise
+   * @example
+   * ```typescript
+   * const dataValidation = univerAPI
+   *  .getActiveWorkbook()
+   *  .getActiveWorksheet()
+   *  .getActiveRange()
+   *  .getDataValidation();
+   * const allowsInvalid = dataValidation.getAllowInvalid();
+   * ```
    */
   getAllowInvalid() {
-    return this.rule.errorStyle !== w.STOP;
+    return this.rule.errorStyle !== DataValidationErrorStyle.STOP;
   }
   /**
    * Gets the data validation type of the rule
-   *
-   * @returns The data validation type
+   * @returns {DataValidationType | string} The data validation type
+   * @example
+   * ```typescript
+   * const dataValidation = univerAPI
+   *  .getActiveWorkbook()
+   *  .getActiveWorksheet()
+   *  .getActiveRange()
+   *  .getDataValidation();
+   * const type = dataValidation.getCriteriaType();
+   * ```
    */
   getCriteriaType() {
     return this.rule.type;
   }
   /**
    * Gets the values used for criteria evaluation
-   *
-   * @returns An array containing the operator, formula1, and formula2 values
+   * @returns {[string | undefined, string | undefined, string | undefined]} An array containing the operator, formula1, and formula2 values
+   * @example
+   * ```typescript
+   * const dataValidation = univerAPI
+   *  .getActiveWorkbook()
+   *  .getActiveWorksheet()
+   *  .getActiveRange()
+   *  .getDataValidation();
+   * const [operator, formula1, formula2] = dataValidation.getCriteriaValues();
+   * ```
    */
   getCriteriaValues() {
     return [this.rule.operator, this.rule.formula1, this.rule.formula2];
   }
   /**
    * Gets the help text information, which is used to provide users with guidance and support
-   *
-   * @returns Returns the help text information. If there is no error message, it returns an undefined value.
+   * @returns {string | undefined} Returns the help text information. If there is no error message, it returns an undefined value
+   * @example
+   * ```typescript
+   * const dataValidation = univerAPI
+   *  .getActiveWorkbook()
+   *  .getActiveWorksheet()
+   *  .getActiveRange()
+   *  .getDataValidation();
+   * const helpText = dataValidation.getHelpText();
+   * ```
    */
   getHelpText() {
     return this.rule.error;
   }
   /**
-   * Creates a new instance of FDataValidationBuilder using the current rule object.
-   * This method is useful for copying an existing data validation rule configuration.
-   *
-   * @return A new FDataValidationBuilder instance with the same rule configuration.
+   * Creates a new instance of FDataValidationBuilder using the current rule object
+   * @returns {FDataValidationBuilder} A new FDataValidationBuilder instance with the same rule configuration
+   * @example
+   * ```typescript
+   * const dataValidation = univerAPI
+   *  .getActiveWorkbook()
+   *  .getActiveWorksheet()
+   *  .getActiveRange()
+   *  .getDataValidation();
+   * const builder = dataValidation.copy();
+   * const newRule = builder.setAllowInvalid(true).build();
+   * ```
    */
   copy() {
-    return new D(this.rule);
+    return new FDataValidationBuilder(this.rule);
   }
   /**
-   * Gets whether the data validation rule is applied to the worksheet.
-   *
-   * @returns true if the rule is applied, false otherwise.
+   * Gets whether the data validation rule is applied to the worksheet
+   * @returns {boolean} true if the rule is applied, false otherwise
+   * @example
+   * ```typescript
+   * const dataValidation = univerAPI
+   *  .getActiveWorkbook()
+   *  .getActiveWorksheet()
+   *  .getActiveRange()
+   *  .getDataValidation();
+   * const isApplied = dataValidation.getApplied();
+   * ```
    */
   getApplied() {
     if (!this._worksheet)
       return !1;
-    const t = this._injector.get(b).getRuleById(this._worksheet.getUnitId(), this._worksheet.getSheetId(), this.rule.uid);
-    return !!(t && t.ranges.length);
+    const currentRule = this._injector.get(DataValidationModel).getRuleById(this._worksheet.getUnitId(), this._worksheet.getSheetId(), this.rule.uid);
+    return !!(currentRule && currentRule.ranges.length);
   }
   /**
-   * Gets the ranges to which the data validation rule is applied.
-   *
-   * @returns An array of IRange objects representing the ranges to which the data validation rule is applied.
+   * Gets the ranges to which the data validation rule is applied
+   * @returns {FRange[]} An array of FRange objects representing the ranges to which the data validation rule is applied
+   * @example
+   * ```typescript
+   * const dataValidation = univerAPI
+   *  .getActiveWorkbook()
+   *  .getActiveWorksheet()
+   *  .getActiveRange()
+   *  .getDataValidation();
+   * const ranges = dataValidation.getRanges();
+   * ```
    */
   getRanges() {
     if (!this.getApplied())
       return [];
-    const e = this._injector.get(H).getUnit(this._worksheet.getUnitId());
-    return this.rule.ranges.map((t) => this._injector.createInstance(y, e, this._worksheet, t));
+    const workbook = this._injector.get(IUniverInstanceService).getUnit(this._worksheet.getUnitId());
+    return this.rule.ranges.map((range) => this._injector.createInstance(FRange, workbook, this._worksheet, range));
   }
   /**
-   * Gets the title of the error message dialog box.
-   *
-   * @returns The title of the error message dialog box.
+   * Gets the unit ID of the worksheet
+   * @returns {string | undefined} The unit ID of the worksheet
+   * @example
+   * ```typescript
+   * const dataValidation = univerAPI
+   *  .getActiveWorkbook()
+   *  .getActiveWorksheet()
+   *  .getActiveRange()
+   *  .getDataValidation();
+   * const unitId = dataValidation.getUnitId();
+   * ```
    */
   getUnitId() {
-    var e;
-    return (e = this._worksheet) == null ? void 0 : e.getUnitId();
+    var _a;
+    return (_a = this._worksheet) == null ? void 0 : _a.getUnitId();
   }
   /**
-   * Gets the sheetId of the worksheet.
-   *
-   * @returns The sheetId of the worksheet.
+   * Gets the sheet ID of the worksheet
+   * @returns {string | undefined} The sheet ID of the worksheet
+   * @example
+   * ```typescript
+   * const dataValidation = univerAPI
+   *  .getActiveWorkbook()
+   *  .getActiveWorksheet()
+   *  .getActiveRange()
+   *  .getDataValidation();
+   * const sheetId = dataValidation.getSheetId();
+   * ```
    */
   getSheetId() {
-    var e;
-    return (e = this._worksheet) == null ? void 0 : e.getSheetId();
+    var _a;
+    return (_a = this._worksheet) == null ? void 0 : _a.getSheetId();
   }
   /**
-   * Set Criteria for the data validation rule.
-   * @param type The type of data validation criteria.
-   * @param values An array containing the operator, formula1, and formula2 values.
-   * @returns true if the criteria is set successfully, false otherwise.
+   * Set Criteria for the data validation rule
+   * @param {DataValidationType} type - The type of data validation criteria
+   * @param {[DataValidationOperator, string, string]} values - An array containing the operator, formula1, and formula2 values
+   * @param {boolean} [allowBlank] - Whether to allow blank values
+   * @returns {FDataValidation} The current instance for method chaining
+   * @example
+   * ```typescript
+   * const dataValidation = univerAPI
+   *  .getActiveWorkbook()
+   *  .getActiveWorksheet()
+   *  .getActiveRange()
+   *  .getDataValidation();
+   * dataValidation.setCriteria(
+   *   DataValidationType.DECIMAL,
+   *   [DataValidationOperator.BETWEEN, '1', '10'],
+   *   true
+   * );
+   * ```
    */
-  setCriteria(e, t, r = !0) {
-    if (this.getApplied() && !this._injector.get(p).syncExecuteCommand(U.id, {
+  setCriteria(type, values, allowBlank = !0) {
+    if (this.getApplied() && !this._injector.get(ICommandService).syncExecuteCommand(UpdateSheetDataValidationSettingCommand.id, {
       unitId: this.getUnitId(),
       subUnitId: this.getSheetId(),
       ruleId: this.rule.uid,
       setting: {
-        operator: t[0],
-        formula1: t[1],
-        formula2: t[2],
+        operator: values[0],
+        formula1: values[1],
+        formula2: values[2],
         type: this.rule.type,
-        allowBlank: r
+        allowBlank
       }
     }))
       throw new Error("setCriteria failed");
-    return this.rule.operator = t[0], this.rule.formula1 = t[1], this.rule.formula2 = t[2], this.rule.type = e, this.rule.allowBlank = r, this;
+    return this.rule.operator = values[0], this.rule.formula1 = values[1], this.rule.formula2 = values[2], this.rule.type = type, this.rule.allowBlank = allowBlank, this;
   }
   /**
-   * Set the options for the data validation rule.
-   * For details of options, please refer to https://univer.ai/typedoc/@univerjs/core/interfaces/IDataValidationRuleOptions
-   * @param options An object containing the options to set. `IDataValidationRuleOptions`
-   * @returns true if the options are set successfully, false otherwise.
+   * Set the options for the data validation rule
+   * @param {Partial<IDataValidationRuleOptions>} options - The options to set for the data validation rule
+   * @returns {FDataValidation} The current instance for method chaining
+   * @example
+   * ```typescript
+   * const dataValidation = univerAPI
+   *  .getActiveWorkbook()
+   *  .getActiveWorksheet()
+   *  .getActiveRange()
+   *  .getDataValidation();
+   * dataValidation.setOptions({
+   *   allowBlank: true,
+   *   showErrorMessage: true,
+   *   error: 'Please enter a valid value'
+   * });
+   * ```
    */
-  setOptions(e) {
-    if (this.getApplied() && !this._injector.get(p).syncExecuteCommand(v.id, {
+  setOptions(options) {
+    if (this.getApplied() && !this._injector.get(ICommandService).syncExecuteCommand(UpdateSheetDataValidationOptionsCommand.id, {
       unitId: this.getUnitId(),
       subUnitId: this.getSheetId(),
       ruleId: this.rule.uid,
       options: {
-        ...F(this.rule),
-        ...e
+        ...getRuleOptions(this.rule),
+        ...options
       }
     }))
       throw new Error("setOptions failed");
-    return Object.assign(this.rule, e), this;
+    return Object.assign(this.rule, options), this;
   }
   /**
-   * Set the ranges to the data validation rule.
-   * @param ranges new ranges array.
-   * @returns true if the ranges are set successfully, false otherwise.
+   * Set the ranges to the data validation rule
+   * @param {FRange[]} ranges - New ranges array
+   * @returns {FDataValidation} The current instance for method chaining
+   * @example
+   * ```typescript
+   * const dataValidation = univerAPI
+   *  .getActiveWorkbook()
+   *  .getActiveWorksheet()
+   *  .getActiveRange()
+   *  .getDataValidation();
+   * const range = FRange.create('Sheet1', 'A1:B10');
+   * dataValidation.setRanges([range]);
+   * ```
    */
-  setRanges(e) {
-    if (this.getApplied() && !this._injector.get(p).syncExecuteCommand(C.id, {
+  setRanges(ranges) {
+    if (this.getApplied() && !this._injector.get(ICommandService).syncExecuteCommand(UpdateSheetDataValidationRangeCommand.id, {
       unitId: this.getUnitId(),
       subUnitId: this.getSheetId(),
       ruleId: this.rule.uid,
-      ranges: e.map((a) => a.getRange())
+      ranges: ranges.map((range) => range.getRange())
     }))
       throw new Error("setRanges failed");
-    return this.rule.ranges = e.map((t) => t.getRange()), this;
+    return this.rule.ranges = ranges.map((range) => range.getRange()), this;
   }
   /**
-   * Delete the data validation rule from the worksheet.
-   * @returns true if the rule is deleted successfully, false otherwise.
+   * Delete the data validation rule from the worksheet
+   * @returns {boolean} true if the rule is deleted successfully, false otherwise
+   * @example
+   * ```typescript
+   * const dataValidation = univerAPI
+   *  .getActiveWorkbook()
+   *  .getActiveWorksheet()
+   *  .getActiveRange()
+   *  .getDataValidation();
+   * const isDeleted = dataValidation.delete();
+   * ```
    */
   delete() {
-    return this.getApplied() ? this._injector.get(p).syncExecuteCommand(T.id, {
+    return this.getApplied() ? this._injector.get(ICommandService).syncExecuteCommand(RemoveSheetDataValidationCommand.id, {
       unitId: this.getUnitId(),
       subUnitId: this.getSheetId(),
       ruleId: this.rule.uid
     }) : !1;
   }
-}
-class G extends y {
-  setDataValidation(e) {
-    if (!e)
-      return this._commandService.syncExecuteCommand(W.id, {
+};
+__name(_FDataValidation, "FDataValidation");
+let FDataValidation = _FDataValidation;
+const _FRangeDataValidationMixin = class _FRangeDataValidationMixin extends FRange {
+  setDataValidation(rule) {
+    if (!rule)
+      return this._commandService.syncExecuteCommand(ClearRangeDataValidationCommand.id, {
         unitId: this._workbook.getUnitId(),
         subUnitId: this._worksheet.getSheetId(),
         ranges: [this._range]
       }), this;
-    const t = {
+    const params = {
       unitId: this._workbook.getUnitId(),
       subUnitId: this._worksheet.getSheetId(),
       rule: {
-        ...e.rule,
+        ...rule.rule,
         ranges: [this._range]
       }
     };
-    return this._commandService.syncExecuteCommand(A.id, t), this;
+    return this._commandService.syncExecuteCommand(AddSheetDataValidationCommand.id, params), this;
   }
   getDataValidation() {
-    const t = this._injector.get(S).getDataValidation(
+    const rule = this._injector.get(SheetsDataValidationValidatorService).getDataValidation(
       this._workbook.getUnitId(),
       this._worksheet.getSheetId(),
       [this._range]
     );
-    return t && new m(t, this._worksheet, this._injector);
+    return rule && new FDataValidation(rule, this._worksheet, this._injector);
   }
   getDataValidations() {
-    return this._injector.get(S).getDataValidations(
+    return this._injector.get(SheetsDataValidationValidatorService).getDataValidations(
       this._workbook.getUnitId(),
       this._worksheet.getSheetId(),
       [this._range]
-    ).map((t) => new m(t, this._worksheet, this._injector));
+    ).map((rule) => new FDataValidation(rule, this._worksheet, this._injector));
   }
   async getValidatorStatus() {
-    return this._injector.get(S).validatorRanges(
+    return this._injector.get(SheetsDataValidationValidatorService).validatorRanges(
       this._workbook.getUnitId(),
       this._worksheet.getSheetId(),
       [this._range]
     );
   }
-}
-y.extend(G);
-class Q extends N {
+};
+__name(_FRangeDataValidationMixin, "FRangeDataValidationMixin");
+let FRangeDataValidationMixin = _FRangeDataValidationMixin;
+FRange.extend(FRangeDataValidationMixin);
+const _FUnvierDataValidationMixin = class _FUnvierDataValidationMixin extends FUniver {
+  // eslint-disable-next-line jsdoc/require-returns
   /**
   /**
-   * @deparecated use `univerAPI.newDataValidation()` as instead.
+   * @deprecated use `univerAPI.newDataValidation()` as instead.
    */
   static newDataValidation() {
-    return new D();
+    return new FDataValidationBuilder();
   }
+  /**
+   * Creates a new instance of FDataValidationBuilder
+   * @returns {FDataValidationBuilder} A new instance of the FDataValidationBuilder class
+   * @example
+   * ```ts
+   * const rule = FUnvier.newDataValidation();
+   * cell.setDataValidation(rule.requireValueInRange(range));
+   * ```
+   */
   newDataValidation() {
-    return new D();
+    return new FDataValidationBuilder();
   }
+  /**
+   * @ignore
+   */
   // eslint-disable-next-line max-lines-per-function
-  _initialize(e) {
-    if (!e.has(V)) return;
-    const t = e.get(V), r = e.get(p);
-    this.disposeWithMe(t.ruleChange$.subscribe((a) => {
-      const { unitId: i, subUnitId: n, rule: h, oldRule: u, type: s } = a, l = this.getSheetTarget(i, n);
-      if (!l)
+  _initialize(injector) {
+    if (!injector.has(SheetDataValidationModel)) return;
+    const sheetDataValidationModel = injector.get(SheetDataValidationModel), commadnService = injector.get(ICommandService);
+    this.disposeWithMe(sheetDataValidationModel.ruleChange$.subscribe((ruleChange) => {
+      const { unitId, subUnitId, rule, oldRule, type } = ruleChange, target = this.getSheetTarget(unitId, subUnitId);
+      if (!target)
         return;
-      const { workbook: I, worksheet: k } = l, E = new m(h, k.getSheet(), this._injector);
+      const { workbook, worksheet } = target, fRule = new FDataValidation(rule, worksheet.getSheet(), this._injector);
       this.fireEvent(this.Event.SheetDataValidationChanged, {
-        origin: a,
-        worksheet: k,
-        workbook: I,
-        changeType: s,
-        oldRule: u,
-        rule: E
+        origin: ruleChange,
+        worksheet,
+        workbook,
+        changeType: type,
+        oldRule,
+        rule: fRule
       });
-    })), this.disposeWithMe(t.validStatusChange$.subscribe((a) => {
-      const { unitId: i, subUnitId: n, ruleId: h, status: u, row: s, col: l } = a, I = this.getSheetTarget(i, n);
-      if (!I)
+    })), this.disposeWithMe(sheetDataValidationModel.validStatusChange$.subscribe((statusChange) => {
+      const { unitId, subUnitId, ruleId, status, row, col } = statusChange, target = this.getSheetTarget(unitId, subUnitId);
+      if (!target)
         return;
-      const { workbook: k, worksheet: E } = I, L = E.getDataValidation(h);
-      L && this.fireEvent(this.Event.SheetDataValidatorStatusChanged, {
-        workbook: k,
-        worksheet: E,
-        row: s,
-        column: l,
-        rule: L,
-        status: u
+      const { workbook, worksheet } = target, rule = worksheet.getDataValidation(ruleId);
+      rule && this.fireEvent(this.Event.SheetDataValidatorStatusChanged, {
+        workbook,
+        worksheet,
+        row,
+        column: col,
+        rule,
+        status
       });
-    })), this.disposeWithMe(r.beforeCommandExecuted((a) => {
-      switch (a.id) {
-        case A.id: {
-          const i = a.params, n = this.getSheetTarget(i.unitId, i.subUnitId);
-          if (!n)
+    })), this.disposeWithMe(commadnService.beforeCommandExecuted((commandInfo) => {
+      switch (commandInfo.id) {
+        case AddSheetDataValidationCommand.id: {
+          const params = commandInfo.params, target = this.getSheetTarget(params.unitId, params.subUnitId);
+          if (!target)
             return;
-          const { workbook: h, worksheet: u } = n, s = {
-            worksheet: u,
-            workbook: h,
-            rule: i.rule
+          const { workbook, worksheet } = target, eventParams = {
+            worksheet,
+            workbook,
+            rule: params.rule
           };
-          if (this.fireEvent(this.Event.BeforeSheetDataValidationAdd, s), s.cancel)
-            throw new _();
+          if (this.fireEvent(this.Event.BeforeSheetDataValidationAdd, eventParams), eventParams.cancel)
+            throw new CanceledError();
           break;
         }
-        case U.id: {
-          const i = a.params, n = this.getSheetTarget(i.unitId, i.subUnitId);
-          if (!n)
+        case UpdateSheetDataValidationSettingCommand.id: {
+          const params = commandInfo.params, target = this.getSheetTarget(params.unitId, params.subUnitId);
+          if (!target)
             return;
-          const { workbook: h, worksheet: u } = n, s = u.getDataValidation(i.ruleId);
-          if (!s)
+          const { workbook, worksheet } = target, rule = worksheet.getDataValidation(params.ruleId);
+          if (!rule)
             return;
-          const l = {
-            worksheet: u,
-            workbook: h,
-            rule: s,
-            ruleId: i.ruleId,
-            newCriteria: i.setting
+          const eventParams = {
+            worksheet,
+            workbook,
+            rule,
+            ruleId: params.ruleId,
+            newCriteria: params.setting
           };
-          if (this.fireEvent(this.Event.BeforeSheetDataValidationCriteriaUpdate, l), l.cancel)
-            throw new _();
+          if (this.fireEvent(this.Event.BeforeSheetDataValidationCriteriaUpdate, eventParams), eventParams.cancel)
+            throw new CanceledError();
           break;
         }
-        case C.id: {
-          const i = a.params, n = this.getSheetTarget(i.unitId, i.subUnitId);
-          if (!n)
+        case UpdateSheetDataValidationRangeCommand.id: {
+          const params = commandInfo.params, target = this.getSheetTarget(params.unitId, params.subUnitId);
+          if (!target)
             return;
-          const { workbook: h, worksheet: u } = n, s = u.getDataValidation(i.ruleId);
-          if (!s)
+          const { workbook, worksheet } = target, rule = worksheet.getDataValidation(params.ruleId);
+          if (!rule)
             return;
-          const l = {
-            worksheet: u,
-            workbook: h,
-            rule: s,
-            ruleId: i.ruleId,
-            newRanges: i.ranges
+          const eventParams = {
+            worksheet,
+            workbook,
+            rule,
+            ruleId: params.ruleId,
+            newRanges: params.ranges
           };
-          if (this.fireEvent(this.Event.BeforeSheetDataValidationRangeUpdate, l), l.cancel)
-            throw new _();
+          if (this.fireEvent(this.Event.BeforeSheetDataValidationRangeUpdate, eventParams), eventParams.cancel)
+            throw new CanceledError();
           break;
         }
-        case v.id: {
-          const i = a.params, n = this.getSheetTarget(i.unitId, i.subUnitId);
-          if (!n)
+        case UpdateSheetDataValidationOptionsCommand.id: {
+          const params = commandInfo.params, target = this.getSheetTarget(params.unitId, params.subUnitId);
+          if (!target)
             return;
-          const { workbook: h, worksheet: u } = n, s = u.getDataValidation(i.ruleId);
-          if (!s)
+          const { workbook, worksheet } = target, rule = worksheet.getDataValidation(params.ruleId);
+          if (!rule)
             return;
-          const l = {
-            worksheet: u,
-            workbook: h,
-            rule: s,
-            ruleId: i.ruleId,
-            newOptions: i.options
+          const eventParams = {
+            worksheet,
+            workbook,
+            rule,
+            ruleId: params.ruleId,
+            newOptions: params.options
           };
-          if (this.fireEvent(this.Event.BeforeSheetDataValidationOptionsUpdate, l), l.cancel)
-            throw new _();
+          if (this.fireEvent(this.Event.BeforeSheetDataValidationOptionsUpdate, eventParams), eventParams.cancel)
+            throw new CanceledError();
           break;
         }
-        case T.id: {
-          const i = a.params, n = this.getSheetTarget(i.unitId, i.subUnitId);
-          if (!n)
+        case RemoveSheetDataValidationCommand.id: {
+          const params = commandInfo.params, target = this.getSheetTarget(params.unitId, params.subUnitId);
+          if (!target)
             return;
-          const { workbook: h, worksheet: u } = n, s = u.getDataValidation(i.ruleId);
-          if (!s)
+          const { workbook, worksheet } = target, rule = worksheet.getDataValidation(params.ruleId);
+          if (!rule)
             return;
-          const l = {
-            worksheet: u,
-            workbook: h,
-            rule: s,
-            ruleId: i.ruleId
+          const eventParams = {
+            worksheet,
+            workbook,
+            rule,
+            ruleId: params.ruleId
           };
-          if (this.fireEvent(this.Event.BeforeSheetDataValidationDelete, l), l.cancel)
-            throw new _();
+          if (this.fireEvent(this.Event.BeforeSheetDataValidationDelete, eventParams), eventParams.cancel)
+            throw new CanceledError();
           break;
         }
-        case O.id: {
-          const i = a.params, n = this.getSheetTarget(i.unitId, i.subUnitId);
-          if (!n)
+        case RemoveSheetAllDataValidationCommand.id: {
+          const params = commandInfo.params, target = this.getSheetTarget(params.unitId, params.subUnitId);
+          if (!target)
             return;
-          const { workbook: h, worksheet: u } = n, s = {
-            worksheet: u,
-            workbook: h,
-            rules: u.getDataValidations()
+          const { workbook, worksheet } = target, eventParams = {
+            worksheet,
+            workbook,
+            rules: worksheet.getDataValidations()
           };
-          if (this.fireEvent(this.Event.BeforeSheetDataValidationDeleteAll, s), s.cancel)
-            throw new _();
+          if (this.fireEvent(this.Event.BeforeSheetDataValidationDeleteAll, eventParams), eventParams.cancel)
+            throw new CanceledError();
           break;
         }
       }
     }));
   }
-}
-N.extend(Q);
-class z extends M {
+};
+__name(_FUnvierDataValidationMixin, "FUnvierDataValidationMixin");
+let FUnvierDataValidationMixin = _FUnvierDataValidationMixin;
+FUniver.extend(FUnvierDataValidationMixin);
+const _FWorkbookDataValidationMixin = class _FWorkbookDataValidationMixin extends FWorkbook {
   _initialize() {
     Object.defineProperty(this, "_dataValidationModel", {
       get() {
-        return this._injector.get(V);
+        return this._injector.get(SheetDataValidationModel);
       }
     });
   }
   getValidatorStatus() {
-    return this._injector.get(S).validatorWorkbook(this._workbook.getUnitId());
+    return this._injector.get(SheetsDataValidationValidatorService).validatorWorkbook(this._workbook.getUnitId());
   }
   // region DataValidationHooks
-  onDataValidationChange(e) {
-    return g(this._dataValidationModel.ruleChange$.pipe(R((t) => t.unitId === this._workbook.getUnitId())).subscribe(e));
+  onDataValidationChange(callback) {
+    return toDisposable(this._dataValidationModel.ruleChange$.pipe(filter((change) => change.unitId === this._workbook.getUnitId())).subscribe(callback));
   }
-  onDataValidationStatusChange(e) {
-    return g(this._dataValidationModel.validStatusChange$.pipe(R((t) => t.unitId === this._workbook.getUnitId())).subscribe(e));
+  onDataValidationStatusChange(callback) {
+    return toDisposable(this._dataValidationModel.validStatusChange$.pipe(filter((change) => change.unitId === this._workbook.getUnitId())).subscribe(callback));
   }
-  onBeforeAddDataValidation(e) {
-    return g(this._commandService.beforeCommandExecuted((t, r) => {
-      const a = t.params;
-      if (t.id === A.id) {
-        if (a.unitId !== this._workbook.getUnitId())
+  onBeforeAddDataValidation(callback) {
+    return toDisposable(this._commandService.beforeCommandExecuted((commandInfo, options) => {
+      const params = commandInfo.params;
+      if (commandInfo.id === AddSheetDataValidationCommand.id) {
+        if (params.unitId !== this._workbook.getUnitId())
           return;
-        if (e(a, r) === !1)
+        if (callback(params, options) === !1)
           throw new Error("Command is stopped by the hook onBeforeAddDataValidation");
       }
     }));
   }
-  onBeforeUpdateDataValidationCriteria(e) {
-    return g(this._commandService.beforeCommandExecuted((t, r) => {
-      const a = t.params;
-      if (t.id === U.id) {
-        if (a.unitId !== this._workbook.getUnitId())
+  onBeforeUpdateDataValidationCriteria(callback) {
+    return toDisposable(this._commandService.beforeCommandExecuted((commandInfo, options) => {
+      const params = commandInfo.params;
+      if (commandInfo.id === UpdateSheetDataValidationSettingCommand.id) {
+        if (params.unitId !== this._workbook.getUnitId())
           return;
-        if (e(a, r) === !1)
+        if (callback(params, options) === !1)
           throw new Error("Command is stopped by the hook onBeforeUpdateDataValidationCriteria");
       }
     }));
   }
-  onBeforeUpdateDataValidationRange(e) {
-    return g(this._commandService.beforeCommandExecuted((t, r) => {
-      const a = t.params;
-      if (t.id === C.id) {
-        if (a.unitId !== this._workbook.getUnitId())
+  onBeforeUpdateDataValidationRange(callback) {
+    return toDisposable(this._commandService.beforeCommandExecuted((commandInfo, options) => {
+      const params = commandInfo.params;
+      if (commandInfo.id === UpdateSheetDataValidationRangeCommand.id) {
+        if (params.unitId !== this._workbook.getUnitId())
           return;
-        if (e(a, r) === !1)
+        if (callback(params, options) === !1)
           throw new Error("Command is stopped by the hook onBeforeUpdateDataValidationRange");
       }
     }));
   }
-  onBeforeUpdateDataValidationOptions(e) {
-    return g(this._commandService.beforeCommandExecuted((t, r) => {
-      const a = t.params;
-      if (t.id === v.id) {
-        if (a.unitId !== this._workbook.getUnitId())
+  onBeforeUpdateDataValidationOptions(callback) {
+    return toDisposable(this._commandService.beforeCommandExecuted((commandInfo, options) => {
+      const params = commandInfo.params;
+      if (commandInfo.id === UpdateSheetDataValidationOptionsCommand.id) {
+        if (params.unitId !== this._workbook.getUnitId())
           return;
-        if (e(a, r) === !1)
+        if (callback(params, options) === !1)
           throw new Error("Command is stopped by the hook onBeforeUpdateDataValidationOptions");
       }
     }));
   }
-  onBeforeDeleteDataValidation(e) {
-    return g(this._commandService.beforeCommandExecuted((t, r) => {
-      const a = t.params;
-      if (t.id === T.id) {
-        if (a.unitId !== this._workbook.getUnitId())
+  onBeforeDeleteDataValidation(callback) {
+    return toDisposable(this._commandService.beforeCommandExecuted((commandInfo, options) => {
+      const params = commandInfo.params;
+      if (commandInfo.id === RemoveSheetDataValidationCommand.id) {
+        if (params.unitId !== this._workbook.getUnitId())
           return;
-        if (e(a, r) === !1)
+        if (callback(params, options) === !1)
           throw new Error("Command is stopped by the hook onBeforeDeleteDataValidation");
       }
     }));
   }
-  onBeforeDeleteAllDataValidation(e) {
-    return g(this._commandService.beforeCommandExecuted((t, r) => {
-      const a = t.params;
-      if (t.id === O.id) {
-        if (a.unitId !== this._workbook.getUnitId())
+  onBeforeDeleteAllDataValidation(callback) {
+    return toDisposable(this._commandService.beforeCommandExecuted((commandInfo, options) => {
+      const params = commandInfo.params;
+      if (commandInfo.id === RemoveSheetAllDataValidationCommand.id) {
+        if (params.unitId !== this._workbook.getUnitId())
           return;
-        if (e(a, r) === !1)
+        if (callback(params, options) === !1)
           throw new Error("Command is stopped by the hook onBeforeDeleteAllDataValidation");
       }
     }));
   }
-}
-M.extend(z);
-class K extends x {
+};
+__name(_FWorkbookDataValidationMixin, "FWorkbookDataValidationMixin");
+let FWorkbookDataValidationMixin = _FWorkbookDataValidationMixin;
+FWorkbook.extend(FWorkbookDataValidationMixin);
+const _FWorksheetDataValidationMixin = class _FWorksheetDataValidationMixin extends FWorksheet {
   getDataValidations() {
-    return this._injector.get(b).getRules(this._workbook.getUnitId(), this._worksheet.getSheetId()).map((t) => new m(t, this._worksheet, this._injector));
+    return this._injector.get(DataValidationModel).getRules(this._workbook.getUnitId(), this._worksheet.getSheetId()).map((rule) => new FDataValidation(rule, this._worksheet, this._injector));
   }
   getValidatorStatus() {
-    return this._injector.get(S).validatorWorksheet(
+    return this._injector.get(SheetsDataValidationValidatorService).validatorWorksheet(
       this._workbook.getUnitId(),
       this._worksheet.getSheetId()
     );
   }
-  getDataValidation(e) {
-    const r = this._injector.get(b).getRuleById(this._workbook.getUnitId(), this._worksheet.getSheetId(), e);
-    return r ? new m(r, this._worksheet, this._injector) : null;
+  getValidatorStatusAsync() {
+    return this.getValidatorStatus();
+  }
+  getDataValidation(ruleId) {
+    const rule = this._injector.get(DataValidationModel).getRuleById(this._workbook.getUnitId(), this._worksheet.getSheetId(), ruleId);
+    return rule ? new FDataValidation(rule, this._worksheet, this._injector) : null;
   }
-}
-x.extend(K);
-class X {
+};
+__name(_FWorksheetDataValidationMixin, "FWorksheetDataValidationMixin");
+let FWorksheetDataValidationMixin = _FWorksheetDataValidationMixin;
+FWorksheet.extend(FWorksheetDataValidationMixin);
+const _FDataValidationEvent = class _FDataValidationEvent {
   get SheetDataValidationChanged() {
     return "SheetDataValidationChanged";
   }
@@ -788,9 +1031,11 @@ class X {
   get BeforeSheetDataValidationOptionsUpdate() {
     return "BeforeSheetDataValidationOptionsUpdate";
   }
-}
-$.extend(X);
+};
+__name(_FDataValidationEvent, "FDataValidationEvent");
+let FDataValidationEvent = _FDataValidationEvent;
+FEventName.extend(FDataValidationEvent);
 export {
-  m as FDataValidation,
-  D as FDataValidationBuilder
+  FDataValidation,
+  FDataValidationBuilder
 };