@gridsuite/commons-ui 0.98.0 → 0.100.0

package/dist/components/parameters/loadflow/load-flow-parameters-utils.js

@@ -0,0 +1,158 @@
+import { LIMIT_REDUCTIONS_FORM, IST_FORM, LIMIT_DURATION_FORM } from "../common/limitreductions/columns-definitions.js";
+import { HVDC_AC_EMULATION, CONNECTED_COMPONENT_MODE, COUNTRIES_TO_BALANCE, BALANCE_TYPE, DC, PHASE_SHIFTER_REGULATION_ON, TRANSFORMER_VOLTAGE_CONTROL_ON, DC_POWER_FACTOR, DC_USE_TRANSFORMER_RATIO, SHUNT_COMPENSATOR_VOLTAGE_CONTROL_ON, DISTRIBUTED_SLACK, WRITE_SLACK_BUS, READ_SLACK_BUS, TWT_SPLIT_SHUNT_ADMITTANCE, USE_REACTIVE_LIMITS, VOLTAGE_INIT_MODE, COMMON_PARAMETERS, SPECIFIC_PARAMETERS, PARAM_PROVIDER_OPENLOADFLOW, PARAM_LIMIT_REDUCTION, DEFAULT_LIMIT_REDUCTION_VALUE } from "./constants.js";
+import { toFormValuesLimitReductions } from "../common/limitreductions/limit-reductions-form-util.js";
+import "../../../utils/yupConfig.js";
+import { ParameterType } from "../../../utils/types/parameters.type.js";
+import "react/jsx-runtime";
+import "react-intl";
+import "@mui/material";
+import { NAME, DESCRIPTION_INPUT } from "../../inputs/reactHookForm/DirectoryItemsInput.js";
+import "react-hook-form";
+import "../../inputs/reactHookForm/agGridTable/BottomRightButtons.js";
+import "react";
+import "../../customAGGrid/customAggrid.js";
+import "ag-grid-community";
+import "react-papaparse";
+import "react-csv-downloader";
+import * as yup from "yup";
+import "../../inputs/reactHookForm/provider/CustomFormProvider.js";
+import "@mui/icons-material";
+import "../../inputs/reactHookForm/numbers/RangeInput.js";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import "../../../utils/conversionUtils.js";
+import "../../../utils/types/equipmentType.js";
+import "notistack";
+import "@react-querybuilder/material";
+import "../../filter/expert/expertFilterConstants.js";
+import "../../inputs/reactQueryBuilder/CustomReactQueryBuilder.js";
+import "uuid";
+import "../../inputs/reactQueryBuilder/PropertyValueEditor.js";
+import "react-querybuilder";
+var TabValues = /* @__PURE__ */ ((TabValues2) => {
+  TabValues2["GENERAL"] = "General";
+  TabValues2["LIMIT_REDUCTIONS"] = "LimitReductions";
+  return TabValues2;
+})(TabValues || {});
+const getBasicLoadFlowParametersFormSchema = () => {
+  return yup.object().shape({
+    [TRANSFORMER_VOLTAGE_CONTROL_ON]: yup.boolean().required(),
+    [PHASE_SHIFTER_REGULATION_ON]: yup.boolean().required(),
+    [DC]: yup.boolean().required(),
+    [BALANCE_TYPE]: yup.string().required(),
+    [COUNTRIES_TO_BALANCE]: yup.array().of(yup.string()).required(),
+    [CONNECTED_COMPONENT_MODE]: yup.string().required(),
+    [HVDC_AC_EMULATION]: yup.boolean().required()
+  });
+};
+const getAdvancedLoadFlowParametersFormSchema = () => {
+  return yup.object().shape({
+    [VOLTAGE_INIT_MODE]: yup.string().required(),
+    [USE_REACTIVE_LIMITS]: yup.boolean().required(),
+    [TWT_SPLIT_SHUNT_ADMITTANCE]: yup.boolean().required(),
+    [READ_SLACK_BUS]: yup.boolean().required(),
+    [WRITE_SLACK_BUS]: yup.boolean().required(),
+    [DISTRIBUTED_SLACK]: yup.boolean().required(),
+    [SHUNT_COMPENSATOR_VOLTAGE_CONTROL_ON]: yup.boolean().required(),
+    [DC_USE_TRANSFORMER_RATIO]: yup.boolean().required(),
+    [DC_POWER_FACTOR]: yup.number().required().positive("dcPowerFactorGreaterThan0").max(1, "dcPowerFactorLessOrEqualThan1")
+  });
+};
+const getDialogLoadFlowParametersFormSchema = (name) => {
+  const shape = {};
+  if (name) {
+    shape[NAME] = yup.string().required();
+    shape[DESCRIPTION_INPUT] = yup.string();
+  }
+  return shape;
+};
+const getCommonLoadFlowParametersFormSchema = () => {
+  return yup.object().shape({
+    [COMMON_PARAMETERS]: yup.object().shape({
+      ...getBasicLoadFlowParametersFormSchema().fields,
+      ...getAdvancedLoadFlowParametersFormSchema().fields
+    })
+  });
+};
+const getSpecificLoadFlowParametersFormSchema = (specificParameters) => {
+  const shape = {};
+  specificParameters == null ? void 0 : specificParameters.forEach((param) => {
+    switch (param.type) {
+      case ParameterType.STRING:
+        shape[param.name] = yup.string().required();
+        break;
+      case ParameterType.DOUBLE:
+        shape[param.name] = yup.number().required();
+        break;
+      case ParameterType.INTEGER:
+        shape[param.name] = yup.number().required();
+        break;
+      case ParameterType.BOOLEAN:
+        shape[param.name] = yup.boolean().required();
+        break;
+      case ParameterType.STRING_LIST:
+        shape[param.name] = yup.array().of(yup.string()).required();
+        break;
+      default:
+        shape[param.name] = yup.mixed().required();
+    }
+  });
+  return yup.object().shape({
+    [SPECIFIC_PARAMETERS]: yup.object().shape(shape)
+  });
+};
+const getDefaultSpecificParamsValues = (specificParams) => {
+  return specificParams == null ? void 0 : specificParams.reduce((acc, param) => {
+    if (param.type === ParameterType.STRING_LIST && param.defaultValue === null) {
+      acc[param.name] = [];
+    } else if ((param.type === ParameterType.DOUBLE || param.type === ParameterType.INTEGER) && Number.isNaN(Number(param.defaultValue))) {
+      acc[param.name] = 0;
+    } else {
+      acc[param.name] = param.defaultValue;
+    }
+    return acc;
+  }, {});
+};
+const setSpecificParameters = (provider, specificParamsDescriptions, formMethods) => {
+  const specificParams = provider ? (specificParamsDescriptions == null ? void 0 : specificParamsDescriptions[provider]) ?? [] : [];
+  const specificParamsValues = getDefaultSpecificParamsValues(specificParams);
+  formMethods.setValue(SPECIFIC_PARAMETERS, specificParamsValues);
+};
+const setLimitReductions = (provider, defaultLimitReductions, formMethods) => {
+  if (provider === PARAM_PROVIDER_OPENLOADFLOW) {
+    formMethods.setValue(
+      LIMIT_REDUCTIONS_FORM,
+      toFormValuesLimitReductions(defaultLimitReductions)[LIMIT_REDUCTIONS_FORM]
+    );
+    formMethods.setValue(PARAM_LIMIT_REDUCTION, null);
+  } else {
+    formMethods.setValue(PARAM_LIMIT_REDUCTION, DEFAULT_LIMIT_REDUCTION_VALUE);
+    formMethods.setValue(LIMIT_REDUCTIONS_FORM, []);
+  }
+};
+const mapLimitReductions = (vlLimits, formLimits, indexVl) => {
+  const vlLNewLimits = {
+    ...vlLimits,
+    permanentLimitReduction: formLimits[indexVl][IST_FORM]
+  };
+  vlLimits.temporaryLimitReductions.forEach((temporaryLimit, index) => {
+    vlLNewLimits.temporaryLimitReductions[index] = {
+      ...temporaryLimit,
+      reduction: formLimits[indexVl][LIMIT_DURATION_FORM + index]
+    };
+  });
+  return vlLNewLimits;
+};
+export {
+  TabValues,
+  getAdvancedLoadFlowParametersFormSchema,
+  getBasicLoadFlowParametersFormSchema,
+  getCommonLoadFlowParametersFormSchema,
+  getDefaultSpecificParamsValues,
+  getDialogLoadFlowParametersFormSchema,
+  getSpecificLoadFlowParametersFormSchema,
+  mapLimitReductions,
+  setLimitReductions,
+  setSpecificParameters
+};

package/dist/components/parameters/loadflow/use-load-flow-context.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) 2025, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+export declare const useLoadFlowContext: () => import('./load-flow-parameters-context').LoadFlowContextProps;

package/dist/components/parameters/loadflow/use-load-flow-context.js

@@ -0,0 +1,12 @@
+import { useContext } from "react";
+import { LoadFlowContext } from "./load-flow-parameters-context.js";
+const useLoadFlowContext = () => {
+  const context = useContext(LoadFlowContext);
+  if (!context) {
+    throw new Error("useLoadFlowContext must be used within a LoadFlowProvider");
+  }
+  return context;
+};
+export {
+  useLoadFlowContext
+};

package/dist/components/parameters/loadflow/use-load-flow-parameters-form.d.ts

@@ -0,0 +1,32 @@
+import { FieldErrors, UseFormReturn } from 'react-hook-form';
+import { Dispatch, SetStateAction, SyntheticEvent } from 'react';
+import { ObjectSchema } from 'yup';
+import { UUID } from 'crypto';
+import { TabValues } from './load-flow-parameters-utils';
+import { LoadFlowParametersInfos } from '../../../utils/types/loadflow.type';
+import { SpecificParameterInfos, UseParametersBackendReturnProps } from '../../../utils/types/parameters.type';
+import { ComputingType } from '../common';
+import { ILimitReductionsByVoltageLevel } from '../common/limitreductions/columns-definitions';
+export interface UseLoadFlowParametersFormReturn {
+    formMethods: UseFormReturn;
+    formSchema: ObjectSchema<any>;
+    selectedTab: TabValues;
+    handleTabChange: (event: SyntheticEvent, newValue: TabValues) => void;
+    tabIndexesWithError: TabValues[];
+    formattedProviders: {
+        id: string;
+        label: string;
+    }[];
+    specificParameters: SpecificParameterInfos[];
+    defaultLimitReductions: ILimitReductionsByVoltageLevel[];
+    toLoadFlowFormValues: (_params: LoadFlowParametersInfos) => any;
+    formatNewParams: (formData: Record<string, any>) => LoadFlowParametersInfos;
+    params: LoadFlowParametersInfos | null;
+    currentProvider: string | undefined;
+    setCurrentProvider: Dispatch<SetStateAction<string | undefined>>;
+    paramsLoaded: boolean;
+    onValidationError: (errors: FieldErrors) => void;
+    onSaveInline: (formData: Record<string, any>) => void;
+    onSaveDialog: (formData: Record<string, any>) => void;
+}
+export declare const useLoadFlowParametersForm: (parametersBackend: UseParametersBackendReturnProps<ComputingType.LOAD_FLOW>, enableDeveloperMode: boolean, parametersUuid: UUID | null, name: string | null, description: string | null) => UseLoadFlowParametersFormReturn;

package/dist/components/parameters/loadflow/use-load-flow-parameters-form.js

@@ -0,0 +1,263 @@
+import { useForm } from "react-hook-form";
+import { yupResolver } from "@hookform/resolvers/yup";
+import { useState, useCallback, useMemo, useEffect } from "react";
+import { TabValues, getDefaultSpecificParamsValues, getSpecificLoadFlowParametersFormSchema, getCommonLoadFlowParametersFormSchema, getDialogLoadFlowParametersFormSchema, mapLimitReductions, setSpecificParameters, setLimitReductions } from "./load-flow-parameters-utils.js";
+import { ParameterType } from "../../../utils/types/parameters.type.js";
+import { PROVIDER } from "../common/constant.js";
+import "react/jsx-runtime";
+import "@mui/material";
+import "react-intl";
+import "../../../utils/types/equipmentType.js";
+import { updateParameter } from "../../../services/explore.js";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import "notistack";
+import "../../inputs/reactHookForm/provider/CustomFormProvider.js";
+import "../../dialogs/descriptionModificationDialog/DescriptionModificationDialog.js";
+import "../../dialogs/elementSaveDialog/ElementSaveDialog.js";
+import "@mui/icons-material";
+import { ElementType } from "../../../utils/types/elementType.js";
+import "../../treeViewFinder/TreeViewFinder.js";
+import { DESCRIPTION_INPUT, NAME } from "../../inputs/reactHookForm/DirectoryItemsInput.js";
+import "../../inputs/reactHookForm/agGridTable/BottomRightButtons.js";
+import "../../customAGGrid/customAggrid.js";
+import "ag-grid-community";
+import "react-papaparse";
+import "react-csv-downloader";
+import * as yup from "yup";
+import "../../inputs/reactHookForm/numbers/RangeInput.js";
+import "../../../utils/conversionUtils.js";
+import "../../../utils/yupConfig.js";
+import "@react-querybuilder/material";
+import "../../filter/expert/expertFilterConstants.js";
+import "../../inputs/reactQueryBuilder/CustomReactQueryBuilder.js";
+import "uuid";
+import "../../inputs/reactQueryBuilder/PropertyValueEditor.js";
+import "react-querybuilder";
+import "../common/widget/parameter-line-slider.js";
+import { getLimitReductionsFormSchema, LIMIT_REDUCTIONS_FORM } from "../common/limitreductions/columns-definitions.js";
+import { toFormValuesLimitReductions } from "../common/limitreductions/limit-reductions-form-util.js";
+import { PARAM_LIMIT_REDUCTION, SPECIFIC_PARAMETERS, COMMON_PARAMETERS, PARAM_PROVIDER_OPENLOADFLOW } from "./constants.js";
+const useLoadFlowParametersForm = (parametersBackend, enableDeveloperMode, parametersUuid, name, description) => {
+  const [
+    providers,
+    provider,
+    ,
+    ,
+    ,
+    params,
+    ,
+    updateParameters,
+    ,
+    specificParamsDescriptions,
+    defaultLimitReductions
+  ] = parametersBackend;
+  const [currentProvider, setCurrentProvider] = useState(params == null ? void 0 : params.provider);
+  const [selectedTab, setSelectedTab] = useState(TabValues.GENERAL);
+  const [tabIndexesWithError, setTabIndexesWithError] = useState([]);
+  const handleTabChange = useCallback((event, newValue) => {
+    setSelectedTab(newValue);
+  }, []);
+  const specificParametersValues = useMemo(() => {
+    const specificParams = currentProvider ? specificParamsDescriptions == null ? void 0 : specificParamsDescriptions[currentProvider] : void 0;
+    return getDefaultSpecificParamsValues(specificParams);
+  }, [currentProvider, specificParamsDescriptions]);
+  const specificParameters = useMemo(() => {
+    const specificParams = currentProvider ? specificParamsDescriptions == null ? void 0 : specificParamsDescriptions[currentProvider] : void 0;
+    return specificParams == null ? void 0 : specificParams.map((param) => ({
+      name: param.name,
+      type: param.type,
+      label: param.label,
+      description: param.description,
+      possibleValues: param.possibleValues,
+      defaultValue: param.defaultValue
+    }));
+  }, [currentProvider, specificParamsDescriptions]);
+  const formSchema = useMemo(() => {
+    var _a;
+    return yup.object({
+      ...getDialogLoadFlowParametersFormSchema(name),
+      [PROVIDER]: yup.string().required(),
+      [PARAM_LIMIT_REDUCTION]: yup.number().nullable(),
+      ...getCommonLoadFlowParametersFormSchema().fields,
+      ...getLimitReductionsFormSchema(
+        (params == null ? void 0 : params.limitReductions) ? (_a = params.limitReductions[0]) == null ? void 0 : _a.temporaryLimitReductions.length : 0
+      ).fields,
+      ...getSpecificLoadFlowParametersFormSchema(specificParameters).fields
+    });
+  }, [name, params == null ? void 0 : params.limitReductions, specificParameters]);
+  const formMethods = useForm({
+    defaultValues: {
+      [NAME]: name,
+      [DESCRIPTION_INPUT]: description,
+      [PROVIDER]: provider,
+      [PARAM_LIMIT_REDUCTION]: null,
+      [COMMON_PARAMETERS]: {
+        ...params == null ? void 0 : params.commonParameters
+      },
+      [SPECIFIC_PARAMETERS]: {
+        ...specificParametersValues
+      },
+      [LIMIT_REDUCTIONS_FORM]: []
+    },
+    resolver: yupResolver(formSchema)
+  });
+  const { watch, reset } = formMethods;
+  const watchProvider = watch("provider");
+  const toLimitReductions = useCallback(
+    (formLimits) => {
+      if ((formLimits == null ? void 0 : formLimits.length) === 0) {
+        return [];
+      }
+      if (watchProvider === PARAM_PROVIDER_OPENLOADFLOW) {
+        if (!(params == null ? void 0 : params.limitReductions)) {
+          return defaultLimitReductions.map(
+            (vlLimits, indexVl) => mapLimitReductions(vlLimits, formLimits, indexVl)
+          );
+        }
+        return params == null ? void 0 : params.limitReductions.map(
+          (vlLimits, indexVl) => mapLimitReductions(vlLimits, formLimits, indexVl)
+        );
+      }
+      return [];
+    },
+    [defaultLimitReductions, params == null ? void 0 : params.limitReductions, watchProvider]
+  );
+  const getSpecificParametersPerProvider = (formData, _specificParametersValues) => {
+    return Object.keys(formData[SPECIFIC_PARAMETERS]).reduce(
+      (acc, key) => {
+        if (_specificParametersValues[key].toString() !== formData[SPECIFIC_PARAMETERS][key].toString()) {
+          acc[key] = formData[SPECIFIC_PARAMETERS][key].toString();
+        }
+        return acc;
+      },
+      {}
+    );
+  };
+  const formatNewParams = useCallback(
+    (formData) => {
+      return {
+        provider: formData[PROVIDER],
+        limitReduction: formData[PARAM_LIMIT_REDUCTION],
+        commonParameters: {
+          ...formData[COMMON_PARAMETERS]
+        },
+        specificParametersPerProvider: {
+          [formData.provider]: getSpecificParametersPerProvider(formData, specificParametersValues)
+        },
+        limitReductions: toLimitReductions(formData[LIMIT_REDUCTIONS_FORM])
+      };
+    },
+    [specificParametersValues, toLimitReductions]
+  );
+  const toLoadFlowFormValues = useCallback(
+    (_params) => {
+      const specificParams = _params.provider ? specificParamsDescriptions == null ? void 0 : specificParamsDescriptions[_params.provider] : void 0;
+      const specificParamsPerProvider = _params.specificParametersPerProvider[_params.provider];
+      const formatted = specificParams == null ? void 0 : specificParams.reduce((acc, param) => {
+        if (specificParamsPerProvider && Object.prototype.hasOwnProperty.call(specificParamsPerProvider, param.name)) {
+          if (param.type === ParameterType.BOOLEAN) {
+            acc[param.name] = specificParamsPerProvider[param.name] === "true";
+          } else if (param.type === ParameterType.STRING_LIST) {
+            acc[param.name] = specificParamsPerProvider[param.name] !== "" ? specificParamsPerProvider[param.name].split(",") : [];
+          } else {
+            acc[param.name] = specificParamsPerProvider[param.name];
+          }
+        } else {
+          acc[param.name] = getDefaultSpecificParamsValues([param])[param.name];
+        }
+        return acc;
+      }, {});
+      return {
+        [PROVIDER]: _params.provider,
+        [PARAM_LIMIT_REDUCTION]: _params.limitReduction,
+        [COMMON_PARAMETERS]: {
+          ..._params.commonParameters
+        },
+        [SPECIFIC_PARAMETERS]: {
+          ...formatted
+        },
+        ...toFormValuesLimitReductions(_params.limitReductions)
+      };
+    },
+    [specificParamsDescriptions]
+  );
+  const paramsLoaded = useMemo(() => !!params && !!currentProvider, [currentProvider, params]);
+  const formattedProviders = useMemo(() => {
+    return Object.entries(providers).filter(([key]) => !key.includes("DynaFlow") || enableDeveloperMode).map(([key, value]) => ({
+      id: key,
+      label: value
+    }));
+  }, [providers, enableDeveloperMode]);
+  const onValidationError = useCallback(
+    (errors) => {
+      const tabsInError = [];
+      if ((errors == null ? void 0 : errors[LIMIT_REDUCTIONS_FORM]) && TabValues.LIMIT_REDUCTIONS !== selectedTab) {
+        tabsInError.push(TabValues.LIMIT_REDUCTIONS);
+      }
+      if (((errors == null ? void 0 : errors[SPECIFIC_PARAMETERS]) || (errors == null ? void 0 : errors[COMMON_PARAMETERS]) || (errors == null ? void 0 : errors[PROVIDER])) && TabValues.GENERAL !== selectedTab) {
+        tabsInError.push(TabValues.GENERAL);
+      }
+      setTabIndexesWithError(tabsInError);
+    },
+    [selectedTab]
+  );
+  const onSaveInline = useCallback(
+    (formData) => {
+      setTabIndexesWithError([]);
+      updateParameters(formatNewParams(formData));
+    },
+    [updateParameters, formatNewParams]
+  );
+  const onSaveDialog = useCallback(
+    (formData) => {
+      if (parametersUuid) {
+        setTabIndexesWithError([]);
+        updateParameter(
+          parametersUuid,
+          formatNewParams(formData),
+          formData[NAME],
+          ElementType.LOADFLOW_PARAMETERS,
+          formData[DESCRIPTION_INPUT] ?? ""
+        );
+      }
+    },
+    [parametersUuid, formatNewParams]
+  );
+  useEffect(() => {
+    if (!params) {
+      return;
+    }
+    reset(toLoadFlowFormValues(params));
+  }, [paramsLoaded, params, reset, specificParamsDescriptions, toLoadFlowFormValues]);
+  useEffect(() => {
+    if (watchProvider !== currentProvider) {
+      setCurrentProvider(watchProvider);
+      setSpecificParameters(watchProvider, specificParamsDescriptions, formMethods);
+      setLimitReductions(watchProvider, defaultLimitReductions, formMethods);
+    }
+  }, [currentProvider, defaultLimitReductions, formMethods, specificParamsDescriptions, watchProvider]);
+  return {
+    formMethods,
+    formSchema,
+    selectedTab,
+    handleTabChange,
+    tabIndexesWithError,
+    formattedProviders,
+    specificParameters,
+    defaultLimitReductions,
+    toLoadFlowFormValues,
+    formatNewParams,
+    params,
+    currentProvider,
+    setCurrentProvider,
+    paramsLoaded,
+    onValidationError,
+    onSaveInline,
+    onSaveDialog
+  };
+};
+export {
+  useLoadFlowParametersForm
+};

package/dist/components/parameters/parameters-style.d.ts

@@ -0,0 +1,150 @@
+import { Theme } from '@mui/material';
+/**
+ * Styles use in parameter forms
+ * @deprecated to discourage its use outside of intended components
+ */
+export declare const parametersStyles: {
+    title: (theme: Theme) => {
+        padding: string;
+    };
+    minWidthMedium: (theme: Theme) => {
+        minWidth: string;
+    };
+    parameterName: (theme: Theme) => {
+        fontWeight: string;
+        marginTop: string;
+    };
+    controlItem: {
+        justifyContent: string;
+        flexGrow: number;
+    };
+    controlParametersItem: {
+        justifyContent: string;
+        flexGrow: number;
+        height: string;
+        paddingBottom: number;
+    };
+    button: (theme: Theme) => {
+        marginBottom: string;
+        marginLeft: string;
+    };
+    subgroupParameters: (theme: Theme) => {
+        marginTop: string;
+        marginBottom: string;
+    };
+    subgroupParametersAccordion: {
+        '&:before': {
+            display: string;
+        };
+        background: string;
+    };
+    subgroupParametersAccordionSummary: (theme: Theme) => {
+        flexDirection: string;
+        '& .MuiAccordionSummary-expandIconWrapper': {
+            transform: string;
+        };
+        '& .MuiAccordionSummary-expandIconWrapper.Mui-expanded': {
+            transform: string;
+        };
+        '& .MuiAccordionSummary-content': {
+            marginLeft: string;
+        };
+    };
+    subgroupParametersAccordionDetails: (theme: Theme) => {
+        padding: string;
+    };
+    marginTopButton: {
+        marginTop: string;
+        position: string;
+        bottom: number;
+    };
+    scrollableGrid: (theme: Theme) => {
+        overflowY: string;
+        overflowX: string;
+        maxHeight: string;
+        paddingRight: string;
+        paddingTop: string;
+        paddingBottom: string;
+        flexGrow: number;
+    };
+    singleItem: (theme: Theme) => {
+        display: string;
+        flex: string;
+        alignItems: string;
+        justifyContent: string;
+        marginTop: string;
+        marginBottom: string;
+    };
+    firstTextField: (theme: Theme) => {
+        marginLeft: string;
+    };
+    secondTextField: (theme: Theme) => {
+        marginLeft: string;
+        marginRight: string;
+    };
+    singleTextField: (theme: Theme) => {
+        display: string;
+        marginRight: string;
+        marginLeft: string;
+    };
+    tooltip: (theme: Theme) => {
+        marginLeft: string;
+    };
+    text: (theme: Theme) => {
+        display: string;
+        marginBottom: string;
+        marginTop: string;
+    };
+    multipleItems: (theme: Theme) => {
+        display: string;
+        flex: string;
+        alignItems: string;
+        justifyContent: string;
+        marginTop: string;
+        marginBottom: string;
+    };
+    tabWithError: (theme: Theme) => {
+        '&.Mui-selected': {
+            color: string;
+        };
+        color: string;
+    };
+    tabWithErrorIndicator: (theme: Theme) => {
+        backgroundColor: string;
+    };
+    panel: (theme: Theme) => {
+        marginTop: string;
+        marginBottom: string;
+    };
+    adjustExistingLimitsInfo: (theme: Theme) => {
+        display: string;
+        alignItems: string;
+        marginTop: string;
+        marginBottom: string;
+    };
+    circularProgress: (theme: Theme) => {
+        marginRight: string;
+        color: string;
+    };
+    icon: (theme: Theme) => {
+        width: string;
+    };
+    modificationsTitle: (theme: Theme) => {
+        display: string;
+        alignItems: string;
+        margin: string;
+        padding: string;
+        backgroundColor: string;
+        color: string;
+        overflow: string;
+    };
+};
+export declare function getTabIndicatorStyle<T extends number | string>(tabIndexesWithError: T[], index: T): ((theme: Theme) => {
+    backgroundColor: string;
+}) | undefined;
+export declare function getTabStyle<T extends number | string>(tabIndexesWithError: T[], index: T): ((theme: Theme) => {
+    '&.Mui-selected': {
+        color: string;
+    };
+    color: string;
+}) | undefined;