@gridsuite/commons-ui 0.176.0 → 0.178.0

package/dist/components/network-modifications/voltage-level/creation/voltageLevelCreation.utils.d.ts

@@ -0,0 +1,155 @@
+import { IntlShape } from 'react-intl';
+import { InferType } from 'yup';
+import { FieldConstants } from '../../../../utils';
+import { SwitchKind, VoltageLevelCreationDto } from './voltageLevelCreation.types';
+import { Option } from '../../../../utils/types/types';
+export declare const SWITCH_TYPE: {
+    readonly BREAKER: {
+        readonly id: "BREAKER";
+        readonly label: "Breaker";
+    };
+    readonly DISCONNECTOR: {
+        readonly id: "DISCONNECTOR";
+        readonly label: "Disconnector";
+    };
+};
+export declare const buildNewBusbarSections: (equipmentId: string, sectionCount: number, busbarCount: number) => Option[];
+export declare const getCreateSwitchesValidationSchema: (id?: FieldConstants) => {
+    [x: string]: import('yup').ArraySchema<{
+        switchKind: string;
+    }[] | null | undefined, import('yup').AnyObject, "", "">;
+};
+export declare const getCreateSwitchesEmptyFormData: (sectionCount: number, id?: FieldConstants) => {
+    [x: string]: any[];
+};
+export declare const voltageLevelCreationFormSchema: import('yup').ObjectSchema<{
+    equipmentID: string;
+    equipmentName: string | null | undefined;
+    addSubstationCreationId: NonNullable<boolean | undefined>;
+    substationId: string | null | undefined;
+    substationCreationId: string | null | undefined;
+    substationName: string | null | undefined;
+    country: string | null | undefined;
+    substationCreation: {
+        AdditionalProperties?: {
+            previousValue?: string | null | undefined;
+            added: NonNullable<boolean | undefined>;
+            deletionMark: NonNullable<boolean | undefined>;
+            name: string;
+            value: string;
+        }[] | undefined;
+    };
+    hideNominalVoltage: NonNullable<boolean | undefined>;
+    nominalV: number | null | undefined;
+    lowVoltageLimit: number | null | undefined;
+    highVoltageLimit: number | null | undefined;
+    lowShortCircuitCurrentLimit: number | null | undefined;
+    highShortCircuitCurrentLimit: number | null | undefined;
+    hideBusBarSection: NonNullable<boolean | undefined>;
+    busbarCount: number | null | undefined;
+    sectionCount: number | null | undefined;
+    switchesBetweenSections: string | null | undefined;
+    switchKinds: {
+        switchKind: string;
+    }[] | undefined;
+    topologyKind: string | null | undefined;
+    couplingOmnibus: {
+        busbarSectionId1: string;
+        busbarSectionId2: string;
+    }[] | undefined;
+} & {
+    AdditionalProperties: {
+        previousValue?: string | null | undefined;
+        added: NonNullable<boolean | undefined>;
+        deletionMark: NonNullable<boolean | undefined>;
+        name: string;
+        value: string;
+    }[] | undefined;
+}, import('yup').AnyObject, {
+    equipmentID: undefined;
+    equipmentName: undefined;
+    addSubstationCreationId: undefined;
+    substationId: undefined;
+    substationCreationId: undefined;
+    substationName: undefined;
+    country: undefined;
+    substationCreation: {
+        AdditionalProperties: "";
+    };
+    hideNominalVoltage: undefined;
+    nominalV: undefined;
+    lowVoltageLimit: undefined;
+    highVoltageLimit: undefined;
+    lowShortCircuitCurrentLimit: undefined;
+    highShortCircuitCurrentLimit: undefined;
+    hideBusBarSection: undefined;
+    busbarCount: undefined;
+    sectionCount: undefined;
+    switchesBetweenSections: undefined;
+    switchKinds: "";
+    topologyKind: undefined;
+    couplingOmnibus: "";
+    AdditionalProperties: "";
+}, "">;
+export type VoltageLevelCreationFormData = InferType<typeof voltageLevelCreationFormSchema>;
+export declare const voltageLevelCreationEmptyFormData: {
+    equipmentID: string;
+    equipmentName: string;
+    addSubstationCreationId: false;
+    substationId: null;
+    substationCreationId: null;
+    substationName: null;
+    country: null;
+    substationCreation: {
+        AdditionalProperties?: {
+            previousValue?: string | null | undefined;
+            added: NonNullable<boolean | undefined>;
+            deletionMark: NonNullable<boolean | undefined>;
+            name: string;
+            value: string;
+        }[] | undefined;
+        country?: string | null | undefined;
+        equipmentName?: string | null | undefined;
+        equipmentID: string;
+    };
+    hideNominalVoltage: false;
+    nominalV: null;
+    lowVoltageLimit: null;
+    highVoltageLimit: null;
+    lowShortCircuitCurrentLimit: null;
+    highShortCircuitCurrentLimit: null;
+    hideBusBarSection: false;
+    busbarCount: number;
+    sectionCount: number;
+    switchesBetweenSections: string;
+    switchKinds: never[];
+    couplingOmnibus: never[];
+    AdditionalProperties: never[];
+};
+export declare const voltageLevelCreationFormToDto: (voltageLevelForm: VoltageLevelCreationFormData) => VoltageLevelCreationDto;
+export declare const translateSwitchKinds: (switchKinds: SwitchKind[] | null, intl?: IntlShape) => string;
+export declare const voltageLevelCreationDtoToForm: (voltageLevelDto: VoltageLevelCreationDto, intl?: IntlShape, includePreviousValue?: boolean) => {
+    AdditionalProperties?: import('../..').Property[];
+    equipmentID: string;
+    equipmentName: string;
+    substationId: string | null;
+    nominalV: number | null;
+    lowVoltageLimit: number | null;
+    highVoltageLimit: number | null;
+    lowShortCircuitCurrentLimit: any;
+    highShortCircuitCurrentLimit: any;
+    busbarCount: number;
+    sectionCount: number;
+    switchesBetweenSections: string;
+    couplingOmnibus: import('./voltageLevelCreation.types').CouplingDevice[];
+    switchKinds: {
+        switchKind: SwitchKind;
+    }[];
+    addSubstationCreationId: boolean;
+    substationCreationId: string | null;
+    substationName: string | null;
+    country: string | null;
+    substationCreation: import('../..').Properties;
+    hideNominalVoltage: boolean;
+    hideBusBarSection: boolean;
+};

package/dist/components/network-modifications/voltage-level/creation/voltageLevelCreation.utils.js

@@ -0,0 +1,248 @@
+import { object, array, string, number, boolean, ref } from "yup";
+import { creationPropertiesSchema, toModificationProperties, getPropertiesFromModification, emptyProperties } from "../../common/properties/propertyUtils.js";
+import { FieldConstants } from "../../../../utils/constants/fieldConstants.js";
+import { YUP_REQUIRED } from "../../../../utils/constants/translationKeys.js";
+import { convertOutputValue, convertInputValue } from "../../../../utils/conversionUtils.js";
+import "../../../../utils/types/equipmentType.js";
+import { MODIFICATION_TYPES } from "../../../../utils/types/modificationType.js";
+import { FieldType } from "../../../../utils/types/fieldType.js";
+import "react/jsx-runtime";
+import "@mui/icons-material";
+import { sanitizeString } from "../../../../utils/ts-utils.js";
+import "../../../../utils/yupConfig.js";
+import "@mui/material";
+import "react-intl";
+import "../../../overflowableText/OverflowableText.js";
+import "react";
+import "react-hook-form";
+import "localized-countries";
+import "localized-countries/data/fr";
+import "localized-countries/data/en";
+import "notistack";
+import "../../../inputs/reactHookForm/provider/CustomFormProvider.js";
+import "../../../treeViewFinder/TreeViewFinder.js";
+import "../../../inputs/reactHookForm/agGridTable/BottomRightButtons.js";
+import "../../../customAGGrid/customAggrid.js";
+import "ag-grid-community";
+import "react-papaparse";
+import "react-csv-downloader";
+import "../../../inputs/reactHookForm/numbers/RangeInput.js";
+import "@material-symbols/svg-400/outlined/left_panel_open.svg?react";
+import "@material-symbols/svg-400/outlined/arrows_output.svg?react";
+import "@material-symbols/svg-400/outlined/left_panel_close.svg?react";
+import "@material-symbols/svg-400/outlined/add_notes.svg?react";
+import "../../../dialogs/descriptionModificationDialog/DescriptionModificationDialog.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 { substationCreationEmptyFormData } from "../../substation/creation/substationCreation.utils.js";
+import "../../substation/modification/substationModification.utils.js";
+const SWITCH_TYPE = {
+  BREAKER: { id: "BREAKER", label: "Breaker" },
+  DISCONNECTOR: { id: "DISCONNECTOR", label: "Disconnector" }
+};
+const buildNewBusbarSections = (equipmentId, sectionCount, busbarCount) => {
+  const newBusbarSections = [];
+  for (let i = 0; i < busbarCount; i++) {
+    for (let j = 0; j < sectionCount; j++) {
+      newBusbarSections.push({
+        id: `${equipmentId}_${i + 1}_${j + 1}`,
+        label: ""
+      });
+    }
+  }
+  return newBusbarSections;
+};
+const getCreateSwitchesValidationSchema = (id = FieldConstants.SWITCH_KINDS) => {
+  return {
+    [id]: array().nullable().of(
+      object().shape({
+        [FieldConstants.SWITCH_KIND]: string().nullable().required(YUP_REQUIRED)
+      })
+    )
+  };
+};
+const getCreateSwitchesEmptyFormData = (sectionCount, id = FieldConstants.SWITCH_KINDS) => ({
+  [id]: new Array(sectionCount - 1).fill({ [FieldConstants.SWITCH_KIND]: "" })
+});
+const voltageLevelCreationFormSchema = object().shape({
+  [FieldConstants.EQUIPMENT_ID]: string().required(YUP_REQUIRED).when([FieldConstants.ADD_SUBSTATION_CREATION], {
+    is: (addSubstationCreation) => !addSubstationCreation,
+    then: (schema) => schema.notOneOf(
+      [ref(FieldConstants.SUBSTATION_ID), null],
+      "CreateSubstationInVoltageLevelIdenticalId"
+    )
+  }).when([FieldConstants.ADD_SUBSTATION_CREATION], {
+    is: (addSubstationCreation) => addSubstationCreation,
+    then: (schema) => schema.notOneOf(
+      [ref(FieldConstants.SUBSTATION_CREATION_ID), null],
+      "CreateSubstationInVoltageLevelIdenticalId"
+    )
+  }),
+  [FieldConstants.EQUIPMENT_NAME]: string().nullable(),
+  [FieldConstants.ADD_SUBSTATION_CREATION]: boolean().required(YUP_REQUIRED),
+  [FieldConstants.SUBSTATION_ID]: string().nullable().when([FieldConstants.ADD_SUBSTATION_CREATION], {
+    is: (addSubstationCreation) => !addSubstationCreation,
+    then: (schema) => schema.required(YUP_REQUIRED).notOneOf(
+      [ref(FieldConstants.EQUIPMENT_ID), null],
+      "CreateSubstationInVoltageLevelIdenticalId"
+    )
+  }),
+  [FieldConstants.SUBSTATION_CREATION_ID]: string().nullable().when([FieldConstants.ADD_SUBSTATION_CREATION], {
+    is: (addSubstationCreation) => addSubstationCreation,
+    then: (schema) => schema.required(YUP_REQUIRED).notOneOf(
+      [ref(FieldConstants.EQUIPMENT_ID), null],
+      "CreateSubstationInVoltageLevelIdenticalId"
+    )
+  }),
+  [FieldConstants.SUBSTATION_NAME]: string().nullable(),
+  [FieldConstants.COUNTRY]: string().nullable(),
+  [FieldConstants.SUBSTATION_CREATION]: creationPropertiesSchema,
+  [FieldConstants.HIDE_NOMINAL_VOLTAGE]: boolean().required(YUP_REQUIRED),
+  [FieldConstants.NOMINAL_V]: number().nullable().when([FieldConstants.HIDE_NOMINAL_VOLTAGE], {
+    is: (hideNominalVoltage) => !hideNominalVoltage,
+    then: (schema) => schema.min(0, "mustBeGreaterOrEqualToZero").required(YUP_REQUIRED)
+  }),
+  [FieldConstants.LOW_VOLTAGE_LIMIT]: number().nullable().min(0, "mustBeGreaterOrEqualToZero").max(ref(FieldConstants.HIGH_VOLTAGE_LIMIT), "voltageLevelNominalVoltageMaxValueError"),
+  [FieldConstants.HIGH_VOLTAGE_LIMIT]: number().nullable().min(0, "mustBeGreaterOrEqualToZero"),
+  [FieldConstants.LOW_SHORT_CIRCUIT_CURRENT_LIMIT]: number().nullable().min(0, "ShortCircuitCurrentLimitMustBeGreaterOrEqualToZero").max(ref(FieldConstants.HIGH_SHORT_CIRCUIT_CURRENT_LIMIT), "ShortCircuitCurrentLimitMinMaxError"),
+  [FieldConstants.HIGH_SHORT_CIRCUIT_CURRENT_LIMIT]: number().nullable().min(0, "ShortCircuitCurrentLimitMustBeGreaterOrEqualToZero").when([FieldConstants.LOW_SHORT_CIRCUIT_CURRENT_LIMIT], {
+    is: (lowShortCircuitCurrentLimit) => lowShortCircuitCurrentLimit != null,
+    then: (schema) => schema.required(YUP_REQUIRED)
+  }),
+  [FieldConstants.HIDE_BUS_BAR_SECTION]: boolean().required(YUP_REQUIRED),
+  [FieldConstants.BUS_BAR_COUNT]: number().nullable().when([FieldConstants.HIDE_BUS_BAR_SECTION], {
+    is: (hideBusBarSection) => !hideBusBarSection,
+    then: (schema) => schema.min(1, "BusBarCountMustBeGreaterThanOrEqualToOne").required(YUP_REQUIRED)
+  }),
+  [FieldConstants.SECTION_COUNT]: number().nullable().when([FieldConstants.HIDE_BUS_BAR_SECTION], {
+    is: (hideBusBarSection) => !hideBusBarSection,
+    then: (schema) => schema.min(1, "SectionCountMustBeGreaterThanOrEqualToOne").required(YUP_REQUIRED)
+  }),
+  [FieldConstants.SWITCHES_BETWEEN_SECTIONS]: string().nullable().when([FieldConstants.SECTION_COUNT], {
+    is: (sectionCount) => sectionCount > 1,
+    then: (schema) => schema.required(YUP_REQUIRED)
+  }),
+  [FieldConstants.SWITCH_KINDS]: array().of(
+    object().shape({
+      [FieldConstants.SWITCH_KIND]: string().required(YUP_REQUIRED)
+    })
+  ),
+  [FieldConstants.TOPOLOGY_KIND]: string().nullable(),
+  [FieldConstants.COUPLING_OMNIBUS]: array().of(
+    object().shape({
+      [FieldConstants.BUS_BAR_SECTION_ID1]: string().nullable().required(YUP_REQUIRED),
+      [FieldConstants.BUS_BAR_SECTION_ID2]: string().nullable().required(YUP_REQUIRED).notOneOf([ref(FieldConstants.BUS_BAR_SECTION_ID1), null], "CreateCouplingDeviceIdenticalBusBar")
+    })
+  )
+}).concat(creationPropertiesSchema);
+const voltageLevelCreationEmptyFormData = {
+  [FieldConstants.EQUIPMENT_ID]: "",
+  [FieldConstants.EQUIPMENT_NAME]: "",
+  [FieldConstants.ADD_SUBSTATION_CREATION]: false,
+  [FieldConstants.SUBSTATION_ID]: null,
+  [FieldConstants.SUBSTATION_CREATION_ID]: null,
+  [FieldConstants.SUBSTATION_NAME]: null,
+  [FieldConstants.COUNTRY]: null,
+  [FieldConstants.SUBSTATION_CREATION]: substationCreationEmptyFormData,
+  [FieldConstants.HIDE_NOMINAL_VOLTAGE]: false,
+  [FieldConstants.NOMINAL_V]: null,
+  [FieldConstants.LOW_VOLTAGE_LIMIT]: null,
+  [FieldConstants.HIGH_VOLTAGE_LIMIT]: null,
+  [FieldConstants.LOW_SHORT_CIRCUIT_CURRENT_LIMIT]: null,
+  [FieldConstants.HIGH_SHORT_CIRCUIT_CURRENT_LIMIT]: null,
+  [FieldConstants.HIDE_BUS_BAR_SECTION]: false,
+  [FieldConstants.BUS_BAR_COUNT]: 1,
+  [FieldConstants.SECTION_COUNT]: 1,
+  [FieldConstants.SWITCHES_BETWEEN_SECTIONS]: "",
+  [FieldConstants.SWITCH_KINDS]: [],
+  [FieldConstants.COUPLING_OMNIBUS]: [],
+  [FieldConstants.ADDITIONAL_PROPERTIES]: []
+};
+const voltageLevelCreationFormToDto = (voltageLevelForm) => {
+  const substationCreation = voltageLevelForm[FieldConstants.ADD_SUBSTATION_CREATION] ? {
+    type: MODIFICATION_TYPES.SUBSTATION_CREATION.type,
+    equipmentId: voltageLevelForm[FieldConstants.SUBSTATION_CREATION_ID] ?? "",
+    equipmentName: voltageLevelForm[FieldConstants.SUBSTATION_NAME] ?? null,
+    country: voltageLevelForm[FieldConstants.COUNTRY] ?? null,
+    properties: toModificationProperties(voltageLevelForm[FieldConstants.SUBSTATION_CREATION])
+  } : null;
+  return {
+    type: MODIFICATION_TYPES.VOLTAGE_LEVEL_CREATION.type,
+    equipmentId: voltageLevelForm[FieldConstants.EQUIPMENT_ID],
+    equipmentName: sanitizeString(voltageLevelForm[FieldConstants.EQUIPMENT_NAME]),
+    substationId: substationCreation ? null : voltageLevelForm[FieldConstants.SUBSTATION_ID] ?? null,
+    substationCreation,
+    nominalV: voltageLevelForm[FieldConstants.NOMINAL_V] ?? null,
+    lowVoltageLimit: voltageLevelForm[FieldConstants.LOW_VOLTAGE_LIMIT] ?? null,
+    highVoltageLimit: voltageLevelForm[FieldConstants.HIGH_VOLTAGE_LIMIT] ?? null,
+    ipMin: convertOutputValue(
+      FieldType.LOW_SHORT_CIRCUIT_CURRENT_LIMIT,
+      voltageLevelForm[FieldConstants.LOW_SHORT_CIRCUIT_CURRENT_LIMIT]
+    ),
+    ipMax: convertOutputValue(
+      FieldType.HIGH_SHORT_CIRCUIT_CURRENT_LIMIT,
+      voltageLevelForm[FieldConstants.HIGH_SHORT_CIRCUIT_CURRENT_LIMIT]
+    ),
+    busbarCount: voltageLevelForm[FieldConstants.BUS_BAR_COUNT] ?? 1,
+    sectionCount: voltageLevelForm[FieldConstants.SECTION_COUNT] ?? 1,
+    switchKinds: (voltageLevelForm[FieldConstants.SWITCH_KINDS] ?? []).map(
+      (e) => e[FieldConstants.SWITCH_KIND]
+    ),
+    couplingDevices: (voltageLevelForm[FieldConstants.COUPLING_OMNIBUS] ?? []).map((device) => ({
+      busbarSectionId1: device[FieldConstants.BUS_BAR_SECTION_ID1] ?? "",
+      busbarSectionId2: device[FieldConstants.BUS_BAR_SECTION_ID2] ?? ""
+    })),
+    properties: toModificationProperties(voltageLevelForm)
+  };
+};
+const translateSwitchKinds = (switchKinds, intl) => switchKinds?.map((kind) => intl ? intl.formatMessage({ id: kind }) : kind).join(" / ") ?? "";
+const voltageLevelCreationDtoToForm = (voltageLevelDto, intl, includePreviousValue = true) => {
+  const isSubstationCreation = voltageLevelDto.substationCreation?.equipmentId != null;
+  const substationProperties = isSubstationCreation ? getPropertiesFromModification(voltageLevelDto.substationCreation?.properties, includePreviousValue) : emptyProperties;
+  return {
+    [FieldConstants.EQUIPMENT_ID]: voltageLevelDto.equipmentId,
+    [FieldConstants.EQUIPMENT_NAME]: voltageLevelDto.equipmentName ?? "",
+    [FieldConstants.SUBSTATION_ID]: isSubstationCreation ? null : voltageLevelDto.substationId,
+    [FieldConstants.NOMINAL_V]: voltageLevelDto.nominalV,
+    [FieldConstants.LOW_VOLTAGE_LIMIT]: voltageLevelDto.lowVoltageLimit,
+    [FieldConstants.HIGH_VOLTAGE_LIMIT]: voltageLevelDto.highVoltageLimit,
+    [FieldConstants.LOW_SHORT_CIRCUIT_CURRENT_LIMIT]: convertInputValue(
+      FieldType.LOW_SHORT_CIRCUIT_CURRENT_LIMIT,
+      voltageLevelDto.ipMin
+    ),
+    [FieldConstants.HIGH_SHORT_CIRCUIT_CURRENT_LIMIT]: convertInputValue(
+      FieldType.HIGH_SHORT_CIRCUIT_CURRENT_LIMIT,
+      voltageLevelDto.ipMax
+    ),
+    [FieldConstants.BUS_BAR_COUNT]: voltageLevelDto.busbarCount ?? 1,
+    [FieldConstants.SECTION_COUNT]: voltageLevelDto.sectionCount ?? 1,
+    [FieldConstants.SWITCHES_BETWEEN_SECTIONS]: translateSwitchKinds(voltageLevelDto.switchKinds, intl),
+    [FieldConstants.COUPLING_OMNIBUS]: voltageLevelDto.couplingDevices ?? [],
+    [FieldConstants.SWITCH_KINDS]: voltageLevelDto.switchKinds?.map((switchKind) => ({
+      switchKind
+    })) ?? [],
+    [FieldConstants.ADD_SUBSTATION_CREATION]: isSubstationCreation,
+    [FieldConstants.SUBSTATION_CREATION_ID]: isSubstationCreation ? voltageLevelDto.substationCreation.equipmentId : null,
+    [FieldConstants.SUBSTATION_NAME]: isSubstationCreation ? voltageLevelDto.substationCreation.equipmentName : null,
+    [FieldConstants.COUNTRY]: isSubstationCreation ? voltageLevelDto.substationCreation.country : null,
+    [FieldConstants.SUBSTATION_CREATION]: substationProperties,
+    [FieldConstants.HIDE_NOMINAL_VOLTAGE]: false,
+    [FieldConstants.HIDE_BUS_BAR_SECTION]: false,
+    ...getPropertiesFromModification(voltageLevelDto.properties, includePreviousValue)
+  };
+};
+export {
+  SWITCH_TYPE,
+  buildNewBusbarSections,
+  getCreateSwitchesEmptyFormData,
+  getCreateSwitchesValidationSchema,
+  translateSwitchKinds,
+  voltageLevelCreationDtoToForm,
+  voltageLevelCreationEmptyFormData,
+  voltageLevelCreationFormSchema,
+  voltageLevelCreationFormToDto
+};

package/dist/components/network-modifications/voltage-level/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) 2026, 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 * from './creation';

package/dist/components/network-modifications/voltage-level/index.js

@@ -0,0 +1,24 @@
+import { CreateSwitchesDialog } from "./creation/switches-between-sections/creation/CreateSwitchesDialog.js";
+import { SwitchesBetweenSections } from "./creation/switches-between-sections/SwitchesBetweenSections.js";
+import { CouplingOmnibusForm } from "./creation/coupling-omnibus/CouplingOmnibusForm.js";
+import { CouplingOmnibusCreation } from "./creation/coupling-omnibus/CouplingOmnibusCreation.js";
+import { VoltageLevelCreationForm } from "./creation/VoltageLevelCreationForm.js";
+import { SWITCH_TYPE, buildNewBusbarSections, getCreateSwitchesEmptyFormData, getCreateSwitchesValidationSchema, translateSwitchKinds, voltageLevelCreationDtoToForm, voltageLevelCreationEmptyFormData, voltageLevelCreationFormSchema, voltageLevelCreationFormToDto } from "./creation/voltageLevelCreation.utils.js";
+import { SwitchKind } from "./creation/voltageLevelCreation.types.js";
+export {
+  CouplingOmnibusCreation,
+  CouplingOmnibusForm,
+  CreateSwitchesDialog,
+  SWITCH_TYPE,
+  SwitchKind,
+  SwitchesBetweenSections,
+  VoltageLevelCreationForm,
+  buildNewBusbarSections,
+  getCreateSwitchesEmptyFormData,
+  getCreateSwitchesValidationSchema,
+  translateSwitchKinds,
+  voltageLevelCreationDtoToForm,
+  voltageLevelCreationEmptyFormData,
+  voltageLevelCreationFormSchema,
+  voltageLevelCreationFormToDto
+};

package/dist/components/parameters/short-circuit/short-circuit-parameters-content.d.ts

@@ -1,7 +1,6 @@
 import { UseShortCircuitParametersFormReturn } from './use-short-circuit-parameters-form';
 type ShortCircuitParametersContentProps = {
     shortCircuitMethods: UseShortCircuitParametersFormReturn;
-    isDeveloperMode: boolean;
 };
-declare function ShortCircuitParametersContent({ shortCircuitMethods, isDeveloperMode, }: Readonly<ShortCircuitParametersContentProps>): import("react/jsx-runtime").JSX.Element;
+declare function ShortCircuitParametersContent({ shortCircuitMethods }: Readonly<ShortCircuitParametersContentProps>): import("react/jsx-runtime").JSX.Element;
 export default ShortCircuitParametersContent;

package/dist/components/parameters/short-circuit/short-circuit-parameters-content.js

@@ -56,10 +56,7 @@ const styles = {
     paddingLeft: 1
   }
 };
-function ShortCircuitParametersContent({
-  shortCircuitMethods,
-  isDeveloperMode
-}) {
+function ShortCircuitParametersContent({ shortCircuitMethods }) {
   const { resetAll, selectedTab, handleTabChange, tabIndexesWithError } = shortCircuitMethods;
   const watchSpecificParameters = useWatch({
     name: `${SPECIFIC_PARAMETERS}`
@@ -78,7 +75,7 @@ function ShortCircuitParametersContent({
           sx: getTabStyle(tabIndexesWithError, ShortCircuitParametersTabValues.GENERAL)
         }
       ),
-      isThereSpecificParameters && isDeveloperMode && /* @__PURE__ */ jsx(
+      isThereSpecificParameters && /* @__PURE__ */ jsx(
         Tab,
         {
           label: /* @__PURE__ */ jsx(FormattedMessage, { id: ShortCircuitParametersTabValues.STUDY_AREA }),
@@ -86,7 +83,7 @@ function ShortCircuitParametersContent({
           sx: getTabStyle(tabIndexesWithError, ShortCircuitParametersTabValues.STUDY_AREA)
         }
       ),
-      isThereSpecificParameters && isDeveloperMode && /* @__PURE__ */ jsx(
+      isThereSpecificParameters && /* @__PURE__ */ jsx(
         Tab,
         {
           label: /* @__PURE__ */ jsx(FormattedMessage, { id: ShortCircuitParametersTabValues.POWER_ELECTRONICS }),
@@ -97,7 +94,7 @@ function ShortCircuitParametersContent({
     ] }) }),
     /* @__PURE__ */ jsx(Box, { sx: styles.wrapper, children: /* @__PURE__ */ jsx(Grid, { container: true, sx: styles.container, children: /* @__PURE__ */ jsxs(Grid, { item: true, sx: styles.maxWidth, children: [
       /* @__PURE__ */ jsx(ShortCircuitGeneralTabPanel, { resetAll, value: selectedTab }),
-      isThereSpecificParameters && isDeveloperMode && /* @__PURE__ */ jsxs(Fragment, { children: [
+      isThereSpecificParameters && /* @__PURE__ */ jsxs(Fragment, { children: [
         /* @__PURE__ */ jsx(ShortCircuitStudyAreaTabPanel, { value: selectedTab }),
         /* @__PURE__ */ jsx(ShortCircuitPowerElectronicsTabPanel, { value: selectedTab })
       ] })

package/dist/components/parameters/short-circuit/short-circuit-parameters-dialog.d.ts

@@ -1,4 +1,2 @@
 import { ParametersEditionDialogProps } from '../common';
-export declare function ShortCircuitParametersEditionDialog({ id, open, onClose, titleId, name, description, activeDirectory, user, language, isDeveloperMode, }: Readonly<ParametersEditionDialogProps & {
-    isDeveloperMode: boolean;
-}>): import("react/jsx-runtime").JSX.Element;
+export declare function ShortCircuitParametersEditionDialog({ id, open, onClose, titleId, name, description, activeDirectory, user, language, }: Readonly<ParametersEditionDialogProps>): import("react/jsx-runtime").JSX.Element;

package/dist/components/parameters/short-circuit/short-circuit-parameters-dialog.js

@@ -53,8 +53,7 @@ function ShortCircuitParametersEditionDialog({
   description,
   activeDirectory,
   user,
-  language,
-  isDeveloperMode
+  language
 }) {
   const parametersBackend = useParametersBackend(user, id, ComputingType.SHORT_CIRCUIT, OptionalServicesStatus.Up, {
     backendFetchParameters: fetchShortCircuitParameters,
@@ -91,7 +90,6 @@ function ShortCircuitParametersEditionDialog({
         ShortCircuitParametersForm,
         {
           shortCircuitMethods,
-          isDeveloperMode,
           renderTitleFields: () => {
             return /* @__PURE__ */ jsx(
               NameElementEditorForm,

package/dist/components/parameters/short-circuit/short-circuit-parameters-form.d.ts

@@ -4,7 +4,6 @@ interface ShortCircuitParametersFormProps {
     shortCircuitMethods: UseShortCircuitParametersFormReturn;
     renderTitleFields?: () => ReactNode;
     renderActions?: () => ReactNode;
-    isDeveloperMode: boolean;
 }
-export declare function ShortCircuitParametersForm({ shortCircuitMethods, renderTitleFields, renderActions, isDeveloperMode, }: Readonly<ShortCircuitParametersFormProps>): import("react/jsx-runtime").JSX.Element;
+export declare function ShortCircuitParametersForm({ shortCircuitMethods, renderTitleFields, renderActions, }: Readonly<ShortCircuitParametersFormProps>): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/parameters/short-circuit/short-circuit-parameters-form.js

@@ -45,19 +45,12 @@ const styles = {
 function ShortCircuitParametersForm({
   shortCircuitMethods,
   renderTitleFields,
-  renderActions,
-  isDeveloperMode
+  renderActions
 }) {
   const { formMethods, formSchema, paramsLoaded } = shortCircuitMethods;
   return /* @__PURE__ */ jsx(CustomFormProvider, { validationSchema: formSchema, ...formMethods, removeOptional: true, children: /* @__PURE__ */ jsxs(Box, { sx: styles.shortCircuitParameters, children: [
     /* @__PURE__ */ jsx(Grid, { item: true, container: true, direction: "column", children: renderTitleFields?.() }),
-    paramsLoaded ? /* @__PURE__ */ jsx(Grid, { sx: parametersStyles.scrollableGrid, children: /* @__PURE__ */ jsx(
-      ShortCircuitParametersContent,
-      {
-        isDeveloperMode,
-        shortCircuitMethods
-      }
-    ) }) : /* @__PURE__ */ jsx(LinearProgress, {}),
+    paramsLoaded ? /* @__PURE__ */ jsx(Grid, { sx: parametersStyles.scrollableGrid, children: /* @__PURE__ */ jsx(ShortCircuitParametersContent, { shortCircuitMethods }) }) : /* @__PURE__ */ jsx(LinearProgress, {}),
     /* @__PURE__ */ jsx(
       Grid,
       {

package/dist/components/parameters/short-circuit/short-circuit-parameters-inline.d.ts

@@ -1,9 +1,8 @@
 import { UUID } from 'node:crypto';
 import { UseParametersBackendReturnProps } from '../../../utils';
 import { ComputingType } from '../common';
-export declare function ShortCircuitParametersInLine({ studyUuid, setHaveDirtyFields, parametersBackend, isDeveloperMode, }: Readonly<{
+export declare function ShortCircuitParametersInLine({ studyUuid, setHaveDirtyFields, parametersBackend, }: Readonly<{
     studyUuid: UUID | null;
     setHaveDirtyFields: (isDirty: boolean) => void;
     parametersBackend: UseParametersBackendReturnProps<ComputingType.SHORT_CIRCUIT>;
-    isDeveloperMode: boolean;
 }>): import("react/jsx-runtime").JSX.Element;

package/dist/components/parameters/short-circuit/short-circuit-parameters-inline.js

@@ -48,8 +48,7 @@ import "../../dialogs/elementSaveDialog/ElementSaveDialog.js";
 function ShortCircuitParametersInLine({
   studyUuid,
   setHaveDirtyFields,
-  parametersBackend,
-  isDeveloperMode
+  parametersBackend
 }) {
   const shortCircuitMethods = useShortCircuitParametersForm({
     parametersBackend,
@@ -105,7 +104,6 @@ function ShortCircuitParametersInLine({
     ShortCircuitParametersForm,
     {
       shortCircuitMethods,
-      isDeveloperMode,
       renderActions: () => {
         return /* @__PURE__ */ jsxs(Box, { children: [
           /* @__PURE__ */ jsxs(Grid, { container: true, item: true, children: [