@openshift-assisted/ui-lib 2.7.11-cim

package/dist/src/ocm/components/ui/OcmFormFields.d.ts

@@ -0,0 +1,22 @@
+import * as React from 'react';
+import { CheckboxProps, RadioProps } from '@patternfly/react-core';
+import { CheckboxFieldProps, CodeFieldProps, RadioFieldProps, SelectFieldProps, SwitchFieldProps } from '../../../common/components/ui/formik/types';
+import { RichInputFieldPropsProps } from '../../../common/components/ui/formik/RichInputField';
+declare type DisableableField = {
+    isDisabled?: boolean;
+};
+export declare function RefFormFieldDisabler<T extends DisableableField>(FormComponent: React.ComponentType<T>): React.ForwardRefExoticComponent<React.PropsWithoutRef<T> & React.RefAttributes<unknown>>;
+declare const OcmInputField: (props: React.PropsWithChildren<import("../../../common/components/ui/formik/types").InputFieldProps & {
+    inputError?: string | undefined;
+    description?: React.ReactNode;
+    labelInfo?: string | undefined;
+}>) => JSX.Element;
+declare const OcmSelectField: (props: SelectFieldProps) => JSX.Element;
+declare const OcmCheckboxField: (props: CheckboxFieldProps) => JSX.Element;
+declare const OcmSwitchField: (props: SwitchFieldProps) => JSX.Element;
+declare const OcmRadioField: (props: RadioFieldProps) => JSX.Element;
+declare const OcmCodeField: (props: CodeFieldProps) => JSX.Element;
+declare const OcmCheckbox: (props: CheckboxProps) => JSX.Element;
+declare const OcmRadio: (props: RadioProps) => JSX.Element;
+declare const OcmRichInputField: React.ForwardRefExoticComponent<Pick<RichInputFieldPropsProps, "name" | "onBlur" | "onChange" | "label" | "max" | "min" | "placeholder" | "type" | "className" | "style" | "isDisabled" | "validate" | "noDefaultOnChange" | "showErrorMessage" | "labelIcon" | "helperText" | "isRequired" | "isReadOnly" | "disableDeleteRow" | "disableAddRow" | "groupClassName" | "idPostfix" | "callFormikOnChange" | "richValidationMessages"> & React.RefAttributes<unknown>>;
+export { OcmInputField, OcmRichInputField, OcmSelectField, OcmCheckbox, OcmCheckboxField, OcmCodeField, OcmSwitchField, OcmRadioField, OcmRadio, };

package/dist/src/ocm/components/ui/index.d.ts

@@ -0,0 +1 @@
+export * from './AssistedUILibVersion';

package/dist/src/ocm/config/constants.d.ts

@@ -0,0 +1,8 @@
+import { AssistedInstallerOCMPermissionTypesListType, AssistedInstallerPermissionTypesListType, Cluster } from '../../common';
+export declare const isSingleClusterMode: () => boolean;
+export declare type ExtendedCluster = Cluster & {
+    permissions: AssistedInstallerOCMPermissionTypesListType;
+};
+export declare const getBasePermissions: (cluster: ExtendedCluster) => AssistedInstallerPermissionTypesListType;
+export declare const ocmPermissionsToAIPermissions: (ocmPermissions: AssistedInstallerOCMPermissionTypesListType) => Partial<AssistedInstallerPermissionTypesListType>;
+export declare const OCM_CLUSTER_LIST_LINK = "/openshift";

package/dist/src/ocm/config/index.d.ts

@@ -0,0 +1,2 @@
+export * from './routeBaseBath';
+export * from './constants';

package/dist/src/ocm/config/routeBaseBath.d.ts

@@ -0,0 +1,2 @@
+export declare let routeBasePath: string;
+export declare const setRouteBasePath: (basePath: string) => void;

package/dist/src/ocm/hooks/index.d.ts

@@ -0,0 +1,7 @@
+export { default as useOpenshiftVersions } from './useOpenshiftVersions';
+export { default as useClusterSupportedPlatforms } from './useClusterSupportedPlatforms';
+export { default as useManagedDomains } from './useManagedDomains';
+export { default as useUsedClusterNames } from './useUsedClusterNames';
+export { default as useInfraEnvId } from './useInfraEnvId';
+export { default as usePullSecret } from './usePullSecret';
+export { default as useClusterPreflightRequirements } from './useClusterPreflightRequirements';

package/dist/src/ocm/hooks/useClusterPreflightRequirements.d.ts

@@ -0,0 +1,7 @@
+import { Cluster, PreflightHardwareRequirements } from '../../common/api/types';
+declare const useClusterPreflightRequirements: (clusterId: Cluster['id']) => {
+    preflightRequirements: PreflightHardwareRequirements | undefined;
+    error: string;
+    isLoading: boolean;
+};
+export default useClusterPreflightRequirements;

package/dist/src/ocm/hooks/useClusterSupportedPlatforms.d.ts

@@ -0,0 +1,10 @@
+import { AxiosError } from 'axios';
+import { SupportedPlatformType } from '../../common';
+import { APIErrorMixin } from '../api/types';
+export declare type SupportedPlatformIntegrationType = 'no-active-integrations' | SupportedPlatformType;
+export default function useClusterSupportedPlatforms(clusterId: string): {
+    isPlatformIntegrationSupported: boolean;
+    supportedPlatformIntegration: SupportedPlatformIntegrationType;
+    isLoading: boolean;
+    error: AxiosError<APIErrorMixin, any> | undefined;
+};

package/dist/src/ocm/hooks/useInfraEnv.d.ts

@@ -0,0 +1,7 @@
+import { Cluster, CpuArchitecture, InfraEnv, InfraEnvUpdateParams } from '../../common';
+export default function useInfraEnv(clusterId: Cluster['id'], cpuArchitecture: CpuArchitecture): {
+    infraEnv: InfraEnv | undefined;
+    error: string;
+    isLoading: boolean;
+    updateInfraEnv: (infraEnvUpdateParams: InfraEnvUpdateParams) => Promise<InfraEnv>;
+};

package/dist/src/ocm/hooks/useInfraEnvId.d.ts

@@ -0,0 +1,5 @@
+import { Cluster, CpuArchitecture } from '../../common';
+export default function useInfraEnvId(clusterId: Cluster['id'], cpuArchitecture: CpuArchitecture): {
+    infraEnvId: string | undefined;
+    error: string;
+};

package/dist/src/ocm/hooks/useInfraEnvImageUrl.d.ts

@@ -0,0 +1,9 @@
+import { Cluster, CpuArchitecture, PresignedUrl } from '../../common';
+declare type ImgUrl = {
+    url: PresignedUrl['url'];
+    error: string;
+};
+export default function useInfraEnvImageUrl(): {
+    getIsoImageUrl: (clusterId: Cluster['id'], cpuArchitecture: CpuArchitecture) => Promise<ImgUrl>;
+};
+export {};

package/dist/src/ocm/hooks/useManagedDomains.d.ts

@@ -0,0 +1,2 @@
+import { ManagedDomain } from '../../common';
+export default function useManagedDomains(): ManagedDomain[] | undefined;

package/dist/src/ocm/hooks/useOpenshiftVersions.d.ts

@@ -0,0 +1,15 @@
+import { Cluster, CpuArchitecture, ImportClusterParams, OpenshiftVersionOptionType } from '../../common';
+declare type OpenShiftVersion = Cluster['openshiftVersion'];
+declare type UseOpenshiftVersionsType = {
+    versions: OpenshiftVersionOptionType[];
+    normalizeClusterVersion: (version: OpenShiftVersion) => ImportClusterParams['openshiftVersion'];
+    isSupportedOpenShiftVersion: (version: OpenShiftVersion) => boolean;
+    getCpuArchitectures: (version: OpenShiftVersion) => CpuArchitecture[];
+    error?: {
+        title: string;
+        message: string;
+    };
+    loading: boolean;
+};
+export default function useOpenshiftVersions(): UseOpenshiftVersionsType;
+export {};

package/dist/src/ocm/hooks/usePullSecret.d.ts

@@ -0,0 +1 @@
+export default function usePullSecret(): string | undefined;

package/dist/src/ocm/hooks/useSetClusterPermissions.d.ts

@@ -0,0 +1,2 @@
+import { AssistedInstallerOCMPermissionTypesListType, Cluster } from '../../common';
+export default function useSetClusterPermissions(): (cluster?: Cluster | undefined, ocmPermissions?: AssistedInstallerOCMPermissionTypesListType | undefined) => void;

package/dist/src/ocm/hooks/useUsedClusterNames.d.ts

@@ -0,0 +1,4 @@
+import { Cluster } from '../../common';
+export default function useUsedClusterNames(clusterId: Cluster['id']): {
+    usedClusterNames: string[] | undefined;
+};

package/dist/src/ocm/index.d.ts

@@ -0,0 +1,11 @@
+export * as Api from './api';
+export * as Store from './store';
+export * as Selectors from './selectors';
+export * as Config from './config';
+export * as Services from './services';
+export * from './components';
+export * as Features from '../common/features';
+export * as Constants from '../common/config';
+export * as Reducers from '../common/reducers';
+export * from '../common/components/ui';
+export * from '../common/api';

package/dist/src/ocm/reducers/clusters/clustersSlice.d.ts

@@ -0,0 +1,25 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { Cluster, ResourceUIState } from '../../../common';
+export declare const fetchClustersAsync: import("@reduxjs/toolkit").AsyncThunk<void | Cluster[], void, {
+    state?: unknown;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    extra?: unknown;
+    rejectValue?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+declare type ClustersStateSlice = {
+    data: Cluster[];
+    uiState: ResourceUIState;
+};
+export declare const clustersSlice: import("@reduxjs/toolkit").Slice<ClustersStateSlice, {
+    deleteCluster: (state: import("immer/dist/internal").WritableDraft<ClustersStateSlice>, action: PayloadAction<Cluster['id']>) => {
+        data: import("immer/dist/internal").WritableDraft<Cluster>[];
+        uiState: ResourceUIState;
+    };
+}, "clusters">;
+export declare const deleteCluster: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, any>;
+declare const _default: import("redux").Reducer<ClustersStateSlice, import("redux").AnyAction>;
+export default _default;

package/dist/src/ocm/reducers/clusters/currentClusterSlice.d.ts

@@ -0,0 +1,130 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { AssistedInstallerPermissionTypesListType, Cluster, Host, ResourceUIState } from '../../../common';
+export declare type FetchErrorType = {
+    code: string | number;
+    message: string;
+};
+declare type CurrentClusterStateSlice = {
+    data?: Cluster;
+    uiState: ResourceUIState;
+    isReloadScheduled: number;
+    permissions: AssistedInstallerPermissionTypesListType;
+    errorDetail?: FetchErrorType;
+};
+export declare const fetchClusterAsync: import("@reduxjs/toolkit").AsyncThunk<void | Cluster, string, {
+    rejectValue: FetchErrorType;
+    dispatch?: import("redux").Dispatch<import("redux").AnyAction> | undefined;
+    state?: unknown;
+    extra?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+export declare const currentClusterSlice: import("@reduxjs/toolkit").Slice<CurrentClusterStateSlice, {
+    updateClusterBase: (state: import("immer/dist/internal").WritableDraft<CurrentClusterStateSlice>, action: PayloadAction<Cluster>) => {
+        data: {
+            hosts: import("immer/dist/internal").WritableDraft<Host>[];
+            kind: "Cluster" | "AddHostsCluster";
+            highAvailabilityMode?: "Full" | "None" | undefined;
+            id: string;
+            href: string;
+            name?: string | undefined;
+            userName?: string | undefined;
+            orgId?: string | undefined;
+            emailDomain?: string | undefined;
+            openshiftVersion?: string | undefined;
+            ocpReleaseImage?: string | undefined;
+            openshiftClusterId?: string | undefined;
+            imageInfo: import("../../../common").ImageInfo;
+            platform?: import("../../../common").Platform | undefined;
+            baseDnsDomain?: string | undefined;
+            clusterNetworkCidr?: string | undefined;
+            clusterNetworkHostPrefix?: number | undefined;
+            serviceNetworkCidr?: string | undefined;
+            apiVip?: string | undefined;
+            apiVipDnsName?: string | undefined;
+            machineNetworkCidr?: string | undefined;
+            ingressVip?: string | undefined;
+            sshPublicKey?: string | undefined;
+            httpProxy?: string | undefined;
+            httpsProxy?: string | undefined;
+            noProxy?: string | undefined;
+            status: "insufficient" | "ready" | "error" | "preparing-for-installation" | "pending-for-input" | "installing" | "finalizing" | "installed" | "adding-hosts" | "cancelled" | "installing-pending-user-action";
+            statusInfo: string;
+            statusUpdatedAt?: string | undefined;
+            progress?: import("../../../common").ClusterProgressInfo | undefined;
+            diskEncryption?: import("../../../common").DiskEncryption | undefined;
+            readyHostCount?: number | undefined;
+            enabledHostCount?: number | undefined;
+            totalHostCount?: number | undefined;
+            schedulableMasters?: boolean | undefined;
+            schedulableMastersForcedTrue?: boolean | undefined;
+            updatedAt?: string | undefined;
+            createdAt?: string | undefined;
+            installStartedAt?: string | undefined;
+            installCompletedAt?: string | undefined;
+            hostNetworks?: import("../../../common").HostNetwork[] | undefined;
+            pullSecretSet?: boolean | undefined;
+            vipDhcpAllocation?: boolean | undefined;
+            validationsInfo?: string | undefined;
+            logsInfo?: "" | "requested" | "collecting" | "completed" | "timeout" | undefined;
+            installConfigOverrides?: string | undefined;
+            controllerLogsCollectedAt?: string | undefined;
+            controllerLogsStartedAt?: string | undefined;
+            connectivityMajorityGroups?: string | undefined;
+            deletedAt?: unknown;
+            userManagedNetworking?: boolean | undefined;
+            additionalNtpSource?: string | undefined;
+            monitoredOperators?: import("../../../common").MonitoredOperator[] | undefined;
+            amsSubscriptionId?: string | undefined;
+            hyperthreading?: "masters" | "workers" | "all" | "none" | undefined;
+            featureUsage?: string | undefined;
+            networkType?: "OpenShiftSDN" | "OVNKubernetes" | undefined;
+            clusterNetworks?: import("../../../common").ClusterNetwork[] | undefined;
+            serviceNetworks?: import("../../../common").ServiceNetwork[] | undefined;
+            machineNetworks?: import("../../../common").MachineNetwork[] | undefined;
+            cpuArchitecture?: string | undefined;
+            ignitionEndpoint?: import("../../../common").IgnitionEndpoint | undefined;
+            imported?: boolean | undefined;
+            tags?: string | undefined;
+        };
+        uiState: ResourceUIState;
+        isReloadScheduled: number;
+        permissions: import("immer/dist/internal").WritableDraft<AssistedInstallerPermissionTypesListType>;
+        errorDetail?: import("immer/dist/internal").WritableDraft<FetchErrorType> | undefined;
+    };
+    updateCluster: (state: import("immer/dist/internal").WritableDraft<CurrentClusterStateSlice>, action: PayloadAction<Cluster>) => {
+        data: Cluster;
+        uiState: ResourceUIState;
+        isReloadScheduled: number;
+        permissions: import("immer/dist/internal").WritableDraft<AssistedInstallerPermissionTypesListType>;
+        errorDetail?: import("immer/dist/internal").WritableDraft<FetchErrorType> | undefined;
+    };
+    updateHost: (state: import("immer/dist/internal").WritableDraft<CurrentClusterStateSlice>, action: PayloadAction<Host>) => import("immer/dist/internal").WritableDraft<CurrentClusterStateSlice>;
+    cleanCluster: () => CurrentClusterStateSlice;
+    forceReload: (state: import("immer/dist/internal").WritableDraft<CurrentClusterStateSlice>) => {
+        isReloadScheduled: number;
+        data?: import("immer/dist/internal").WritableDraft<Cluster> | undefined;
+        uiState: ResourceUIState;
+        permissions: import("immer/dist/internal").WritableDraft<AssistedInstallerPermissionTypesListType>;
+        errorDetail?: import("immer/dist/internal").WritableDraft<FetchErrorType> | undefined;
+    };
+    cancelForceReload: (state: import("immer/dist/internal").WritableDraft<CurrentClusterStateSlice>) => {
+        isReloadScheduled: number;
+        data?: import("immer/dist/internal").WritableDraft<Cluster> | undefined;
+        uiState: ResourceUIState;
+        permissions: import("immer/dist/internal").WritableDraft<AssistedInstallerPermissionTypesListType>;
+        errorDetail?: import("immer/dist/internal").WritableDraft<FetchErrorType> | undefined;
+    };
+    updateClusterPermissions: (state: import("immer/dist/internal").WritableDraft<CurrentClusterStateSlice>, action: PayloadAction<AssistedInstallerPermissionTypesListType>) => {
+        permissions: AssistedInstallerPermissionTypesListType;
+        data?: import("immer/dist/internal").WritableDraft<Cluster> | undefined;
+        uiState: ResourceUIState;
+        isReloadScheduled: number;
+        errorDetail?: import("immer/dist/internal").WritableDraft<FetchErrorType> | undefined;
+    };
+}, "currentCluster">;
+export declare const updateCluster: import("@reduxjs/toolkit").ActionCreatorWithPayload<Cluster, any>, updateClusterBase: import("@reduxjs/toolkit").ActionCreatorWithPayload<Cluster, any>, updateHost: import("@reduxjs/toolkit").ActionCreatorWithPayload<Host, any>, cleanCluster: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<any>, forceReload: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<any>, cancelForceReload: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<any>, updateClusterPermissions: import("@reduxjs/toolkit").ActionCreatorWithPayload<AssistedInstallerPermissionTypesListType, any>;
+declare const _default: import("redux").Reducer<CurrentClusterStateSlice, import("redux").AnyAction>;
+export default _default;

package/dist/src/ocm/reducers/clusters/index.d.ts

@@ -0,0 +1,2 @@
+export * from './clustersSlice';
+export * from './currentClusterSlice';

package/dist/src/ocm/selectors/clusters.d.ts

@@ -0,0 +1,61 @@
+import { IRowData } from '@patternfly/react-table';
+import { ClusterTableRows } from '../../common/types/clusters';
+import { Cluster, HumanizedSortable, ResourceUIState } from '../../common';
+import { TFunction } from 'i18next';
+export declare const selectClustersUIState: import("reselect/*").OutputSelector<{
+    clusters: {
+        data: Cluster[];
+        uiState: ResourceUIState;
+    };
+    currentCluster: {
+        data?: Cluster | undefined;
+        uiState: ResourceUIState;
+        isReloadScheduled: number;
+        permissions: import("../../common").AssistedInstallerPermissionTypesListType;
+        errorDetail?: import("../reducers/clusters").FetchErrorType | undefined;
+    };
+    infraEnvs: import("../../common").InfraEnv[];
+}, ResourceUIState, (res1: Cluster[], res2: ResourceUIState) => ResourceUIState>;
+export declare const getClusterTableStatusCell: (rowData: IRowData) => HumanizedSortable;
+export declare const selectClusterTableRows: (t: TFunction) => import("reselect/*").OutputSelector<{
+    clusters: {
+        data: Cluster[];
+        uiState: ResourceUIState;
+    };
+    currentCluster: {
+        data?: Cluster | undefined;
+        uiState: ResourceUIState;
+        isReloadScheduled: number;
+        permissions: import("../../common").AssistedInstallerPermissionTypesListType;
+        errorDetail?: import("../reducers/clusters").FetchErrorType | undefined;
+    };
+    infraEnvs: import("../../common").InfraEnv[];
+}, ClusterTableRows, (res: Cluster[]) => ClusterTableRows>;
+export declare const selectClusterNames: import("reselect/*").OutputSelector<{
+    clusters: {
+        data: Cluster[];
+        uiState: ResourceUIState;
+    };
+    currentCluster: {
+        data?: Cluster | undefined;
+        uiState: ResourceUIState;
+        isReloadScheduled: number;
+        permissions: import("../../common").AssistedInstallerPermissionTypesListType;
+        errorDetail?: import("../reducers/clusters").FetchErrorType | undefined;
+    };
+    infraEnvs: import("../../common").InfraEnv[];
+}, (string | undefined)[], (res: Cluster[]) => (string | undefined)[]>;
+export declare const selectClusterNamesButCurrent: import("reselect/*").OutputSelector<{
+    clusters: {
+        data: Cluster[];
+        uiState: ResourceUIState;
+    };
+    currentCluster: {
+        data?: Cluster | undefined;
+        uiState: ResourceUIState;
+        isReloadScheduled: number;
+        permissions: import("../../common").AssistedInstallerPermissionTypesListType;
+        errorDetail?: import("../reducers/clusters").FetchErrorType | undefined;
+    };
+    infraEnvs: import("../../common").InfraEnv[];
+}, (string | undefined)[], (res1: (string | undefined)[], res2: string | undefined) => (string | undefined)[]>;

package/dist/src/ocm/selectors/currentCluster.d.ts

@@ -0,0 +1,13 @@
+import { AssistedInstallerPermissionTypesListType } from '../../common';
+import { RootState } from '../store';
+export declare const selectCurrentClusterState: (state: RootState) => {
+    data?: import("../../common").Cluster | undefined;
+    uiState: import("../../common").ResourceUIState;
+    isReloadScheduled: number;
+    permissions: AssistedInstallerPermissionTypesListType;
+    errorDetail?: import("../reducers/clusters").FetchErrorType | undefined;
+};
+export declare const selectCurrentCluster: (state: RootState) => import("../../common").Cluster | undefined;
+export declare const selectCurrentClusterUIState: (state: RootState) => import("../../common").ResourceUIState;
+export declare const selectIsCurrentClusterSNO: (state: RootState) => boolean;
+export declare const selectCurrentClusterPermissionsState: (state: RootState) => AssistedInstallerPermissionTypesListType;

package/dist/src/ocm/selectors/index.d.ts

@@ -0,0 +1,2 @@
+export * from './currentCluster';
+export * from './clusters';

package/dist/src/ocm/sentry.d.ts

@@ -0,0 +1,2 @@
+import * as Sentry from '@sentry/browser';
+export declare const captureException: (error: any, message?: string | undefined, severity?: Sentry.Severity) => void;

package/dist/src/ocm/services/ClusterDetailsService.d.ts

@@ -0,0 +1,14 @@
+import { Cluster, InfraEnv, ManagedDomain, OpenshiftVersionOptionType } from '../../common';
+import { ClusterCreateParamsWithStaticNetworking, OcmClusterDetailsValues } from './types';
+declare const ClusterDetailsService: {
+    getClusterCreateParams(values: OcmClusterDetailsValues): ClusterCreateParamsWithStaticNetworking;
+    getClusterDetailsInitialValues({ cluster, infraEnv, urlSearchParams, ...args }: {
+        cluster?: Cluster | undefined;
+        infraEnv?: InfraEnv | undefined;
+        pullSecret?: string | undefined;
+        managedDomains: ManagedDomain[];
+        ocpVersions: OpenshiftVersionOptionType[];
+        urlSearchParams: string;
+    }): OcmClusterDetailsValues;
+};
+export default ClusterDetailsService;

package/dist/src/ocm/services/ClustersService.d.ts

@@ -0,0 +1,16 @@
+import { Cluster, Host, V2ClusterUpdateParams } from '../../common';
+import { ClusterCreateParamsWithStaticNetworking } from './types';
+declare const ClustersService: {
+    findHost(hosts: Cluster['hosts'], hostId: Host['id']): Host | undefined;
+    create(params: ClusterCreateParamsWithStaticNetworking): Promise<Cluster>;
+    remove(clusterId: Cluster['id']): Promise<void>;
+    downloadLogs(clusterId: Cluster['id'], hostId?: string | undefined): Promise<{
+        data: Blob;
+        fileName: string | undefined;
+    }>;
+    update(clusterId: Cluster['id'], clusterTags: Cluster['tags'], params: V2ClusterUpdateParams): Promise<import("axios").AxiosResponse<Cluster, any>>;
+    install(clusterId: Cluster['id'], clusterTags: Cluster['tags']): Promise<import("axios").AxiosResponse<Cluster, any>>;
+    updateClusterTags(clusterTags: Cluster['tags'], params: V2ClusterUpdateParams): V2ClusterUpdateParams;
+    get(clusterId: Cluster['id']): Promise<Cluster>;
+};
+export default ClustersService;

package/dist/src/ocm/services/CpuArchitectureService.d.ts

@@ -0,0 +1,14 @@
+import { Cluster, CpuArchitecture, OcmCpuArchitecture } from '../../common';
+declare const mapOcmArchToCpuArchitecture: (ocmArch: OcmCpuArchitecture | string) => CpuArchitecture;
+/**
+ * Takes the cluster.cpuArchitecture value and maps it to
+ * a valid infraEnv cpuArchitecture value (currently either x86 or AMD).
+ *
+ * As of 2022-10-27, cluster's cpuArchitecture can be:
+ * - For an AI cluster: CpuArchitecture.x86, CpuArchitecture.ARM or the value "multi"
+ * - For an OCM cluster: values as defined in OcmCpuArchitecture
+ *
+ * @param clusterCpuArchitecture the cluster's cpuArchitecture value
+ */
+declare const mapClusterCpuArchToInfraEnvCpuArch: (clusterCpuArchitecture: Cluster['cpuArchitecture'] | OcmCpuArchitecture) => CpuArchitecture;
+export { mapOcmArchToCpuArchitecture, mapClusterCpuArchToInfraEnvCpuArch };

package/dist/src/ocm/services/Day2ClusterService.d.ts

@@ -0,0 +1,87 @@
+import { Cluster, CpuArchitecture, OcmCpuArchitecture } from '../../common';
+import { OcmClusterExtraInfo, OcmClusterType } from '../components/AddHosts/types';
+export declare const getApiVipDnsName: (ocmCluster: OcmClusterType) => {
+    apiVipDnsname: string;
+    errorType: string;
+};
+declare const Day2ClusterService: {
+    getOpenshiftClusterId(ocmCluster?: OcmClusterType | undefined): string | undefined;
+    fetchCluster(ocmCluster: OcmClusterType, pullSecret: string, openshiftVersion: string, extraInfo: OcmClusterExtraInfo): Promise<Cluster | undefined>;
+    fetchClusterById(clusterId: Cluster['id']): Promise<Cluster>;
+    getDay2ClusterId(openshiftClusterId: OcmClusterType['external_id']): Promise<string | undefined>;
+    createCluster(openshiftClusterId: OcmClusterType['external_id'], clusterName: string, apiVipDnsname: string, pullSecret: string, openshiftVersion: string, cpuArchitectures: CpuArchitecture[]): Promise<Cluster>;
+    /**
+     * Complete the day2Cluster coming from AI polling with the data in the OCM cluster
+     * @param day2Cluster Day2 cluster
+     * @param ocmCluster OCM cluster
+     * @param extraInfo Extra information coming from OCM
+     */
+    completeAiClusterWithOcmCluster: (day2Cluster: Cluster | undefined, ocmCluster: OcmClusterType | undefined, extraInfo: OcmClusterExtraInfo) => Cluster | {
+        openshiftVersion: string;
+        cpuArchitecture: OcmCpuArchitecture;
+        canSelectCpuArch: boolean;
+        kind: "Cluster" | "AddHostsCluster";
+        highAvailabilityMode?: "Full" | "None" | undefined;
+        id: string;
+        href: string;
+        name?: string | undefined;
+        userName?: string | undefined;
+        orgId?: string | undefined;
+        emailDomain?: string | undefined;
+        ocpReleaseImage?: string | undefined;
+        openshiftClusterId?: string | undefined;
+        imageInfo: import("../../common").ImageInfo;
+        platform?: import("../../common").Platform | undefined;
+        baseDnsDomain?: string | undefined;
+        clusterNetworkCidr?: string | undefined;
+        clusterNetworkHostPrefix?: number | undefined;
+        serviceNetworkCidr?: string | undefined;
+        apiVip?: string | undefined;
+        apiVipDnsName?: string | undefined;
+        machineNetworkCidr?: string | undefined;
+        ingressVip?: string | undefined;
+        sshPublicKey?: string | undefined;
+        httpProxy?: string | undefined;
+        httpsProxy?: string | undefined;
+        noProxy?: string | undefined;
+        status: "insufficient" | "ready" | "error" | "preparing-for-installation" | "pending-for-input" | "installing" | "finalizing" | "installed" | "adding-hosts" | "cancelled" | "installing-pending-user-action";
+        statusInfo: string;
+        statusUpdatedAt?: string | undefined;
+        progress?: import("../../common").ClusterProgressInfo | undefined;
+        diskEncryption?: import("../../common").DiskEncryption | undefined;
+        hosts?: import("../../common").Host[] | undefined;
+        readyHostCount?: number | undefined;
+        enabledHostCount?: number | undefined;
+        totalHostCount?: number | undefined;
+        schedulableMasters?: boolean | undefined;
+        schedulableMastersForcedTrue?: boolean | undefined;
+        updatedAt?: string | undefined;
+        createdAt?: string | undefined;
+        installStartedAt?: string | undefined;
+        installCompletedAt?: string | undefined;
+        hostNetworks?: import("../../common").HostNetwork[] | undefined;
+        pullSecretSet?: boolean | undefined;
+        vipDhcpAllocation?: boolean | undefined;
+        validationsInfo?: string | undefined;
+        logsInfo?: "" | "requested" | "collecting" | "completed" | "timeout" | undefined;
+        installConfigOverrides?: string | undefined;
+        controllerLogsCollectedAt?: string | undefined;
+        controllerLogsStartedAt?: string | undefined;
+        connectivityMajorityGroups?: string | undefined;
+        deletedAt?: unknown;
+        userManagedNetworking?: boolean | undefined;
+        additionalNtpSource?: string | undefined;
+        monitoredOperators?: import("../../common").MonitoredOperator[] | undefined;
+        amsSubscriptionId?: string | undefined;
+        hyperthreading?: "masters" | "workers" | "all" | "none" | undefined;
+        featureUsage?: string | undefined;
+        networkType?: "OpenShiftSDN" | "OVNKubernetes" | undefined;
+        clusterNetworks?: import("../../common").ClusterNetwork[] | undefined;
+        serviceNetworks?: import("../../common").ServiceNetwork[] | undefined;
+        machineNetworks?: import("../../common").MachineNetwork[] | undefined;
+        ignitionEndpoint?: import("../../common").IgnitionEndpoint | undefined;
+        imported?: boolean | undefined;
+        tags?: string | undefined;
+    } | undefined;
+};
+export default Day2ClusterService;

package/dist/src/ocm/services/DiscoveryImageFormService.d.ts

@@ -0,0 +1,9 @@
+import { Cluster, InfraEnv } from '../../common/api/types';
+import { DiscoveryImageFormValues } from '../../common/components/clusterConfiguration';
+declare const DiscoveryImageFormService: {
+    update(clusterId: Cluster['id'], clusterTags: Cluster['tags'], infraEnvId: InfraEnv['id'], formValues: DiscoveryImageFormValues, ocmPullSecret?: string | undefined): Promise<{
+        updatedCluster: Cluster;
+        updatedInfraEnv: InfraEnv;
+    }>;
+};
+export default DiscoveryImageFormService;

package/dist/src/ocm/services/DiskEncryptionService.d.ts

@@ -0,0 +1,6 @@
+import { ClusterCreateParams, ClusterDetailsValues, DiskEncryption } from '../../common';
+declare const DiskEncryptionService: {
+    diskEncryptionEnableOn(isEnableOnMasters: boolean, isEnableOnWorkers: boolean): DiskEncryption['enableOn'];
+    getDiskEncryptionParams(values: ClusterDetailsValues): ClusterCreateParams['diskEncryption'];
+};
+export default DiskEncryptionService;

package/dist/src/ocm/services/HostDiscoveryService.d.ts

@@ -0,0 +1,6 @@
+import { Cluster, V2ClusterUpdateParams, HostDiscoveryValues, SupportedPlatformType } from '../../common';
+declare const HostDiscoveryService: {
+    setPlatform(params: V2ClusterUpdateParams, platformToIntegrate: SupportedPlatformType | undefined, userManagedNetworking: boolean | undefined): void;
+    setSchedulableMasters(params: V2ClusterUpdateParams, values: HostDiscoveryValues, cluster: Cluster): void;
+};
+export default HostDiscoveryService;

package/dist/src/ocm/services/HostsService.d.ts

@@ -0,0 +1,20 @@
+import { Disk, DiskRole, Host, HostUpdateParams } from '../../common';
+declare const HostsService: {
+    /**
+     * Removes all the hosts in the list assuming
+     * all of them have a valid infraEnvId value.
+     * @param hosts
+     */
+    removeAll(hosts: Host[]): Promise<import("axios").AxiosResponse<void, any>[]>;
+    update(host: Host, params: HostUpdateParams): Promise<import("axios").AxiosResponse<Host, any>>;
+    updateHostName(host: Host, newHostName: HostUpdateParams['hostName']): Promise<import("axios").AxiosResponse<Host, any>>;
+    updateRole(host: Host, newHostRole: HostUpdateParams['hostRole']): Promise<import("axios").AxiosResponse<Host, any>>;
+    updateHostODF(host: Host, newNodeLabels: HostUpdateParams['nodeLabels']): Promise<import("axios").AxiosResponse<Host, any>>;
+    updateDiskRole(host: Host, diskId: Required<Disk>['id'], newDiskRole: DiskRole): Promise<import("axios").AxiosResponse<Host, any>>;
+    updateFormattingDisks(host: Host, diskIdValue: Required<Disk>['id'], shouldSkipFormat: boolean): Promise<import("axios").AxiosResponse<Host, any>>;
+    delete(host: Host): Promise<import("axios").AxiosResponse<void, any>>;
+    reset(host: Host): Promise<import("axios").AxiosResponse<Host, any>>;
+    install(host: Host): Promise<import("axios").AxiosResponse<Host, any>>;
+    installAll(hosts: Host[]): Promise<import("axios").AxiosResponse<Host, any>[]>;
+};
+export default HostsService;

package/dist/src/ocm/services/InfraEnvIdsCacheService.d.ts

@@ -0,0 +1,9 @@
+import { CpuArchitecture, InfraEnv } from '../../common';
+declare type InfraEnvStorage = Omit<Storage, 'getItem' | 'removeItem' | 'setItem'> & {
+    getInfraEnvId(clusterId: string, cpuArchitecture: CpuArchitecture): string | null;
+    removeInfraEnvId(clusterId: string, cpuArchitecture: CpuArchitecture): void;
+    removeInfraEnvs(clusterId: string): void;
+    updateInfraEnvs(clusterId: string, infraEnvs: InfraEnv[]): void;
+};
+declare const InfraEnvIdsCacheService: InfraEnvStorage;
+export default InfraEnvIdsCacheService;

package/dist/src/ocm/services/InfraEnvsService.d.ts

@@ -0,0 +1,13 @@
+import { AxiosResponse } from 'axios';
+import { Cluster, CpuArchitecture, HostStaticNetworkConfig, InfraEnv, InfraEnvCreateParams } from '../../common';
+declare const InfraEnvsService: {
+    getInfraEnvId(clusterId: Cluster['id'], cpuArchitecture: CpuArchitecture): Promise<string>;
+    getInfraEnv(clusterId: Cluster['id'], cpuArchitecture: CpuArchitecture): Promise<InfraEnv>;
+    getAllInfraEnvIds(clusterId: Cluster['id']): Promise<string[]>;
+    create(params: InfraEnvCreateParams): Promise<void>;
+    removeAll(clusterId: Cluster['id']): Promise<AxiosResponse<void, any>[]>;
+    updateAllInfraEnvsToDhcp(clusterId: Cluster['id']): Promise<AxiosResponse<InfraEnv, any>[]>;
+    setDummyStaticConfigToInfraEnv(infraEnvId: InfraEnv['id']): Promise<InfraEnv>;
+    syncStaticIpConfigs(clusterId: Cluster['id'], currentInfraEnvId: InfraEnv['id'], staticNetworkConfig: HostStaticNetworkConfig[]): Promise<InfraEnv>;
+};
+export default InfraEnvsService;

package/dist/src/ocm/services/OperatorsService.d.ts

@@ -0,0 +1,11 @@
+import { Cluster, OperatorsValues, OperatorCreateParams } from '../../common';
+declare const OperatorsService: {
+    getOLMOperators(values: OperatorsValues, cluster: Cluster): OperatorCreateParams[];
+    /**
+     * Depending on the Openshift version and certain selected operators, the
+     * Backend can activate some other operators.
+     * We need to synchronise them back to the form
+     */
+    syncOperators(uiOperators: OperatorCreateParams[], updatedOperators: Cluster['monitoredOperators']): Partial<OperatorsValues>;
+};
+export default OperatorsService;