@gridsuite/commons-ui 0.63.3 → 0.63.5

package/dist/components/inputs/react-hook-form/utils/text-field-with-adornment.js

@@ -3,32 +3,22 @@ import { useState, useCallback } from "react";
 import { Clear } from "@mui/icons-material";
 import { InputAdornment, IconButton, TextField } from "@mui/material";
 function TextFieldWithAdornment(props) {
-  const {
-    adornmentPosition,
-    adornmentText,
-    value,
-    variant,
-    handleClearValue,
-    ...otherProps
-  } = props;
+  const { adornmentPosition, adornmentText, value, variant, handleClearValue, ...otherProps } = props;
   const [isFocused, setIsFocused] = useState(false);
-  const getAdornmentStyle = useCallback(
-    (innerVariant) => {
-      if (innerVariant === "filled") {
-        return {
-          alignItems: "start",
-          marginBottom: "0.4em"
-        };
-      }
-      if (innerVariant === "standard") {
-        return {
-          marginBottom: "0.3em"
-        };
-      }
-      return void 0;
-    },
-    []
-  );
+  const getAdornmentStyle = useCallback((innerVariant) => {
+    if (innerVariant === "filled") {
+      return {
+        alignItems: "start",
+        marginBottom: "0.4em"
+      };
+    }
+    if (innerVariant === "standard") {
+      return {
+        marginBottom: "0.3em"
+      };
+    }
+    return void 0;
+  }, []);
   const getClearAdornment = useCallback(
     (position) => {
       return /* @__PURE__ */ jsx(InputAdornment, { position, children: /* @__PURE__ */ jsx(IconButton, { onClick: handleClearValue, children: /* @__PURE__ */ jsx(Clear, {}) }) });
@@ -37,14 +27,7 @@ function TextFieldWithAdornment(props) {
   );
   const getTextAdornment = useCallback(
     (position) => {
-      return /* @__PURE__ */ jsx(
-        InputAdornment,
-        {
-          position,
-          sx: variant && getAdornmentStyle(variant),
-          children: adornmentText
-        }
-      );
+      return /* @__PURE__ */ jsx(InputAdornment, { position, sx: variant && getAdornmentStyle(variant), children: adornmentText });
     },
     [adornmentText, getAdornmentStyle, variant]
   );
@@ -54,26 +37,14 @@ function TextFieldWithAdornment(props) {
       endAdornment: getTextAdornment("end"),
       sx: { textAlign: "end" }
     } : void 0;
-  }, [
-    value,
-    handleClearValue,
-    getClearAdornment,
-    isFocused,
-    getTextAdornment
-  ]);
+  }, [value, handleClearValue, getClearAdornment, isFocused, getTextAdornment]);
   const withStartAdornmentText = useCallback(() => {
     return value !== "" || isFocused ? {
       startAdornment: getTextAdornment("start"),
       endAdornment: value && handleClearValue && getClearAdornment("end"),
       sx: { textAlign: "start" }
     } : void 0;
-  }, [
-    value,
-    handleClearValue,
-    getClearAdornment,
-    isFocused,
-    getTextAdornment
-  ]);
+  }, [value, handleClearValue, getClearAdornment, isFocused, getTextAdornment]);
   return /* @__PURE__ */ jsx(
     TextField,
     {

package/dist/components/inputs/react-query-builder/add-button.js

@@ -4,16 +4,7 @@ import AddIcon from "@mui/icons-material/ControlPoint";
 import { FormattedMessage } from "react-intl";
 function AddButton(props) {
   const { label, handleOnClick } = props;
-  return /* @__PURE__ */ jsx("span", { children: /* @__PURE__ */ jsx(
-    Button,
-    {
-      startIcon: /* @__PURE__ */ jsx(AddIcon, {}),
-      onClick: handleOnClick,
-      size: "small",
-      className: "add-button",
-      children: /* @__PURE__ */ jsx(FormattedMessage, { id: label })
-    }
-  ) });
+  return /* @__PURE__ */ jsx("span", { children: /* @__PURE__ */ jsx(Button, { startIcon: /* @__PURE__ */ jsx(AddIcon, {}), onClick: handleOnClick, size: "small", className: "add-button", children: /* @__PURE__ */ jsx(FormattedMessage, { id: label }) }) });
 }
 export {
   AddButton as default

package/dist/components/inputs/react-query-builder/autocomplete-with-favorites.d.ts

@@ -0,0 +1,12 @@
+import { AutocompleteProps } from '@mui/material/Autocomplete/Autocomplete';
+
+interface AutocompleteWithFavoritesProps<Value> extends Omit<AutocompleteProps<Value, boolean, false, boolean>, 'multiple' | 'renderInput' | 'renderGroup' | 'groupBy'> {
+    favorites: Value[];
+    valid: boolean;
+}
+/**
+ * Autocomplete component which allows to have a few "favorite" options always displayed
+ * at the beginning of the selector and separated from the others options
+ */
+declare function AutocompleteWithFavorites<Value>({ favorites, valid, options, value, ...otherProps }: AutocompleteWithFavoritesProps<Value>): import("react/jsx-runtime").JSX.Element;
+export default AutocompleteWithFavorites;

package/dist/components/inputs/react-query-builder/autocomplete-with-favorites.js

@@ -0,0 +1,43 @@
+import { jsx } from "react/jsx-runtime";
+import { Autocomplete, TextField, Box } from "@mui/material";
+import { useMemo } from "react";
+const styles = {
+  favBox: (theme) => ({
+    borderBottom: "1px solid",
+    borderColor: theme.palette.divider
+  })
+};
+function AutocompleteWithFavorites({
+  favorites,
+  valid,
+  options,
+  value,
+  ...otherProps
+}) {
+  const optionsWithFavorites = useMemo(() => {
+    if (favorites) {
+      const optionsWithoutFavorites = options.filter((option) => !favorites.includes(option));
+      return [...favorites, ...optionsWithoutFavorites];
+    }
+    return options;
+  }, [options, favorites]);
+  return /* @__PURE__ */ jsx(
+    Autocomplete,
+    {
+      size: "small",
+      value,
+      options: optionsWithFavorites,
+      ...otherProps,
+      groupBy: (option) => favorites.includes(option) ? `fav` : "not_fav",
+      multiple: Array.isArray(value),
+      renderInput: (params) => /* @__PURE__ */ jsx(TextField, { ...params, error: !valid }),
+      renderGroup: (item) => {
+        const { group, children } = item;
+        return /* @__PURE__ */ jsx(Box, { sx: styles.favBox, children }, `keyBoxGroup_${group}`);
+      }
+    }
+  );
+}
+export {
+  AutocompleteWithFavorites as default
+};

package/dist/components/inputs/react-query-builder/composite-rule-editor/group-value-editor.js

@@ -29,33 +29,20 @@ function GroupValueEditor(props) {
     },
     [handleOnChange, combinator, value]
   );
-  return /* @__PURE__ */ jsx(
-    Grid,
-    {
-      container: true,
-      direction: "column",
-      sx: styles.group,
-      paddingLeft: 1,
-      paddingRight: 1,
-      paddingBottom: 1,
-      children: children && Object.values(children).map((fieldData) => {
-        var _a;
-        return /* @__PURE__ */ createElement(
-          RuleValueEditor,
-          {
-            ...props,
-            key: fieldData.name,
-            field: fieldData.name,
-            fieldData,
-            rule: (_a = value == null ? void 0 : value.rules) == null ? void 0 : _a[fieldData.name],
-            handleOnChangeRule: generateOnChangeRuleHandler(
-              fieldData.name
-            )
-          }
-        );
-      })
-    }
-  );
+  return /* @__PURE__ */ jsx(Grid, { container: true, direction: "column", sx: styles.group, paddingLeft: 1, paddingRight: 1, paddingBottom: 1, children: children && Object.values(children).map((fieldData) => {
+    var _a;
+    return /* @__PURE__ */ createElement(
+      RuleValueEditor,
+      {
+        ...props,
+        key: fieldData.name,
+        field: fieldData.name,
+        fieldData,
+        rule: (_a = value == null ? void 0 : value.rules) == null ? void 0 : _a[fieldData.name],
+        handleOnChangeRule: generateOnChangeRuleHandler(fieldData.name)
+      }
+    );
+  }) });
 }
 export {
   GroupValueEditor as default

package/dist/components/inputs/react-query-builder/composite-rule-editor/rule-value-editor.js

@@ -44,9 +44,7 @@ function RuleValueEditor(props) {
           handleOnChangeOperator(event.target.value);
         },
         variant: "standard",
-        children: (_b = fieldData.operators) == null ? void 0 : _b.map(
-          (option) => /* @__PURE__ */ jsx(MenuItem, { value: option.name, children: intl.formatMessage({ id: option.label }) }, option.name)
-        )
+        children: (_b = fieldData.operators) == null ? void 0 : _b.map((option) => /* @__PURE__ */ jsx(MenuItem, { value: option.name, children: intl.formatMessage({ id: option.label }) }, option.name))
       }
     ) }),
     /* @__PURE__ */ jsx(Grid, { container: true, item: true, xs: 5.5, sx: styles.gridItem, paddingLeft: 1, children: /* @__PURE__ */ jsx(

package/dist/components/inputs/react-query-builder/country-value-editor.js

@@ -1,43 +1,42 @@
 import { jsx } from "react/jsx-runtime";
-import { MaterialValueEditor } from "@react-querybuilder/material";
-import { Autocomplete, TextField } from "@mui/material";
-import { useMemo } from "react";
-import useConvertValue from "./use-convert-value.js";
-import useValid from "./use-valid.js";
+import { useState, useEffect } from "react";
 import { useLocalizedCountries } from "../../../hooks/localized-countries-hook.js";
 import useCustomFormContext from "../react-hook-form/provider/use-custom-form-context.js";
+import { fetchFavoriteAndDefaultCountries } from "../../../services/apps-metadata.js";
+import AutocompleteWithFavorites from "./autocomplete-with-favorites.js";
+import useConvertValue from "./use-convert-value.js";
+import useValid from "./use-valid.js";
 function CountryValueEditor(props) {
+  const { value, handleOnChange } = props;
   const { language } = useCustomFormContext();
   const { translate, countryCodes } = useLocalizedCountries(language);
-  const { value, handleOnChange } = props;
-  const countriesList = useMemo(
-    () => countryCodes.map((country) => {
-      return { name: country, label: translate(country) };
-    }),
-    [countryCodes, translate]
-  );
+  const [favoriteCountryCodes, setFavoriteCountryCodes] = useState([]);
+  const [initialized, setInitialized] = useState(false);
+  useEffect(() => {
+    if (!initialized) {
+      fetchFavoriteAndDefaultCountries().then(({ favoriteCountries, defaultCountry }) => {
+        setFavoriteCountryCodes(favoriteCountries);
+        if (defaultCountry && !value) {
+          handleOnChange(defaultCountry);
+        }
+        setInitialized(true);
+      });
+    }
+  }, [initialized, setInitialized, handleOnChange, value]);
   useConvertValue(props);
   const valid = useValid(props);
-  if (!Array.isArray(value)) {
-    return /* @__PURE__ */ jsx(
-      MaterialValueEditor,
-      {
-        ...props,
-        values: countriesList,
-        title: void 0
-      }
-    );
-  }
   return /* @__PURE__ */ jsx(
-    Autocomplete,
+    AutocompleteWithFavorites,
     {
       value,
       options: countryCodes,
-      getOptionLabel: (code) => translate(code),
-      onChange: (event, newValue) => handleOnChange(newValue),
-      multiple: true,
-      fullWidth: true,
-      renderInput: (params) => /* @__PURE__ */ jsx(TextField, { ...params, error: !valid })
+      favorites: favoriteCountryCodes,
+      getOptionLabel: (code) => code ? translate(code) : "",
+      valid,
+      onChange: (event, newValue) => {
+        handleOnChange(newValue);
+      },
+      fullWidth: true
     }
   );
 }

package/dist/components/inputs/react-query-builder/custom-react-query-builder.js

@@ -53,39 +53,33 @@ function CustomReactQueryBuilder(props) {
     }));
   }, [intl]);
   return /* @__PURE__ */ jsxs(Fragment, { children: [
-    /* @__PURE__ */ jsx(Grid, { item: true, xs: 12, children: /* @__PURE__ */ jsx(QueryBuilderMaterial, { children: /* @__PURE__ */ jsx(
-      QueryBuilderDnD,
+    /* @__PURE__ */ jsx(Grid, { item: true, xs: 12, children: /* @__PURE__ */ jsx(QueryBuilderMaterial, { children: /* @__PURE__ */ jsx(QueryBuilderDnD, { dnd: { ...ReactDnD, ...ReactDndHtml5Backend }, children: /* @__PURE__ */ jsx(
+      QueryBuilder,
       {
-        dnd: { ...ReactDnD, ...ReactDndHtml5Backend },
-        children: /* @__PURE__ */ jsx(
-          QueryBuilder,
-          {
-            fields,
-            query,
-            addRuleToNewGroups: true,
-            combinators,
-            onQueryChange: handleQueryChange,
-            getOperators: (fieldName) => getOperators(fieldName, intl),
-            validator: queryValidator,
-            controlClassnames: {
-              queryBuilder: "queryBuilder-branches"
-            },
-            controlElements: {
-              addRuleAction: RuleAddButton,
-              addGroupAction: GroupAddButton,
-              combinatorSelector: CombinatorSelector,
-              removeRuleAction: RemoveButton,
-              removeGroupAction: RemoveButton,
-              valueEditor: ValueEditor,
-              operatorSelector: ValueSelector,
-              fieldSelector: ValueSelector,
-              valueSourceSelector: ValueSelector
-            },
-            listsAsArrays: true
-          }
-        )
+        fields,
+        query,
+        addRuleToNewGroups: true,
+        combinators,
+        onQueryChange: handleQueryChange,
+        getOperators: (fieldName) => getOperators(fieldName, intl),
+        validator: queryValidator,
+        controlClassnames: {
+          queryBuilder: "queryBuilder-branches"
+        },
+        controlElements: {
+          addRuleAction: RuleAddButton,
+          addGroupAction: GroupAddButton,
+          combinatorSelector: CombinatorSelector,
+          removeRuleAction: RemoveButton,
+          removeGroupAction: RemoveButton,
+          valueEditor: ValueEditor,
+          operatorSelector: ValueSelector,
+          fieldSelector: ValueSelector,
+          valueSourceSelector: ValueSelector
+        },
+        listsAsArrays: true
       }
-    ) }) }),
+    ) }) }) }),
     /* @__PURE__ */ jsx(Grid, { item: true, xs: 12, children: /* @__PURE__ */ jsx(ErrorInput, { name, InputField: FieldErrorAlert }) })
   ] });
 }

package/dist/components/inputs/react-query-builder/element-value-editor.js

@@ -5,16 +5,7 @@ import useCustomFormContext from "../react-hook-form/provider/use-custom-form-co
 import { fetchElementsInfos } from "../../../services/explore.js";
 import DirectoryItemsInput from "../react-hook-form/directory-items-input.js";
 function ElementValueEditor(props) {
-  const {
-    defaultValue,
-    name,
-    elementType,
-    equipmentTypes,
-    titleId,
-    hideErrorMessage,
-    itemFilter,
-    onChange
-  } = props;
+  const { defaultValue, name, elementType, equipmentTypes, titleId, hideErrorMessage, itemFilter, onChange } = props;
   const { setValue } = useCustomFormContext();
   useEffect(() => {
     if (defaultValue && Array.isArray(defaultValue) && defaultValue.length > 0 && defaultValue[0].length > 0 && validate(defaultValue[0])) {

package/dist/components/inputs/react-query-builder/property-value-editor.js

@@ -57,26 +57,20 @@ function PropertyValueEditor(props) {
         renderInput: (params) => /* @__PURE__ */ jsx(TextField, { ...params, error: !valid }),
         onChange: (event, value) => {
           onChange(FieldConstants.PROPERTY_NAME, value);
-        }
+        },
+        size: "small"
       }
     ) }),
     /* @__PURE__ */ jsx(Grid, { item: true, xs: 2.5, children: /* @__PURE__ */ jsx(
       Select,
       {
         value: propertyOperator ?? PROPERTY_VALUE_OPERATORS[0].customName,
-        size: "medium",
+        size: "small",
         error: !valid,
         onChange: (event, value) => {
           onChange(FieldConstants.PROPERTY_OPERATOR, value);
         },
-        children: PROPERTY_VALUE_OPERATORS.map((operator) => /* @__PURE__ */ jsx(
-          MenuItem,
-          {
-            value: operator.customName,
-            children: intl.formatMessage({ id: operator.label })
-          },
-          operator.customName
-        ))
+        children: PROPERTY_VALUE_OPERATORS.map((operator) => /* @__PURE__ */ jsx(MenuItem, { value: operator.customName, children: intl.formatMessage({ id: operator.label }) }, operator.customName))
       }
     ) }),
     /* @__PURE__ */ jsx(Grid, { item: true, xs: 4.5, children: /* @__PURE__ */ jsx(
@@ -90,7 +84,8 @@ function PropertyValueEditor(props) {
         autoSelect: true,
         onChange: (event, value) => {
           onChange(FieldConstants.PROPERTY_VALUES, value);
-        }
+        },
+        size: "small"
       }
     ) })
   ] });

package/dist/components/inputs/react-query-builder/remove-button.js

@@ -13,15 +13,7 @@ function RemoveButton(props) {
     onChange(recursiveRemove(query, path));
   }
   const isLastRuleOrGroup = path.toString() === [0].toString() && getNumberOfSiblings(path, query) === 1;
-  return /* @__PURE__ */ jsx(
-    IconButton,
-    {
-      size: "small",
-      onClick: () => handleDelete(),
-      className,
-      children: !isLastRuleOrGroup && /* @__PURE__ */ jsx(DeleteIcon, {})
-    }
-  );
+  return /* @__PURE__ */ jsx(IconButton, { size: "small", onClick: () => handleDelete(), className, children: !isLastRuleOrGroup && /* @__PURE__ */ jsx(DeleteIcon, {}) });
 }
 export {
   RemoveButton as default

package/dist/components/inputs/react-query-builder/text-value-editor.js

@@ -25,7 +25,8 @@ function TextValueEditor(props) {
       onChange: (event, newValue) => handleOnChange(newValue),
       multiple: true,
       fullWidth: true,
-      renderInput: (params) => /* @__PURE__ */ jsx(TextField, { ...params, error: !valid })
+      renderInput: (params) => /* @__PURE__ */ jsx(TextField, { ...params, error: !valid }),
+      size: "small"
     }
   );
 }

package/dist/components/inputs/react-query-builder/translated-value-editor.js

@@ -20,9 +20,7 @@ function TranslatedValueEditor(props) {
     if (!values) {
       return {};
     }
-    return Object.fromEntries(
-      values.map((v) => [v.name, intl.formatMessage({ id: v.label })])
-    );
+    return Object.fromEntries(values.map((v) => [v.name, intl.formatMessage({ id: v.label })]));
   }, [intl, values]);
   useConvertValue(props);
   const valid = useValid(props);
@@ -45,7 +43,8 @@ function TranslatedValueEditor(props) {
       onChange: (event, newValue) => handleOnChange(newValue),
       multiple: true,
       fullWidth: true,
-      renderInput: (params) => /* @__PURE__ */ jsx(TextField, { ...params, error: !valid })
+      renderInput: (params) => /* @__PURE__ */ jsx(TextField, { ...params, error: !valid }),
+      size: "small"
     }
   );
 }

package/dist/components/inputs/react-query-builder/use-convert-value.d.ts

@@ -5,5 +5,5 @@ import { ValueEditorProps } from 'react-querybuilder';
  * PS : can be extended to manage more than the IN operator
  * PS 2 : don't use this if the operator can be another array operator (like BETWEEN) or change a bit the conditions
  */
-declare const useConvertValue: ({ operator, value, fieldData: { defaultValue }, handleOnChange, }: ValueEditorProps) => void;
+declare const useConvertValue: ({ operator, value, fieldData: { defaultValue }, handleOnChange }: ValueEditorProps) => void;
 export default useConvertValue;

package/dist/components/inputs/react-query-builder/use-convert-value.js

@@ -1,11 +1,6 @@
 import { useEffect } from "react";
 import { OPERATOR_OPTIONS } from "../../filter/expert/expert-filter-constants.js";
-const useConvertValue = ({
-  operator,
-  value,
-  fieldData: { defaultValue },
-  handleOnChange
-}) => {
+const useConvertValue = ({ operator, value, fieldData: { defaultValue }, handleOnChange }) => {
   useEffect(
     () => {
       if (operator === OPERATOR_OPTIONS.IN.name && !Array.isArray(value)) {

package/dist/components/inputs/react-query-builder/value-editor.js

@@ -26,15 +26,7 @@ const styles = {
   }
 };
 function ValueEditor(props) {
-  const {
-    field,
-    operator,
-    value,
-    rule,
-    handleOnChange,
-    inputType,
-    fieldData
-  } = props;
+  const { field, operator, value, rule, handleOnChange, inputType, fieldData } = props;
   const formContext = useFormContext();
   const { getValues } = formContext;
   const itemFilter = useCallback(
@@ -54,9 +46,7 @@ function ValueEditor(props) {
   if (operator === OPERATOR_OPTIONS.EXISTS.name || operator === OPERATOR_OPTIONS.NOT_EXISTS.name) {
     return null;
   }
-  if ([FieldType.COUNTRY, FieldType.COUNTRY_1, FieldType.COUNTRY_2].includes(
-    field
-  )) {
+  if ([FieldType.COUNTRY, FieldType.COUNTRY_1, FieldType.COUNTRY_2].includes(field)) {
     return /* @__PURE__ */ jsx(CountryValueEditor, { ...props });
   }
   if (fieldData.dataType === DataType.ENUM) {
@@ -85,7 +75,7 @@ function ValueEditor(props) {
       }
     );
   }
-  if (field === FieldType.ID || field === FieldType.NAME || field === FieldType.REGULATING_TERMINAL_VL_ID || field === FieldType.REGULATING_TERMINAL_CONNECTABLE_ID || field === FieldType.VOLTAGE_LEVEL_ID || field === FieldType.VOLTAGE_LEVEL_ID_1 || field === FieldType.VOLTAGE_LEVEL_ID_2 || field === FieldType.VOLTAGE_LEVEL_ID_3) {
+  if (fieldData.dataType === DataType.STRING) {
     return /* @__PURE__ */ jsx(TextValueEditor, { ...props });
   }
   if (fieldData.dataType === DataType.PROPERTY) {
@@ -97,13 +87,7 @@ function ValueEditor(props) {
     } else {
       equipmentType = getValues(FieldConstants.EQUIPMENT_TYPE);
     }
-    return /* @__PURE__ */ jsx(
-      PropertyValueEditor,
-      {
-        equipmentType,
-        valueEditorProps: props
-      }
-    );
+    return /* @__PURE__ */ jsx(PropertyValueEditor, { equipmentType, valueEditorProps: props });
   }
   if (fieldData.dataType === DataType.COMBINATOR) {
     return /* @__PURE__ */ jsx(GroupValueEditor, { ...props });

package/dist/components/translations/filter-expert-en.d.ts

@@ -92,27 +92,39 @@ declare const filterExpertEn: {
     substationProperty: string;
     substationProperty1: string;
     substationProperty2: string;
-    substationProperty3: string;
-    ratedVoltage0KV: string;
+    substationProperty1Twt: string;
+    substationProperty2Twt: string;
+    substationProperty3Twt: string;
     ratedVoltage1KV: string;
     ratedVoltage2KV: string;
-    ratedVoltage3KV: string;
+    ratedVoltage0KVTwt: string;
+    ratedVoltage1KVTwt: string;
+    ratedVoltage2KVTwt: string;
+    ratedVoltage3KVTwt: string;
     nominalVoltage1: string;
     nominalVoltage2: string;
     nominalVoltage3: string;
     nominalVoltage1KV: string;
     nominalVoltage2KV: string;
-    nominalVoltage3KV: string;
+    nominalVoltage1KVTwt: string;
+    nominalVoltage2KVTwt: string;
+    nominalVoltage3KVTwt: string;
     voltageLevelId1: string;
     voltageLevelId2: string;
-    voltageLevelId3: string;
+    voltageLevelId1Twt: string;
+    voltageLevelId2Twt: string;
+    voltageLevelId3Twt: string;
     terminal1Connected: string;
     terminal2Connected: string;
-    terminal3Connected: string;
+    terminal1ConnectedTwt: string;
+    terminal2ConnectedTwt: string;
+    terminal3ConnectedTwt: string;
     voltageLevelProperty: string;
     voltageLevelProperty1: string;
     voltageLevelProperty2: string;
-    voltageLevelProperty3: string;
+    voltageLevelProperty1Twt: string;
+    voltageLevelProperty2Twt: string;
+    voltageLevelProperty3Twt: string;
     'maxQAtNominalV.svar': string;
     'minQAtNominalV.svar': string;
     'fixQAtNominalV.svar': string;
@@ -162,5 +174,7 @@ declare const filterExpertEn: {
     shuntSusceptance1: string;
     shuntConductance2: string;
     shuntSusceptance2: string;
+    pairingKey: string;
+    tieLineId: string;
 };
 export default filterExpertEn;