@gridsuite/commons-ui 0.214.0 → 0.216.0

package/dist/components/parameters/dynamic-simulation/curve/dialog/curve-selector-utils.js

@@ -1,283 +0,0 @@
-import { EquipmentType, EQUIPMENTS_WITH_ONE_SUBSTATION, EQUIPMENTS_WITH_TWO_SUBSTATIONS, EQUIPMENTS_WITH_ONE_NOMINAL_VOLTAGE, EQUIPMENTS_WITH_TWO_NOMINAL_VOLTAGES, EQUIPMENTS_WITH_THREE_NOMINAL_VOLTAGES } from "../../../../../utils/types/equipmentType.js";
-import { FieldType } from "../../../../../utils/types/fieldType.js";
-import { DataType, OperatorType, CombinatorType } from "../../../../filter/expert/expertFilter.type.js";
-import { FilterType } from "../../../../filter/constants/FilterConstants.js";
-const CURVE_EQUIPMENT_TYPES = [
-  EquipmentType.GENERATOR,
-  EquipmentType.LOAD,
-  EquipmentType.BUS,
-  EquipmentType.BUSBAR_SECTION
-];
-const getReferencedEquipmentTypeForModel = (equipmentType) => {
-  return equipmentType === EquipmentType.BUSBAR_SECTION ? EquipmentType.BUS : equipmentType;
-};
-const getTopologyKindIfNecessary = (equipmentType) => {
-  return equipmentType === EquipmentType.BUS ? {
-    topologyKind: "BUS_BREAKER"
-  } : {};
-};
-const buildSubstationPropertiesRules = (equipmentType, substationProperties, rules) => {
-  if (EQUIPMENTS_WITH_ONE_SUBSTATION.includes(equipmentType)) {
-    let propertyField = FieldType.SUBSTATION_PROPERTIES;
-    if (equipmentType === EquipmentType.SUBSTATION) {
-      propertyField = FieldType.FREE_PROPERTIES;
-    }
-    Object.entries(substationProperties).forEach(([propertyName, propertyValues]) => {
-      if (propertyValues?.length) {
-        const substationPropertiesRule = {
-          field: propertyField,
-          operator: OperatorType.IN,
-          propertyName,
-          propertyValues,
-          dataType: DataType.PROPERTY
-        };
-        rules.push(substationPropertiesRule);
-      }
-    });
-  } else if (EQUIPMENTS_WITH_TWO_SUBSTATIONS.includes(equipmentType)) {
-    Object.entries(substationProperties).forEach(([propertyName, propertyValues]) => {
-      if (propertyValues?.length) {
-        const substationPropertiesRule = {
-          combinator: CombinatorType.OR,
-          dataType: DataType.COMBINATOR,
-          rules: [
-            {
-              field: FieldType.SUBSTATION_PROPERTIES_1,
-              operator: OperatorType.IN,
-              propertyName,
-              propertyValues,
-              dataType: DataType.PROPERTY
-            },
-            {
-              field: FieldType.SUBSTATION_PROPERTIES_2,
-              operator: OperatorType.IN,
-              propertyName,
-              propertyValues,
-              dataType: DataType.PROPERTY
-            }
-          ]
-        };
-        rules.push(substationPropertiesRule);
-      }
-    });
-  }
-};
-const buildExpertRules = (equipmentType, voltageLevelIds, countries, nominalVoltages, substationProperties, ids) => {
-  const rules = [];
-  if (voltageLevelIds?.length) {
-    const voltageLevelIdsRule = {
-      field: FieldType.VOLTAGE_LEVEL_ID,
-      operator: OperatorType.IN,
-      values: voltageLevelIds,
-      dataType: DataType.STRING
-    };
-    rules.push(voltageLevelIdsRule);
-  }
-  if (countries?.length && EQUIPMENTS_WITH_ONE_SUBSTATION.includes(equipmentType)) {
-    const countriesRule = {
-      field: FieldType.COUNTRY,
-      operator: OperatorType.IN,
-      values: countries,
-      dataType: DataType.ENUM
-    };
-    rules.push(countriesRule);
-  } else if (countries?.length && EQUIPMENTS_WITH_TWO_SUBSTATIONS.includes(equipmentType)) {
-    const countriesRule = {
-      combinator: CombinatorType.OR,
-      dataType: DataType.COMBINATOR,
-      rules: [
-        {
-          field: FieldType.COUNTRY_1,
-          operator: OperatorType.IN,
-          values: countries,
-          dataType: DataType.ENUM
-        },
-        {
-          field: FieldType.COUNTRY_2,
-          operator: OperatorType.IN,
-          values: countries,
-          dataType: DataType.ENUM
-        }
-      ]
-    };
-    rules.push(countriesRule);
-  }
-  if (nominalVoltages?.length && EQUIPMENTS_WITH_ONE_NOMINAL_VOLTAGE.includes(equipmentType)) {
-    const nominalVoltagesRule = {
-      field: FieldType.NOMINAL_VOLTAGE,
-      operator: OperatorType.IN,
-      values: nominalVoltages,
-      dataType: DataType.NUMBER
-    };
-    rules.push(nominalVoltagesRule);
-  } else if (nominalVoltages?.length && EQUIPMENTS_WITH_TWO_NOMINAL_VOLTAGES.includes(equipmentType)) {
-    const nominalVoltagesRule = {
-      combinator: CombinatorType.OR,
-      dataType: DataType.COMBINATOR,
-      rules: [
-        {
-          field: FieldType.NOMINAL_VOLTAGE_1,
-          operator: OperatorType.IN,
-          values: nominalVoltages,
-          dataType: DataType.NUMBER
-        },
-        {
-          field: FieldType.NOMINAL_VOLTAGE_2,
-          operator: OperatorType.IN,
-          values: nominalVoltages,
-          dataType: DataType.NUMBER
-        }
-      ]
-    };
-    rules.push(nominalVoltagesRule);
-  } else if (nominalVoltages?.length && EQUIPMENTS_WITH_THREE_NOMINAL_VOLTAGES.includes(equipmentType)) {
-    const nominalVoltagesRule = {
-      combinator: CombinatorType.OR,
-      dataType: DataType.COMBINATOR,
-      rules: [
-        {
-          field: FieldType.NOMINAL_VOLTAGE_1,
-          operator: OperatorType.IN,
-          values: nominalVoltages,
-          dataType: DataType.NUMBER
-        },
-        {
-          field: FieldType.NOMINAL_VOLTAGE_2,
-          operator: OperatorType.IN,
-          values: nominalVoltages,
-          dataType: DataType.NUMBER
-        },
-        {
-          field: FieldType.NOMINAL_VOLTAGE_3,
-          operator: OperatorType.IN,
-          values: nominalVoltages,
-          dataType: DataType.NUMBER
-        }
-      ]
-    };
-    rules.push(nominalVoltagesRule);
-  }
-  if (substationProperties) {
-    buildSubstationPropertiesRules(equipmentType, substationProperties, rules);
-  }
-  Object.entries(ids ?? {}).forEach(([eqType, values]) => {
-    if (eqType === EquipmentType.SUBSTATION) {
-      if (EQUIPMENTS_WITH_ONE_SUBSTATION.includes(equipmentType)) {
-        const idsRule = {
-          field: equipmentType === EquipmentType.SUBSTATION ? FieldType.ID : FieldType.SUBSTATION_ID,
-          operator: OperatorType.IN,
-          values,
-          dataType: DataType.STRING
-        };
-        rules.push(idsRule);
-      } else if (EQUIPMENTS_WITH_TWO_SUBSTATIONS.includes(equipmentType)) {
-        const idsRule = {
-          combinator: CombinatorType.OR,
-          dataType: DataType.COMBINATOR,
-          rules: [
-            {
-              field: FieldType.SUBSTATION_ID_1,
-              operator: OperatorType.IN,
-              values,
-              dataType: DataType.STRING
-            },
-            {
-              field: FieldType.SUBSTATION_ID_2,
-              operator: OperatorType.IN,
-              values,
-              dataType: DataType.STRING
-            }
-          ]
-        };
-        rules.push(idsRule);
-      }
-    } else if (eqType === EquipmentType.VOLTAGE_LEVEL) {
-      if (EQUIPMENTS_WITH_ONE_NOMINAL_VOLTAGE.includes(equipmentType)) {
-        const idsRule = {
-          field: equipmentType === EquipmentType.VOLTAGE_LEVEL ? FieldType.ID : FieldType.VOLTAGE_LEVEL_ID,
-          operator: OperatorType.IN,
-          values,
-          dataType: DataType.STRING
-        };
-        rules.push(idsRule);
-      } else if (EQUIPMENTS_WITH_TWO_NOMINAL_VOLTAGES.includes(equipmentType)) {
-        const idsRule = {
-          combinator: CombinatorType.OR,
-          dataType: DataType.COMBINATOR,
-          rules: [
-            {
-              field: FieldType.VOLTAGE_LEVEL_ID_1,
-              operator: OperatorType.IN,
-              values,
-              dataType: DataType.STRING
-            },
-            {
-              field: FieldType.VOLTAGE_LEVEL_ID_2,
-              operator: OperatorType.IN,
-              values,
-              dataType: DataType.STRING
-            }
-          ]
-        };
-        rules.push(idsRule);
-      } else if (EQUIPMENTS_WITH_THREE_NOMINAL_VOLTAGES.includes(equipmentType)) {
-        const idsRule = {
-          combinator: CombinatorType.OR,
-          dataType: DataType.COMBINATOR,
-          rules: [
-            {
-              field: FieldType.VOLTAGE_LEVEL_ID_1,
-              operator: OperatorType.IN,
-              values,
-              dataType: DataType.STRING
-            },
-            {
-              field: FieldType.VOLTAGE_LEVEL_ID_2,
-              operator: OperatorType.IN,
-              values,
-              dataType: DataType.STRING
-            },
-            {
-              field: FieldType.VOLTAGE_LEVEL_ID_3,
-              operator: OperatorType.IN,
-              values,
-              dataType: DataType.STRING
-            }
-          ]
-        };
-        rules.push(idsRule);
-      }
-    } else {
-      const idsRule = {
-        field: FieldType.ID,
-        operator: OperatorType.IN,
-        values,
-        dataType: DataType.STRING
-      };
-      rules.push(idsRule);
-    }
-  });
-  return {
-    combinator: CombinatorType.AND,
-    dataType: DataType.COMBINATOR,
-    rules
-  };
-};
-const buildExpertFilter = (equipmentType, voltageLevelIds, countries, nominalVoltages, substationProperties, ids) => {
-  return {
-    ...getTopologyKindIfNecessary(equipmentType),
-    // for optimizing 'search bus' in filter-server
-    type: FilterType.EXPERT.id,
-    equipmentType,
-    rules: buildExpertRules(equipmentType, voltageLevelIds, countries, nominalVoltages, substationProperties, ids)
-  };
-};
-const NOMINAL_VOLTAGE_UNIT = "kV";
-export {
-  CURVE_EQUIPMENT_TYPES,
-  NOMINAL_VOLTAGE_UNIT,
-  buildExpertFilter,
-  buildExpertRules,
-  getReferencedEquipmentTypeForModel,
-  getTopologyKindIfNecessary
-};

package/dist/components/parameters/dynamic-simulation/curve/dialog/curve-selector.d.ts

@@ -1,16 +0,0 @@
-import { VoltageLevelInfos } from '../../../../../utils/types/equipmentType';
-import { ModelVariable } from '../common/curve.type';
-import { DynamicSimulationModelInfos } from '../../../../../utils/types/dynamic-simulation.type';
-import { ExpertFilter, IdentifiableAttributes } from '../../../../filter/filter.type';
-export type CurveSelectorApi = {
-    getSelectedEquipments: () => IdentifiableAttributes[];
-    getSelectedVariables: () => ModelVariable[];
-};
-type CurveSelectorProps = {
-    voltageLevelsFetcher?: () => Promise<VoltageLevelInfos[]>;
-    countriesFetcher?: () => Promise<string[]>;
-    evaluateFilterFetcher?: (filter: ExpertFilter) => Promise<IdentifiableAttributes[]>;
-    modelsFetcher?: () => Promise<DynamicSimulationModelInfos[]> | undefined;
-};
-declare const CurveSelector: import('react').ForwardRefExoticComponent<Readonly<CurveSelectorProps> & import('react').RefAttributes<CurveSelectorApi>>;
-export default CurveSelector;

package/dist/components/parameters/dynamic-simulation/curve/dialog/equipment-filter.d.ts

@@ -1,14 +0,0 @@
-import { EquipmentType, VoltageLevelInfos } from '../../../../../utils/types/equipmentType';
-import { ExpertFilter, IdentifiableAttributes } from '../../../../filter';
-export type EquipmentFilterApi = {
-    getSelectedEquipments: () => IdentifiableAttributes[];
-};
-type EquipmentFilterProps = {
-    equipmentType: EquipmentType;
-    onChangeEquipmentType: (newEquipmentType: EquipmentType) => void;
-    voltageLevelsFetcher?: () => Promise<VoltageLevelInfos[]>;
-    countriesFetcher?: () => Promise<string[]>;
-    evaluateFilterFetcher?: (filter: ExpertFilter) => Promise<IdentifiableAttributes[]>;
-};
-declare const EquipmentFilter: import('react').ForwardRefExoticComponent<EquipmentFilterProps & import('react').RefAttributes<EquipmentFilterApi>>;
-export default EquipmentFilter;

package/dist/components/parameters/dynamic-simulation/curve/dialog/equipment-filter.js

@@ -1,239 +0,0 @@
-import { jsxs, Fragment, jsx } from "react/jsx-runtime";
-import { Grid, Typography, Select, MenuItem, Box } from "@mui/material";
-import { useIntl, FormattedMessage } from "react-intl";
-import { forwardRef, useState, useRef, useCallback, useEffect, useMemo, useImperativeHandle } from "react";
-import { buildExpertFilter, CURVE_EQUIPMENT_TYPES, NOMINAL_VOLTAGE_UNIT } from "./curve-selector-utils.js";
-import { AGGRID_LOCALES } from "../../../../../translations/not-intl/aggrid-locales.js";
-import { useLocalizedCountries } from "../../../../../hooks/useLocalizedCountries.js";
-import { CheckboxAutocomplete } from "../../../../ui/inputs/checkbox-autocomplete/checkbox-autocomplete.js";
-import { CustomAGGrid } from "../../../../customAGGrid/customAggrid.js";
-import "../../../../../utils/conversionUtils.js";
-import { snackWithFallback } from "../../../../../utils/error.js";
-import "../../../../../utils/types/equipmentType.js";
-import "@mui/icons-material";
-import "../../../../../utils/yupConfig.js";
-import { useSnackMessage } from "../../../../../hooks/useSnackMessage.js";
-const styles = {
-  grid: {
-    width: "100%",
-    height: "100%"
-  },
-  criteria: {
-    width: "100%",
-    height: "56px"
-  },
-  equipment: {
-    width: "100%",
-    flexGrow: 1
-  },
-  equipmentTitle: (theme) => ({
-    marginBottom: theme.spacing(1)
-  })
-};
-const EquipmentFilter = forwardRef(
-  ({
-    equipmentType: initialEquipmentType,
-    onChangeEquipmentType,
-    voltageLevelsFetcher,
-    countriesFetcher,
-    evaluateFilterFetcher
-  }, ref) => {
-    const { snackError } = useSnackMessage();
-    const [gridReady, setGridReady] = useState(false);
-    const [isFetching, setIsFetching] = useState();
-    const intl = useIntl();
-    const [equipmentRowData, setEquipmentRowData] = useState();
-    const equipmentsRef = useRef(null);
-    const [equipmentType, setEquipmentType] = useState(initialEquipmentType);
-    const handleEquipmentTypeChange = useCallback(
-      (event) => {
-        const selectedEquipmentType = event.target.value;
-        setEquipmentType(selectedEquipmentType);
-        onChangeEquipmentType(selectedEquipmentType);
-      },
-      [onChangeEquipmentType]
-    );
-    const [voltageLevelsMap, setVoltageLevelsMap] = useState(/* @__PURE__ */ new Map());
-    const [voltageLevelIds, setVoltageLevelIds] = useState([]);
-    const [selectedVoltageLevelIds, setSelectedVoltageLevelIds] = useState([]);
-    const [nominalVoltages, setNominalVoltages] = useState([]);
-    const [selectedNominalVoltages, setSelectedNominalVoltages] = useState([]);
-    const [countries, setCountries] = useState([]);
-    const [selectedCountries, setSelectedCountries] = useState([]);
-    const { translate } = useLocalizedCountries(intl.locale);
-    useEffect(() => {
-      voltageLevelsFetcher?.().then((voltageLevels) => {
-        const vlMap = /* @__PURE__ */ new Map();
-        const nvSet = /* @__PURE__ */ new Set();
-        voltageLevels.forEach((vl) => {
-          vlMap.set(vl.id, vl.name);
-          nvSet.add(vl.nominalV);
-        });
-        setVoltageLevelsMap(vlMap);
-        setNominalVoltages([...nvSet.values()].sort((nv1, nv2) => nv1 - nv2));
-        setVoltageLevelIds([...vlMap.keys()]);
-      }).catch((error) => {
-        snackWithFallback(snackError, error, { headerId: "FetchVoltageLevelsError" });
-      });
-      countriesFetcher?.().then((countryCodes) => setCountries(countryCodes)).catch((error) => {
-        snackWithFallback(snackError, error, { headerId: "FetchCountryError" });
-      });
-    }, [voltageLevelsFetcher, countriesFetcher, snackError]);
-    const expertFilter = useMemo(() => {
-      return buildExpertFilter(
-        equipmentType,
-        selectedVoltageLevelIds,
-        selectedCountries,
-        selectedNominalVoltages
-      );
-    }, [equipmentType, selectedVoltageLevelIds, selectedCountries, selectedNominalVoltages]);
-    const [selectedRowsLength, setSelectedRowsLength] = useState(0);
-    useEffect(() => {
-      let ignore = false;
-      if (gridReady && evaluateFilterFetcher) {
-        setIsFetching(true);
-        setEquipmentRowData([]);
-        setSelectedRowsLength(0);
-        evaluateFilterFetcher(expertFilter).then((equipments) => {
-          if (!ignore) {
-            setEquipmentRowData(equipments);
-          }
-        }).catch((error) => {
-          if (!ignore) {
-            snackWithFallback(snackError, error, { headerId: "FilterEvaluationError" });
-          }
-        }).finally(() => {
-          if (!ignore) {
-            setIsFetching(false);
-          }
-        });
-      }
-      return () => {
-        ignore = true;
-      };
-    }, [evaluateFilterFetcher, expertFilter, gridReady, snackError]);
-    const columnDefs = useMemo(() => {
-      return [
-        {
-          field: "id",
-          checkboxSelection: true,
-          headerCheckboxSelection: true,
-          headerCheckboxSelectionFilteredOnly: true,
-          minWidth: 80,
-          headerName: intl.formatMessage({
-            id: "DynamicSimulationCurveDynamicModelHeader"
-          })
-        }
-      ];
-    }, [intl]);
-    const defaultColDef = useMemo(() => {
-      return {
-        flex: 1,
-        minWidth: 100,
-        filter: true,
-        sortable: true,
-        resizable: true,
-        lockPinned: true,
-        wrapHeaderText: true,
-        autoHeaderHeight: true
-      };
-    }, []);
-    const onGridReady = useCallback(() => {
-      setGridReady(true);
-    }, []);
-    const handleEquipmentSelectionChanged = useCallback(() => {
-      const selectedRows = equipmentsRef.current?.api.getSelectedRows();
-      setSelectedRowsLength(selectedRows?.length ?? 0);
-    }, []);
-    useImperativeHandle(
-      ref,
-      () => ({
-        getSelectedEquipments: () => {
-          return equipmentsRef.current?.api.getSelectedRows() ?? [];
-        }
-      }),
-      []
-    );
-    return /* @__PURE__ */ jsxs(Fragment, { children: [
-      /* @__PURE__ */ jsxs(Grid, { item: true, container: true, sx: styles.criteria, children: [
-        /* @__PURE__ */ jsx(Grid, { item: true, xs: 4, children: /* @__PURE__ */ jsx(Typography, { children: /* @__PURE__ */ jsx(FormattedMessage, { id: "DynamicSimulationCurveEquipmentType" }) }) }),
-        /* @__PURE__ */ jsx(Grid, { item: true, xs: 8, children: /* @__PURE__ */ jsx(
-          Select,
-          {
-            labelId: "DynamicSimulationCurveEquipmentType",
-            value: equipmentType,
-            onChange: handleEquipmentTypeChange,
-            size: "small",
-            sx: { width: "100%" },
-            children: CURVE_EQUIPMENT_TYPES.map((type) => /* @__PURE__ */ jsx(MenuItem, { value: type, children: intl.formatMessage({ id: type }) }, type))
-          }
-        ) })
-      ] }),
-      /* @__PURE__ */ jsxs(Grid, { item: true, container: true, sx: styles.criteria, children: [
-        /* @__PURE__ */ jsx(Grid, { item: true, xs: 4, children: /* @__PURE__ */ jsx(Typography, { children: /* @__PURE__ */ jsx(FormattedMessage, { id: "DynamicSimulationCurvePost" }) }) }),
-        /* @__PURE__ */ jsx(Grid, { item: true, xs: 8, children: /* @__PURE__ */ jsx(
-          CheckboxAutocomplete,
-          {
-            id: "voltage-level",
-            virtualize: true,
-            maxSelection: 10,
-            options: voltageLevelIds,
-            value: selectedVoltageLevelIds,
-            getOptionLabel: (value) => voltageLevelsMap.get(value) ?? value,
-            onChange: setSelectedVoltageLevelIds
-          }
-        ) })
-      ] }),
-      /* @__PURE__ */ jsxs(Grid, { item: true, container: true, sx: styles.criteria, children: [
-        /* @__PURE__ */ jsx(Grid, { item: true, xs: 4, children: /* @__PURE__ */ jsx(Typography, { children: /* @__PURE__ */ jsx(FormattedMessage, { id: "DynamicSimulationCurveCountry" }) }) }),
-        /* @__PURE__ */ jsx(Grid, { item: true, xs: 8, children: /* @__PURE__ */ jsx(
-          CheckboxAutocomplete,
-          {
-            id: "country",
-            options: countries,
-            value: selectedCountries,
-            getOptionLabel: (value) => translate(value),
-            onChange: setSelectedCountries
-          }
-        ) })
-      ] }),
-      /* @__PURE__ */ jsxs(Grid, { item: true, container: true, sx: styles.criteria, children: [
-        /* @__PURE__ */ jsx(Grid, { item: true, xs: 4, children: /* @__PURE__ */ jsx(Typography, { children: /* @__PURE__ */ jsx(FormattedMessage, { id: "DynamicSimulationCurveTension" }) }) }),
-        /* @__PURE__ */ jsx(Grid, { item: true, xs: 8, children: /* @__PURE__ */ jsx(
-          CheckboxAutocomplete,
-          {
-            id: "nominal-voltage",
-            options: nominalVoltages,
-            value: selectedNominalVoltages,
-            getOptionLabel: (value) => `${value} ${NOMINAL_VOLTAGE_UNIT}`,
-            onChange: setSelectedNominalVoltages
-          }
-        ) })
-      ] }),
-      /* @__PURE__ */ jsxs(Grid, { item: true, container: true, sx: styles.equipment, direction: "column", children: [
-        /* @__PURE__ */ jsx(Grid, { item: true, children: /* @__PURE__ */ jsxs(Typography, { sx: styles.equipmentTitle, variant: "subtitle1", children: [
-          /* @__PURE__ */ jsx(FormattedMessage, { id: "DynamicSimulationCurveEquipment" }),
-          ` (${selectedRowsLength} / ${equipmentRowData?.length ?? 0})`
-        ] }) }),
-        /* @__PURE__ */ jsx(Grid, { item: true, xs: true, children: /* @__PURE__ */ jsx(Box, { sx: styles.grid, children: /* @__PURE__ */ jsx(
-          CustomAGGrid,
-          {
-            ref: equipmentsRef,
-            rowData: equipmentRowData,
-            columnDefs,
-            defaultColDef,
-            rowSelection: "multiple",
-            onGridReady,
-            onSelectionChanged: handleEquipmentSelectionChanged,
-            loading: isFetching,
-            overlayLoadingTemplate: intl.formatMessage({ id: "LoadingRemoteData" }),
-            overrideLocales: AGGRID_LOCALES
-          }
-        ) }) })
-      ] })
-    ] });
-  }
-);
-export {
-  EquipmentFilter as default
-};

package/dist/components/parameters/dynamic-simulation/dynamic-simulation-inline.d.ts

@@ -1,15 +0,0 @@
-import { UUID } from 'node:crypto';
-import { VoltageLevelInfos } from '../../../utils';
-import { UseParametersBackendReturnProps } from '../../../utils/types/parameters.type';
-import { ComputingType } from '../common';
-import { ExpertFilter, IdentifiableAttributes } from '../../filter';
-type DynamicSimulationInlineProps = {
-    studyUuid: UUID | null;
-    parametersBackend: UseParametersBackendReturnProps<ComputingType.DYNAMIC_SIMULATION>;
-    setHaveDirtyFields: (isDirty: boolean) => void;
-    voltageLevelsFetcher: () => Promise<VoltageLevelInfos[]>;
-    countriesFetcher: () => Promise<string[]>;
-    evaluateFilterFetcher: (filter: ExpertFilter) => Promise<IdentifiableAttributes[]>;
-};
-export declare function DynamicSimulationInline({ studyUuid, parametersBackend, setHaveDirtyFields, voltageLevelsFetcher, countriesFetcher, evaluateFilterFetcher, }: Readonly<DynamicSimulationInlineProps>): import("react/jsx-runtime").JSX.Element;
-export {};