@gridsuite/commons-ui 0.62.0 → 0.63.1

package/dist/components/filter/expert/expert-filter-edition-dialog.d.ts

@@ -1,6 +1,5 @@
-import { elementExistsType } from '../criteria-based/criteria-based-filter-edition-dialog';
+import { ElementExistsType } from '../../../utils/ElementType';
 import { UUID } from 'crypto';
-import { FunctionComponent } from 'react';
 
 export interface ExpertFilterEditionDialogProps {
     id: string;
@@ -15,8 +14,8 @@ export interface ExpertFilterEditionDialogProps {
     }>;
     setSelectionForCopy: (selection: any) => void;
     activeDirectory?: UUID;
-    elementExists?: elementExistsType;
+    elementExists?: ElementExistsType;
     language?: string;
 }
-declare const ExpertFilterEditionDialog: FunctionComponent<ExpertFilterEditionDialogProps>;
+declare function ExpertFilterEditionDialog({ id, name, titleId, open, onClose, broadcastChannel, selectionForCopy, getFilterById, setSelectionForCopy, activeDirectory, elementExists, language, }: ExpertFilterEditionDialogProps): import("react/jsx-runtime").JSX.Element;
 export default ExpertFilterEditionDialog;

package/dist/components/filter/expert/expert-filter-edition-dialog.js

@@ -1,18 +1,131 @@
-import "react/jsx-runtime";
-import "react";
-import "../../../utils/field-constants.js";
-import "../../../utils/equipment-types.js";
-import "react-hook-form";
-import "@hookform/resolvers/yup";
-import "../../../hooks/useSnackMessage.js";
-import "../../dialogs/custom-mui-dialog.js";
+import { jsx } from "react/jsx-runtime";
+import { useState, useEffect, useCallback } from "react";
+import { useForm } from "react-hook-form";
+import { yupResolver } from "@hookform/resolvers/yup";
+import FieldConstants from "../../../utils/field-constants.js";
+import { noSelectionForCopy } from "../../../utils/equipment-types.js";
+import { useSnackMessage } from "../../../hooks/useSnackMessage.js";
+import CustomMuiDialog from "../../dialogs/custom-mui-dialog.js";
 import "../../../utils/yup-config.js";
-import { E } from "../../../chunks/criteria-based-filter-edition-dialog.CAT38SvB.js";
-import "../utils/filter-api.js";
-import "./expert-filter-utils.js";
-import "../constants/filter-constants.js";
-import "../../../utils/FetchStatus.js";
-import "yup";
+import FilterForm from "../filter-form.js";
+import { expertFilterSchema, EXPERT_FILTER_QUERY } from "./expert-filter-form.js";
+import { saveExpertFilter } from "../utils/filter-api.js";
+import { importExpertRules } from "./expert-filter-utils.js";
+import { FilterType } from "../constants/filter-constants.js";
+import FetchStatus from "../../../utils/FetchStatus.js";
+import * as yup from "yup";
+const formSchema = yup.object().shape({
+  [FieldConstants.NAME]: yup.string().trim().required("nameEmpty"),
+  [FieldConstants.FILTER_TYPE]: yup.string().required(),
+  [FieldConstants.EQUIPMENT_TYPE]: yup.string().required(),
+  ...expertFilterSchema
+}).required();
+function ExpertFilterEditionDialog({
+  id,
+  name,
+  titleId,
+  open,
+  onClose,
+  broadcastChannel,
+  selectionForCopy,
+  getFilterById,
+  setSelectionForCopy,
+  activeDirectory,
+  elementExists,
+  language
+}) {
+  var _a;
+  const { snackError } = useSnackMessage();
+  const [dataFetchStatus, setDataFetchStatus] = useState(FetchStatus.IDLE);
+  const formMethods = useForm({
+    resolver: yupResolver(formSchema)
+  });
+  const {
+    reset,
+    formState: { errors }
+  } = formMethods;
+  const nameError = errors[FieldConstants.NAME];
+  const isValidating = (_a = errors.root) == null ? void 0 : _a.isValidating;
+  useEffect(() => {
+    if (id && open) {
+      setDataFetchStatus(FetchStatus.FETCHING);
+      getFilterById(id).then((response) => {
+        setDataFetchStatus(FetchStatus.FETCH_SUCCESS);
+        reset({
+          [FieldConstants.NAME]: name,
+          [FieldConstants.FILTER_TYPE]: FilterType.EXPERT.id,
+          [FieldConstants.EQUIPMENT_TYPE]: response[FieldConstants.EQUIPMENT_TYPE],
+          [EXPERT_FILTER_QUERY]: importExpertRules(
+            response[EXPERT_FILTER_QUERY]
+          )
+        });
+      }).catch((error) => {
+        setDataFetchStatus(FetchStatus.FETCH_ERROR);
+        snackError({
+          messageTxt: error.message,
+          headerId: "cannotRetrieveFilter"
+        });
+      });
+    }
+  }, [id, name, open, reset, snackError, getFilterById]);
+  const onSubmit = useCallback(
+    (filterForm) => {
+      saveExpertFilter(
+        id,
+        filterForm[EXPERT_FILTER_QUERY],
+        filterForm[FieldConstants.EQUIPMENT_TYPE],
+        filterForm[FieldConstants.NAME],
+        "",
+        // The description can not be edited from this dialog
+        false,
+        null,
+        onClose,
+        (error) => {
+          snackError({
+            messageTxt: error
+          });
+        }
+      );
+      if (selectionForCopy.sourceItemUuid === id) {
+        setSelectionForCopy(noSelectionForCopy);
+        broadcastChannel.postMessage({
+          noSelectionForCopy
+        });
+      }
+    },
+    [
+      broadcastChannel,
+      id,
+      onClose,
+      selectionForCopy.sourceItemUuid,
+      snackError,
+      setSelectionForCopy
+    ]
+  );
+  const isDataReady = dataFetchStatus === FetchStatus.FETCH_SUCCESS;
+  return /* @__PURE__ */ jsx(
+    CustomMuiDialog,
+    {
+      open,
+      onClose,
+      onSave: onSubmit,
+      formSchema,
+      formMethods,
+      titleId,
+      removeOptional: true,
+      disabledSave: !!nameError || !!isValidating,
+      isDataFetching: dataFetchStatus === FetchStatus.FETCHING,
+      language,
+      children: isDataReady && /* @__PURE__ */ jsx(
+        FilterForm,
+        {
+          activeDirectory,
+          elementExists
+        }
+      )
+    }
+  );
+}
 export {
-  E as default
+  ExpertFilterEditionDialog as default
 };

package/dist/components/filter/expert/expert-filter-form.d.ts

@@ -1,8 +1,8 @@
 import { FieldType } from './expert-filter.type';
-import { FunctionComponent } from 'react';
 
 import * as yup from 'yup';
 export declare const EXPERT_FILTER_QUERY = "rules";
+export declare const rqbQuerySchemaValidator: (schema: yup.Schema) => yup.Schema<any, any, any, "">;
 export declare const expertFilterSchema: {
     rules: yup.ObjectSchema<{}, yup.AnyObject, {}, "">;
 };
@@ -17,5 +17,5 @@ export declare function getExpertFilterEmptyFormData(): {
         }[];
     };
 };
-declare const ExpertFilterForm: FunctionComponent;
+declare function ExpertFilterForm(): import("react/jsx-runtime").JSX.Element;
 export default ExpertFilterForm;

package/dist/components/filter/expert/expert-filter-form.js

@@ -1,22 +1,117 @@
-import "react/jsx-runtime";
-import "react";
-import "@mui/material/Grid";
-import "react-querybuilder";
-import { k, n, l, m } from "../../../chunks/criteria-based-filter-edition-dialog.CAT38SvB.js";
-import "react-hook-form";
-import "./expert-filter-utils.js";
-import "./expert-filter-constants.js";
-import "yup";
-import "./expert-filter.type.js";
-import "uuid";
-import "react-intl";
-import "../../../utils/field-constants.js";
-import "../../inputs/react-hook-form/select-inputs/input-with-popup-confirmation.js";
-import "../../inputs/react-hook-form/select-inputs/select-input.js";
-import "../constants/filter-constants.js";
+import '../../../assets/expert-filter-form.css';
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useCallback, useMemo } from "react";
+import Grid from "@mui/material/Grid";
+import { formatQuery } from "react-querybuilder";
+import { useFormContext, useWatch } from "react-hook-form";
+import * as yup from "yup";
+import { v4 } from "uuid";
+import { useIntl } from "react-intl";
+import { testQuery } from "./expert-filter-utils.js";
+import { COMBINATOR_OPTIONS, OPERATOR_OPTIONS, EXPERT_FILTER_EQUIPMENTS, RULES, fields } from "./expert-filter-constants.js";
+import { FieldType } from "./expert-filter.type.js";
+import FieldConstants from "../../../utils/field-constants.js";
+import InputWithPopupConfirmation from "../../inputs/react-hook-form/select-inputs/input-with-popup-confirmation.js";
+import SelectInput from "../../inputs/react-hook-form/select-inputs/select-input.js";
+import { FilterType } from "../constants/filter-constants.js";
+import CustomReactQueryBuilder from "../../inputs/react-query-builder/custom-react-query-builder.js";
+yup.setLocale({
+  mixed: {
+    required: "YupRequired",
+    notType: ({ type }) => {
+      if (type === "number") {
+        return "YupNotTypeNumber";
+      }
+      return "YupNotTypeDefault";
+    }
+  }
+});
+const EXPERT_FILTER_QUERY = "rules";
+function isSupportedEquipmentType(equipmentType) {
+  return Object.values(EXPERT_FILTER_EQUIPMENTS).map((equipments) => equipments.id).includes(equipmentType);
+}
+const rqbQuerySchemaValidator = (schema) => schema.test(RULES.EMPTY_GROUP, RULES.EMPTY_GROUP, (query) => {
+  return testQuery(RULES.EMPTY_GROUP, query);
+}).test(RULES.EMPTY_RULE, RULES.EMPTY_RULE, (query) => {
+  return testQuery(RULES.EMPTY_RULE, query);
+}).test(RULES.INCORRECT_RULE, RULES.INCORRECT_RULE, (query) => {
+  return testQuery(RULES.INCORRECT_RULE, query);
+}).test(RULES.BETWEEN_RULE, RULES.BETWEEN_RULE, (query) => {
+  return testQuery(RULES.BETWEEN_RULE, query);
+});
+const expertFilterSchema = {
+  [EXPERT_FILTER_QUERY]: yup.object().when([FieldConstants.FILTER_TYPE], {
+    is: FilterType.EXPERT.id,
+    then: (schema) => schema.when([FieldConstants.EQUIPMENT_TYPE], {
+      is: (equipmentType) => isSupportedEquipmentType(equipmentType),
+      then: rqbQuerySchemaValidator
+    })
+  })
+};
+const defaultQuery = {
+  combinator: COMBINATOR_OPTIONS.AND.name,
+  rules: [
+    {
+      id: v4(),
+      field: FieldType.ID,
+      operator: OPERATOR_OPTIONS.CONTAINS.name,
+      value: ""
+    }
+  ]
+};
+function getExpertFilterEmptyFormData() {
+  return {
+    [EXPERT_FILTER_QUERY]: defaultQuery
+  };
+}
+function ExpertFilterForm() {
+  const intl = useIntl();
+  const { getValues, setValue } = useFormContext();
+  const openConfirmationPopup = useCallback(() => {
+    return formatQuery(getValues(EXPERT_FILTER_QUERY), "json_without_ids") !== formatQuery(defaultQuery, "json_without_ids");
+  }, [getValues]);
+  const handleResetOnConfirmation = useCallback(() => {
+    setValue(EXPERT_FILTER_QUERY, defaultQuery);
+  }, [setValue]);
+  const watchEquipmentType = useWatch({
+    name: FieldConstants.EQUIPMENT_TYPE
+  });
+  const translatedFields = useMemo(() => {
+    var _a;
+    return (_a = fields[watchEquipmentType]) == null ? void 0 : _a.map((field) => {
+      return {
+        ...field,
+        label: intl.formatMessage({ id: field.label })
+      };
+    });
+  }, [intl, watchEquipmentType]);
+  return /* @__PURE__ */ jsxs(Grid, { container: true, item: true, spacing: 2, children: [
+    /* @__PURE__ */ jsx(Grid, { item: true, xs: 12, children: /* @__PURE__ */ jsx(
+      InputWithPopupConfirmation,
+      {
+        Input: SelectInput,
+        name: FieldConstants.EQUIPMENT_TYPE,
+        options: Object.values(EXPERT_FILTER_EQUIPMENTS),
+        label: "equipmentType",
+        shouldOpenPopup: openConfirmationPopup,
+        resetOnConfirmation: handleResetOnConfirmation,
+        message: "changeTypeMessage",
+        validateButtonLabel: "button.changeType"
+      }
+    ) }),
+    watchEquipmentType && isSupportedEquipmentType(watchEquipmentType) && /* @__PURE__ */ jsx(
+      CustomReactQueryBuilder,
+      {
+        name: EXPERT_FILTER_QUERY,
+        fields: translatedFields
+      }
+    )
+  ] });
+}
 export {
-  k as EXPERT_FILTER_QUERY,
-  n as default,
-  l as expertFilterSchema,
-  m as getExpertFilterEmptyFormData
+  EXPERT_FILTER_QUERY,
+  ExpertFilterForm as default,
+  expertFilterSchema,
+  getExpertFilterEmptyFormData,
+  rqbQuerySchemaValidator
 };

package/dist/components/filter/expert/expert-filter-utils.d.ts

@@ -81,7 +81,7 @@ export declare const getOperators: (fieldName: string, intl: IntlShape) => {
 export declare function exportExpertRules(query: RuleGroupType): RuleGroupTypeExport;
 export declare function importExpertRules(query: RuleGroupTypeExport): RuleGroupType;
 export declare function countRules(query: RuleGroupTypeAny): number;
-export declare const testQuery: (check: string, query: RuleGroupTypeAny) => boolean;
 export declare const queryValidator: QueryValidator;
-export declare function recursiveRemove(query: RuleGroupTypeAny, path: number[]): RuleGroupTypeAny;
+export declare const testQuery: (check: string, query: RuleGroupTypeAny) => boolean;
 export declare function getNumberOfSiblings(path: number[], query: RuleGroupTypeAny): number;
+export declare function recursiveRemove(query: RuleGroupTypeAny, path: number[]): RuleGroupTypeAny;

package/dist/components/filter/expert/expert-filter-utils.js

@@ -1,6 +1,6 @@
-import { defaultOperators, getParentPath, remove, findPath } from "react-querybuilder";
-import { FieldType, DataType } from "./expert-filter.type.js";
+import { defaultOperators, getParentPath, findPath, remove } from "react-querybuilder";
 import { validate } from "uuid";
+import { FieldType, DataType } from "./expert-filter.type.js";
 import { FIELDS_OPTIONS, OPERATOR_OPTIONS, RULES } from "./expert-filter-constants.js";
 import { isBlankOrEmpty, microUnitToUnit, unitToMicroUnit } from "../../../utils/conversion-utils.js";
 const microUnits = [
@@ -37,10 +37,10 @@ const getDataType = (fieldName, operator) => {
 };
 const getOperators = (fieldName, intl) => {
   const field = Object.values(FIELDS_OPTIONS).find(
-    (field2) => field2.name === fieldName
+    (fieldOption) => fieldOption.name === fieldName
   );
   switch (field == null ? void 0 : field.dataType) {
-    case DataType.STRING:
+    case DataType.STRING: {
       let stringOperators = [
         OPERATOR_OPTIONS.CONTAINS,
         OPERATOR_OPTIONS.IS,
@@ -63,8 +63,9 @@ const getOperators = (fieldName, intl) => {
         name: operator.name,
         label: intl.formatMessage({ id: operator.label })
       }));
-    case DataType.NUMBER:
-      let numberOperators = [
+    }
+    case DataType.NUMBER: {
+      const numberOperators = [
         OPERATOR_OPTIONS.EQUALS,
         OPERATOR_OPTIONS.GREATER,
         OPERATOR_OPTIONS.GREATER_OR_EQUALS,
@@ -78,7 +79,8 @@ const getOperators = (fieldName, intl) => {
         name: operator.name,
         label: intl.formatMessage({ id: operator.label })
       }));
-    case DataType.BOOLEAN:
+    }
+    case DataType.BOOLEAN: {
       let booleanOperators = [OPERATOR_OPTIONS.EQUALS];
       if (field.name === FieldType.AUTOMATE) {
         booleanOperators = [
@@ -90,7 +92,8 @@ const getOperators = (fieldName, intl) => {
         name: operator.name,
         label: intl.formatMessage({ id: operator.label })
       }));
-    case DataType.ENUM:
+    }
+    case DataType.ENUM: {
       let enumOperators = [
         OPERATOR_OPTIONS.EQUALS,
         OPERATOR_OPTIONS.NOT_EQUALS,
@@ -105,13 +108,15 @@ const getOperators = (fieldName, intl) => {
         name: operator.name,
         label: intl.formatMessage({ id: operator.label })
       }));
-    case DataType.PROPERTY:
-      let propertiesOperators = [OPERATOR_OPTIONS.IS];
+    }
+    case DataType.PROPERTY: {
+      const propertiesOperators = [OPERATOR_OPTIONS.IS];
       return propertiesOperators.map((operator) => ({
         name: operator.name,
         label: intl.formatMessage({ id: operator.label })
       }));
-    case DataType.COMBINATOR:
+    }
+    case DataType.COMBINATOR: {
       const combinatorOperators = [OPERATOR_OPTIONS.IS];
       if (field.name === FieldType.REMOTE_REGULATED_TERMINAL) {
         combinatorOperators.push(OPERATOR_OPTIONS.EXISTS);
@@ -121,16 +126,17 @@ const getOperators = (fieldName, intl) => {
         name: operator.name,
         label: intl.formatMessage({ id: operator.label })
       }));
+    }
+    default:
+      return defaultOperators;
   }
-  return defaultOperators;
 };
 function changeValueUnit(value, field) {
   if (microUnits.includes(field)) {
     if (!Array.isArray(value)) {
       return microUnitToUnit(value);
-    } else {
-      return value.map((a) => microUnitToUnit(a));
     }
+    return value.map((a) => microUnitToUnit(a));
   }
   return value;
 }
@@ -143,6 +149,7 @@ function exportExpertRules(query) {
       return transformCompositeRule(rule);
     }
     return {
+      id: rule.id,
       field: rule.field,
       operator: dataType !== DataType.PROPERTY ? (_a = Object.values(OPERATOR_OPTIONS).find(
         (operator) => operator.name === rule.operator
@@ -166,6 +173,7 @@ function exportExpertRules(query) {
       })
     );
     return {
+      id: compositeGroup.id,
       combinator: compositeGroup.combinator,
       dataType: DataType.COMBINATOR,
       rules: transformedRules,
@@ -180,11 +188,11 @@ function exportExpertRules(query) {
     const transformedRules = group.rules.map((ruleOrGroup) => {
       if ("rules" in ruleOrGroup) {
         return transformGroup(ruleOrGroup);
-      } else {
-        return transformRule(ruleOrGroup);
       }
+      return transformRule(ruleOrGroup);
     });
     return {
+      id: group.id,
       combinator: group.combinator,
       dataType: DataType.COMBINATOR,
       rules: transformedRules
@@ -200,21 +208,21 @@ function importExpertRules(query) {
         propertyValues: rule.propertyValues,
         propertyOperator: rule.operator
       };
-    } else if (rule.values) {
+    }
+    if (rule.values) {
       if (rule.dataType === DataType.NUMBER) {
         return rule.values.map((value) => parseFloat(value)).map((numberValue) => {
           return microUnits.includes(rule.field) ? unitToMicroUnit(numberValue) : numberValue;
         }).sort((a, b) => a - b);
-      } else {
-        return rule.values.sort();
       }
-    } else {
-      return microUnits.includes(rule.field) ? unitToMicroUnit(parseFloat(rule.value)) : rule.value;
+      return rule.values.sort();
     }
+    return microUnits.includes(rule.field) ? unitToMicroUnit(parseFloat(rule.value)) : rule.value;
   }
   function transformRule(rule) {
     var _a;
     return {
+      id: rule.id,
       field: rule.field,
       operator: rule.dataType !== DataType.PROPERTY ? (_a = Object.values(OPERATOR_OPTIONS).find(
         (operator) => operator.customName === rule.operator
@@ -235,6 +243,7 @@ function importExpertRules(query) {
       {}
     );
     return {
+      id: group.id,
       field: group.field,
       operator: (_a = Object.values(OPERATOR_OPTIONS).find(
         (operator) => operator.customName === group.operator
@@ -249,16 +258,14 @@ function importExpertRules(query) {
     const transformedRules = group.rules.map((ruleOrGroup) => {
       if ("rules" in ruleOrGroup) {
         if ("field" in ruleOrGroup && "operator" in ruleOrGroup) {
-          return transformCompositeGroup(
-            ruleOrGroup
-          );
+          return transformCompositeGroup(ruleOrGroup);
         }
         return transformGroup(ruleOrGroup);
-      } else {
-        return transformRule(ruleOrGroup);
       }
+      return transformRule(ruleOrGroup);
     });
     return {
+      id: group.id,
       combinator: group.combinator,
       rules: transformedRules
     };
@@ -266,27 +273,23 @@ function importExpertRules(query) {
   return transformGroup(query);
 }
 function countRules(query) {
+  if (!query) {
+    return 0;
+  }
   if ("rules" in query) {
     const group = query;
     return group.rules.reduce(
       (sum, ruleOrGroup) => sum + countRules(ruleOrGroup),
       0
     );
-  } else {
-    return 1;
   }
+  return 1;
 }
-const testQuery = (check, query) => {
-  const queryValidatorResult = queryValidator(query);
-  return !Object.values(queryValidatorResult).some((ruleValidation) => {
-    if (typeof ruleValidation !== "boolean" && ruleValidation.reasons) {
-      return ruleValidation.reasons.includes(check);
-    }
-    return false;
-  });
-};
 const queryValidator = (query) => {
   const result = {};
+  if (!query) {
+    return result;
+  }
   const validateRule = (rule) => {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i;
     const isValueAnArray = Array.isArray(rule.value);
@@ -304,7 +307,7 @@ const queryValidator = (query) => {
           valid: false,
           reasons: [RULES.EMPTY_RULE]
         };
-      } else if (isNaN(parseFloat(rule.value[0])) || isNaN(parseFloat(rule.value[1]))) {
+      } else if (Number.isNaN(parseFloat(rule.value[0])) || Number.isNaN(parseFloat(rule.value[1]))) {
         result[rule.id] = {
           valid: false,
           reasons: [RULES.INCORRECT_RULE]
@@ -325,7 +328,7 @@ const queryValidator = (query) => {
         valid: false,
         reasons: [RULES.EMPTY_RULE]
       };
-    } else if (rule.id && isNumberInput && isNaN(parseFloat(rule.value))) {
+    } else if (rule.id && isNumberInput && Number.isNaN(parseFloat(rule.value))) {
       result[rule.id] = {
         valid: false,
         reasons: [RULES.INCORRECT_RULE]
@@ -381,17 +384,26 @@ const queryValidator = (query) => {
   validateGroup(query);
   return result;
 };
+const testQuery = (check, query) => {
+  const queryValidatorResult = queryValidator(query);
+  return !Object.values(queryValidatorResult).some((ruleValidation) => {
+    if (typeof ruleValidation !== "boolean" && ruleValidation.reasons) {
+      return ruleValidation.reasons.includes(check);
+    }
+    return false;
+  });
+};
+function getNumberOfSiblings(path, query) {
+  var _a;
+  const parentPath = getParentPath(path);
+  const parentGroup = findPath(parentPath, query);
+  return (_a = parentGroup == null ? void 0 : parentGroup.rules) == null ? void 0 : _a.length;
+}
 function recursiveRemove(query, path) {
   if (getNumberOfSiblings(path, query) === 1 && path.toString() !== [0].toString()) {
     return recursiveRemove(query, getParentPath(path));
-  } else {
-    return remove(query, path);
   }
-}
-function getNumberOfSiblings(path, query) {
-  const parentPath = getParentPath(path);
-  const parentGroup = findPath(parentPath, query);
-  return parentGroup.rules.length;
+  return remove(query, path);
 }
 export {
   countRules,

package/dist/components/filter/expert/expert-filter.type.d.ts

@@ -1,3 +1,4 @@
+import { UUID } from 'crypto';
 import { FullField } from 'react-querybuilder';
 
 export declare enum OperatorType {
@@ -117,6 +118,7 @@ export type OperatorOption = {
     label: string;
 };
 export interface RuleTypeExport {
+    id?: UUID;
     field: FieldType;
     operator: OperatorType;
     value: string | number | undefined;
@@ -126,6 +128,7 @@ export interface RuleTypeExport {
     propertyValues?: string[];
 }
 export interface RuleGroupTypeExport {
+    id?: UUID;
     combinator: CombinatorType;
     dataType: DataType;
     field?: FieldType;
@@ -139,6 +142,7 @@ export interface CompositeField extends FullField {
     };
 }
 export interface CompositeGroup {
+    id?: string;
     combinator: string;
     rules: {
         [field: string]: CompositeRule;

package/dist/components/filter/explicit-naming/explicit-naming-filter-edition-dialog.d.ts

@@ -1,6 +1,5 @@
-import { elementExistsType } from '../criteria-based/criteria-based-filter-edition-dialog';
+import { ElementExistsType } from '../../../utils/ElementType';
 import { UUID } from 'crypto';
-import { FunctionComponent } from 'react';
 
 interface ExplicitNamingFilterEditionDialogProps {
     id: string;
@@ -13,8 +12,8 @@ interface ExplicitNamingFilterEditionDialogProps {
     setSelectionForCopy: (selection: any) => void;
     getFilterById: (id: string) => Promise<any>;
     activeDirectory?: UUID;
-    elementExists?: elementExistsType;
+    elementExists?: ElementExistsType;
     language?: string;
 }
-declare const ExplicitNamingFilterEditionDialog: FunctionComponent<ExplicitNamingFilterEditionDialogProps>;
+declare function ExplicitNamingFilterEditionDialog({ id, name, titleId, open, onClose, broadcastChannel, selectionForCopy, setSelectionForCopy, getFilterById, activeDirectory, elementExists, language, }: ExplicitNamingFilterEditionDialogProps): import("react/jsx-runtime").JSX.Element;
 export default ExplicitNamingFilterEditionDialog;