@openshift-assisted/ui-lib 2.9.8-cim → 2.9.9-cim

package/lib/ocm/components/clusterWizard/ClusterWizardContextProvider.tsx

@@ -18,9 +18,9 @@ import {
   useAlerts,
 } from '../../../common';
 import useSetClusterPermissions from '../../hooks/useSetClusterPermissions';
-import useClusterCustomManifests from '../../hooks/useClusterCustomManifests';
-import { ListManifestsExtended } from '../clusterConfiguration/manifestsConfiguration/data/dataTypes';
 import { Cluster, InfraEnv } from '@openshift-assisted/types/assisted-installer-service';
+import { useUISettings } from '../../hooks';
+import { AlertVariant } from '@patternfly/react-core';
 
 const addStepToClusterWizard = (
   wizardStepIds: ClusterWizardStepsType[],
@@ -52,7 +52,7 @@ const removeStepFromClusterWizard = (
 const getWizardStepIds = (
   wizardStepIds: ClusterWizardStepsType[] | undefined,
   staticIpView?: StaticIpView | 'dhcp-selected',
-  addCustomManifests?: boolean,
+  customManifestsStep?: boolean,
   isSingleClusterFeatureEnabled?: boolean,
 ): ClusterWizardStepsType[] => {
   let stepsCopy = wizardStepIds ? [...wizardStepIds] : [...defaultWizardSteps];
@@ -66,7 +66,7 @@ const getWizardStepIds = (
     stepsCopy = removeStepFromClusterWizard(stepsCopy, 'static-ip-network-wide-configurations', 2);
   }
 
-  if (addCustomManifests) {
+  if (customManifestsStep) {
     stepsCopy = addStepToClusterWizard(stepsCopy, 'networking', ['custom-manifests']);
   } else {
     stepsCopy = removeStepFromClusterWizard(stepsCopy, 'custom-manifests', 1);
@@ -79,12 +79,6 @@ const getWizardStepIds = (
   return stepsCopy;
 };
 
-const validateIfCustomsManifestsNeedToBeFilled = (
-  customManifests: ListManifestsExtended | undefined,
-): boolean => {
-  return (customManifests || []).some((customManifest) => customManifest.yamlContent === '');
-};
-
 const ClusterWizardContextProvider = ({
   children,
   cluster,
@@ -95,48 +89,71 @@ const ClusterWizardContextProvider = ({
   infraEnv?: InfraEnv;
   permissions?: AssistedInstallerOCMPermissionTypesListType;
 }>) => {
+  const isSingleClusterFeatureEnabled = useFeature('ASSISTED_INSTALLER_SINGLE_CLUSTER_FEATURE');
   const [currentStepId, setCurrentStepId] = React.useState<ClusterWizardStepsType>();
   const [wizardStepIds, setWizardStepIds] = React.useState<ClusterWizardStepsType[]>();
-  const [addCustomManifests, setAddCustomManifests] = React.useState<boolean>(false);
+  const [wizardPerPage, setWizardPerPage] = React.useState(10);
+  const [customManifestsStep, setCustomManifestsStep] = React.useState<boolean>(false);
   const { state: locationState } = useLocation<ClusterWizardFlowStateType>();
-  const { customManifests } = useClusterCustomManifests(cluster?.id || '', true);
+  const {
+    uiSettings,
+    updateUISettings,
+    loading: UISettingsLoading,
+    error: UISettingsError,
+  } = useUISettings(cluster?.id);
+  const { clearAlerts, addAlert, alerts } = useAlerts();
   const setClusterPermissions = useSetClusterPermissions();
-  const isSingleClusterFeatureEnabled = useFeature('ASSISTED_INSTALLER_SINGLE_CLUSTER_FEATURE');
-  const { clearAlerts } = useAlerts();
-  const [wizardPerPage, setWizardPerPage] = React.useState(10);
 
   React.useEffect(() => {
-    const staticIpInfo = infraEnv ? getStaticIpInfo(infraEnv) : undefined;
-    const customManifestsStepNeedsToBeFilled =
-      validateIfCustomsManifestsNeedToBeFilled(customManifests);
-    const hasManifests = (customManifests || []).length > 0;
-    const requiredStepId = getClusterWizardFirstStep(
-      locationState,
-      staticIpInfo,
-      cluster?.status,
-      cluster?.hosts,
-      isSingleClusterFeatureEnabled,
-      customManifestsStepNeedsToBeFilled,
-    );
-    const firstStepIds = getWizardStepIds(
-      wizardStepIds,
-      staticIpInfo?.view,
-      hasManifests,
-      isSingleClusterFeatureEnabled,
-    );
-    // Only move step if there is still none, or the user is at a forbidden step
-    const shouldMoveStep =
-      !currentStepId ||
-      (customManifestsStepNeedsToBeFilled && isStepAfter(currentStepId, requiredStepId));
-    if (shouldMoveStep) {
-      setCurrentStepId(requiredStepId);
+    if (!UISettingsLoading) {
+      const staticIpInfo = infraEnv ? getStaticIpInfo(infraEnv) : undefined;
+      const customManifestsStepEnabled = !!uiSettings?.addCustomManifests;
+      const customManifestsStepNeedsToBeFilled = !!(
+        uiSettings?.addCustomManifests && !uiSettings?.customManifestsAdded
+      );
+
+      const requiredStepId = getClusterWizardFirstStep(
+        locationState,
+        staticIpInfo,
+        cluster?.status,
+        cluster?.hosts,
+        isSingleClusterFeatureEnabled,
+        customManifestsStepNeedsToBeFilled,
+      );
+
+      const firstStepIds = getWizardStepIds(
+        wizardStepIds,
+        staticIpInfo?.view,
+        customManifestsStepEnabled,
+        isSingleClusterFeatureEnabled,
+      );
+
+      // Only move step if there is still none, or the user is at a forbidden step
+      if (
+        !currentStepId ||
+        (customManifestsStepNeedsToBeFilled && isStepAfter(currentStepId, requiredStepId))
+      ) {
+        setCurrentStepId(requiredStepId);
+      }
+
+      setWizardStepIds(firstStepIds);
+      setClusterPermissions(cluster, permissions);
+      setCustomManifestsStep(!!uiSettings?.addCustomManifests);
+    }
+
+    if (
+      !!UISettingsError &&
+      !alerts.some((alert) => alert.title === "Couldn't retrieve UI settings")
+    ) {
+      addAlert({
+        title: "Couldn't retrieve UI settings",
+        message: UISettingsError,
+        variant: AlertVariant.warning,
+      });
     }
 
-    setWizardStepIds(firstStepIds);
-    setClusterPermissions(cluster, permissions);
-    setAddCustomManifests(hasManifests);
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [customManifests]);
+  }, [uiSettings, UISettingsLoading, UISettingsError]);
 
   const contextValue = React.useMemo<ClusterWizardContextType | null>(() => {
     if (!wizardStepIds || !currentStepId) {
@@ -152,7 +169,7 @@ const ClusterWizardContextProvider = ({
       const newStepIds = getWizardStepIds(
         wizardStepIds,
         staticIpInfo.view,
-        addCustomManifests,
+        customManifestsStep,
         isSingleClusterFeatureEnabled,
       );
       setWizardStepIds(newStepIds);
@@ -165,8 +182,8 @@ const ClusterWizardContextProvider = ({
       setCurrentStepId(stepId);
     };
 
-    const onSetAddCustomManifests = (addCustomManifest: boolean) => {
-      setAddCustomManifests(addCustomManifest);
+    const onSetAddCustomManifestsStep = (addCustomManifest: boolean) => {
+      setCustomManifestsStep(addCustomManifest);
       setWizardStepIds(
         getWizardStepIds(
           wizardStepIds,
@@ -199,7 +216,7 @@ const ClusterWizardContextProvider = ({
           setCurrentStepId('static-ip-network-wide-configurations');
         }
         setWizardStepIds(
-          getWizardStepIds(wizardStepIds, view, addCustomManifests, isSingleClusterFeatureEnabled),
+          getWizardStepIds(wizardStepIds, view, customManifestsStep, isSingleClusterFeatureEnabled),
         );
       },
       onUpdateHostNetworkConfigType(type: HostsNetworkConfigurationType): void {
@@ -208,7 +225,7 @@ const ClusterWizardContextProvider = ({
             getWizardStepIds(
               wizardStepIds,
               StaticIpView.FORM,
-              addCustomManifests,
+              customManifestsStep,
               isSingleClusterFeatureEnabled,
             ),
           );
@@ -217,7 +234,7 @@ const ClusterWizardContextProvider = ({
             getWizardStepIds(
               wizardStepIds,
               'dhcp-selected',
-              addCustomManifests,
+              customManifestsStep,
               isSingleClusterFeatureEnabled,
             ),
           );
@@ -226,25 +243,29 @@ const ClusterWizardContextProvider = ({
       wizardStepIds,
       currentStepId,
       setCurrentStepId: onSetCurrentStepId,
-      addCustomManifests,
-      setAddCustomManifests: onSetAddCustomManifests,
-      customManifests,
+      customManifestsStep,
+      setCustomManifestsStep: onSetAddCustomManifestsStep,
       wizardPerPage,
       setWizardPerPage,
+      uiSettings,
+      updateUISettings,
     };
   }, [
     wizardStepIds,
     currentStepId,
     infraEnv,
-    addCustomManifests,
-    customManifests,
+    customManifestsStep,
     wizardPerPage,
     isSingleClusterFeatureEnabled,
     clearAlerts,
+    uiSettings,
+    updateUISettings,
   ]);
+
   if (!contextValue) {
     return null;
   }
+
   return (
     <>
       <ClusterWizardContext.Provider value={contextValue}>{children}</ClusterWizardContext.Provider>

package/lib/ocm/hooks/index.ts

@@ -4,3 +4,4 @@ export { default as useUsedClusterNames } from './useUsedClusterNames';
 export { default as useInfraEnvId } from './useInfraEnvId';
 export { default as usePullSecret } from './usePullSecret';
 export { default as useClusterPreflightRequirements } from './useClusterPreflightRequirements';
+export { default as useUISettings } from './useUISettings';

package/lib/ocm/hooks/useOpenshiftVersions.tsx

@@ -3,17 +3,12 @@ import { CpuArchitecture, OpenshiftVersionOptionType } from '../../common';
 import { getApiErrorMessage, handleApiError } from '../api';
 import { SupportedOpenshiftVersionsAPI } from '../services/apis';
 import { getKeys } from '../../common/utils';
-import {
-  Cluster,
-  ImportClusterParams,
-  OpenshiftVersion,
-} from '@openshift-assisted/types/assisted-installer-service';
+import { Cluster, OpenshiftVersion } from '@openshift-assisted/types/assisted-installer-service';
 
 type OpenShiftVersion = Cluster['openshiftVersion'];
 
 type UseOpenshiftVersionsType = {
   versions: OpenshiftVersionOptionType[];
-  normalizeClusterVersion: (version: OpenShiftVersion) => ImportClusterParams['openshiftVersion'];
   isSupportedOpenShiftVersion: (version: OpenShiftVersion) => boolean;
   getCpuArchitectures: (version: OpenShiftVersion) => CpuArchitecture[];
   error?: { title: string; message: string };
@@ -72,14 +67,6 @@ export default function useOpenshiftVersions(): UseOpenshiftVersionsType {
     }
   }, []);
 
-  const normalizeClusterVersion = React.useCallback(
-    (version: OpenShiftVersion) => {
-      const matchingVersion = findVersionItemByVersion(version);
-      return matchingVersion?.value || version;
-    },
-    [findVersionItemByVersion],
-  );
-
   const isSupportedOpenShiftVersion = React.useCallback(
     (version: OpenShiftVersion) => {
       if (versions.length === 0) {
@@ -109,7 +96,6 @@ export default function useOpenshiftVersions(): UseOpenshiftVersionsType {
     error,
     loading: !error && versions.length === 0,
     versions,
-    normalizeClusterVersion,
     isSupportedOpenShiftVersion,
     getCpuArchitectures,
   };

package/lib/ocm/hooks/useSupportLevelsAPI.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { CpuArchitecture, useAlerts } from '../../common';
+import { CpuArchitecture, SupportedCpuArchitecture, useAlerts } from '../../common';
 import {
   ArchitectureSupportLevelMap,
   NewFeatureSupportLevelMap,
@@ -8,11 +8,13 @@ import { getApiErrorMessage, handleApiError } from '../api';
 import NewFeatureSupportLevelsAPI from '../../common/api/assisted-service/NewFeatureSupportLevelsAPI';
 import { PlatformType } from '@openshift-assisted/types/./assisted-installer-service';
 
-type SupportLevelAPIResources = 'architectures' | 'features';
+type SupportLevelAPIResources = 'architectures' | 'features' | 'featureForAllCpus';
 type UseSupportLevelAPIResponse<T extends SupportLevelAPIResources> = T extends 'architectures'
   ? ArchitectureSupportLevelMap | null
   : T extends 'features'
   ? NewFeatureSupportLevelMap | null
+  : T extends 'featureForAllCpus'
+  ? Record<SupportedCpuArchitecture, NewFeatureSupportLevelMap | null> | null
   : null;
 
 export default function useSupportLevelsAPI<T extends SupportLevelAPIResources>(
@@ -20,10 +22,13 @@ export default function useSupportLevelsAPI<T extends SupportLevelAPIResources>(
   openshiftVersion?: string,
   cpuArchitecture?: CpuArchitecture,
   platformType?: PlatformType,
+  supportedCpuArchitectures?: SupportedCpuArchitecture[],
 ): UseSupportLevelAPIResponse<T> | null {
   const [cpuArchitectures, setCpuArchitectures] =
     React.useState<ArchitectureSupportLevelMap | null>(null);
   const [features, setFeatures] = React.useState<NewFeatureSupportLevelMap | null>(null);
+  const [supportLevelData, setSupportLevelData] =
+    React.useState<Record<SupportedCpuArchitecture, NewFeatureSupportLevelMap | null>>();
   const { addAlert } = useAlerts();
 
   const fetchArchitecturesSupportLevels = React.useCallback(
@@ -72,10 +77,53 @@ export default function useSupportLevelsAPI<T extends SupportLevelAPIResources>(
     [addAlert],
   );
 
+  const fetchFeaturesSupportLevelsForAllCpuArchs = React.useCallback(
+    async (
+      supportedCpuArchitectures: SupportedCpuArchitecture[],
+      openshiftVersion: string,
+      platformType?: PlatformType,
+    ) => {
+      try {
+        const data: Record<SupportedCpuArchitecture, NewFeatureSupportLevelMap | null> = {
+          x86_64: null,
+          arm64: null,
+          ppc64le: null,
+          s390x: null,
+        };
+        if (supportedCpuArchitectures) {
+          for (const cpuArch of supportedCpuArchitectures) {
+            const { data: features } = await NewFeatureSupportLevelsAPI.featuresSupportLevel(
+              openshiftVersion,
+              cpuArch,
+              platformType,
+            );
+            data[cpuArch] = features.features;
+          }
+          setSupportLevelData(data);
+        }
+      } catch (e) {
+        handleApiError(e, () =>
+          addAlert({
+            title: 'Failed to retrieve feature support levels',
+            message: getApiErrorMessage(e),
+          }),
+        );
+        setFeatures(null);
+      }
+    },
+    [addAlert],
+  );
+
   React.useEffect(() => {
     if (openshiftVersion) {
       if (resourceKind === 'architectures') {
         void fetchArchitecturesSupportLevels(openshiftVersion);
+      } else if (resourceKind === 'featureForAllCpus' && supportedCpuArchitectures) {
+        void fetchFeaturesSupportLevelsForAllCpuArchs(
+          supportedCpuArchitectures,
+          openshiftVersion,
+          platformType,
+        );
       } else {
         void fetchFeaturesSupportLevels(openshiftVersion, cpuArchitecture, platformType);
       }
@@ -87,10 +135,14 @@ export default function useSupportLevelsAPI<T extends SupportLevelAPIResources>(
     fetchFeaturesSupportLevels,
     resourceKind,
     platformType,
+    supportedCpuArchitectures,
+    fetchFeaturesSupportLevelsForAllCpuArchs,
   ]);
 
   if (resourceKind === 'architectures') {
     return cpuArchitectures as UseSupportLevelAPIResponse<T>;
+  } else if (resourceKind === 'featureForAllCpus') {
+    return supportLevelData as UseSupportLevelAPIResponse<T>;
   } else {
     return features as UseSupportLevelAPIResponse<T>;
   }

package/lib/ocm/hooks/useUISettings.ts

@@ -0,0 +1,71 @@
+import React from 'react';
+import { Cluster } from '@openshift-assisted/types/./assisted-installer-service';
+import { UISettingService, UISettingsValues } from '../services';
+import { ClustersAPI } from '../services/apis';
+
+const useUISettings = (clusterId?: Cluster['id']) => {
+  const [uiSettings, setUISettings] = React.useState<UISettingsValues>();
+  const [loading, setLoading] = React.useState(true);
+  const [error, setError] = React.useState<string>('');
+
+  const updateUISettings = React.useCallback(
+    async (newSettings: UISettingsValues) => {
+      if (clusterId) {
+        const updatedSettings = { ...uiSettings, ...newSettings };
+        try {
+          await UISettingService.update(clusterId, updatedSettings);
+          setUISettings(updatedSettings);
+        } catch (e) {
+          throw new Error();
+        }
+      }
+    },
+    [clusterId, uiSettings],
+  );
+
+  React.useEffect(() => {
+    const handleUISettingsError = async () => {
+      if (clusterId) {
+        try {
+          const { data: customManifests } = await ClustersAPI.getManifests(clusterId);
+
+          const mockUISettings: UISettingsValues = {
+            addCustomManifests: !!customManifests.length,
+            customManifestsAdded: !!customManifests.length,
+          };
+
+          setUISettings(mockUISettings);
+        } catch (error) {
+          setError('Failed to retrieve cluster custom manifests information');
+        }
+      }
+    };
+
+    const fetchUISettings = async () => {
+      if (clusterId) {
+        try {
+          const settings = await UISettingService.fetch(clusterId);
+          setUISettings(settings);
+        } catch (e) {
+          await handleUISettingsError();
+        }
+      } else {
+        setUISettings({});
+      }
+      setLoading(false);
+    };
+
+    if (!uiSettings) {
+      void fetchUISettings();
+    }
+  }, [clusterId, setUISettings, uiSettings]);
+
+  const returnValue = React.useMemo(
+    () => ({ uiSettings, loading, error, updateUISettings }),
+    [uiSettings, loading, error, updateUISettings],
+  );
+
+  return returnValue;
+};
+
+export default useUISettings;

package/lib/ocm/services/ClusterDetailsService.ts

@@ -92,6 +92,7 @@ const ClusterDetailsService = {
     cluster,
     infraEnv,
     urlSearchParams,
+    addCustomManifests,
     ...args
   }: {
     cluster?: Cluster;
@@ -100,6 +101,7 @@ const ClusterDetailsService = {
     managedDomains: ManagedDomain[];
     ocpVersions: OpenshiftVersionOptionType[];
     urlSearchParams: string;
+    addCustomManifests?: boolean;
   }): OcmClusterDetailsValues {
     const values = getClusterDetailsInitialValues({
       cluster,
@@ -118,7 +120,7 @@ const ClusterDetailsService = {
       ...values,
       cpuArchitecture,
       hostsNetworkConfigurationType,
-      addCustomManifest: false,
+      addCustomManifest: !!addCustomManifests,
       isCMNSupported: true,
     };
   },

package/lib/ocm/services/ClustersService.ts

@@ -11,7 +11,6 @@ import {
 } from '../components/clusterConfiguration/manifestsConfiguration/data/dataTypes';
 import {
   Cluster,
-  CreateManifestParams,
   Host,
   InfraEnvCreateParams,
   UpdateManifestParams,
@@ -138,15 +137,6 @@ const ClustersService = {
     return Promise.all(promises);
   },
 
-  createDummyManifest(clusterId: Cluster['id']) {
-    const dummyManifest: CreateManifestParams = {
-      folder: 'manifests' as 'manifests' | 'openshift',
-      fileName: 'manifest1.yaml',
-      content: '',
-    };
-    return ClustersAPI.createCustomManifest(clusterId, dummyManifest);
-  },
-
   updateCustomManifest(
     existingManifest: CustomManifestValues,
     updatedManifest: CustomManifestValues,

package/lib/ocm/services/Day2ClusterService.ts

@@ -3,7 +3,11 @@ import { ClustersAPI } from './apis';
 import { CpuArchitecture, SupportedCpuArchitecture } from '../../common';
 import { OcmClusterType } from '../components/AddHosts/types';
 import { mapOcmArchToCpuArchitecture } from './CpuArchitectureService';
-import { Cluster } from '@openshift-assisted/types/assisted-installer-service';
+import {
+  Cluster,
+  Platform,
+  PlatformType,
+} from '@openshift-assisted/types/assisted-installer-service';
 
 export const getApiVipDnsName = (ocmCluster: OcmClusterType) => {
   let apiVipDnsname = '';
@@ -30,12 +34,20 @@ export const getApiVipDnsName = (ocmCluster: OcmClusterType) => {
   return { apiVipDnsname, errorType: apiVipDnsname ? '' : urlType };
 };
 
+export const mapCloudProviderToPlatformType = (cloudProviderId?: string) => {
+  const platformType = cloudProviderId === 'external' ? 'oci' : cloudProviderId;
+  const platform: Platform = {
+    type: (platformType as PlatformType) || 'baremetal',
+  };
+  return platform;
+};
+
 const Day2ClusterService = {
   getOpenshiftClusterId(ocmCluster?: OcmClusterType) {
     return ocmCluster && ocmCluster.external_id;
   },
 
-  async fetchCluster(ocmCluster: OcmClusterType, pullSecret: string, openshiftVersion: string) {
+  async fetchCluster(ocmCluster: OcmClusterType, pullSecret: string) {
     const openshiftClusterId = Day2ClusterService.getOpenshiftClusterId(ocmCluster);
 
     if (!openshiftClusterId) {
@@ -53,7 +65,7 @@ const Day2ClusterService = {
       ocmCluster.display_name || ocmCluster.name || openshiftClusterId,
       getApiVipDnsName(ocmCluster).apiVipDnsname,
       pullSecret,
-      openshiftVersion,
+      ocmCluster.openshift_version,
       mapOcmArchToCpuArchitecture(ocmCluster.cpu_architecture) || CpuArchitecture.x86,
     );
   },
@@ -69,6 +81,7 @@ const Day2ClusterService = {
     if (day2Clusters.length > 0) {
       return day2Clusters[0].id;
     }
+
     return undefined;
   },
 
@@ -117,6 +130,7 @@ const Day2ClusterService = {
         // The field "cpu_architecture" is calculated based on the existing hosts' architecture
         // It can be a specific architecture, or "multi" if hosts from several architectures have been discovered
         cpuArchitecture: mapOcmArchToCpuArchitecture(ocmCluster.cpu_architecture),
+        platform: mapCloudProviderToPlatformType(ocmCluster.cloud_provider?.id),
       };
     }
     return treakedCluster;

package/lib/ocm/services/UISettingsService.ts

@@ -0,0 +1,17 @@
+import { Cluster } from '@openshift-assisted/types/./assisted-installer-service';
+import { UISettingsAPI } from '../../common/api/assisted-service';
+import { UISettingsValues } from './types';
+
+const PREFIX_LENGHT = 6;
+
+const UISettingService = {
+  async fetch(clusterId: Cluster['id']) {
+    const { data } = await UISettingsAPI.get(clusterId);
+    return (data.length ? JSON.parse(data.slice(PREFIX_LENGHT)) : {}) as UISettingsValues;
+  },
+  update(clusterId: Cluster['id'], data: UISettingsValues) {
+    return UISettingsAPI.put(clusterId, `AI_UI:${JSON.stringify(data)}`);
+  },
+};
+
+export default UISettingService;

package/lib/ocm/services/index.ts

@@ -7,5 +7,6 @@ export { default as DiscoveryImageFormService } from './DiscoveryImageFormServic
 export { default as DiskEncryptionService } from './DiskEncryptionService';
 export { default as OperatorsService } from './OperatorsService';
 export { default as NewFeatureSupportLevelsService } from './NewFeatureSupportLevelsService';
+export { default as UISettingService } from './UISettingsService';
 export * from './types';
 export * as APIs from './apis';

package/lib/ocm/services/types.ts

@@ -24,3 +24,8 @@ export type OcmClusterDetailsValues = ClusterDetailsValues & {
   addCustomManifest: boolean;
   isCMNSupported: boolean;
 };
+
+export type UISettingsValues = {
+  addCustomManifests?: boolean;
+  customManifestsAdded?: boolean;
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "dependencies": {
-    "@openshift-assisted/locales": "2.9.8-cim",
-    "@openshift-assisted/types": "2.9.8-cim",
+    "@openshift-assisted/locales": "2.9.9-cim",
+    "@openshift-assisted/types": "2.9.9-cim",
     "axios-case-converter": "^0.11.1",
     "camel-case": "^4.1.2",
     "cidr-tools": "^4.3.0",
@@ -127,5 +127,5 @@
       ]
     }
   },
-  "version": "2.9.8-cim"
+  "version": "2.9.9-cim"
 }