@univerjs/sheets-data-validation 0.6.7 → 0.6.9-nightly.202504021607

package/lib/facade.js

@@ -0,0 +1,1453 @@
+var H = Object.defineProperty;
+var q = (h, e, t) => e in h ? H(h, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : h[e] = t;
+var _ = (h, e, t) => q(h, typeof e != "symbol" ? e + "" : e, t);
+import { UpdateSheetDataValidationSettingCommand as b, UpdateSheetDataValidationOptionsCommand as U, UpdateSheetDataValidationRangeCommand as C, RemoveSheetDataValidationCommand as A, ClearRangeDataValidationCommand as j, AddSheetDataValidationCommand as T, SheetsDataValidationValidatorService as S, SheetDataValidationModel as f, RemoveSheetAllDataValidationCommand as O } from "@univerjs/sheets-data-validation";
+import { FRange as y, FWorkbook as x, FWorksheet as M } from "@univerjs/sheets/facade";
+import { DataValidationType as a, generateRandomId as L, DataValidationErrorStyle as k, DataValidationOperator as u, IUniverInstanceService as W, ICommandService as p, CanceledError as c, toDisposable as g } from "@univerjs/core";
+import { DataValidationModel as w, getRuleOptions as $ } from "@univerjs/data-validation";
+import { serializeRangeToRefString as F } from "@univerjs/engine-formula";
+import { FUniver as N, FEventName as P } from "@univerjs/core/facade";
+import { filter as R } from "rxjs";
+class E {
+  constructor(e) {
+    _(this, "_rule");
+    this._rule = e != null ? e : {
+      uid: L(),
+      ranges: void 0,
+      type: a.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 fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Create a new data validation rule that requires a number between 1 and 10 for the range A1:B10
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberBetween(1, 10)
+   *   .setOptions({
+   *     allowBlank: true,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a number between 1 and 10'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
+   * ```
+   */
+  build() {
+    return new m(this._rule);
+  }
+  /**
+   * Creates a duplicate of the current DataValidationBuilder object
+   * @returns {FDataValidationBuilder} A new instance of the DataValidationBuilder class
+   * @example
+   * ```typescript
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Create a new data validation rule that requires a number between 1 and 10 for the range A1:B10
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const builder = univerAPI.newDataValidation()
+   *   .requireNumberBetween(1, 10)
+   *   .setOptions({
+   *     allowBlank: true,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a number between 1 and 10'
+   *   });
+   * fRange.setDataValidation(builder.build());
+   *
+   * // Copy the builder applied to the new range F1:G10
+   * const newRange = fWorksheet.getRange('F1:G10');
+   * const copyBuilder = builder.copy();
+   * newRange.setDataValidation(copyBuilder.build());
+   * ```
+   */
+  copy() {
+    return new E({
+      ...this._rule,
+      uid: L()
+    });
+  }
+  /**
+   * Determines whether invalid data is allowed
+   * @returns {boolean} True if invalid data is allowed, False otherwise
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation().requireNumberBetween(1, 10);
+   * console.log(builder.getAllowInvalid());
+   * ```
+   */
+  getAllowInvalid() {
+    return this._rule.errorStyle !== k.STOP;
+  }
+  /**
+   * Gets the data validation type of the rule
+   * @returns {DataValidationType | string} The data validation type
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation();
+   * console.log(builder.getCriteriaType()); // custom
+   *
+   * builder.requireNumberBetween(1, 10);
+   * console.log(builder.getCriteriaType()); // decimal
+   *
+   * builder.requireValueInList(['Yes', 'No']);
+   * console.log(builder.getCriteriaType()); // list
+   * ```
+   */
+  getCriteriaType() {
+    return this._rule.type;
+  }
+  /**
+   * Gets the values used for criteria evaluation
+   * @returns {[string | undefined, string | undefined, string | undefined]} An array containing the operator, formula1, and formula2 values
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation().requireNumberBetween(1, 10);
+   * const [operator, formula1, formula2] = builder.getCriteriaValues();
+   * console.log(operator, formula1, formula2); // between 1 10
+   *
+   * builder.requireValueInList(['Yes', 'No']);
+   * console.log(builder.getCriteriaValues()); // undefined Yes,No undefined
+   * ```
+   */
+  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
+   * @example
+   * ```typescript
+   * const builder = univerAPI.newDataValidation().setOptions({
+   *   showErrorMessage: true,
+   *   error: 'Please enter a valid value'
+   * });
+   * console.log(builder.getHelpText()); // 'Please enter a valid value'
+   * ```
+   */
+  getHelpText() {
+    return this._rule.error;
+  }
+  /**
+   * Sets the data validation rule to require that the input is a boolean value; this value is rendered as a checkbox.
+   * @param {string} [checkedValue] - The value assigned to a checked box.
+   * @param {string} [uncheckedValue] - The value assigned to an unchecked box.
+   * @returns {FDataValidationBuilder} The current instance for method chaining.
+   * @example
+   * ```typescript
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Set the data validation for cell A1:A10 to require a checkbox with default 1 and 0 values
+   * const fRange = fWorksheet.getRange('A1:A10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireCheckbox()
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * // Set the data validation for cell B1:B10 to require a checkbox with 'Yes' and 'No' values
+   * const fRange2 = fWorksheet.getRange('B1:B10');
+   * const rule2 = univerAPI.newDataValidation()
+   *   .requireCheckbox('Yes', 'No')
+   *   .build();
+   * fRange2.setDataValidation(rule2);
+   * ```
+   */
+  requireCheckbox(e, t) {
+    return this._rule.type = a.CHECKBOX, this._rule.formula1 = e, this._rule.formula2 = t, this;
+  }
+  /**
+   * Set the data validation type to DATE and configure the validation rules to be after a specific date.
+   * @param {Date} date - The latest unacceptable date.
+   * @returns {FDataValidationBuilder} The current instance for method chaining.
+   * @example
+   * ```typescript
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Set some date values in the range A1:B2
+   * const fRange = fWorksheet.getRange('A1:B2');
+   * fRange.setValues([
+   *   ['2024-01-01', '2024-12-31'],
+   *   ['2025-01-01', '2025-12-31']
+   * ]);
+   *
+   * // Create a data validation rule that requires a date after 2025-01-01
+   * const rule = univerAPI.newDataValidation()
+   *   .requireDateAfter(new Date('2025-01-01'))
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * // Get the validation status of the range
+   * const status = await fRange.getValidatorStatus();
+   * console.log(status); // [['invalid', 'invalid', 'invalid', 'valid']]
+   * ```
+   */
+  requireDateAfter(e) {
+    return this._rule.type = a.DATE, this._rule.formula1 = e.toLocaleDateString(), this._rule.operator = u.GREATER_THAN, this;
+  }
+  /**
+   * Set the data validation type to DATE and configure the validation rules to be before a specific date.
+   * @param {Date} date - The earliest unacceptable date.
+   * @returns {FDataValidationBuilder} The current instance for method chaining.
+   * @example
+   * ```typescript
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Set some date values in the range A1:B2
+   * const fRange = fWorksheet.getRange('A1:B2');
+   * fRange.setValues([
+   *   ['2024-01-01', '2024-12-31'],
+   *   ['2025-01-01', '2025-12-31']
+   * ]);
+   *
+   * // Create a data validation rule that requires a date before 2025-01-01
+   * const rule = univerAPI.newDataValidation()
+   *   .requireDateBefore(new Date('2025-01-01'))
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * // Get the validation status of the range
+   * const status = await fRange.getValidatorStatus();
+   * console.log(status); // [['valid', 'valid', 'invalid', 'invalid']]
+   * ```
+   */
+  requireDateBefore(e) {
+    return this._rule.type = a.DATE, this._rule.formula1 = e.toLocaleDateString(), this._rule.formula2 = void 0, this._rule.operator = u.LESS_THAN, this;
+  }
+  /**
+   * Set the data validation type to DATE and configure the validation rules to be within a specific date range.
+   * @param {Date} start - The earliest acceptable date.
+   * @param {Date} end - The latest acceptable date.
+   * @returns {FDataValidationBuilder} The current instance for method chaining.
+   * @example
+   * ```typescript
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Set some date values in the range A1:B2
+   * const fRange = fWorksheet.getRange('A1:B2');
+   * fRange.setValues([
+   *   ['2024-01-01', '2024-12-31'],
+   *   ['2025-01-01', '2025-12-31']
+   * ]);
+   *
+   * // Create a data validation rule that requires a date between 2024-06-01 and 2025-06-01
+   * const rule = univerAPI.newDataValidation()
+   *   .requireDateBetween(new Date('2024-06-01'), new Date('2025-06-01'))
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * // Get the validation status of the range
+   * const status = await fRange.getValidatorStatus();
+   * console.log(status); // [['invalid', 'valid', 'valid', 'invalid']]
+   * ```
+   */
+  requireDateBetween(e, t) {
+    return this._rule.type = a.DATE, this._rule.formula1 = e.toLocaleDateString(), this._rule.formula2 = t.toLocaleDateString(), this._rule.operator = u.BETWEEN, this;
+  }
+  /**
+   * Set the data validation type to DATE and configure the validation rules to be equal to a specific date.
+   * @param {Date} date - The sole acceptable date.
+   * @returns {FDataValidationBuilder} The current instance for method chaining.
+   * @example
+   * ```typescript
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Set some date values in the range A1:B2
+   * const fRange = fWorksheet.getRange('A1:B2');
+   * fRange.setValues([
+   *   ['2024-01-01', '2024-12-31'],
+   *   ['2025-01-01', '2025-12-31']
+   * ]);
+   *
+   * // Create a data validation rule that requires a date equal to 2025-01-01
+   * const rule = univerAPI.newDataValidation()
+   *   .requireDateEqualTo(new Date('2025-01-01'))
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * // Get the validation status of the cell A2
+   * const status = await fWorksheet.getRange('A2').getValidatorStatus();
+   * console.log(status?.[0]?.[0]); // 'valid'
+   *
+   * // Get the validation status of the cell B2
+   * const status2 = await fWorksheet.getRange('B2').getValidatorStatus();
+   * console.log(status2?.[0]?.[0]); // 'invalid'
+   * ```
+   */
+  requireDateEqualTo(e) {
+    return this._rule.type = a.DATE, this._rule.formula1 = e.toLocaleDateString(), this._rule.formula2 = void 0, this._rule.operator = u.EQUAL, this;
+  }
+  /**
+   * Set the data validation type to DATE and configure the validation rules to be not within a specific date range.
+   * @param {Date} start - The earliest unacceptable date.
+   * @param {Date} end - The latest unacceptable date.
+   * @returns {FDataValidationBuilder} The current instance for method chaining.
+   * @example
+   * ```typescript
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Set some date values in the range A1:B2
+   * const fRange = fWorksheet.getRange('A1:B2');
+   * fRange.setValues([
+   *   ['2024-01-01', '2024-12-31'],
+   *   ['2025-01-01', '2025-12-31']
+   * ]);
+   *
+   * // Create a data validation rule that requires a date not between 2024-06-01 and 2025-06-01
+   * const rule = univerAPI.newDataValidation()
+   *   .requireDateNotBetween(new Date('2024-06-01'), new Date('2025-06-01'))
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * // Get the validation status of the range
+   * const status = await fRange.getValidatorStatus();
+   * console.log(status); // [['valid', 'invalid', 'invalid', 'valid']]
+   * ```
+   */
+  requireDateNotBetween(e, t) {
+    return this._rule.type = a.DATE, this._rule.formula1 = e.toLocaleDateString(), this._rule.formula2 = t.toLocaleDateString(), this._rule.operator = u.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} date - The earliest acceptable date.
+   * @returns {FDataValidationBuilder} The current instance for method chaining.
+   * @example
+   * ```typescript
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Set some date values in the range A1:B2
+   * const fRange = fWorksheet.getRange('A1:B2');
+   * fRange.setValues([
+   *   ['2024-01-01', '2024-12-31'],
+   *   ['2025-01-01', '2025-12-31']
+   * ]);
+   *
+   * // Create a data validation rule that requires a date on or after 2025-01-01
+   * const rule = univerAPI.newDataValidation()
+   *   .requireDateOnOrAfter(new Date('2025-01-01'))
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * // Get the validation status of the range
+   * const status = await fRange.getValidatorStatus();
+   * console.log(status); // [['invalid', 'invalid', 'valid', 'valid']]
+   * ```
+   */
+  requireDateOnOrAfter(e) {
+    return this._rule.type = a.DATE, this._rule.formula1 = e.toLocaleDateString(), this._rule.formula2 = void 0, this._rule.operator = u.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} date - The latest acceptable date.
+   * @returns {FDataValidationBuilder} The current instance for method chaining.
+   * @example
+   * ```typescript
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Set some date values in the range A1:B2
+   * const fRange = fWorksheet.getRange('A1:B2');
+   * fRange.setValues([
+   *   ['2024-01-01', '2024-12-31'],
+   *   ['2025-01-01', '2025-12-31']
+   * ]);
+   *
+   * // Create a data validation rule that requires a date on or before 2025-01-01
+   * const rule = univerAPI.newDataValidation()
+   *   .requireDateOnOrBefore(new Date('2025-01-01'))
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * // Get the validation status of the range
+   * const status = await fRange.getValidatorStatus();
+   * console.log(status); // [['valid', 'valid', 'valid', 'invalid']]
+   * ```
+   */
+  requireDateOnOrBefore(e) {
+    return this._rule.type = a.DATE, this._rule.formula1 = e.toLocaleDateString(), this._rule.formula2 = void 0, this._rule.operator = u.LESS_THAN_OR_EQUAL, this;
+  }
+  /**
+   * Sets the data validation rule to require that the given formula evaluates to `true`.
+   * @param {string} formula - The formula string that needs to be satisfied, formula result should be TRUE or FALSE, and references range will relative offset.
+   * @returns {FDataValidationBuilder} The current instance for method chaining.
+   * @example
+   * ```typescript
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Set some values in the range A1:B2 and C1:D2
+   * const cell = fWorksheet.getRange('A1:B2');
+   * cell.setValues([
+   *   [4, 3],
+   *   [2, 1]
+   * ]);
+   * const fRange = fWorksheet.getRange('C1:D2');
+   * fRange.setValues([
+   *   [1, 2],
+   *   [3, 4]
+   * ]);
+   *
+   * // Create a data validation rule that requires the formula '=A1>2' to be satisfied
+   * const rule = univerAPI.newDataValidation()
+   *   .requireFormulaSatisfied('=A1>2')
+   *   .setOptions({
+   *     showErrorMessage: true,
+   *     error: 'Please enter a value equal to A1'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * // Get the validation status of the range
+   * const status = await fRange.getValidatorStatus();
+   * console.log(status); // [['valid', 'valid', 'invalid', 'invalid']]
+   * ```
+   */
+  requireFormulaSatisfied(e) {
+    return this._rule.type = a.CUSTOM, this._rule.formula1 = e, this._rule.formula2 = void 0, this;
+  }
+  /**
+   * Sets the data validation rule to require a number that falls between, or is either of, two specified numbers.
+   * @param {number} start - The lowest acceptable value.
+   * @param {number} end - The highest acceptable value.
+   * @param {boolean} [isInteger] - Indicates whether the required number is an integer.
+   * @returns {FDataValidationBuilder} The current instance for method chaining.
+   * @example
+   * ```typescript
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Create a new data validation rule that requires a number between 1 and 10 for the range A1:B10
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberBetween(1, 10)
+   *   .setOptions({
+   *     allowBlank: false,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a number between 1 and 10'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
+   * ```
+   */
+  requireNumberBetween(e, t, i) {
+    return this._rule.formula1 = `${e}`, this._rule.formula2 = `${t}`, this._rule.operator = u.BETWEEN, this._rule.type = i ? a.WHOLE : a.DECIMAL, this;
+  }
+  /**
+   * Sets the data validation rule to require a number equal to the given value.
+   * @param {number} num - The sole acceptable value.
+   * @param {boolean} [isInteger] - Indicates whether the required number is an integer.
+   * @returns {FDataValidationBuilder} The current instance for method chaining.
+   * @example
+   * ```typescript
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Create a new data validation rule that requires a number equal to 10 for the range A1:B10
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberEqualTo(10)
+   *   .setOptions({
+   *     allowBlank: false,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a number equal to 10'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
+   * ```
+   */
+  requireNumberEqualTo(e, t) {
+    return this._rule.formula1 = `${e}`, this._rule.formula2 = void 0, this._rule.operator = u.EQUAL, this._rule.type = t ? a.WHOLE : a.DECIMAL, this;
+  }
+  /**
+   * Sets the data validation rule to require a number greater than the given value.
+   * @param {number} num - The highest unacceptable value.
+   * @param {boolean} [isInteger] - Indicates whether the required number is an integer.
+   * @returns {FDataValidationBuilder} The current instance for method chaining.
+   * @example
+   * ```typescript
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Create a new data validation rule that requires a number greater than 10 for the range A1:B10
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberGreaterThan(10)
+   *   .setOptions({
+   *     allowBlank: false,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a number greater than 10'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
+   * ```
+   */
+  requireNumberGreaterThan(e, t) {
+    return this._rule.formula1 = `${e}`, this._rule.formula2 = void 0, this._rule.operator = u.GREATER_THAN, this._rule.type = t ? a.WHOLE : a.DECIMAL, this;
+  }
+  /**
+   * Sets the data validation rule to require a number greater than or equal to the given value.
+   * @param {number} num - The lowest acceptable value.
+   * @param {boolean} [isInteger] - Indicates whether the required number is an integer.
+   * @returns {FDataValidationBuilder} The current instance for method chaining.
+   * @example
+   * ```typescript
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Create a new data validation rule that requires a number greater than 10 or equal to 10 for the range A1:B10
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberGreaterThanOrEqualTo(10)
+   *   .setOptions({
+   *     allowBlank: false,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a number greater than 10 or equal to 10'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
+   * ```
+   */
+  requireNumberGreaterThanOrEqualTo(e, t) {
+    return this._rule.formula1 = `${e}`, this._rule.formula2 = void 0, this._rule.operator = u.GREATER_THAN_OR_EQUAL, this._rule.type = t ? a.WHOLE : a.DECIMAL, this;
+  }
+  /**
+   * Sets the data validation rule to require a number less than the given value.
+   * @param {number} num - The lowest unacceptable value.
+   * @param {boolean} [isInteger] - Indicates whether the required number is an integer.
+   * @returns {FDataValidationBuilder} The current instance for method chaining.
+   * @example
+   * ```typescript
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Create a new data validation rule that requires a number less than 10 for the range A1:B10
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberLessThan(10)
+   *   .setOptions({
+   *     allowBlank: false,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a number less than 10'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
+   * ```
+   */
+  requireNumberLessThan(e, t) {
+    return this._rule.formula1 = `${e}`, this._rule.formula2 = void 0, this._rule.operator = u.LESS_THAN, this._rule.type = t ? a.WHOLE : a.DECIMAL, this;
+  }
+  /**
+   * Sets the data validation rule to require a number less than or equal to the given value.
+   * @param {number} num - The highest acceptable value.
+   * @param {boolean} [isInteger] - Indicates whether the required number is an integer.
+   * @returns {FDataValidationBuilder} The current instance for method chaining.
+   * @example
+   * ```typescript
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Create a new data validation rule that requires a number less than 10 or equal to 10 for the range A1:B10
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberLessThanOrEqualTo(10)
+   *   .setOptions({
+   *     allowBlank: false,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a number less than 10 or equal to 10'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
+   * ```
+   */
+  requireNumberLessThanOrEqualTo(e, t) {
+    return this._rule.formula1 = `${e}`, this._rule.formula2 = void 0, this._rule.operator = u.LESS_THAN_OR_EQUAL, this._rule.type = t ? a.WHOLE : a.DECIMAL, this;
+  }
+  /**
+   * Sets the data validation rule to require a number that does not fall between, and is neither of, two specified numbers.
+   * @param {number} start - The lowest unacceptable value.
+   * @param {number} end - The highest unacceptable value.
+   * @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 fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Create a new data validation rule that requires a number not between 1 and 10 for the range A1:B10
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberNotBetween(1, 10)
+   *   .setOptions({
+   *     allowBlank: false,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a number not between 1 and 10'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
+   * ```
+   */
+  requireNumberNotBetween(e, t, i) {
+    return this._rule.formula1 = `${e}`, this._rule.formula2 = `${t}`, this._rule.operator = u.NOT_BETWEEN, this._rule.type = i ? a.WHOLE : a.DECIMAL, this;
+  }
+  /**
+   * Sets the data validation rule to require a number not equal to the given value.
+   * @param {number} num - The sole unacceptable value.
+   * @param {boolean} [isInteger] - Indicates whether the required number is an integer.
+   * @returns {FDataValidationBuilder} The current instance for method chaining.
+   * @example
+   * ```typescript
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Create a new data validation rule that requires a number not equal to 10 for the range A1:B10
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberNotEqualTo(10)
+   *   .setOptions({
+   *     allowBlank: false,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a number not equal to 10'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
+   * ```
+   */
+  requireNumberNotEqualTo(e, t) {
+    return this._rule.formula1 = `${e}`, this._rule.formula2 = void 0, this._rule.operator = u.NOT_EQUAL, this._rule.type = t ? a.WHOLE : a.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 {string[]} values - An array of acceptable values.
+   * @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 fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Create a new data validation rule that requires the user to enter a value from the list ['Yes', 'No'] for the range A1:B10
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireValueInList(['Yes', 'No'])
+   *   .setOptions({
+   *     allowBlank: true,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a value from the list'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
+   * ```
+   */
+  requireValueInList(e, t, i) {
+    return this._rule.type = t ? a.LIST_MULTIPLE : a.LIST, this._rule.formula1 = e.join(","), this._rule.formula2 = void 0, this._rule.showDropDown = i != null ? i : !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 {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 fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Set the values in the range B1:B2
+   * const fRange = fWorksheet.getRange('B1:B2');
+   * fRange.setValues([
+   *   ['Yes'],
+   *   ['No']
+   * ]);
+   *
+   * // Create a new data validation rule that requires the user to enter a value from the range B1:B2 for the range A1:A10
+   * const rule = univerAPI.newDataValidation()
+   *   .requireValueInRange(fRange)
+   *   .setOptions({
+   *     allowBlank: false,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a value from the list'
+   *   })
+   *   .build();
+   * const cell = fWorksheet.getRange('A1');
+   * cell.setDataValidation(rule);
+   * ```
+   */
+  requireValueInRange(e, t, i) {
+    return this._rule.type = t ? a.LIST_MULTIPLE : a.LIST, this._rule.formula1 = `=${F({
+      unitId: e.getUnitId(),
+      sheetName: e.getSheetName(),
+      range: e.getRange()
+    })}`, this._rule.formula2 = void 0, this._rule.showDropDown = i != null ? i : !0, this;
+  }
+  /**
+   * 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 fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Set the data validation for cell A1:B2 to allow invalid data, so A1:B2 will display a warning when invalid data is entered
+   * const fRange = fWorksheet.getRange('A1:B2');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireValueInList(['Yes', 'No'])
+   *   .setAllowInvalid(true)
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * // Set the data validation for cell C1:D2 to not allow invalid data, so C1:D2 will stop data entry when invalid data is entered
+   * const fRange2 = fWorksheet.getRange('C1:D2');
+   * const rule2 = univerAPI.newDataValidation()
+   *   .requireValueInList(['Yes', 'No'])
+   *   .setAllowInvalid(false)
+   *   .build();
+   * fRange2.setDataValidation(rule2);
+   * ```
+   */
+  setAllowInvalid(e) {
+    return this._rule.errorStyle = e ? k.WARNING : k.STOP, this;
+  }
+  /**
+   * Sets whether to allow blank values.
+   * @param {boolean} allowBlank - Whether to allow blank values.
+   * @returns {FDataValidationBuilder} The current instance for method chaining.
+   * @example
+   * ```typescript
+   * // Assume current sheet is empty data
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Set the data validation for cell A1:B2 to allow blank values
+   * const fRange = fWorksheet.getRange('A1:B2');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireValueInList(['Yes', 'No'])
+   *   .setAllowBlank(true)
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * // Set the data validation for cell C1:D2 to not allow blank values
+   * const fRange2 = fWorksheet.getRange('C1:D2');
+   * const rule2 = univerAPI.newDataValidation()
+   *   .requireValueInList(['Yes', 'No'])
+   *   .setAllowBlank(false)
+   *   .build();
+   * fRange2.setDataValidation(rule2);
+   * ```
+   */
+  setAllowBlank(e) {
+    return this._rule.allowBlank = e, this;
+  }
+  /**
+   * 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 fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Create a new data validation rule that requires the user to enter a value from the list ['Yes', 'No'] for the range A1:B10
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireValueInList(['Yes', 'No'])
+   *   .setOptions({
+   *     allowBlank: true,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a value from the list'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
+   * ```
+   */
+  setOptions(e) {
+    return Object.assign(this._rule, e), this;
+  }
+}
+class m {
+  constructor(e, t, i) {
+    _(this, "rule");
+    _(this, "_worksheet");
+    _(this, "_injector");
+    this._injector = i, this.rule = e, this._worksheet = t;
+  }
+  /**
+   * 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 fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const rules = fWorksheet.getDataValidations();
+   * rules.forEach((rule) => {
+   *   console.log(rule, rule.getAllowInvalid());
+   * });
+   * ```
+   */
+  getAllowInvalid() {
+    return this.rule.errorStyle !== k.STOP;
+  }
+  /**
+   * Gets the data validation type of the rule
+   * @returns {DataValidationType | string} The data validation type
+   * @example
+   * ```typescript
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const rules = fWorksheet.getDataValidations();
+   * rules.forEach((rule) => {
+   *   console.log(rule, rule.getCriteriaType());
+   * });
+   * ```
+   */
+  getCriteriaType() {
+    return this.rule.type;
+  }
+  /**
+   * Gets the values used for criteria evaluation
+   * @returns {[string | undefined, string | undefined, string | undefined]} An array containing the operator, formula1, and formula2 values
+   * @example
+   * ```typescript
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const rules = fWorksheet.getDataValidations();
+   * rules.forEach((rule) => {
+   *   console.log(rule);
+   *   const criteriaValues = rule.getCriteriaValues();
+   *   const [operator, formula1, formula2] = criteriaValues;
+   *   console.log(operator, formula1, formula2);
+   * });
+   * ```
+   */
+  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
+   * @example
+   * ```typescript
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberBetween(1, 10)
+   *   .setOptions({
+   *     allowBlank: true,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a number between 1 and 10'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
+   * console.log(fRange.getDataValidation().getHelpText()); // 'Please enter a number between 1 and 10'
+   * ```
+   */
+  getHelpText() {
+    return this.rule.error;
+  }
+  /**
+   * 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 fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberBetween(1, 10)
+   *   .setOptions({
+   *     allowBlank: true,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a number between 1 and 10'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * const builder = fRange.getDataValidation().copy();
+   * const newRule = builder
+   *   .requireNumberBetween(1, 5)
+   *   .setOptions({
+   *     error: 'Please enter a number between 1 and 5'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(newRule);
+   * ```
+   */
+  copy() {
+    return new E(this.rule);
+  }
+  /**
+   * Gets whether the data validation rule is applied to the worksheet
+   * @returns {boolean} true if the rule is applied, false otherwise
+   * @example
+   * ```typescript
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const rules = fWorksheet.getDataValidations();
+   * rules.forEach((rule) => {
+   *   console.log(rule, rule.getApplied());
+   * });
+   *
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * console.log(fRange.getDataValidation()?.getApplied());
+   * ```
+   */
+  getApplied() {
+    if (!this._worksheet)
+      return !1;
+    const t = this._injector.get(w).getRuleById(this._worksheet.getUnitId(), this._worksheet.getSheetId(), this.rule.uid);
+    return !!(t && t.ranges.length);
+  }
+  /**
+   * 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 fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const rules = fWorksheet.getDataValidations();
+   * rules.forEach((rule) => {
+   *   console.log(rule);
+   *   const ranges = rule.getRanges();
+   *   ranges.forEach((range) => {
+   *     console.log(range.getA1Notation());
+   *   });
+   * });
+   * ```
+   */
+  getRanges() {
+    if (!this.getApplied())
+      return [];
+    const e = this._injector.get(W).getUnit(this._worksheet.getUnitId());
+    return this.rule.ranges.map((t) => this._injector.createInstance(y, e, this._worksheet, t));
+  }
+  /**
+   * Gets the unit ID of the worksheet
+   * @returns {string | undefined} The unit ID of the worksheet
+   * @example
+   * ```typescript
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * console.log(fRange.getDataValidation().getUnitId());
+   * ```
+   */
+  getUnitId() {
+    var e;
+    return (e = this._worksheet) == null ? void 0 : e.getUnitId();
+  }
+  /**
+   * Gets the sheet ID of the worksheet
+   * @returns {string | undefined} The sheet ID of the worksheet
+   * @example
+   * ```typescript
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * console.log(fRange.getDataValidation().getSheetId());
+   * ```
+   */
+  getSheetId() {
+    var e;
+    return (e = this._worksheet) == null ? void 0 : e.getSheetId();
+  }
+  /**
+   * 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 fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Create a new data validation rule that requires a number equal to 20 for the range A1:B10
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberEqualTo(20)
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * // Change the rule criteria to require a number between 1 and 10
+   * fRange.getDataValidation().setCriteria(
+   *   univerAPI.Enum.DataValidationType.DECIMAL,
+   *   [univerAPI.Enum.DataValidationOperator.BETWEEN, '1', '10']
+   * );
+   * ```
+   */
+  setCriteria(e, t, i = !0) {
+    if (this.getApplied() && !this._injector.get(p).syncExecuteCommand(b.id, {
+      unitId: this.getUnitId(),
+      subUnitId: this.getSheetId(),
+      ruleId: this.rule.uid,
+      setting: {
+        operator: t[0],
+        formula1: t[1],
+        formula2: t[2],
+        type: this.rule.type,
+        allowBlank: i
+      }
+    }))
+      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 = i, this;
+  }
+  /**
+   * 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 fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Create a new data validation rule that requires a number equal to 20 for the range A1:B10
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberEqualTo(20)
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * // Supplement the rule with additional options
+   * fRange.getDataValidation().setOptions({
+   *   allowBlank: true,
+   *   showErrorMessage: true,
+   *   error: 'Please enter a valid value'
+   * });
+   * ```
+   */
+  setOptions(e) {
+    if (this.getApplied() && !this._injector.get(p).syncExecuteCommand(U.id, {
+      unitId: this.getUnitId(),
+      subUnitId: this.getSheetId(),
+      ruleId: this.rule.uid,
+      options: {
+        ...$(this.rule),
+        ...e
+      }
+    }))
+      throw new Error("setOptions failed");
+    return Object.assign(this.rule, e), this;
+  }
+  /**
+   * 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 fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Create a new data validation rule that requires a number equal to 20 for the range A1:B10
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberEqualTo(20)
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * // Change the range to C1:D10
+   * const newRuleRange = fWorksheet.getRange('C1:D10');
+   * fRange.getDataValidation().setRanges([newRuleRange]);
+   * ```
+   */
+  setRanges(e) {
+    if (this.getApplied() && !this._injector.get(p).syncExecuteCommand(C.id, {
+      unitId: this.getUnitId(),
+      subUnitId: this.getSheetId(),
+      ruleId: this.rule.uid,
+      ranges: e.map((r) => r.getRange())
+    }))
+      throw new Error("setRanges failed");
+    return this.rule.ranges = e.map((t) => t.getRange()), this;
+  }
+  /**
+   * Delete the data validation rule from the worksheet
+   * @returns {boolean} true if the rule is deleted successfully, false otherwise
+   * @example
+   * ```typescript
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Create a new data validation rule that requires a number equal to 20 for the range A1:B10
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberEqualTo(20)
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * // Delete the data validation rule
+   * fRange.getDataValidation().delete();
+   * ```
+   */
+  delete() {
+    return this.getApplied() ? this._injector.get(p).syncExecuteCommand(A.id, {
+      unitId: this.getUnitId(),
+      subUnitId: this.getSheetId(),
+      ruleId: this.rule.uid
+    }) : !1;
+  }
+}
+class G extends y {
+  setDataValidation(e) {
+    if (!e)
+      return this._commandService.syncExecuteCommand(j.id, {
+        unitId: this._workbook.getUnitId(),
+        subUnitId: this._worksheet.getSheetId(),
+        ranges: [this._range]
+      }), this;
+    const t = {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      rule: {
+        ...e.rule,
+        ranges: [this._range]
+      }
+    };
+    return this._commandService.syncExecuteCommand(T.id, t), this;
+  }
+  getDataValidation() {
+    const t = this._injector.get(S).getDataValidation(
+      this._workbook.getUnitId(),
+      this._worksheet.getSheetId(),
+      [this._range]
+    );
+    return t && new m(t, this._worksheet, this._injector);
+  }
+  getDataValidations() {
+    return this._injector.get(S).getDataValidations(
+      this._workbook.getUnitId(),
+      this._worksheet.getSheetId(),
+      [this._range]
+    ).map((t) => new m(t, this._worksheet, this._injector));
+  }
+  async getValidatorStatus() {
+    return this._injector.get(S).validatorRanges(
+      this._workbook.getUnitId(),
+      this._worksheet.getSheetId(),
+      [this._range]
+    );
+  }
+}
+y.extend(G);
+class Q extends N {
+  /**
+   * @deprecated use `univerAPI.newDataValidation()` as instead.
+   * @returns {FDataValidationBuilder} A new instance of the FDataValidationBuilder class
+   */
+  static newDataValidation() {
+    return new E();
+  }
+  newDataValidation() {
+    return new E();
+  }
+  /**
+   * @ignore
+   */
+  // eslint-disable-next-line max-lines-per-function
+  _initialize(e) {
+    const t = e.get(p);
+    this.registerEventHandler(
+      this.Event.SheetDataValidationChanged,
+      () => e.has(f) ? e.get(f).ruleChange$.subscribe((r) => {
+        const { unitId: o, subUnitId: l, rule: s, oldRule: n, type: d } = r, D = this.getSheetTarget(o, l);
+        if (!D)
+          return;
+        const { workbook: I, worksheet: V } = D, v = new m(s, V.getSheet(), this._injector);
+        this.fireEvent(this.Event.SheetDataValidationChanged, {
+          origin: r,
+          worksheet: V,
+          workbook: I,
+          changeType: d,
+          oldRule: n,
+          rule: v
+        });
+      }) : { dispose: () => {
+      } }
+    ), this.registerEventHandler(
+      this.Event.SheetDataValidatorStatusChanged,
+      () => e.has(f) ? e.get(f).validStatusChange$.subscribe((r) => {
+        const { unitId: o, subUnitId: l, ruleId: s, status: n, row: d, col: D } = r, I = this.getSheetTarget(o, l);
+        if (!I)
+          return;
+        const { workbook: V, worksheet: v } = I, B = v.getDataValidation(s);
+        B && this.fireEvent(this.Event.SheetDataValidatorStatusChanged, {
+          workbook: V,
+          worksheet: v,
+          row: d,
+          column: D,
+          rule: B,
+          status: n
+        });
+      }) : { dispose: () => {
+      } }
+    ), this.registerEventHandler(
+      this.Event.BeforeSheetDataValidationAdd,
+      () => t.beforeCommandExecuted((i) => {
+        if (i.id === T.id) {
+          const r = i.params, o = this.getSheetTarget(r.unitId, r.subUnitId);
+          if (!o)
+            return;
+          const { workbook: l, worksheet: s } = o, n = {
+            worksheet: s,
+            workbook: l,
+            rule: r.rule
+          };
+          if (this.fireEvent(this.Event.BeforeSheetDataValidationAdd, n), n.cancel)
+            throw new c();
+        }
+      })
+    ), this.registerEventHandler(
+      this.Event.BeforeSheetDataValidationCriteriaUpdate,
+      () => t.beforeCommandExecuted((i) => {
+        if (i.id === b.id) {
+          const r = i.params, o = this.getSheetTarget(r.unitId, r.subUnitId);
+          if (!o)
+            return;
+          const { workbook: l, worksheet: s } = o, n = s.getDataValidation(r.ruleId);
+          if (!n)
+            return;
+          const d = {
+            worksheet: s,
+            workbook: l,
+            rule: n,
+            ruleId: r.ruleId,
+            newCriteria: r.setting
+          };
+          if (this.fireEvent(this.Event.BeforeSheetDataValidationCriteriaUpdate, d), d.cancel)
+            throw new c();
+        }
+      })
+    ), this.registerEventHandler(
+      this.Event.BeforeSheetDataValidationRangeUpdate,
+      () => t.beforeCommandExecuted((i) => {
+        if (i.id === C.id) {
+          const r = i.params, o = this.getSheetTarget(r.unitId, r.subUnitId);
+          if (!o)
+            return;
+          const { workbook: l, worksheet: s } = o, n = s.getDataValidation(r.ruleId);
+          if (!n)
+            return;
+          const d = {
+            worksheet: s,
+            workbook: l,
+            rule: n,
+            ruleId: r.ruleId,
+            newRanges: r.ranges
+          };
+          if (this.fireEvent(this.Event.BeforeSheetDataValidationRangeUpdate, d), d.cancel)
+            throw new c();
+        }
+      })
+    ), this.registerEventHandler(
+      this.Event.BeforeSheetDataValidationOptionsUpdate,
+      () => t.beforeCommandExecuted((i) => {
+        if (i.id === U.id) {
+          const r = i.params, o = this.getSheetTarget(r.unitId, r.subUnitId);
+          if (!o)
+            return;
+          const { workbook: l, worksheet: s } = o, n = s.getDataValidation(r.ruleId);
+          if (!n)
+            return;
+          const d = {
+            worksheet: s,
+            workbook: l,
+            rule: n,
+            ruleId: r.ruleId,
+            newOptions: r.options
+          };
+          if (this.fireEvent(this.Event.BeforeSheetDataValidationOptionsUpdate, d), d.cancel)
+            throw new c();
+        }
+      })
+    ), this.registerEventHandler(
+      this.Event.BeforeSheetDataValidationDelete,
+      () => t.beforeCommandExecuted((i) => {
+        if (i.id === A.id) {
+          const r = i.params, o = this.getSheetTarget(r.unitId, r.subUnitId);
+          if (!o)
+            return;
+          const { workbook: l, worksheet: s } = o, n = s.getDataValidation(r.ruleId);
+          if (!n)
+            return;
+          const d = {
+            worksheet: s,
+            workbook: l,
+            rule: n,
+            ruleId: r.ruleId
+          };
+          if (this.fireEvent(this.Event.BeforeSheetDataValidationDelete, d), d.cancel)
+            throw new c();
+        }
+      })
+    ), this.registerEventHandler(
+      this.Event.BeforeSheetDataValidationDeleteAll,
+      () => t.beforeCommandExecuted((i) => {
+        if (i.id === O.id) {
+          const r = i.params, o = this.getSheetTarget(r.unitId, r.subUnitId);
+          if (!o)
+            return;
+          const { workbook: l, worksheet: s } = o, n = {
+            worksheet: s,
+            workbook: l,
+            rules: s.getDataValidations()
+          };
+          if (this.fireEvent(this.Event.BeforeSheetDataValidationDeleteAll, n), n.cancel)
+            throw new c();
+        }
+      })
+    );
+  }
+}
+N.extend(Q);
+class z extends x {
+  _initialize() {
+    Object.defineProperty(this, "_dataValidationModel", {
+      get() {
+        return this._injector.get(f);
+      }
+    });
+  }
+  getValidatorStatus() {
+    return this._injector.get(S).validatorWorkbook(this._workbook.getUnitId());
+  }
+  // region DataValidationHooks
+  onDataValidationChange(e) {
+    return g(this._dataValidationModel.ruleChange$.pipe(R((t) => t.unitId === this._workbook.getUnitId())).subscribe(e));
+  }
+  onDataValidationStatusChange(e) {
+    return g(this._dataValidationModel.validStatusChange$.pipe(R((t) => t.unitId === this._workbook.getUnitId())).subscribe(e));
+  }
+  onBeforeAddDataValidation(e) {
+    return g(this._commandService.beforeCommandExecuted((t, i) => {
+      const r = t.params;
+      if (t.id === T.id) {
+        if (r.unitId !== this._workbook.getUnitId())
+          return;
+        if (e(r, i) === !1)
+          throw new Error("Command is stopped by the hook onBeforeAddDataValidation");
+      }
+    }));
+  }
+  onBeforeUpdateDataValidationCriteria(e) {
+    return g(this._commandService.beforeCommandExecuted((t, i) => {
+      const r = t.params;
+      if (t.id === b.id) {
+        if (r.unitId !== this._workbook.getUnitId())
+          return;
+        if (e(r, i) === !1)
+          throw new Error("Command is stopped by the hook onBeforeUpdateDataValidationCriteria");
+      }
+    }));
+  }
+  onBeforeUpdateDataValidationRange(e) {
+    return g(this._commandService.beforeCommandExecuted((t, i) => {
+      const r = t.params;
+      if (t.id === C.id) {
+        if (r.unitId !== this._workbook.getUnitId())
+          return;
+        if (e(r, i) === !1)
+          throw new Error("Command is stopped by the hook onBeforeUpdateDataValidationRange");
+      }
+    }));
+  }
+  onBeforeUpdateDataValidationOptions(e) {
+    return g(this._commandService.beforeCommandExecuted((t, i) => {
+      const r = t.params;
+      if (t.id === U.id) {
+        if (r.unitId !== this._workbook.getUnitId())
+          return;
+        if (e(r, i) === !1)
+          throw new Error("Command is stopped by the hook onBeforeUpdateDataValidationOptions");
+      }
+    }));
+  }
+  onBeforeDeleteDataValidation(e) {
+    return g(this._commandService.beforeCommandExecuted((t, i) => {
+      const r = t.params;
+      if (t.id === A.id) {
+        if (r.unitId !== this._workbook.getUnitId())
+          return;
+        if (e(r, i) === !1)
+          throw new Error("Command is stopped by the hook onBeforeDeleteDataValidation");
+      }
+    }));
+  }
+  onBeforeDeleteAllDataValidation(e) {
+    return g(this._commandService.beforeCommandExecuted((t, i) => {
+      const r = t.params;
+      if (t.id === O.id) {
+        if (r.unitId !== this._workbook.getUnitId())
+          return;
+        if (e(r, i) === !1)
+          throw new Error("Command is stopped by the hook onBeforeDeleteAllDataValidation");
+      }
+    }));
+  }
+}
+x.extend(z);
+class K extends M {
+  getDataValidations() {
+    return this._injector.get(w).getRules(this._workbook.getUnitId(), this._worksheet.getSheetId()).map((t) => new m(t, this._worksheet, this._injector));
+  }
+  getValidatorStatus() {
+    return this._injector.get(S).validatorWorksheet(
+      this._workbook.getUnitId(),
+      this._worksheet.getSheetId()
+    );
+  }
+  getValidatorStatusAsync() {
+    return this.getValidatorStatus();
+  }
+  getDataValidation(e) {
+    const i = this._injector.get(w).getRuleById(this._workbook.getUnitId(), this._worksheet.getSheetId(), e);
+    return i ? new m(i, this._worksheet, this._injector) : null;
+  }
+}
+M.extend(K);
+class X {
+  get SheetDataValidationChanged() {
+    return "SheetDataValidationChanged";
+  }
+  get SheetDataValidatorStatusChanged() {
+    return "SheetDataValidatorStatusChanged";
+  }
+  get BeforeSheetDataValidationAdd() {
+    return "BeforeSheetDataValidationAdd";
+  }
+  get BeforeSheetDataValidationDelete() {
+    return "BeforeSheetDataValidationDelete";
+  }
+  get BeforeSheetDataValidationDeleteAll() {
+    return "BeforeSheetDataValidationDeleteAll";
+  }
+  get BeforeSheetDataValidationCriteriaUpdate() {
+    return "BeforeSheetDataValidationCriteriaUpdate";
+  }
+  get BeforeSheetDataValidationRangeUpdate() {
+    return "BeforeSheetDataValidationRangeUpdate";
+  }
+  get BeforeSheetDataValidationOptionsUpdate() {
+    return "BeforeSheetDataValidationOptionsUpdate";
+  }
+}
+P.extend(X);
+export {
+  m as FDataValidation,
+  E as FDataValidationBuilder
+};