v1beta2

const (
	// KubeadmControlPlaneFinalizer is the finalizer applied to KubeadmControlPlane resources
	// by its managing controller.
	KubeadmControlPlaneFinalizer = "kubeadm.controlplane.cluster.x-k8s.io"

	// SkipCoreDNSAnnotation annotation explicitly skips reconciling CoreDNS if set.
	SkipCoreDNSAnnotation = "controlplane.cluster.x-k8s.io/skip-coredns"

	// SkipKubeProxyAnnotation annotation explicitly skips reconciling kube-proxy if set.
	SkipKubeProxyAnnotation = "controlplane.cluster.x-k8s.io/skip-kube-proxy"

	// RemediationInProgressAnnotation is used to keep track that a KCP remediation is in progress, and more
	// specifically it tracks that the system is in between having deleted an unhealthy machine and recreating its replacement.
	// NOTE: if something external to CAPI removes this annotation the system cannot detect the above situation; this can lead to
	// failures in updating remediation retry or remediation count (both counters restart from zero).
	RemediationInProgressAnnotation = "controlplane.cluster.x-k8s.io/remediation-in-progress"

	// RemediationForAnnotation is used to link a new machine to the unhealthy machine it is replacing;
	// please note that in case of retry, when also the remediating machine fails, the system keeps track of
	// the first machine of the sequence only.
	// NOTE: if something external to CAPI removes this annotation the system this can lead to
	// failures in updating remediation retry (the counter restarts from zero).
	RemediationForAnnotation = "controlplane.cluster.x-k8s.io/remediation-for"

	// PreTerminateHookCleanupAnnotation is the annotation KCP sets on Machines to ensure it can later remove the
	// etcd member right before Machine termination (i.e. before InfraMachine deletion).
	// Note: Starting with Kubernetes v1.31 this hook will wait for all other pre-terminate hooks to finish to
	// ensure it runs last (thus ensuring that kubelet is still working while other pre-terminate hooks run).
	PreTerminateHookCleanupAnnotation = clusterv1.PreTerminateDeleteHookAnnotationPrefix + "/kcp-cleanup"

	// DefaultMinHealthyPeriodSeconds defines the default minimum period before we consider a remediation on a
	// machine unrelated from the previous remediation.
	DefaultMinHealthyPeriodSeconds = int32(60 * 60)
)

const (
	// KubeadmControlPlaneAvailableCondition is true if KubeadmControlPlane is not deleted, `CertificatesAvailable` is true,
	// at least one Machine with healthy control plane components, and etcd has enough operational members to meet quorum requirements.
	// More specifically, considering how kubeadm layouts components:
	// -  Kubernetes API server, scheduler and controller manager health is inferred by the status of
	//    the corresponding Pods hosted on each machine.
	// -  In case of managed etcd, also a healthy etcd Pod and a healthy etcd member must exist on the same
	//    machine with the healthy Kubernetes API server, scheduler and controller manager, otherwise the k8s control
	//    plane cannot be considered operational (if etcd is not operational on a machine, most likely also API server,
	//    scheduler and controller manager on the same machine will be impacted).
	// -  In case of external etcd, KCP cannot make any assumption on etcd status, so all the etcd checks are skipped.
	//
	// Please note that when this condition is true, partial unavailability will be surfaced in the condition message,
	// but with a 10s delay to ensure flakes do not impact condition stability.
	KubeadmControlPlaneAvailableCondition = clusterv1.AvailableCondition

	// KubeadmControlPlaneAvailableInspectionFailedReason documents a failure when inspecting the status of the
	// etcd cluster hosted on KubeadmControlPlane controlled machines.
	KubeadmControlPlaneAvailableInspectionFailedReason = clusterv1.InspectionFailedReason

	// KubeadmControlPlaneAvailableReason surfaces when the KubeadmControlPlane is available.
	KubeadmControlPlaneAvailableReason = clusterv1.AvailableReason

	// KubeadmControlPlaneNotAvailableReason surfaces when the KubeadmControlPlane is not available.
	KubeadmControlPlaneNotAvailableReason = clusterv1.NotAvailableReason
)

const (
	// KubeadmControlPlaneInitializedCondition is true when the control plane is functional enough to accept
	// requests. This information is usually used as a signal for starting all the provisioning operations that
	// depend on a functional API server, but do not require a full HA control plane to exist.
	KubeadmControlPlaneInitializedCondition = "Initialized"

	// KubeadmControlPlaneInitializedReason surfaces when the control plane is initialized.
	KubeadmControlPlaneInitializedReason = "Initialized"

	// KubeadmControlPlaneNotInitializedReason surfaces when the control plane is not initialized.
	KubeadmControlPlaneNotInitializedReason = "NotInitialized"
)

const (
	// KubeadmControlPlaneCertificatesAvailableCondition True if all the cluster certificates exist.
	KubeadmControlPlaneCertificatesAvailableCondition = "CertificatesAvailable"

	// KubeadmControlPlaneCertificatesInternalErrorReason surfaces unexpected failures when reconciling cluster certificates.
	KubeadmControlPlaneCertificatesInternalErrorReason = clusterv1.InternalErrorReason

	// KubeadmControlPlaneCertificatesAvailableReason surfaces when cluster certificates are available,
	// no matter if those certificates have been provided by the user or generated by  KubeadmControlPlane itself.
	// Cluster certificates include: certificate authorities for ca, sa, front-proxy, etcd, and if external etcd is used,
	// also the apiserver-etcd-client client certificate.
	KubeadmControlPlaneCertificatesAvailableReason = clusterv1.AvailableReason
)

const (
	// KubeadmControlPlaneEtcdClusterHealthyCondition surfaces issues to etcd cluster hosted on machines managed by this object.
	// It is computed as aggregation of Machine's EtcdMemberHealthy conditions plus additional checks validating
	// potential issues to etcd quorum.
	// Note: this condition is not set when using an external etcd.
	KubeadmControlPlaneEtcdClusterHealthyCondition = "EtcdClusterHealthy"

	// KubeadmControlPlaneEtcdClusterInspectionFailedReason documents a failure when inspecting the status of the
	// etcd cluster hosted on KubeadmControlPlane controlled machines.
	KubeadmControlPlaneEtcdClusterInspectionFailedReason = clusterv1.InspectionFailedReason

	// KubeadmControlPlaneEtcdClusterConnectionDownReason surfaces that the connection to the workload
	// cluster is down.
	KubeadmControlPlaneEtcdClusterConnectionDownReason = clusterv1.ConnectionDownReason

	// KubeadmControlPlaneEtcdClusterHealthyReason surfaces when the etcd cluster hosted on KubeadmControlPlane
	// machines is healthy.
	KubeadmControlPlaneEtcdClusterHealthyReason = "Healthy"

	// KubeadmControlPlaneEtcdClusterNotHealthyReason surfaces when the etcd cluster hosted on KubeadmControlPlane
	// machines is not healthy.
	KubeadmControlPlaneEtcdClusterNotHealthyReason = "NotHealthy"

	// KubeadmControlPlaneEtcdClusterHealthUnknownReason surfaces when the health status of the etcd cluster hosted
	// on KubeadmControlPlane machines is unknown.
	KubeadmControlPlaneEtcdClusterHealthUnknownReason = "HealthUnknown"
)

const (
	// KubeadmControlPlaneControlPlaneComponentsHealthyCondition surfaces issues to Kubernetes control plane components
	// hosted on machines managed by this object. It is computed as aggregation of Machine's `APIServerPodHealthy`,
	// `ControllerManagerPodHealthy`, `SchedulerPodHealthy`, `EtcdPodHealthy` conditions plus additional checks on
	// control plane machines and nodes.
	KubeadmControlPlaneControlPlaneComponentsHealthyCondition = "ControlPlaneComponentsHealthy"

	// KubeadmControlPlaneControlPlaneComponentsInspectionFailedReason documents a failure when inspecting the status of the
	// control plane components hosted on KubeadmControlPlane controlled machines.
	KubeadmControlPlaneControlPlaneComponentsInspectionFailedReason = clusterv1.InspectionFailedReason

	// KubeadmControlPlaneControlPlaneComponentsConnectionDownReason surfaces that the connection to the workload
	// cluster is down.
	KubeadmControlPlaneControlPlaneComponentsConnectionDownReason = clusterv1.ConnectionDownReason

	// KubeadmControlPlaneControlPlaneComponentsHealthyReason surfaces when the Kubernetes control plane components
	// hosted on KubeadmControlPlane machines are healthy.
	KubeadmControlPlaneControlPlaneComponentsHealthyReason = "Healthy"

	// KubeadmControlPlaneControlPlaneComponentsNotHealthyReason surfaces when the Kubernetes control plane components
	// hosted on KubeadmControlPlane machines are not healthy.
	KubeadmControlPlaneControlPlaneComponentsNotHealthyReason = "NotHealthy"

	// KubeadmControlPlaneControlPlaneComponentsHealthUnknownReason surfaces when the health status of the
	// Kubernetes control plane components hosted on KubeadmControlPlane machines is unknown.
	KubeadmControlPlaneControlPlaneComponentsHealthUnknownReason = "HealthUnknown"
)

const (
	// KubeadmControlPlaneMachinesReadyCondition surfaces detail of issues on the controlled machines, if any.
	// Please note this will include also APIServerPodHealthy, ControllerManagerPodHealthy, SchedulerPodHealthy conditions.
	// If not using an external etcd also EtcdPodHealthy, EtcdMemberHealthy conditions are included.
	KubeadmControlPlaneMachinesReadyCondition = clusterv1.MachinesReadyCondition

	// KubeadmControlPlaneMachinesReadyReason surfaces when all the controlled machine's Ready conditions are true.
	KubeadmControlPlaneMachinesReadyReason = clusterv1.ReadyReason

	// KubeadmControlPlaneMachinesNotReadyReason surfaces when at least one of the controlled machine's Ready conditions is false.
	KubeadmControlPlaneMachinesNotReadyReason = clusterv1.NotReadyReason

	// KubeadmControlPlaneMachinesReadyUnknownReason surfaces when at least one of the controlled machine's Ready conditions is unknown
	// and no one of the controlled machine's Ready conditions is false.
	KubeadmControlPlaneMachinesReadyUnknownReason = clusterv1.ReadyUnknownReason

	// KubeadmControlPlaneMachinesReadyNoReplicasReason surfaces when no machines exist for the KubeadmControlPlane.
	KubeadmControlPlaneMachinesReadyNoReplicasReason = clusterv1.NoReplicasReason

	// KubeadmControlPlaneMachinesReadyInternalErrorReason surfaces unexpected failures when computing the MachinesReady condition.
	KubeadmControlPlaneMachinesReadyInternalErrorReason = clusterv1.InternalErrorReason
)

const (
	// KubeadmControlPlaneMachinesUpToDateCondition surfaces details of controlled machines not up to date, if any.
	// Note: New machines are considered 10s after machine creation. This gives time to the machine's owner controller to recognize the new machine and add the UpToDate condition.
	KubeadmControlPlaneMachinesUpToDateCondition = clusterv1.MachinesUpToDateCondition

	// KubeadmControlPlaneMachinesUpToDateReason surfaces when all the controlled machine's UpToDate conditions are true.
	KubeadmControlPlaneMachinesUpToDateReason = clusterv1.UpToDateReason

	// KubeadmControlPlaneMachinesNotUpToDateReason surfaces when at least one of the controlled machine's UpToDate conditions is false.
	KubeadmControlPlaneMachinesNotUpToDateReason = clusterv1.NotUpToDateReason

	// KubeadmControlPlaneMachinesUpToDateUnknownReason surfaces when at least one of the controlled machine's UpToDate conditions is unknown
	// and no one of the controlled machine's UpToDate conditions is false.
	KubeadmControlPlaneMachinesUpToDateUnknownReason = clusterv1.UpToDateUnknownReason

	// KubeadmControlPlaneMachinesUpToDateNoReplicasReason surfaces when no machines exist for the KubeadmControlPlane.
	KubeadmControlPlaneMachinesUpToDateNoReplicasReason = clusterv1.NoReplicasReason

	// KubeadmControlPlaneMachinesUpToDateInternalErrorReason surfaces unexpected failures when computing the MachinesUpToDate condition.
	KubeadmControlPlaneMachinesUpToDateInternalErrorReason = clusterv1.InternalErrorReason
)

const (
	// KubeadmControlPlaneRollingOutCondition  is true if there is at least one machine not up-to-date.
	KubeadmControlPlaneRollingOutCondition = clusterv1.RollingOutCondition

	// KubeadmControlPlaneRollingOutReason  surfaces when there is at least one machine not up-to-date.
	KubeadmControlPlaneRollingOutReason = clusterv1.RollingOutReason

	// KubeadmControlPlaneNotRollingOutReason surfaces when all the machines are up-to-date.
	KubeadmControlPlaneNotRollingOutReason = clusterv1.NotRollingOutReason
)

const (
	// KubeadmControlPlaneScalingUpCondition is true if actual replicas < desired replicas.
	// Note: In case a KubeadmControlPlane preflight check is preventing scale up, this will surface in the condition message.
	KubeadmControlPlaneScalingUpCondition = clusterv1.ScalingUpCondition

	// KubeadmControlPlaneScalingUpReason surfaces when actual replicas < desired replicas.
	KubeadmControlPlaneScalingUpReason = clusterv1.ScalingUpReason

	// KubeadmControlPlaneNotScalingUpReason surfaces when actual replicas >= desired replicas.
	KubeadmControlPlaneNotScalingUpReason = clusterv1.NotScalingUpReason

	// KubeadmControlPlaneScalingUpWaitingForReplicasSetReason surfaces when the .spec.replicas
	// field of the KubeadmControlPlane is not set.
	KubeadmControlPlaneScalingUpWaitingForReplicasSetReason = clusterv1.WaitingForReplicasSetReason
)

const (
	// KubeadmControlPlaneScalingDownCondition is true if actual replicas > desired replicas.
	// Note: In case a KubeadmControlPlane preflight check is preventing scale down, this will surface in the condition message.
	KubeadmControlPlaneScalingDownCondition = clusterv1.ScalingDownCondition

	// KubeadmControlPlaneScalingDownReason surfaces when actual replicas > desired replicas.
	KubeadmControlPlaneScalingDownReason = clusterv1.ScalingDownReason

	// KubeadmControlPlaneNotScalingDownReason surfaces when actual replicas <= desired replicas.
	KubeadmControlPlaneNotScalingDownReason = clusterv1.NotScalingDownReason

	// KubeadmControlPlaneScalingDownWaitingForReplicasSetReason surfaces when the .spec.replicas
	// field of the KubeadmControlPlane is not set.
	KubeadmControlPlaneScalingDownWaitingForReplicasSetReason = clusterv1.WaitingForReplicasSetReason
)

const (
	// KubeadmControlPlaneRemediatingCondition surfaces details about ongoing remediation of the controlled machines, if any.
	// Note: KubeadmControlPlane only remediates machines with HealthCheckSucceeded set to false and with the OwnerRemediated condition set to false.
	KubeadmControlPlaneRemediatingCondition = clusterv1.RemediatingCondition

	// KubeadmControlPlaneRemediatingReason surfaces when the KubeadmControlPlane has at least one machine with HealthCheckSucceeded set to false
	// and with the OwnerRemediated condition set to false.
	KubeadmControlPlaneRemediatingReason = clusterv1.RemediatingReason

	// KubeadmControlPlaneNotRemediatingReason surfaces when the KubeadmControlPlane does not have any machine with HealthCheckSucceeded set to false
	// and with the OwnerRemediated condition set to false.
	KubeadmControlPlaneNotRemediatingReason = clusterv1.NotRemediatingReason

	// KubeadmControlPlaneRemediatingInternalErrorReason surfaces unexpected failures when computing the Remediating condition.
	KubeadmControlPlaneRemediatingInternalErrorReason = clusterv1.InternalErrorReason
)

const (
	// KubeadmControlPlaneMachineRemediationInternalErrorReason surfaces unexpected failures while remediating a control plane machine.
	KubeadmControlPlaneMachineRemediationInternalErrorReason = clusterv1.InternalErrorReason

	// KubeadmControlPlaneMachineCannotBeRemediatedReason surfaces when remediation of a control plane machine can't be started.
	KubeadmControlPlaneMachineCannotBeRemediatedReason = "CannotBeRemediated"

	// KubeadmControlPlaneMachineRemediationDeferredReason surfaces when remediation of a control plane machine must be deferred.
	KubeadmControlPlaneMachineRemediationDeferredReason = "RemediationDeferred"

	// KubeadmControlPlaneMachineRemediationMachineDeletingReason surfaces when remediation of a control plane machine
	// has been completed by deleting the unhealthy machine.
	// Note: After an unhealthy machine is deleted, a new one is created by the KubeadmControlPlaneMachine as part of the
	// regular reconcile loop that ensures the correct number of replicas exist; KubeadmControlPlane machine waits for
	// the new machine to exists before removing the controlplane.cluster.x-k8s.io/remediation-in-progress annotation.
	// This is part of a series of safeguards to ensure that operation are performed sequentially on control plane machines.
	KubeadmControlPlaneMachineRemediationMachineDeletingReason = "MachineDeleting"
)

const (
	// KubeadmControlPlaneDeletingCondition surfaces details about ongoing deletion of the controlled machines.
	KubeadmControlPlaneDeletingCondition = clusterv1.DeletingCondition

	// KubeadmControlPlaneNotDeletingReason surfaces when the KCP is not deleting because the
	// DeletionTimestamp is not set.
	KubeadmControlPlaneNotDeletingReason = clusterv1.NotDeletingReason

	// KubeadmControlPlaneDeletingWaitingForWorkersDeletionReason surfaces when the KCP deletion
	// waits for the workers to be deleted.
	KubeadmControlPlaneDeletingWaitingForWorkersDeletionReason = "WaitingForWorkersDeletion"

	// KubeadmControlPlaneDeletingWaitingForMachineDeletionReason surfaces when the KCP deletion
	// waits for the control plane Machines to be deleted.
	KubeadmControlPlaneDeletingWaitingForMachineDeletionReason = "WaitingForMachineDeletion"

	// KubeadmControlPlaneDeletingDeletionCompletedReason surfaces when the KCP deletion has been completed.
	// This reason is set right after the `kubeadm.controlplane.cluster.x-k8s.io` finalizer is removed.
	// This means that the object will go away (i.e. be removed from etcd), except if there are other
	// finalizers on the KCP object.
	KubeadmControlPlaneDeletingDeletionCompletedReason = clusterv1.DeletionCompletedReason

	// KubeadmControlPlaneDeletingInternalErrorReason surfaces unexpected failures when deleting a KCP object.
	KubeadmControlPlaneDeletingInternalErrorReason = clusterv1.InternalErrorReason
)

const (
	// KubeadmControlPlaneMachineAPIServerPodHealthyCondition surfaces the status of the API server pod hosted on a KubeadmControlPlane controlled machine.
	KubeadmControlPlaneMachineAPIServerPodHealthyCondition = "APIServerPodHealthy"

	// KubeadmControlPlaneMachineControllerManagerPodHealthyCondition surfaces the status of the controller manager pod hosted on a KubeadmControlPlane controlled machine.
	KubeadmControlPlaneMachineControllerManagerPodHealthyCondition = "ControllerManagerPodHealthy"

	// KubeadmControlPlaneMachineSchedulerPodHealthyCondition surfaces the status of the scheduler pod hosted on a KubeadmControlPlane controlled machine.
	KubeadmControlPlaneMachineSchedulerPodHealthyCondition = "SchedulerPodHealthy"

	// KubeadmControlPlaneMachineEtcdPodHealthyCondition surfaces the status of the etcd pod hosted on a KubeadmControlPlane controlled machine.
	KubeadmControlPlaneMachineEtcdPodHealthyCondition = "EtcdPodHealthy"

	// KubeadmControlPlaneMachinePodRunningReason surfaces a pod hosted on a KubeadmControlPlane controlled machine that is running.
	KubeadmControlPlaneMachinePodRunningReason = "Running"

	// KubeadmControlPlaneMachinePodProvisioningReason surfaces a pod hosted on a KubeadmControlPlane controlled machine
	// waiting to be provisioned i.e., Pod is in "Pending" phase.
	KubeadmControlPlaneMachinePodProvisioningReason = "Provisioning"

	// KubeadmControlPlaneMachinePodDoesNotExistReason surfaces a when a pod hosted on a KubeadmControlPlane controlled machine
	// does not exist.
	KubeadmControlPlaneMachinePodDoesNotExistReason = "DoesNotExist"

	// KubeadmControlPlaneMachinePodFailedReason surfaces a when a pod hosted on a KubeadmControlPlane controlled machine
	// failed during provisioning, e.g. CrashLoopBackOff, ImagePullBackOff or if all the containers in a pod have terminated.
	KubeadmControlPlaneMachinePodFailedReason = "Failed"

	// KubeadmControlPlaneMachinePodInspectionFailedReason documents a failure when inspecting the status of a
	// pod hosted on a KubeadmControlPlane controlled machine.
	KubeadmControlPlaneMachinePodInspectionFailedReason = clusterv1.InspectionFailedReason

	// KubeadmControlPlaneMachinePodConnectionDownReason surfaces that the connection to the workload
	// cluster is down.
	KubeadmControlPlaneMachinePodConnectionDownReason = clusterv1.ConnectionDownReason

	// KubeadmControlPlaneMachinePodDeletingReason surfaces when the machine hosting control plane components
	// is being deleted.
	KubeadmControlPlaneMachinePodDeletingReason = "Deleting"
)

const (
	// KubeadmControlPlaneMachineEtcdMemberHealthyCondition surfaces the status of the etcd member hosted on a KubeadmControlPlane controlled machine.
	KubeadmControlPlaneMachineEtcdMemberHealthyCondition = "EtcdMemberHealthy"

	// KubeadmControlPlaneMachineEtcdMemberNotHealthyReason surfaces when the etcd member hosted on a KubeadmControlPlane controlled machine is not healthy.
	KubeadmControlPlaneMachineEtcdMemberNotHealthyReason = "NotHealthy"

	// KubeadmControlPlaneMachineEtcdMemberHealthyReason surfaces when the etcd member hosted on a KubeadmControlPlane controlled machine is healthy.
	KubeadmControlPlaneMachineEtcdMemberHealthyReason = "Healthy"

	// KubeadmControlPlaneMachineEtcdMemberInspectionFailedReason documents a failure when inspecting the status of an
	// etcd member hosted on a KubeadmControlPlane controlled machine.
	KubeadmControlPlaneMachineEtcdMemberInspectionFailedReason = clusterv1.InspectionFailedReason

	// KubeadmControlPlaneMachineEtcdMemberConnectionDownReason surfaces that the connection to the workload
	// cluster is down.
	KubeadmControlPlaneMachineEtcdMemberConnectionDownReason = clusterv1.ConnectionDownReason

	// KubeadmControlPlaneMachineEtcdMemberDeletingReason surfaces when the machine hosting an etcd member
	// is being deleted.
	KubeadmControlPlaneMachineEtcdMemberDeletingReason = "Deleting"
)

const (
	// CertificatesAvailableV1Beta1Condition documents that cluster certificates were generated as part of the
	// processing of a KubeadmControlPlane object.
	CertificatesAvailableV1Beta1Condition clusterv1.ConditionType = "CertificatesAvailable"

	// CertificatesGenerationFailedV1Beta1Reason (Severity=Warning) documents a KubeadmControlPlane controller detecting
	// an error while generating certificates; those kind of errors are usually temporary and the controller
	// automatically recover from them.
	CertificatesGenerationFailedV1Beta1Reason = "CertificatesGenerationFailed"
)

const (
	// AvailableV1Beta1Condition documents that the first control plane instance has completed the kubeadm init operation
	// and so the control plane is available and an API server instance is ready for processing requests.
	AvailableV1Beta1Condition clusterv1.ConditionType = "Available"

	// WaitingForKubeadmInitV1Beta1Reason (Severity=Info) documents a KubeadmControlPlane object waiting for the first
	// control plane instance to complete the kubeadm init operation.
	WaitingForKubeadmInitV1Beta1Reason = "WaitingForKubeadmInit"
)

const (
	// MachinesSpecUpToDateV1Beta1Condition documents that the spec of the machines controlled by the KubeadmControlPlane
	// is up to date. When this condition is false, the KubeadmControlPlane is executing a rolling upgrade.
	MachinesSpecUpToDateV1Beta1Condition clusterv1.ConditionType = "MachinesSpecUpToDate"

	// RollingUpdateInProgressV1Beta1Reason (Severity=Warning) documents a KubeadmControlPlane object executing a
	// rolling upgrade for aligning the machines spec to the desired state.
	RollingUpdateInProgressV1Beta1Reason = "RollingUpdateInProgress"
)

const (
	// ResizedV1Beta1Condition documents a KubeadmControlPlane that is resizing the set of controlled machines.
	ResizedV1Beta1Condition clusterv1.ConditionType = "Resized"

	// ScalingUpV1Beta1Reason (Severity=Info) documents a KubeadmControlPlane that is increasing the number of replicas.
	ScalingUpV1Beta1Reason = "ScalingUp"

	// ScalingDownV1Beta1Reason (Severity=Info) documents a KubeadmControlPlane that is decreasing the number of replicas.
	ScalingDownV1Beta1Reason = "ScalingDown"
)

const (
	// ControlPlaneComponentsHealthyV1Beta1Condition reports the overall status of control plane components
	// implemented as static pods generated by kubeadm including kube-api-server, kube-controller manager,
	// kube-scheduler and etcd if managed.
	ControlPlaneComponentsHealthyV1Beta1Condition clusterv1.ConditionType = "ControlPlaneComponentsHealthy"

	// ControlPlaneComponentsUnhealthyV1Beta1Reason (Severity=Error) documents a control plane component not healthy.
	ControlPlaneComponentsUnhealthyV1Beta1Reason = "ControlPlaneComponentsUnhealthy"

	// ControlPlaneComponentsUnknownV1Beta1Reason reports a control plane component in unknown status.
	ControlPlaneComponentsUnknownV1Beta1Reason = "ControlPlaneComponentsUnknown"

	// ControlPlaneComponentsInspectionFailedV1Beta1Reason documents a failure in inspecting the control plane component status.
	ControlPlaneComponentsInspectionFailedV1Beta1Reason = "ControlPlaneComponentsInspectionFailed"

	// MachineAPIServerPodHealthyV1Beta1Condition reports a machine's kube-apiserver's operational status.
	MachineAPIServerPodHealthyV1Beta1Condition clusterv1.ConditionType = "APIServerPodHealthy"

	// MachineControllerManagerPodHealthyV1Beta1Condition reports a machine's kube-controller-manager's health status.
	MachineControllerManagerPodHealthyV1Beta1Condition clusterv1.ConditionType = "ControllerManagerPodHealthy"

	// MachineSchedulerPodHealthyV1Beta1Condition reports a machine's kube-scheduler's operational status.
	MachineSchedulerPodHealthyV1Beta1Condition clusterv1.ConditionType = "SchedulerPodHealthy"

	// MachineEtcdPodHealthyV1Beta1Condition reports a machine's etcd pod's operational status.
	// NOTE: This conditions exists only if a stacked etcd cluster is used.
	MachineEtcdPodHealthyV1Beta1Condition clusterv1.ConditionType = "EtcdPodHealthy"

	// PodProvisioningV1Beta1Reason (Severity=Info) documents a pod waiting to be provisioned i.e., Pod is in "Pending" phase.
	PodProvisioningV1Beta1Reason = "PodProvisioning"

	// PodMissingV1Beta1Reason (Severity=Error) documents a pod does not exist.
	PodMissingV1Beta1Reason = "PodMissing"

	// PodFailedV1Beta1Reason (Severity=Error) documents if a pod failed during provisioning i.e., e.g CrashLoopbackOff, ImagePullBackOff
	// or if all the containers in a pod have terminated.
	PodFailedV1Beta1Reason = "PodFailed"

	// PodInspectionFailedV1Beta1Reason documents a failure in inspecting the pod status.
	PodInspectionFailedV1Beta1Reason = "PodInspectionFailed"
)

const (
	// EtcdClusterHealthyV1Beta1Condition documents the overall etcd cluster's health.
	EtcdClusterHealthyV1Beta1Condition clusterv1.ConditionType = "EtcdClusterHealthy"

	// EtcdClusterInspectionFailedV1Beta1Reason documents a failure in inspecting the etcd cluster status.
	EtcdClusterInspectionFailedV1Beta1Reason = "EtcdClusterInspectionFailed"

	// EtcdClusterUnknownV1Beta1Reason reports an etcd cluster in unknown status.
	EtcdClusterUnknownV1Beta1Reason = "EtcdClusterUnknown"

	// EtcdClusterUnhealthyV1Beta1Reason (Severity=Error) is set when the etcd cluster is unhealthy.
	EtcdClusterUnhealthyV1Beta1Reason = "EtcdClusterUnhealthy"

	// MachineEtcdMemberHealthyV1Beta1Condition report the machine's etcd member's health status.
	// NOTE: This conditions exists only if a stacked etcd cluster is used.
	MachineEtcdMemberHealthyV1Beta1Condition clusterv1.ConditionType = "EtcdMemberHealthy"

	// EtcdMemberInspectionFailedV1Beta1Reason documents a failure in inspecting the etcd member status.
	EtcdMemberInspectionFailedV1Beta1Reason = "MemberInspectionFailed"

	// EtcdMemberUnhealthyV1Beta1Reason (Severity=Error) documents a Machine's etcd member is unhealthy.
	EtcdMemberUnhealthyV1Beta1Reason = "EtcdMemberUnhealthy"

	// MachinesCreatedV1Beta1Condition documents that the machines controlled by the KubeadmControlPlane are created.
	// When this condition is false, it indicates that there was an error when cloning the infrastructure/bootstrap template or
	// when generating the machine object.
	MachinesCreatedV1Beta1Condition clusterv1.ConditionType = "MachinesCreated"

	// InfrastructureTemplateCloningFailedV1Beta1Reason (Severity=Error) documents a KubeadmControlPlane failing to
	// clone the infrastructure template.
	InfrastructureTemplateCloningFailedV1Beta1Reason = "InfrastructureTemplateCloningFailed"

	// BootstrapTemplateCloningFailedV1Beta1Reason (Severity=Error) documents a KubeadmControlPlane failing to
	// clone the bootstrap template.
	BootstrapTemplateCloningFailedV1Beta1Reason = "BootstrapTemplateCloningFailed"

	// MachineGenerationFailedV1Beta1Reason (Severity=Error) documents a KubeadmControlPlane failing to
	// generate a machine object.
	MachineGenerationFailedV1Beta1Reason = "MachineGenerationFailed"
)

const (
	// MachinesReadyV1Beta1Condition reports an aggregate of current status of the machines controlled by the KubeadmControlPlane.
	MachinesReadyV1Beta1Condition clusterv1.ConditionType = "MachinesReady"
)