@openshift-assisted/ui-lib 2.7.11-cim

package/dist/src/common/api/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const stringToJSON: <T>(jsonString: string | undefined) => T | undefined;
+export declare const removeProtocolFromURL: (url?: string) => string;

package/dist/src/common/components/AddHosts/AddHostsContext.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { Cluster } from '../../api';
+export declare type AddHostsContextType = {
+    cluster?: Cluster;
+    resetCluster?: () => Promise<void>;
+    ocpConsoleUrl?: string;
+};
+export declare const AddHostsContext: React.Context<AddHostsContextType>;
+export declare const AddHostsContextProvider: React.FC<AddHostsContextType>;

package/dist/src/common/components/AddHosts/index.d.ts

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

package/dist/src/common/components/AlertsContextProvider.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { AlertProps, AlertPayload } from '../reducers';
+export declare type AlertsContextType = {
+    alerts: AlertProps[];
+    addAlert: (alert: AlertPayload) => void;
+    removeAlert: (alertKey: string) => void;
+    clearAlerts: () => void;
+};
+export declare const AlertsContextProvider: React.FC;
+export declare const useAlerts: () => AlertsContextType;

package/dist/src/common/components/ErrorHandling/ErrorMonitorContext.d.ts

@@ -0,0 +1,12 @@
+import React, { PropsWithChildren } from 'react';
+export declare type ErrorSeverity = 'error' | 'warning' | 'info';
+export declare type ExceptionReporter = (error: unknown, message?: string, severity?: ErrorSeverity) => void;
+export declare const ErrorMonitorContext: React.Context<{
+    captureException: ExceptionReporter;
+}>;
+export declare const ErrorMonitorContextProvider: ({ exceptionReporter, children, }: React.PropsWithChildren<{
+    exceptionReporter: ExceptionReporter;
+}>) => JSX.Element;
+export declare const useErrorMonitor: () => {
+    captureException: ExceptionReporter;
+};

package/dist/src/common/components/ErrorHandling/WithErrorBoundary.d.ts

@@ -0,0 +1,5 @@
+import { PropsWithChildren } from 'react';
+export declare type WithErrorBoundaryProps = {
+    title?: string;
+};
+export declare const WithErrorBoundary: ({ children, ...props }: PropsWithChildren<WithErrorBoundaryProps>) => JSX.Element;

package/dist/src/common/components/clusterConfiguration/AdvancedNetworkFields.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+declare type AdvancedNetworkFieldsProps = {
+    isSDNSelectable: boolean;
+    isClusterCIDRIPv6: boolean;
+};
+declare const AdvancedNetworkFields: React.FC<AdvancedNetworkFieldsProps>;
+export default AdvancedNetworkFields;

package/dist/src/common/components/clusterConfiguration/DiscoveryImageConfigForm.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { FormikHelpers } from 'formik';
+import { ImageCreateParams, ImageType, Proxy } from '../../api';
+import { ProxyFieldsType } from '../../types';
+export declare const StaticIPInfo: React.FC;
+export declare type DiscoveryImageFormValues = ImageCreateParams & ProxyFieldsType;
+declare type DiscoveryImageConfigFormProps = Proxy & {
+    onCancel: () => void;
+    handleSubmit: (values: DiscoveryImageFormValues, formikActions: FormikHelpers<DiscoveryImageFormValues>) => Promise<void>;
+    hasDHCP?: boolean;
+    hideDiscoveryImageType?: boolean;
+    sshPublicKey?: string;
+    imageType?: ImageType;
+};
+export declare const DiscoveryImageConfigForm: React.FC<DiscoveryImageConfigFormProps>;
+export {};

package/dist/src/common/components/clusterConfiguration/DiscoveryImageCpuArchitectureControlGroup.d.ts

@@ -0,0 +1,8 @@
+import { CpuArchitecture } from '../../types';
+import { Cluster } from '../../api';
+declare const DiscoverImageCpuArchitectureControlGroup: ({ canSelectCpuArchitecture, day1CpuArchitecture, openshiftVersion, }: {
+    canSelectCpuArchitecture: boolean;
+    day1CpuArchitecture: CpuArchitecture | undefined;
+    openshiftVersion: Cluster['openshiftVersion'];
+}) => JSX.Element;
+export default DiscoverImageCpuArchitectureControlGroup;

package/dist/src/common/components/clusterConfiguration/DiscoveryImageTypeControlGroup.d.ts

@@ -0,0 +1,2 @@
+declare const DiscoveryImageTypeControlGroup: () => JSX.Element;
+export default DiscoveryImageTypeControlGroup;

package/dist/src/common/components/clusterConfiguration/DiscoveryInstructions.d.ts

@@ -0,0 +1,6 @@
+declare type DiscoveryInstructionsProps = {
+    showAllInstructions?: boolean;
+    isSNO?: boolean;
+};
+declare const DiscoveryInstructions: ({ showAllInstructions, isSNO, }: DiscoveryInstructionsProps) => JSX.Element;
+export default DiscoveryInstructions;

package/dist/src/common/components/clusterConfiguration/DiscoveryTroubleshootingModal.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+export declare const DiscoveryTroubleshootingModalContent: React.FC;
+export declare type HostsNotShowingLinkProps = {
+    setDiscoveryHintModalOpen: (isOpen: boolean) => void;
+    isSNO?: boolean;
+};
+declare type DiscoveryTroubleshootingModalProps = {
+    setDiscoveryHintModalOpen: (isOpen: boolean) => void;
+    isOpen: boolean;
+};
+export declare const HostsNotShowingLink: React.FC<HostsNotShowingLinkProps>;
+export declare const DiscoveryTroubleshootingModal: React.FC<DiscoveryTroubleshootingModalProps>;
+export {};

package/dist/src/common/components/clusterConfiguration/DiskEncryptionFields/DiskEncryptionControlGroup.d.ts

@@ -0,0 +1,8 @@
+import { DiskEncryptionValues } from './DiskEncryptionValues';
+export interface DiskEncryptionControlGroupProps {
+    values: DiskEncryptionValues;
+    isSNO: boolean;
+    isDisabled?: boolean;
+}
+declare const DiskEncryptionControlGroup: ({ values, isSNO, isDisabled, }: DiskEncryptionControlGroupProps) => JSX.Element;
+export default DiskEncryptionControlGroup;

package/dist/src/common/components/clusterConfiguration/DiskEncryptionFields/DiskEncryptionMode.d.ts

@@ -0,0 +1,6 @@
+import { DiskEncryption } from '../../../api';
+export interface DiskEncryptionModeProps {
+    isDisabled: boolean;
+    diskEncryptionMode: DiskEncryption['mode'];
+}
+export declare const DiskEncryptionMode: ({ diskEncryptionMode, isDisabled }: DiskEncryptionModeProps) => JSX.Element;

package/dist/src/common/components/clusterConfiguration/DiskEncryptionFields/DiskEncryptionValues.d.ts

@@ -0,0 +1,11 @@
+import { DiskEncryption } from '../../../api';
+export declare type TangServer = {
+    url: string;
+    thumbprint: string;
+};
+export interface DiskEncryptionValues {
+    enableDiskEncryptionOnMasters?: boolean;
+    enableDiskEncryptionOnWorkers: boolean;
+    diskEncryptionMode: DiskEncryption['mode'];
+    diskEncryptionTangServers: TangServer[];
+}

package/dist/src/common/components/clusterConfiguration/DiskEncryptionFields/TangServers.d.ts

@@ -0,0 +1,3 @@
+export declare const TangServers: ({ isDisabled }: {
+    isDisabled: boolean;
+}) => JSX.Element;

package/dist/src/common/components/clusterConfiguration/DownloadIso.d.ts

@@ -0,0 +1,10 @@
+export declare type DownloadISOProps = {
+    hasDHCP?: boolean;
+    isSNO?: boolean;
+    fileName?: string;
+    downloadUrl?: string;
+    onClose: () => void;
+    onReset?: () => void;
+};
+declare const DownloadIso: ({ fileName, downloadUrl, onClose, onReset, hasDHCP, isSNO, }: DownloadISOProps) => JSX.Element;
+export default DownloadIso;

package/dist/src/common/components/clusterConfiguration/DownloadIsoModal.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { DownloadISOProps } from './DownloadIso';
+declare type DownloadIsoModalProps = DownloadISOProps & {
+    isOpen: boolean;
+};
+declare const DownloadIsoModal: React.FC<DownloadIsoModalProps>;
+export default DownloadIsoModal;

package/dist/src/common/components/clusterConfiguration/FormatDiskWarning.d.ts

@@ -0,0 +1,5 @@
+declare type FormatDiskWarningProps = {
+    someDisksAreSkipFormatting?: boolean;
+};
+declare const FormatDiskWarning: ({ someDisksAreSkipFormatting }: FormatDiskWarningProps) => JSX.Element;
+export default FormatDiskWarning;

package/dist/src/common/components/clusterConfiguration/OpenShiftVersionSelect.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { OpenshiftVersionOptionType } from '../../types';
+declare type OpenShiftVersionSelectProps = {
+    versions: OpenshiftVersionOptionType[];
+};
+declare const OpenShiftVersionSelect: React.FC<OpenShiftVersionSelectProps>;
+export default OpenShiftVersionSelect;

package/dist/src/common/components/clusterConfiguration/ProxyFields.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import './ProxyFields.css';
+export declare const ProxyInputFields: () => JSX.Element;
+declare const ProxyFields: React.FC;
+export default ProxyFields;

package/dist/src/common/components/clusterConfiguration/SNOControlGroup.d.ts

@@ -0,0 +1,8 @@
+import { ClusterDetailsValues } from '../../../common/components/clusterWizard/types';
+import { OpenshiftVersionOptionType } from '../../types';
+declare type SNOControlGroupProps = {
+    versions: OpenshiftVersionOptionType[];
+    highAvailabilityMode: ClusterDetailsValues['highAvailabilityMode'];
+};
+declare const SNOControlGroup: ({ versions, highAvailabilityMode }: SNOControlGroupProps) => JSX.Element;
+export default SNOControlGroup;

package/dist/src/common/components/clusterConfiguration/SNODisclaimer.d.ts

@@ -0,0 +1,8 @@
+import { SupportLevel } from '../../types';
+declare type SNODisclaimerProps = {
+    snoSupportLevel: SupportLevel;
+    isDisabled?: boolean;
+    snoExpansionSupported?: boolean;
+};
+declare const SNODisclaimer: ({ snoSupportLevel, isDisabled, snoExpansionSupported, }: SNODisclaimerProps) => JSX.Element | null;
+export default SNODisclaimer;

package/dist/src/common/components/clusterConfiguration/SecurityFields.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { Cluster } from '../../api';
+export declare const SshPublicKeyHelperText: React.FC<{
+    fieldId?: string;
+}>;
+interface SecurityFieldsFieldsProps {
+    clusterSshKey: Cluster['sshPublicKey'];
+    imageSshKey?: Cluster['imageInfo']['sshPublicKey'];
+    isDisabled?: boolean;
+}
+declare const SecurityFields: ({ clusterSshKey, imageSshKey, isDisabled, }: SecurityFieldsFieldsProps) => JSX.Element;
+export default SecurityFields;

package/dist/src/common/components/clusterConfiguration/UploadSSH.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+declare type UploadSSHProps = {
+    isRequired?: boolean;
+};
+declare const UploadSSH: React.FC<UploadSSHProps>;
+export default UploadSSH;

package/dist/src/common/components/clusterConfiguration/index.d.ts

@@ -0,0 +1,13 @@
+export { default as SNOControlGroup } from './SNOControlGroup';
+export { default as SNODisclaimer } from './SNODisclaimer';
+export { default as OpenShiftVersionSelect } from './OpenShiftVersionSelect';
+export { default as UploadSSH } from './UploadSSH';
+export { default as ProxyFields, ProxyInputFields } from './ProxyFields';
+export { default as DownloadIsoModal } from './DownloadIsoModal';
+export { default as DownloadIso } from './DownloadIso';
+export { default as DiscoveryInstructions } from './DiscoveryInstructions';
+export { default as FormatDiskWarning } from './FormatDiskWarning';
+export { default as SecurityFields } from './SecurityFields';
+export * from './utils';
+export * from './DiscoveryTroubleshootingModal';
+export * from './DiscoveryImageConfigForm';

package/dist/src/common/components/clusterConfiguration/utils.d.ts

@@ -0,0 +1,20 @@
+import { Address4, Address6 } from 'ip-address';
+import { Cluster, ClusterDefaultConfig, ClusterNetwork, ServiceNetwork } from '../../api';
+import { HostDiscoveryValues, HostSubnets, StorageValues, Validation, ValidationGroup, ValidationsInfo } from '../../types/clusters';
+export declare const getSubnet: (cidr: string) => Address6 | Address4 | null;
+export declare const getHumanizedSubnetRange: (subnet: Address6 | Address4 | null) => string;
+export declare const getHumanizedSubnet: (subnet: Address6 | Address4 | null) => string;
+export declare const getHostSubnets: (cluster: Cluster) => HostSubnets;
+export declare const getSubnetFromMachineNetworkCidr: (machineNetworkCidr?: string | undefined) => string | undefined;
+export declare const serviceNetworksEqual: (array1: ServiceNetwork[], array2: ServiceNetwork[]) => boolean;
+export declare const clusterNetworksEqual: (array1: ClusterNetwork[], array2: ClusterNetwork[]) => boolean;
+export declare const isAdvNetworkConf: (cluster: Cluster, defaultNetworkSettings: ClusterDefaultConfig, defaultNetworkType: string) => boolean;
+export declare const canSelectNetworkTypeSDN: (isSNO: boolean, isIPv6?: boolean) => boolean;
+export declare const getDefaultNetworkType: (isSNO: boolean, isIPv6?: boolean) => "OpenShiftSDN" | "OVNKubernetes";
+export declare const canBeDualStack: (subnets: HostSubnets) => boolean;
+export declare const isDualStack: ({ machineNetworks, clusterNetworks, serviceNetworks, }: Pick<Cluster, 'machineNetworks' | 'clusterNetworks' | 'serviceNetworks'>) => boolean | undefined;
+export declare const isSubnetInIPv6: ({ clusterNetworkCidr, machineNetworkCidr, serviceNetworkCidr, }: Pick<Cluster, 'clusterNetworkCidr' | 'machineNetworkCidr' | 'serviceNetworkCidr'>) => boolean;
+export declare const getHostDiscoveryInitialValues: (cluster: Cluster) => HostDiscoveryValues;
+export declare const getStorageInitialValues: () => StorageValues;
+export declare function filterValidationsInfoByGroup(validationsInfo: ValidationsInfo, selectedGroups?: ValidationGroup[]): ValidationsInfo;
+export declare function filterValidationsInfoByStatus(validationsInfo: ValidationsInfo, selectedStatuses?: Validation['status'][]): ValidationsInfo;

package/dist/src/common/components/clusterDetail/ClusterCredentials.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { Credentials, Cluster } from '../../api/types';
+declare type ClusterCredentialsProps = {
+    cluster: Cluster;
+    error?: boolean;
+    retry?: () => void;
+    credentials?: Credentials;
+    idPrefix?: string;
+    credentialsError?: string;
+};
+declare const ClusterCredentials: React.FC<ClusterCredentialsProps>;
+export default ClusterCredentials;

package/dist/src/common/components/clusterDetail/ClusterProgress.d.ts

@@ -0,0 +1,9 @@
+import { Cluster } from '../../api/types';
+import './ClusterProgress.css';
+declare type ClusterProgressProps = {
+    cluster: Cluster;
+    minimizedView?: boolean;
+    totalPercentage?: number;
+};
+declare const ClusterProgress: ({ cluster, minimizedView, totalPercentage, }: ClusterProgressProps) => JSX.Element;
+export default ClusterProgress;

package/dist/src/common/components/clusterDetail/ClusterProgressItem.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+declare const ClusterProgressItem: ({ icon, children, }: {
+    icon: React.ReactElement;
+    children: React.ReactNode;
+}) => JSX.Element;
+export default ClusterProgressItem;

package/dist/src/common/components/clusterDetail/ClusterProgressItems.d.ts

@@ -0,0 +1,11 @@
+import { Cluster } from '../../api';
+import { EventListFetchProps } from '../../types';
+declare type ClusterProgressItemsProps = {
+    cluster: Cluster;
+    minimizedView?: boolean;
+    onFetchEvents: EventListFetchProps['onFetchEvents'];
+    totalPercentage?: number;
+    fallbackEventsURL?: string;
+};
+declare const ClusterProgressItems: ({ cluster, minimizedView, onFetchEvents, fallbackEventsURL, }: ClusterProgressItemsProps) => JSX.Element;
+export default ClusterProgressItems;

package/dist/src/common/components/clusterDetail/ClusterPropertiesList.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+declare type ClusterPropertyItem = {
+    key: string;
+    value?: React.ReactNode;
+};
+declare type ClusterPropertiesListProps = {
+    leftItems: ClusterPropertyItem[];
+    rightItems?: ClusterPropertyItem[];
+};
+declare const ClusterPropertiesList: ({ leftItems, rightItems }: ClusterPropertiesListProps) => JSX.Element;
+export default ClusterPropertiesList;

package/dist/src/common/components/clusterDetail/ConsoleModal.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import { Cluster } from '../../api';
+declare type WebConsoleHintProps = {
+    cluster: Cluster;
+    consoleUrl?: string;
+    idPrefix?: string;
+};
+declare type LaunchOpenshiftConsoleButtonProps = WebConsoleHintProps & {
+    isDisabled: boolean;
+    id?: string;
+};
+declare type ConsoleModalProps = WebConsoleHintProps & {
+    closeModal: () => void;
+    isOpen: boolean;
+};
+export declare const WebConsoleHint: React.FC<WebConsoleHintProps>;
+export declare const LaunchOpenshiftConsoleButton: React.FC<LaunchOpenshiftConsoleButtonProps>;
+export declare const TroubleshootingOpenshiftConsoleButton: React.FC<WebConsoleHintProps>;
+export declare const ConsoleModal: React.FC<ConsoleModalProps>;
+export {};

package/dist/src/common/components/clusterDetail/FinalizingProgress.d.ts

@@ -0,0 +1,14 @@
+import { Cluster } from '../../api/types';
+import { EventListFetchProps } from '../../types';
+import React from 'react';
+declare type FinalizingProgressProps = {
+    cluster: Cluster;
+    onFetchEvents: EventListFetchProps['onFetchEvents'];
+    fallbackEventsURL?: string;
+};
+export declare const getFinalizingStatus: (cluster: Cluster) => {
+    finalizingIcon: JSX.Element;
+    initializationStatus: string;
+};
+export declare const FinalizingProgress: React.FC<FinalizingProgressProps>;
+export {};

package/dist/src/common/components/clusterDetail/KubeconfigDownload.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { Cluster } from '../../api/types';
+declare type KubeconfigDownloadProps = {
+    clusterId: Cluster['id'];
+    status: Cluster['status'];
+    id?: string;
+    handleDownload?: () => void;
+};
+declare const KubeconfigDownload: React.FC<KubeconfigDownloadProps>;
+export default KubeconfigDownload;

package/dist/src/common/components/clusterDetail/OperatorsProgressItem.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { MonitoredOperatorsList, OperatorStatus } from '../../api/types';
+import './OperatorsProgressItem.css';
+import { TFunction } from 'i18next';
+export declare function getAggregatedStatus(operators: MonitoredOperatorsList): "failed" | "progressing" | "available" | "pending";
+export declare const getOperatorCountString: (count: number) => string;
+export declare function getOperatorsLabel(operators: MonitoredOperatorsList, t: TFunction): string;
+export declare function getOperatorsIcon(status: OperatorStatus | 'pending'): JSX.Element;
+declare type OperatorsProgressItemProps = {
+    operators: MonitoredOperatorsList;
+};
+declare const OperatorsProgressItem: React.FC<OperatorsProgressItemProps>;
+export default OperatorsProgressItem;

package/dist/src/common/components/clusterDetail/ProgressBarTexts.d.ts

@@ -0,0 +1,7 @@
+import { Host, HostRole } from '../../api/types';
+declare type HostProgressProps = {
+    hosts: Host[];
+    hostRole: HostRole;
+};
+export declare const ProgressBarTexts: ({ hosts, hostRole }: HostProgressProps) => JSX.Element;
+export {};

package/dist/src/common/components/clusterDetail/index.d.ts

@@ -0,0 +1,4 @@
+export { default as ClusterPropertiesList } from './ClusterPropertiesList';
+export { default as ClusterProgress } from './ClusterProgress';
+export { default as ClusterCredentials } from './ClusterCredentials';
+export { default as KubeconfigDownload } from './KubeconfigDownload';

package/dist/src/common/components/clusterWizard/ClusterWizardStep.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import './ClusterWizardStep.css';
+declare type ClusterWizardStepProps = {
+    footer?: React.ReactNode;
+    navigation?: React.ReactNode;
+};
+declare const ClusterWizardStep: React.FC<ClusterWizardStepProps>;
+export default ClusterWizardStep;

package/dist/src/common/components/clusterWizard/ClusterWizardStepHeader.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const ClusterWizardStepHeader: React.FC;
+export default ClusterWizardStepHeader;

package/dist/src/common/components/clusterWizard/ClusterWizardStepValidationsAlert.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { WizardStepsValidationMap } from './validationsInfoUtils';
+import { Cluster } from '../../api/types';
+import { ValidationsInfo } from '../../types/clusters';
+import { ClusterWizardStepHostStatusDeterminationObject } from '../../types/hosts';
+declare type ClusterWizardStepValidationsAlertProps<ClusterWizardStepsType extends string> = {
+    currentStepId: ClusterWizardStepsType;
+    validationsInfo?: ValidationsInfo;
+    clusterStatus: Cluster['status'];
+    hosts: ClusterWizardStepHostStatusDeterminationObject[];
+    wizardStepsValidationsMap: WizardStepsValidationMap<ClusterWizardStepsType>;
+    children?: React.ReactNode;
+};
+declare const ClusterWizardStepValidationsAlert: <ClusterWizardStepsType extends string>({ currentStepId, clusterStatus, validationsInfo, hosts, wizardStepsValidationsMap, children, }: ClusterWizardStepValidationsAlertProps<ClusterWizardStepsType>) => JSX.Element;
+export default ClusterWizardStepValidationsAlert;

package/dist/src/common/components/clusterWizard/ReviewHostsInventory.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import { Host } from '../../api';
+declare const ReviewHostsInventory: React.FC<{
+    hosts?: Host[];
+}>;
+export default ReviewHostsInventory;

package/dist/src/common/components/clusterWizard/ReviewValidations.d.ts

@@ -0,0 +1,3 @@
+import { HostsValidationsFC, ClusterValidationsFC } from './types';
+export declare const ClusterValidations: ClusterValidationsFC;
+export declare const HostsValidations: HostsValidationsFC;

package/dist/src/common/components/clusterWizard/clusterDetailsValidation.d.ts

@@ -0,0 +1,24 @@
+import * as Yup from 'yup';
+import { Cluster, ManagedDomain } from '../../api';
+import { OpenshiftVersionOptionType } from '../../types';
+import { TangServer } from '../clusterConfiguration/DiskEncryptionFields/DiskEncryptionValues';
+import { FeatureSupportLevelData } from '../featureSupportLevels';
+import { ClusterDetailsValues } from './types';
+import { TFunction } from 'i18next';
+export declare const parseTangServers: (tangServersString?: string | undefined) => TangServer[];
+export declare const getClusterDetailsInitialValues: ({ cluster, pullSecret, managedDomains, ocpVersions, baseDomain, }: {
+    cluster?: Cluster | undefined;
+    pullSecret?: string | undefined;
+    managedDomains: ManagedDomain[];
+    ocpVersions: OpenshiftVersionOptionType[];
+    baseDomain?: string | undefined;
+}) => ClusterDetailsValues;
+export declare const getClusterDetailsValidationSchema: ({ usedClusterNames, featureSupportLevels, pullSecretSet, ocpVersions, validateUniqueName, isOcm, t, }: {
+    usedClusterNames: string[];
+    featureSupportLevels: FeatureSupportLevelData;
+    pullSecretSet?: boolean | undefined;
+    ocpVersions?: OpenshiftVersionOptionType[] | undefined;
+    validateUniqueName?: boolean | undefined;
+    isOcm?: boolean | undefined;
+    t: TFunction;
+}) => Yup.Lazy;

package/dist/src/common/components/clusterWizard/index.d.ts

@@ -0,0 +1,8 @@
+export { default as ClusterWizardStepHeader } from './ClusterWizardStepHeader';
+export { default as ClusterWizardStep } from './ClusterWizardStep';
+export { default as ClusterWizardStepValidationsAlert } from './ClusterWizardStepValidationsAlert';
+export { default as ReviewHostsInventory } from './ReviewHostsInventory';
+export { ClusterValidations, HostsValidations } from './ReviewValidations';
+export * from './clusterDetailsValidation';
+export * from './types';
+export * from './validationsInfoUtils';

package/dist/src/common/components/clusterWizard/networkingSteps/AvailableSubnetsControl.d.ts

@@ -0,0 +1,9 @@
+import { HostSubnets } from '../../../types/clusters';
+import { Host } from '../../../api';
+export interface AvailableSubnetsControlProps {
+    hostSubnets: HostSubnets;
+    hosts: Host[];
+    isRequired: boolean;
+    isMultiNodeCluster: boolean;
+}
+export declare const AvailableSubnetsControl: ({ hostSubnets, hosts, isRequired, isMultiNodeCluster, }: AvailableSubnetsControlProps) => JSX.Element;

package/dist/src/common/components/clusterWizard/networkingSteps/ManagedNetworkingControlGroup.d.ts

@@ -0,0 +1,5 @@
+export interface ManagedNetworkingControlGroupProps {
+    disabled: boolean;
+    tooltip?: string;
+}
+export declare const ManagedNetworkingControlGroup: ({ disabled, tooltip, }: ManagedNetworkingControlGroupProps) => JSX.Element;

package/dist/src/common/components/clusterWizard/networkingSteps/NetworkTypeControlGroup.d.ts

@@ -0,0 +1,5 @@
+export interface NetworkTypeControlGroupProps {
+    isDisabled?: boolean;
+    isSDNSelectable: boolean;
+}
+export declare const NetworkTypeControlGroup: ({ isDisabled, isSDNSelectable, }: NetworkTypeControlGroupProps) => JSX.Element;

package/dist/src/common/components/clusterWizard/networkingSteps/UserManagedNetworkingTextContent.d.ts

@@ -0,0 +1,4 @@
+export interface UserManagedNetworkingTextContentProps {
+    shouldDisplayLoadBalancersBullet?: boolean;
+}
+export declare const UserManagedNetworkingTextContent: ({ shouldDisplayLoadBalancersBullet, }: UserManagedNetworkingTextContentProps) => JSX.Element;

package/dist/src/common/components/clusterWizard/networkingSteps/VirtualIPControlGroup.d.ts

@@ -0,0 +1,8 @@
+import { Cluster } from '../../../api';
+import { HostSubnets } from '../../../types/clusters';
+export declare type VirtualIPControlGroupProps = {
+    cluster: Cluster;
+    hostSubnets: HostSubnets;
+    isVipDhcpAllocationDisabled?: boolean;
+};
+export declare const VirtualIPControlGroup: ({ cluster, hostSubnets, isVipDhcpAllocationDisabled, }: VirtualIPControlGroupProps) => JSX.Element;

package/dist/src/common/components/clusterWizard/networkingSteps/index.d.ts

@@ -0,0 +1,8 @@
+export { AvailableSubnetsControl } from './AvailableSubnetsControl';
+export type { AvailableSubnetsControlProps } from './AvailableSubnetsControl';
+export { UserManagedNetworkingTextContent } from './UserManagedNetworkingTextContent';
+export type { UserManagedNetworkingTextContentProps } from './UserManagedNetworkingTextContent';
+export { ManagedNetworkingControlGroup } from './ManagedNetworkingControlGroup';
+export type { ManagedNetworkingControlGroupProps } from './ManagedNetworkingControlGroup';
+export { VirtualIPControlGroup } from './VirtualIPControlGroup';
+export type { VirtualIPControlGroupProps } from './VirtualIPControlGroup';

package/dist/src/common/components/clusterWizard/types.d.ts

@@ -0,0 +1,62 @@
+import { DiskEncryption, Host, Cluster } from '../../api';
+import { ValidationGroup as ClusterValidationGroup, Validation as ClusterValidation } from '../../types/clusters';
+import { ValidationGroup as HostValidationGroup, Validation as HostValidation } from '../../types/hosts';
+import { TangServer } from '../clusterConfiguration/DiskEncryptionFields/DiskEncryptionValues';
+import { WizardStepsValidationMap } from './validationsInfoUtils';
+export declare type ClusterDetailsValues = {
+    name: string;
+    highAvailabilityMode: 'Full' | 'None';
+    openshiftVersion: string;
+    pullSecret: string;
+    baseDnsDomain: string;
+    SNODisclaimer: boolean;
+    useRedHatDnsService: boolean;
+    enableDiskEncryptionOnMasters: boolean;
+    enableDiskEncryptionOnWorkers: boolean;
+    diskEncryptionMode: DiskEncryption['mode'];
+    diskEncryptionTangServers: TangServer[];
+    diskEncryption: DiskEncryption;
+    cpuArchitecture: string;
+};
+export declare type HostsValidationsProps<S extends string, V extends string[]> = {
+    hosts?: Host[];
+    setCurrentStepId: (stepId: S) => void;
+    wizardStepNames: {
+        [key in S]: string;
+    };
+    allClusterWizardSoftValidationIds: V;
+    wizardStepsValidationsMap: WizardStepsValidationMap<S>;
+};
+export declare type HostsValidationsFC = <S extends string, V extends string[]>(props: HostsValidationsProps<S, V>) => JSX.Element;
+export declare type ClusterValidationsProps<S extends string> = {
+    validationsInfo?: Cluster['validationsInfo'];
+    setCurrentStepId: (stepId: S) => void;
+    wizardStepNames: {
+        [key in S]: string;
+    };
+    wizardStepsValidationsMap: WizardStepsValidationMap<S>;
+};
+export declare type ClusterValidationsFC = <S extends string>(props: ClusterValidationsProps<S>) => JSX.Element;
+export declare type FailingValidationsProps<S extends string> = {
+    validation: HostValidation | ClusterValidation;
+    setCurrentStepId: (stepId: S) => void;
+    clusterGroup?: ClusterValidationGroup;
+    hostGroup?: HostValidationGroup;
+    severity?: 'danger' | 'warning';
+    wizardStepNames: {
+        [key in S]: string;
+    };
+    wizardStepsValidationsMap: WizardStepsValidationMap<S>;
+};
+export declare type FailingValidationsFC = <S extends string>(props: FailingValidationsProps<S>) => JSX.Element;
+export declare type ValidationActionLinkProps<S extends string> = {
+    step: S;
+    setCurrentStepId: (stepId: S) => void;
+    wizardStepNames: {
+        [key in S]: string;
+    };
+};
+export declare type ValidationActionLinkFC = <S extends string>(props: ValidationActionLinkProps<S>) => JSX.Element;
+export declare type ClusterOperatorProps = Pick<Cluster, 'openshiftVersion'> & {
+    clusterId: Cluster['id'];
+};