@openshift-assisted/ui-lib 2.7.11-cim

package/dist/src/cim/components/Hypershift/modals/AddNodePoolModal.d.ts

@@ -0,0 +1,12 @@
+import { AgentK8sResource, ConfigMapK8sResource } from '../../../types';
+import { HostedClusterK8sResource, NodePoolK8sResource } from '../types';
+declare type AddNodePoolModalProps = {
+    agentsNamespace: string;
+    onSubmit: (nodePool: NodePoolK8sResource) => Promise<unknown>;
+    onClose: VoidFunction;
+    agents: AgentK8sResource[];
+    hostedCluster: HostedClusterK8sResource;
+    supportedVersionsCM?: ConfigMapK8sResource;
+};
+declare const AddNodePoolModal: ({ onSubmit, onClose, agents, hostedCluster, agentsNamespace, }: AddNodePoolModalProps) => JSX.Element;
+export default AddNodePoolModal;

package/dist/src/cim/components/Hypershift/modals/ManageHostsModal.d.ts

@@ -0,0 +1,16 @@
+import { AgentK8sResource } from '../../../types';
+import { NodePoolK8sResource, HostedClusterK8sResource, AgentMachineK8sResource } from '../types';
+declare type ManageHostsModalProps = {
+    hostedCluster: HostedClusterK8sResource;
+    agents: AgentK8sResource[];
+    nodePool: NodePoolK8sResource;
+    onClose: VoidFunction;
+    onSubmit: (nodePool: NodePoolK8sResource, nodePoolPatches: {
+        op: string;
+        value: unknown;
+        path: string;
+    }[]) => Promise<unknown>;
+    agentMachines: AgentMachineK8sResource[];
+};
+declare const ManageHostsModal: ({ onClose, nodePool, hostedCluster, agents, onSubmit, agentMachines, }: ManageHostsModalProps) => JSX.Element;
+export default ManageHostsModal;

package/dist/src/cim/components/Hypershift/modals/NodePoolForm.d.ts

@@ -0,0 +1,18 @@
+import { AgentK8sResource } from '../../../types';
+import { AgentMachineK8sResource, HostedClusterK8sResource, NodePoolK8sResource } from '../types';
+export declare type NodePoolFormValues = {
+    nodePoolName: string;
+    agentLabels: {
+        key: string;
+        value: string;
+    }[];
+    count: number;
+};
+declare type NodePoolFormProps = {
+    agents: AgentK8sResource[];
+    agentMachines?: AgentMachineK8sResource[];
+    hostedCluster: HostedClusterK8sResource;
+    nodePool?: NodePoolK8sResource;
+};
+declare const NodePoolForm: ({ agents, nodePool, hostedCluster, agentMachines }: NodePoolFormProps) => JSX.Element;
+export default NodePoolForm;

package/dist/src/cim/components/Hypershift/modals/RemoveNodePoolModal.d.ts

@@ -0,0 +1,8 @@
+import { NodePoolK8sResource } from '../types';
+declare type RemoveNodePoolModalProps = {
+    nodePool: NodePoolK8sResource;
+    onClose: VoidFunction;
+    onRemove: (nodePool: NodePoolK8sResource) => Promise<unknown>;
+};
+declare const RemoveNodePoolModal: ({ onClose, onRemove, nodePool }: RemoveNodePoolModalProps) => JSX.Element;
+export default RemoveNodePoolModal;

package/dist/src/cim/components/Hypershift/types.d.ts

@@ -0,0 +1,195 @@
+import { K8sResourceCommon } from '@openshift-console/dynamic-plugin-sdk';
+import { StatusCondition } from '../../types/k8s/shared';
+export declare type NodePoolK8sResource = K8sResourceCommon & {
+    spec: {
+        clusterName: string;
+        replicas: number;
+        management: {
+            autoRepair?: boolean;
+            replace?: {
+                rollingUpdate: {
+                    maxSurge: number;
+                    maxUnavailable: number;
+                };
+                strategy: 'RollingUpdate' | 'OnDelete';
+            };
+            upgradeType: 'Replace' | 'InPlace';
+        };
+        autoScaling?: {
+            min: number;
+            max: number;
+        };
+        platform: {
+            type: string;
+            agent?: {
+                agentLabelSelector?: {
+                    matchLabels?: {
+                        [key: string]: string;
+                    };
+                };
+            };
+            aws?: {
+                instanceProfile: string;
+                instanceType: string;
+                rootVolume: {
+                    size: number;
+                    type: string;
+                };
+                securityGroups: {
+                    id: string;
+                }[];
+                subnet: {
+                    id: string;
+                };
+            };
+        };
+        release: {
+            image: string;
+        };
+    };
+    status?: {
+        conditions?: StatusCondition<string>[];
+        replicas?: number;
+        version?: string;
+    };
+};
+export declare type HostedClusterK8sResource = K8sResourceCommon & {
+    spec: {
+        autoscaling?: {
+            maxNodeProvisionTime?: string;
+            maxNodesTotal?: number;
+            maxPodGracePeriod?: number;
+            podPriorityThreshold?: number;
+        };
+        clusterID?: string;
+        controllerAvailabilityPolicy?: string;
+        dns: {
+            baseDomain: string;
+            privateZoneID?: string;
+            publicZoneID?: string;
+        };
+        etcd?: {
+            managementType: 'Managed' | 'Unmanaged';
+            managed?: Record<string, unknown>;
+            unmanaged?: Record<string, unknown>;
+        };
+        networking?: {
+            apiServer?: {
+                advertiseAddress?: string;
+                allowedCIDRBlocks?: string;
+                port?: number;
+            };
+            clusterNetwork?: {
+                cidr: string;
+                hostPrefix?: number;
+            }[];
+            machineCIDR?: string;
+            machineNetwork?: {
+                cidr: string;
+            }[];
+            networkType: 'OpenShiftSDN' | 'Calico' | 'OVNKubernetes' | 'Other';
+            podCIDR?: string;
+            serviceCIDR?: string;
+            serviceNetwork?: {
+                cidr: string;
+            }[];
+        };
+        fips?: boolean;
+        infraID?: string;
+        infrastructureAvailabilityPolicy?: string;
+        issuerURL?: string;
+        olmCatalogPlacement?: 'management' | 'guest';
+        release: {
+            image: string;
+        };
+        secretEncryption?: Record<string, unknown>;
+        services: {
+            service: 'APIServer' | 'OAuthServer' | 'OIDC' | 'Konnectivity' | 'Ignition' | 'OVNSbDb';
+            servicePublishingStrategy: {
+                loadBalancer?: {
+                    hostname?: string;
+                };
+                nodePort?: {
+                    address: string;
+                    port?: number;
+                };
+                route?: {
+                    hostname?: string;
+                };
+                type: 'LoadBalancer' | 'NodePort' | 'Route' | 'None' | 'S3';
+            };
+        }[];
+        platform: {
+            agent?: {
+                agentNamespace: string;
+            };
+            aws?: {
+                cloudProviderConfig: {
+                    subnet: {
+                        id: string;
+                    };
+                    vpc: string;
+                    zone: string;
+                };
+                controlPlaneOperatorCreds: {
+                    name?: string;
+                };
+                endpointAccess: 'Public';
+                kubeCloudControllerCreds: {
+                    name?: string;
+                };
+                nodePoolManagementCreds: {
+                    name?: string;
+                };
+                region: 'us-west-2';
+                resourceTags: [{
+                    key: 'kubernetes.io/cluster/feng-hs-scale-74zxh';
+                    value: 'owned';
+                }];
+            };
+            powervs?: Record<string, unknown>;
+            azure?: Record<string, unknown>;
+            type?: 'AWS' | 'None' | 'IBMCloud' | 'Agent' | 'KubeVirt' | 'Azure' | 'PowerVS';
+        };
+        sshKey: {
+            name: string;
+        };
+        pullSecret: {
+            name: string;
+        };
+    };
+    status?: {
+        conditions?: StatusCondition<string>[];
+        kubeconfig?: {
+            name: string;
+        };
+        kubeadminPassword?: {
+            name: string;
+        };
+        ignitionEndpoint?: string;
+        oauthCallbackURLTemplate?: string;
+        version?: {
+            desired: {
+                image: string;
+            };
+            history: {
+                acceptedRisks?: string;
+                completionTime: string;
+                image: string;
+                startedTime: string;
+                state: string;
+                verified: boolean;
+                version?: string;
+            }[];
+            observedGeneration: number;
+        };
+    };
+};
+export declare type AgentMachineK8sResource = K8sResourceCommon & {
+    status?: {
+        agentRef?: {
+            name: string;
+            namespace: string;
+        };
+    };
+};

package/dist/src/cim/components/Hypershift/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './labels';
+export * from './nodepool';
+export * from './status';

package/dist/src/cim/components/Hypershift/utils/labels.d.ts

@@ -0,0 +1,10 @@
+export declare const labelsToFormikValue: (labels: {
+    [key: string]: string;
+}) => {
+    key: string;
+    value: string;
+}[];
+export declare const formikLabelsToLabels: (labels: {
+    key: string;
+    value: string;
+}[]) => {};

package/dist/src/cim/components/Hypershift/utils/nodepool.d.ts

@@ -0,0 +1,3 @@
+import { AgentK8sResource } from '../../../types';
+import { AgentMachineK8sResource, HostedClusterK8sResource, NodePoolK8sResource } from '../types';
+export declare const getNodepoolAgents: (nodePool: NodePoolK8sResource, agents: AgentK8sResource[], agentMachines: AgentMachineK8sResource[], hostedCluster: HostedClusterK8sResource) => AgentK8sResource[];

package/dist/src/cim/components/Hypershift/utils/status.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { AgentK8sResource } from '../../../types';
+import { NodePoolK8sResource } from '../types';
+import { TFunction } from 'i18next';
+export declare type NodePoolStatus = {
+    type: 'error' | 'pending' | 'ok' | 'warning';
+    text: string;
+    icon: React.ReactNode;
+};
+export declare const getNodePoolStatus: (nodePool: NodePoolK8sResource, agents: AgentK8sResource[], t: TFunction) => NodePoolStatus;

package/dist/src/cim/components/InfraEnv/AddHostDropdown.d.ts

@@ -0,0 +1,4 @@
+import { AddHostDropdownProps } from './types';
+import './AddHostDropdown.css';
+declare const AddHostDropdown: ({ infraEnv, agentClusterInstall, onSaveISOParams, usedHostnames, onCreateBMH, docVersion, onCreateBmcByYaml, isBMPlatform, }: AddHostDropdownProps) => JSX.Element;
+export default AddHostDropdown;

package/dist/src/cim/components/InfraEnv/AgentAlerts.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { BareMetalHostK8sResource, InfraEnvK8sResource } from '../../types';
+declare type AgentAlertsProps = {
+    docVersion: string;
+    infraEnv: InfraEnvK8sResource;
+    bareMetalHosts: BareMetalHostK8sResource[];
+};
+declare const AgentAlerts: React.FC<AgentAlertsProps>;
+export default AgentAlerts;

package/dist/src/cim/components/InfraEnv/EnvironmentDetails.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { InfraEnvK8sResource, SecretK8sResource } from '../../types';
+import { EditPullSecretModalProps } from '../modals/EditPullSecretModal';
+import { EditSSHKeyModalProps } from '../modals/EditSSHKeyModal';
+import { EditNtpSourcesModalProps } from '../modals/EditNtpSourcesModal';
+declare type EnvironmentDetailsProps = {
+    infraEnv: InfraEnvK8sResource;
+    fetchSecret: (namespace: string, name: string) => Promise<SecretK8sResource>;
+    onEditPullSecret: EditPullSecretModalProps['onSubmit'];
+    onEditSSHKey: EditSSHKeyModalProps['onSubmit'];
+    onEditNtpSources: EditNtpSourcesModalProps['onSubmit'];
+    hasAgents: boolean;
+    hasBMHs: boolean;
+};
+declare const EnvironmentDetails: React.FC<EnvironmentDetailsProps>;
+export default EnvironmentDetails;

package/dist/src/cim/components/InfraEnv/EnvironmentErrors.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { InfraEnvK8sResource } from '../../types';
+export declare type EnvironmentErrorsProps = {
+    infraEnv: InfraEnvK8sResource;
+    docVersion: string;
+    inModal?: boolean;
+    children?: React.ReactNode;
+};
+export declare const EnvironmentErrors: React.FC<EnvironmentErrorsProps>;

package/dist/src/cim/components/InfraEnv/InfraEnvAgentTable.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import { InfraEnvAgentTableProps } from '../ClusterDeployment/types';
+declare const InfraEnvAgentTable: React.FC<InfraEnvAgentTableProps>;
+export default InfraEnvAgentTable;

package/dist/src/cim/components/InfraEnv/InfraEnvFormPage.d.ts

@@ -0,0 +1,31 @@
+import * as React from 'react';
+import { FormikProps } from 'formik';
+import { CpuArchitecture } from '../../../common';
+import './infra-env.css';
+export declare type EnvironmentStepFormValues = {
+    name: string;
+    location: string;
+    pullSecret: string;
+    sshPublicKey: string;
+    httpProxy: string;
+    httpsProxy: string;
+    noProxy: string;
+    enableProxy: boolean;
+    labels: string[];
+    networkType: 'dhcp' | 'static';
+    cpuArchitecture: CpuArchitecture;
+    enableNtpSources: boolean;
+    additionalNtpSources: string;
+};
+declare type InfraEnvFormProps = {
+    onValuesChanged?: (values: EnvironmentStepFormValues) => void;
+};
+declare type InfraEnvFormPageProps = InfraEnvFormProps & {
+    usedNames: string[];
+    onSubmit?: (values: EnvironmentStepFormValues) => Promise<any>;
+    onFinish?: (values: EnvironmentStepFormValues) => void;
+    onClose?: VoidFunction;
+    formRef: React.Ref<FormikProps<EnvironmentStepFormValues>>;
+};
+export declare const InfraEnvFormPage: React.FC<InfraEnvFormPageProps>;
+export {};

package/dist/src/cim/components/InfraEnv/InfraEnvHostsTabAgentsWarning.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { AgentK8sResource, BareMetalHostK8sResource } from '../../types';
+export declare type InfraEnvHostsTabAgentsWarning = {
+    infraAgents: AgentK8sResource[];
+    infraBMHs: BareMetalHostK8sResource[];
+};
+declare const InfraEnvHostsTabAgentsWarning: React.FC<InfraEnvHostsTabAgentsWarning>;
+export default InfraEnvHostsTabAgentsWarning;

package/dist/src/cim/components/InfraEnv/InfraTableToolbar.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { Host } from '../../../common';
+import { usePagination } from '../../../common/components/hosts/usePagination';
+declare type InfraTableToolbarProps = ReturnType<typeof usePagination> & {
+    setSelectedHostIDs: (items: string[]) => void;
+    massActions: React.ReactNode[];
+    hosts: Host[];
+    statusFilter: string[];
+    statusCount: object;
+    hostnameFilter: string | undefined;
+    setHostnameFilter: (hostname: string | undefined) => void;
+    setStatusFilter: (status: string[]) => void;
+    selectedHostIDs: string[];
+};
+declare const InfraTableToolbar: React.FC<InfraTableToolbarProps>;
+export default InfraTableToolbar;

package/dist/src/cim/components/InfraEnv/index.d.ts

@@ -0,0 +1,8 @@
+export { default as EnvironmentDetails } from './EnvironmentDetails';
+export { default as InfraEnvAgentTable } from './InfraEnvAgentTable';
+export { default as InfraEnvHostsTabAgentsWarning } from './InfraEnvHostsTabAgentsWarning';
+export { default as AgentAlerts } from './AgentAlerts';
+export { default as AddHostDropdown } from './AddHostDropdown';
+export * from './EnvironmentErrors';
+export * from './InfraEnvFormPage';
+export * from './utils';

package/dist/src/cim/components/InfraEnv/types.d.ts

@@ -0,0 +1,12 @@
+import { AgentClusterInstallK8sResource, InfraEnvK8sResource } from '../../types';
+import { AddBmcHostModalProps, AddHostModalProps, UploadActionModalProps } from '../modals/types';
+export declare type AddHostDropdownProps = {
+    infraEnv: InfraEnvK8sResource;
+    agentClusterInstall?: AgentClusterInstallK8sResource;
+    docVersion: string;
+    onSaveISOParams: AddHostModalProps['onSaveISOParams'];
+    onCreateBMH: AddBmcHostModalProps['onCreateBMH'];
+    usedHostnames: AddBmcHostModalProps['usedHostnames'];
+    onCreateBmcByYaml: UploadActionModalProps['onCreateBmcByYaml'];
+    isBMPlatform: boolean;
+};

package/dist/src/cim/components/InfraEnv/utils.d.ts

@@ -0,0 +1,13 @@
+import { AgentClusterInstallK8sResource, ClusterDeploymentK8sResource, InfraEnvK8sResource, SecretK8sResource } from '../../types';
+import { EnvironmentStepFormValues } from './InfraEnvFormPage';
+export declare const getLabels: (values: EnvironmentStepFormValues) => {};
+export declare const getClusterDeploymentForInfraEnv: (pullSecretName: string, namespace: string, values: EnvironmentStepFormValues) => ClusterDeploymentK8sResource;
+declare type GetAgentClusterInstallProps = {
+    clusterDeploymentName?: string;
+    namespace: string;
+    values: EnvironmentStepFormValues;
+};
+export declare const getAgentClusterInstall: ({ clusterDeploymentName, namespace, values, }: GetAgentClusterInstallProps) => AgentClusterInstallK8sResource;
+export declare const getSecret: (namespace: string, values: EnvironmentStepFormValues) => SecretK8sResource;
+export declare const getInfraEnv: (namespace: string, values: EnvironmentStepFormValues) => InfraEnvK8sResource;
+export {};

package/dist/src/cim/components/YamlPreview/YamlPreview.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+declare type YamlPreviewProps = {
+    code: string;
+    setPreviewOpen: (open: boolean) => void;
+    loading: boolean;
+};
+declare const YamlPreview: React.FC<YamlPreviewProps>;
+export default YamlPreview;

package/dist/src/cim/components/YamlPreview/index.d.ts

@@ -0,0 +1,2 @@
+export { default as YamlPreview } from './YamlPreview';
+export { useYamlPreview } from './useYAMLPreview';

package/dist/src/cim/components/YamlPreview/useYAMLPreview.d.ts

@@ -0,0 +1,14 @@
+import { K8sResourceCommon } from '@openshift-console/dynamic-plugin-sdk';
+import { ClusterDeploymentK8sResource, AgentClusterInstallK8sResource, SecretK8sResource } from '../../types';
+declare type YamlPreviewArgs = {
+    clusterDeployment: ClusterDeploymentK8sResource;
+    agentClusterInstall: AgentClusterInstallK8sResource;
+    fetchSecret: (namespace: string, bmhName: string) => Promise<SecretK8sResource>;
+    fetchManagedClusters: () => Promise<K8sResourceCommon[]>;
+    fetchKlusterletAddonConfig: () => Promise<K8sResourceCommon[]>;
+};
+export declare const useYamlPreview: ({ clusterDeployment, agentClusterInstall, fetchSecret, fetchManagedClusters, fetchKlusterletAddonConfig, }: YamlPreviewArgs) => {
+    code: string;
+    loadingResources: boolean;
+};
+export {};

package/dist/src/cim/components/common/InfoAndTroubleshootingNotification.d.ts

@@ -0,0 +1,7 @@
+import { ConfigMapK8sResource } from '../../types/fromOCP/k8sTypes';
+declare type InfoAndTroubleshootingNotificationProps = {
+    isSNO?: boolean;
+    assistedServiceConfigMap: ConfigMapK8sResource;
+};
+declare const InfoAndTroubleshootingNotification: ({ isSNO, assistedServiceConfigMap, }: InfoAndTroubleshootingNotificationProps) => JSX.Element;
+export default InfoAndTroubleshootingNotification;

package/dist/src/cim/components/common/ResourceAlerts.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { StatusCondition } from '../../types';
+import './ResourceAlerts.css';
+export declare const SingleResourceAlerts: React.FC<{
+    conditions: StatusCondition<string>[];
+    title: string;
+}>;

package/dist/src/cim/components/common/SpecSyncErrAlert.d.ts

@@ -0,0 +1,5 @@
+import { AgentK8sResource } from '../../types';
+declare const SpecSyncErrAlert: ({ agent }: {
+    agent: AgentK8sResource;
+}) => JSX.Element;
+export default SpecSyncErrAlert;

package/dist/src/cim/components/common/ValidationsRunningAlert.d.ts

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

package/dist/src/cim/components/common/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const AGENT_LOCATION_LABEL_KEY = "agentclusterinstalls.extensions.hive.openshift.io/location";
+export declare const AGENT_SELECTOR = "agentBareMetal-agentSelector-";
+export declare const AGENT_AUTO_SELECT_ANNOTATION_KEY = "agentBareMetal-agentSelector/autoSelect";
+export declare const AGENT_NOLOCATION_VALUE = "NOLOCATION";
+export declare const INFRAENV_AGENTINSTALL_LABEL_KEY = "infraenvs.agent-install.openshift.io";
+export declare const AGENT_BMH_NAME_LABEL_KEY = "agent-install.openshift.io/bmh";
+export declare const INFRAENV_GENERATED_AI_FLOW = "agentBareMetal-generated-infraenv-ai-flow";
+export declare const CPU_ARCHITECTURE_ANNOTATION_KEY = "agentBareMetal-cpuArchitecture";
+export declare const getInfraEnvDocs: (docVersion: string) => string;
+export declare const BMH_HOSTNAME_ANNOTATION = "bmac.agent-install.openshift.io/hostname";

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

@@ -0,0 +1,2 @@
+export * from './constants';
+export { default as InfoAndTroubleshootingNotification } from './InfoAndTroubleshootingNotification';

package/dist/src/cim/components/featureSupportLevels/ACMFeatureSupportLevelProvider.d.ts

@@ -0,0 +1,8 @@
+import React, { PropsWithChildren } from 'react';
+import { ClusterImageSetK8sResource } from '../../types';
+export declare type ACMFeatureSupportLevelProvider = PropsWithChildren<{
+    clusterImages: ClusterImageSetK8sResource[];
+    isEditClusterFlow?: boolean;
+}>;
+export declare const ACMFeatureSupportLevelProvider: React.FC<ACMFeatureSupportLevelProvider>;
+export default ACMFeatureSupportLevelProvider;

package/dist/src/cim/components/featureSupportLevels/featureStateUtils.d.ts

@@ -0,0 +1,4 @@
+import { FeatureId, OpenshiftVersionOptionType, SupportLevel } from '../../../common/types';
+import { TFunction } from 'i18next';
+export declare const getFeatureDisabledReason: (featureId: FeatureId, clusterExists: boolean, versionName: string, versionOptions: OpenshiftVersionOptionType[], isSupported: boolean, t: TFunction) => string | undefined;
+export declare const isFeatureSupported: (supportLevel: SupportLevel | undefined) => boolean;

package/dist/src/cim/components/featureSupportLevels/index.d.ts

@@ -0,0 +1 @@
+export { default as ACMFeatureSupportLevelProvider } from './ACMFeatureSupportLevelProvider';

package/dist/src/cim/components/helpers/agentClusterInstall.d.ts

@@ -0,0 +1,3 @@
+import { AgentClusterInstallK8sResource, AgentK8sResource } from '../../types/k8s';
+export declare const getIsSNOCluster: (agentClusterInstall?: AgentClusterInstallK8sResource | undefined) => boolean;
+export declare const getAgentClusterInstallOfAgent: (agentClusterInstalls: AgentClusterInstallK8sResource[], agent?: AgentK8sResource | undefined) => AgentClusterInstallK8sResource | undefined;

package/dist/src/cim/components/helpers/agentStatus.d.ts

@@ -0,0 +1,3 @@
+import { HostStatus } from '../../../common/components/hosts/types';
+export declare const bmhStatus: HostStatus<string>;
+export declare const agentStatus: HostStatus<string>;

package/dist/src/cim/components/helpers/agents.d.ts

@@ -0,0 +1,15 @@
+import { Host } from '../../../common/api/types';
+import { AgentK8sResource, BareMetalHostK8sResource } from '../../types';
+export declare const hostToAgent: (agents: AgentK8sResource[] | undefined, host: Host) => AgentK8sResource;
+export declare const getAgentsForSelection: (agents: AgentK8sResource[]) => AgentK8sResource[];
+export declare const getAgentRole: (agent: AgentK8sResource) => import("../../../common/api/types").HostRole;
+export declare const getAgentProgress: (agent: AgentK8sResource) => {
+    currentStage?: "Starting installation" | "Waiting for control plane" | "Waiting for bootkube" | "Waiting for controller" | "Installing" | "Writing image to disk" | "Rebooting" | "Waiting for ignition" | "Configuring" | "Joined" | "Done" | "Failed" | undefined;
+    installationPercentage?: number | undefined;
+    progressInfo?: string | undefined;
+    progressStages?: import("../../../common/api/types").HostStage[] | undefined;
+    stageStartTime?: string | undefined;
+    stageUpdateTime?: string | undefined;
+} | undefined;
+export declare const getInfraEnvNameOfAgent: (resource?: BareMetalHostK8sResource | AgentK8sResource | undefined) => string | undefined;
+export declare const getClusterNameOfAgent: (agent?: AgentK8sResource | undefined) => string | undefined;

package/dist/src/cim/components/helpers/clusterDeployment.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="react" />
+import { ObjectMetadata } from '@openshift-console/dynamic-plugin-sdk';
+import { CpuArchitecture } from '../../../common';
+import { AgentClusterInstallK8sResource, ClusterDeploymentK8sResource, InfraEnvK8sResource } from '../../types';
+import { AgentSelectorChangeProps, ClusterDeploymentHostsSelectionValues } from '../ClusterDeployment/types';
+export declare type ClusterDeploymentParams = {
+    name: string;
+    namespace: string;
+    baseDnsDomain: string;
+    annotations?: {
+        [key: string]: string;
+    };
+    pullSecretName: string;
+};
+export declare const getAgentSelectorFieldsFromAnnotations: (annotations?: ObjectMetadata['annotations']) => AgentSelectorChangeProps;
+export declare const getAnnotationsFromAgentSelector: (clusterDeployment: ClusterDeploymentK8sResource, values: ClusterDeploymentHostsSelectionValues) => ObjectMetadata['annotations'];
+export declare const getClusterDeploymentResource: ({ name, namespace, baseDnsDomain, annotations, pullSecretName, }: ClusterDeploymentParams) => ClusterDeploymentK8sResource;
+export declare const getConsoleUrl: (clusterDeployment?: ClusterDeploymentK8sResource | undefined, agentClusterInstall?: AgentClusterInstallK8sResource | undefined) => string | undefined;
+export declare const getClusterApiUrl: (clusterDeployment?: ClusterDeploymentK8sResource | undefined, agentClusterInstall?: AgentClusterInstallK8sResource | undefined) => string | undefined;
+declare type ClusterPropertyKeys = 'name' | 'openshiftVersion' | 'baseDnsDomain' | 'apiVip' | 'ingressVip' | 'clusterId' | 'clusterNetworkCidr' | 'clusterNetworkHostPrefix' | 'serviceNetworkCidr' | 'installedTimestamp';
+declare type ClusterPropertyItem = {
+    key: string;
+    value?: React.ReactNode;
+};
+export declare const getClusterProperties: (clusterDeployment: ClusterDeploymentK8sResource, agentClusterInstall: AgentClusterInstallK8sResource) => {
+    name: ClusterPropertyItem;
+    clusterNetworkCidr: ClusterPropertyItem;
+    clusterNetworkHostPrefix: ClusterPropertyItem;
+    serviceNetworkCidr: ClusterPropertyItem;
+    apiVip: ClusterPropertyItem;
+    ingressVip: ClusterPropertyItem;
+    baseDnsDomain: ClusterPropertyItem;
+    openshiftVersion: ClusterPropertyItem;
+    clusterId: ClusterPropertyItem;
+    installedTimestamp: ClusterPropertyItem;
+};
+export declare const getClusterDeploymentCpuArchitecture: (clusterDeployment: ClusterDeploymentK8sResource, infraEnv?: InfraEnvK8sResource | undefined) => CpuArchitecture.x86 | CpuArchitecture.ARM;
+export {};

package/dist/src/cim/components/helpers/conditions.d.ts

@@ -0,0 +1,9 @@
+import { StatusCondition } from '../../types';
+import { AgentK8sResource } from '../../types/k8s/agent';
+export declare const REQUIRED_AGENT_CONDITION_TYPES: string[];
+export declare const getFailingAgentConditions: (agents?: AgentK8sResource[]) => {};
+export declare const getFailingResourceConditions: (resource?: {
+    status?: {
+        conditions?: StatusCondition<string>[];
+    };
+}, ofType?: string[] | undefined) => StatusCondition<string>[];

package/dist/src/cim/components/helpers/index.d.ts

@@ -0,0 +1,11 @@
+export * from './units';
+export * from './status';
+export * from './toAssisted';
+export * from './network';
+export * from './conditions';
+export * from './versions';
+export * from './labels';
+export * from './agents';
+export * from './clusterDeployment';
+export * from './agentClusterInstall';
+export * from './storage';

package/dist/src/cim/components/helpers/labels.d.ts

@@ -0,0 +1,3 @@
+import { MatchExpression } from '@openshift-console/dynamic-plugin-sdk/lib/api/common-types';
+export declare const getLocationsFromMatchExpressions: (expressions?: MatchExpression[]) => string[];
+export declare const getAgentLocationMatchExpression: (locations?: string[] | undefined) => MatchExpression[] | undefined;

package/dist/src/cim/components/helpers/network.d.ts

@@ -0,0 +1,6 @@
+import { AgentK8sResource } from '../../types/k8s/agent';
+import { AgentClusterInstallK8sResource } from '../../types/k8s/agent-cluster-install';
+export declare const getHostNetworks: (agents: AgentK8sResource[], agentClusterInstall?: AgentClusterInstallK8sResource | undefined) => {
+    cidr: string;
+    hostIds: string[];
+}[];

package/dist/src/cim/components/helpers/proxy.d.ts

@@ -0,0 +1 @@
+export declare const getK8sProxyURL: (aiNamespace?: string) => string;