zz_generated.conversion.go

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

/*
Copyright The Kubernetes Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

// Code generated by conversion-gen. DO NOT EDIT.

package v1beta1

import (
	unsafe "unsafe"

	corev1 "k8s.io/api/core/v1"
	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	conversion "k8s.io/apimachinery/pkg/conversion"
	runtime "k8s.io/apimachinery/pkg/runtime"
	v1beta2 "sigs.k8s.io/cluster-api/api/core/v1beta2"
)

func init() {
	localSchemeBuilder.Register(RegisterConversions)
}

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
	if err := s.AddGeneratedConversionFunc((*APIEndpoint)(nil), (*v1beta2.APIEndpoint)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_APIEndpoint_To_v1beta2_APIEndpoint(a.(*APIEndpoint), b.(*v1beta2.APIEndpoint), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.APIEndpoint)(nil), (*APIEndpoint)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_APIEndpoint_To_v1beta1_APIEndpoint(a.(*v1beta2.APIEndpoint), b.(*APIEndpoint), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*Cluster)(nil), (*v1beta2.Cluster)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_Cluster_To_v1beta2_Cluster(a.(*Cluster), b.(*v1beta2.Cluster), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.Cluster)(nil), (*Cluster)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_Cluster_To_v1beta1_Cluster(a.(*v1beta2.Cluster), b.(*Cluster), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*ClusterAvailabilityGate)(nil), (*v1beta2.ClusterAvailabilityGate)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_ClusterAvailabilityGate_To_v1beta2_ClusterAvailabilityGate(a.(*ClusterAvailabilityGate), b.(*v1beta2.ClusterAvailabilityGate), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.ClusterAvailabilityGate)(nil), (*ClusterAvailabilityGate)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_ClusterAvailabilityGate_To_v1beta1_ClusterAvailabilityGate(a.(*v1beta2.ClusterAvailabilityGate), b.(*ClusterAvailabilityGate), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*ClusterClass)(nil), (*v1beta2.ClusterClass)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_ClusterClass_To_v1beta2_ClusterClass(a.(*ClusterClass), b.(*v1beta2.ClusterClass), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*ClusterClassList)(nil), (*v1beta2.ClusterClassList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_ClusterClassList_To_v1beta2_ClusterClassList(a.(*ClusterClassList), b.(*v1beta2.ClusterClassList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.ClusterClassList)(nil), (*ClusterClassList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_ClusterClassList_To_v1beta1_ClusterClassList(a.(*v1beta2.ClusterClassList), b.(*ClusterClassList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*ClusterClassPatch)(nil), (*v1beta2.ClusterClassPatch)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_ClusterClassPatch_To_v1beta2_ClusterClassPatch(a.(*ClusterClassPatch), b.(*v1beta2.ClusterClassPatch), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.ClusterClassPatch)(nil), (*ClusterClassPatch)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_ClusterClassPatch_To_v1beta1_ClusterClassPatch(a.(*v1beta2.ClusterClassPatch), b.(*ClusterClassPatch), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*ClusterClassStatusVariable)(nil), (*v1beta2.ClusterClassStatusVariable)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_ClusterClassStatusVariable_To_v1beta2_ClusterClassStatusVariable(a.(*ClusterClassStatusVariable), b.(*v1beta2.ClusterClassStatusVariable), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.ClusterClassStatusVariable)(nil), (*ClusterClassStatusVariable)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_ClusterClassStatusVariable_To_v1beta1_ClusterClassStatusVariable(a.(*v1beta2.ClusterClassStatusVariable), b.(*ClusterClassStatusVariable), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*ClusterClassVariableMetadata)(nil), (*v1beta2.ClusterClassVariableMetadata)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_ClusterClassVariableMetadata_To_v1beta2_ClusterClassVariableMetadata(a.(*ClusterClassVariableMetadata), b.(*v1beta2.ClusterClassVariableMetadata), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.ClusterClassVariableMetadata)(nil), (*ClusterClassVariableMetadata)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_ClusterClassVariableMetadata_To_v1beta1_ClusterClassVariableMetadata(a.(*v1beta2.ClusterClassVariableMetadata), b.(*ClusterClassVariableMetadata), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*ClusterControlPlaneStatus)(nil), (*v1beta2.ClusterControlPlaneStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_ClusterControlPlaneStatus_To_v1beta2_ClusterControlPlaneStatus(a.(*ClusterControlPlaneStatus), b.(*v1beta2.ClusterControlPlaneStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.ClusterControlPlaneStatus)(nil), (*ClusterControlPlaneStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_ClusterControlPlaneStatus_To_v1beta1_ClusterControlPlaneStatus(a.(*v1beta2.ClusterControlPlaneStatus), b.(*ClusterControlPlaneStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*ClusterList)(nil), (*v1beta2.ClusterList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_ClusterList_To_v1beta2_ClusterList(a.(*ClusterList), b.(*v1beta2.ClusterList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.ClusterList)(nil), (*ClusterList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_ClusterList_To_v1beta1_ClusterList(a.(*v1beta2.ClusterList), b.(*ClusterList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.ClusterVariable)(nil), (*ClusterVariable)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_ClusterVariable_To_v1beta1_ClusterVariable(a.(*v1beta2.ClusterVariable), b.(*ClusterVariable), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*Condition)(nil), (*v1beta2.Condition)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_Condition_To_v1beta2_Condition(a.(*Condition), b.(*v1beta2.Condition), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.Condition)(nil), (*Condition)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_Condition_To_v1beta1_Condition(a.(*v1beta2.Condition), b.(*Condition), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*ControlPlaneVariables)(nil), (*v1beta2.ControlPlaneVariables)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_ControlPlaneVariables_To_v1beta2_ControlPlaneVariables(a.(*ControlPlaneVariables), b.(*v1beta2.ControlPlaneVariables), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.ControlPlaneVariables)(nil), (*ControlPlaneVariables)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_ControlPlaneVariables_To_v1beta1_ControlPlaneVariables(a.(*v1beta2.ControlPlaneVariables), b.(*ControlPlaneVariables), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*JSONPatch)(nil), (*v1beta2.JSONPatch)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_JSONPatch_To_v1beta2_JSONPatch(a.(*JSONPatch), b.(*v1beta2.JSONPatch), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.JSONPatch)(nil), (*JSONPatch)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_JSONPatch_To_v1beta1_JSONPatch(a.(*v1beta2.JSONPatch), b.(*JSONPatch), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*JSONPatchValue)(nil), (*v1beta2.JSONPatchValue)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_JSONPatchValue_To_v1beta2_JSONPatchValue(a.(*JSONPatchValue), b.(*v1beta2.JSONPatchValue), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.JSONPatchValue)(nil), (*JSONPatchValue)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_JSONPatchValue_To_v1beta1_JSONPatchValue(a.(*v1beta2.JSONPatchValue), b.(*JSONPatchValue), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*Machine)(nil), (*v1beta2.Machine)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_Machine_To_v1beta2_Machine(a.(*Machine), b.(*v1beta2.Machine), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.Machine)(nil), (*Machine)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_Machine_To_v1beta1_Machine(a.(*v1beta2.Machine), b.(*Machine), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*MachineAddress)(nil), (*v1beta2.MachineAddress)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineAddress_To_v1beta2_MachineAddress(a.(*MachineAddress), b.(*v1beta2.MachineAddress), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.MachineAddress)(nil), (*MachineAddress)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineAddress_To_v1beta1_MachineAddress(a.(*v1beta2.MachineAddress), b.(*MachineAddress), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*MachineDeployment)(nil), (*v1beta2.MachineDeployment)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineDeployment_To_v1beta2_MachineDeployment(a.(*MachineDeployment), b.(*v1beta2.MachineDeployment), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.MachineDeployment)(nil), (*MachineDeployment)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineDeployment_To_v1beta1_MachineDeployment(a.(*v1beta2.MachineDeployment), b.(*MachineDeployment), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*MachineDeploymentList)(nil), (*v1beta2.MachineDeploymentList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineDeploymentList_To_v1beta2_MachineDeploymentList(a.(*MachineDeploymentList), b.(*v1beta2.MachineDeploymentList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.MachineDeploymentList)(nil), (*MachineDeploymentList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineDeploymentList_To_v1beta1_MachineDeploymentList(a.(*v1beta2.MachineDeploymentList), b.(*MachineDeploymentList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*MachineDeploymentVariables)(nil), (*v1beta2.MachineDeploymentVariables)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineDeploymentVariables_To_v1beta2_MachineDeploymentVariables(a.(*MachineDeploymentVariables), b.(*v1beta2.MachineDeploymentVariables), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.MachineDeploymentVariables)(nil), (*MachineDeploymentVariables)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineDeploymentVariables_To_v1beta1_MachineDeploymentVariables(a.(*v1beta2.MachineDeploymentVariables), b.(*MachineDeploymentVariables), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*MachineDrainRule)(nil), (*v1beta2.MachineDrainRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineDrainRule_To_v1beta2_MachineDrainRule(a.(*MachineDrainRule), b.(*v1beta2.MachineDrainRule), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.MachineDrainRule)(nil), (*MachineDrainRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineDrainRule_To_v1beta1_MachineDrainRule(a.(*v1beta2.MachineDrainRule), b.(*MachineDrainRule), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*MachineDrainRuleDrainConfig)(nil), (*v1beta2.MachineDrainRuleDrainConfig)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineDrainRuleDrainConfig_To_v1beta2_MachineDrainRuleDrainConfig(a.(*MachineDrainRuleDrainConfig), b.(*v1beta2.MachineDrainRuleDrainConfig), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.MachineDrainRuleDrainConfig)(nil), (*MachineDrainRuleDrainConfig)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineDrainRuleDrainConfig_To_v1beta1_MachineDrainRuleDrainConfig(a.(*v1beta2.MachineDrainRuleDrainConfig), b.(*MachineDrainRuleDrainConfig), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*MachineDrainRuleList)(nil), (*v1beta2.MachineDrainRuleList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineDrainRuleList_To_v1beta2_MachineDrainRuleList(a.(*MachineDrainRuleList), b.(*v1beta2.MachineDrainRuleList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.MachineDrainRuleList)(nil), (*MachineDrainRuleList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineDrainRuleList_To_v1beta1_MachineDrainRuleList(a.(*v1beta2.MachineDrainRuleList), b.(*MachineDrainRuleList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*MachineDrainRuleMachineSelector)(nil), (*v1beta2.MachineDrainRuleMachineSelector)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineDrainRuleMachineSelector_To_v1beta2_MachineDrainRuleMachineSelector(a.(*MachineDrainRuleMachineSelector), b.(*v1beta2.MachineDrainRuleMachineSelector), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.MachineDrainRuleMachineSelector)(nil), (*MachineDrainRuleMachineSelector)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineDrainRuleMachineSelector_To_v1beta1_MachineDrainRuleMachineSelector(a.(*v1beta2.MachineDrainRuleMachineSelector), b.(*MachineDrainRuleMachineSelector), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*MachineDrainRulePodSelector)(nil), (*v1beta2.MachineDrainRulePodSelector)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineDrainRulePodSelector_To_v1beta2_MachineDrainRulePodSelector(a.(*MachineDrainRulePodSelector), b.(*v1beta2.MachineDrainRulePodSelector), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.MachineDrainRulePodSelector)(nil), (*MachineDrainRulePodSelector)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineDrainRulePodSelector_To_v1beta1_MachineDrainRulePodSelector(a.(*v1beta2.MachineDrainRulePodSelector), b.(*MachineDrainRulePodSelector), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*MachineDrainRuleSpec)(nil), (*v1beta2.MachineDrainRuleSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineDrainRuleSpec_To_v1beta2_MachineDrainRuleSpec(a.(*MachineDrainRuleSpec), b.(*v1beta2.MachineDrainRuleSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.MachineDrainRuleSpec)(nil), (*MachineDrainRuleSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineDrainRuleSpec_To_v1beta1_MachineDrainRuleSpec(a.(*v1beta2.MachineDrainRuleSpec), b.(*MachineDrainRuleSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*MachineHealthCheck)(nil), (*v1beta2.MachineHealthCheck)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineHealthCheck_To_v1beta2_MachineHealthCheck(a.(*MachineHealthCheck), b.(*v1beta2.MachineHealthCheck), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.MachineHealthCheck)(nil), (*MachineHealthCheck)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineHealthCheck_To_v1beta1_MachineHealthCheck(a.(*v1beta2.MachineHealthCheck), b.(*MachineHealthCheck), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*MachineHealthCheckList)(nil), (*v1beta2.MachineHealthCheckList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineHealthCheckList_To_v1beta2_MachineHealthCheckList(a.(*MachineHealthCheckList), b.(*v1beta2.MachineHealthCheckList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.MachineHealthCheckList)(nil), (*MachineHealthCheckList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineHealthCheckList_To_v1beta1_MachineHealthCheckList(a.(*v1beta2.MachineHealthCheckList), b.(*MachineHealthCheckList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*MachineList)(nil), (*v1beta2.MachineList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineList_To_v1beta2_MachineList(a.(*MachineList), b.(*v1beta2.MachineList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.MachineList)(nil), (*MachineList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineList_To_v1beta1_MachineList(a.(*v1beta2.MachineList), b.(*MachineList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*MachinePool)(nil), (*v1beta2.MachinePool)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachinePool_To_v1beta2_MachinePool(a.(*MachinePool), b.(*v1beta2.MachinePool), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.MachinePool)(nil), (*MachinePool)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachinePool_To_v1beta1_MachinePool(a.(*v1beta2.MachinePool), b.(*MachinePool), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*MachinePoolList)(nil), (*v1beta2.MachinePoolList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachinePoolList_To_v1beta2_MachinePoolList(a.(*MachinePoolList), b.(*v1beta2.MachinePoolList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.MachinePoolList)(nil), (*MachinePoolList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachinePoolList_To_v1beta1_MachinePoolList(a.(*v1beta2.MachinePoolList), b.(*MachinePoolList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.MachinePoolSpec)(nil), (*MachinePoolSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachinePoolSpec_To_v1beta1_MachinePoolSpec(a.(*v1beta2.MachinePoolSpec), b.(*MachinePoolSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*MachinePoolVariables)(nil), (*v1beta2.MachinePoolVariables)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachinePoolVariables_To_v1beta2_MachinePoolVariables(a.(*MachinePoolVariables), b.(*v1beta2.MachinePoolVariables), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.MachinePoolVariables)(nil), (*MachinePoolVariables)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachinePoolVariables_To_v1beta1_MachinePoolVariables(a.(*v1beta2.MachinePoolVariables), b.(*MachinePoolVariables), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*MachineReadinessGate)(nil), (*v1beta2.MachineReadinessGate)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineReadinessGate_To_v1beta2_MachineReadinessGate(a.(*MachineReadinessGate), b.(*v1beta2.MachineReadinessGate), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.MachineReadinessGate)(nil), (*MachineReadinessGate)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineReadinessGate_To_v1beta1_MachineReadinessGate(a.(*v1beta2.MachineReadinessGate), b.(*MachineReadinessGate), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*MachineSet)(nil), (*v1beta2.MachineSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineSet_To_v1beta2_MachineSet(a.(*MachineSet), b.(*v1beta2.MachineSet), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.MachineSet)(nil), (*MachineSet)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineSet_To_v1beta1_MachineSet(a.(*v1beta2.MachineSet), b.(*MachineSet), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*MachineSetList)(nil), (*v1beta2.MachineSetList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineSetList_To_v1beta2_MachineSetList(a.(*MachineSetList), b.(*v1beta2.MachineSetList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.MachineSetList)(nil), (*MachineSetList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineSetList_To_v1beta1_MachineSetList(a.(*v1beta2.MachineSetList), b.(*MachineSetList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*MachineTemplateSpec)(nil), (*v1beta2.MachineTemplateSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineTemplateSpec_To_v1beta2_MachineTemplateSpec(a.(*MachineTemplateSpec), b.(*v1beta2.MachineTemplateSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.MachineTemplateSpec)(nil), (*MachineTemplateSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineTemplateSpec_To_v1beta1_MachineTemplateSpec(a.(*v1beta2.MachineTemplateSpec), b.(*MachineTemplateSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*NetworkRanges)(nil), (*v1beta2.NetworkRanges)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_NetworkRanges_To_v1beta2_NetworkRanges(a.(*NetworkRanges), b.(*v1beta2.NetworkRanges), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.NetworkRanges)(nil), (*NetworkRanges)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_NetworkRanges_To_v1beta1_NetworkRanges(a.(*v1beta2.NetworkRanges), b.(*NetworkRanges), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*ObjectMeta)(nil), (*v1beta2.ObjectMeta)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_ObjectMeta_To_v1beta2_ObjectMeta(a.(*ObjectMeta), b.(*v1beta2.ObjectMeta), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.ObjectMeta)(nil), (*ObjectMeta)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_ObjectMeta_To_v1beta1_ObjectMeta(a.(*v1beta2.ObjectMeta), b.(*ObjectMeta), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*PatchDefinition)(nil), (*v1beta2.PatchDefinition)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_PatchDefinition_To_v1beta2_PatchDefinition(a.(*PatchDefinition), b.(*v1beta2.PatchDefinition), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.PatchDefinition)(nil), (*PatchDefinition)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_PatchDefinition_To_v1beta1_PatchDefinition(a.(*v1beta2.PatchDefinition), b.(*PatchDefinition), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*PatchSelector)(nil), (*v1beta2.PatchSelector)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_PatchSelector_To_v1beta2_PatchSelector(a.(*PatchSelector), b.(*v1beta2.PatchSelector), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.PatchSelector)(nil), (*PatchSelector)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_PatchSelector_To_v1beta1_PatchSelector(a.(*v1beta2.PatchSelector), b.(*PatchSelector), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*PatchSelectorMatch)(nil), (*v1beta2.PatchSelectorMatch)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_PatchSelectorMatch_To_v1beta2_PatchSelectorMatch(a.(*PatchSelectorMatch), b.(*v1beta2.PatchSelectorMatch), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.PatchSelectorMatch)(nil), (*PatchSelectorMatch)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_PatchSelectorMatch_To_v1beta1_PatchSelectorMatch(a.(*v1beta2.PatchSelectorMatch), b.(*PatchSelectorMatch), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*PatchSelectorMatchMachineDeploymentClass)(nil), (*v1beta2.PatchSelectorMatchMachineDeploymentClass)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_PatchSelectorMatchMachineDeploymentClass_To_v1beta2_PatchSelectorMatchMachineDeploymentClass(a.(*PatchSelectorMatchMachineDeploymentClass), b.(*v1beta2.PatchSelectorMatchMachineDeploymentClass), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.PatchSelectorMatchMachineDeploymentClass)(nil), (*PatchSelectorMatchMachineDeploymentClass)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_PatchSelectorMatchMachineDeploymentClass_To_v1beta1_PatchSelectorMatchMachineDeploymentClass(a.(*v1beta2.PatchSelectorMatchMachineDeploymentClass), b.(*PatchSelectorMatchMachineDeploymentClass), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*PatchSelectorMatchMachinePoolClass)(nil), (*v1beta2.PatchSelectorMatchMachinePoolClass)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_PatchSelectorMatchMachinePoolClass_To_v1beta2_PatchSelectorMatchMachinePoolClass(a.(*PatchSelectorMatchMachinePoolClass), b.(*v1beta2.PatchSelectorMatchMachinePoolClass), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.PatchSelectorMatchMachinePoolClass)(nil), (*PatchSelectorMatchMachinePoolClass)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_PatchSelectorMatchMachinePoolClass_To_v1beta1_PatchSelectorMatchMachinePoolClass(a.(*v1beta2.PatchSelectorMatchMachinePoolClass), b.(*PatchSelectorMatchMachinePoolClass), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*ValidationRule)(nil), (*v1beta2.ValidationRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_ValidationRule_To_v1beta2_ValidationRule(a.(*ValidationRule), b.(*v1beta2.ValidationRule), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.ValidationRule)(nil), (*ValidationRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_ValidationRule_To_v1beta1_ValidationRule(a.(*v1beta2.ValidationRule), b.(*ValidationRule), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*VariableSchema)(nil), (*v1beta2.VariableSchema)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_VariableSchema_To_v1beta2_VariableSchema(a.(*VariableSchema), b.(*v1beta2.VariableSchema), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.VariableSchema)(nil), (*VariableSchema)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_VariableSchema_To_v1beta1_VariableSchema(a.(*v1beta2.VariableSchema), b.(*VariableSchema), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*VariableSchemaMetadata)(nil), (*v1beta2.VariableSchemaMetadata)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_VariableSchemaMetadata_To_v1beta2_VariableSchemaMetadata(a.(*VariableSchemaMetadata), b.(*v1beta2.VariableSchemaMetadata), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.VariableSchemaMetadata)(nil), (*VariableSchemaMetadata)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_VariableSchemaMetadata_To_v1beta1_VariableSchemaMetadata(a.(*v1beta2.VariableSchemaMetadata), b.(*VariableSchemaMetadata), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*WorkersClass)(nil), (*v1beta2.WorkersClass)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_WorkersClass_To_v1beta2_WorkersClass(a.(*WorkersClass), b.(*v1beta2.WorkersClass), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.WorkersClass)(nil), (*WorkersClass)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_WorkersClass_To_v1beta1_WorkersClass(a.(*v1beta2.WorkersClass), b.(*WorkersClass), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*WorkersStatus)(nil), (*v1beta2.WorkersStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_WorkersStatus_To_v1beta2_WorkersStatus(a.(*WorkersStatus), b.(*v1beta2.WorkersStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.WorkersStatus)(nil), (*WorkersStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_WorkersStatus_To_v1beta1_WorkersStatus(a.(*v1beta2.WorkersStatus), b.(*WorkersStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*WorkersTopology)(nil), (*v1beta2.WorkersTopology)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_WorkersTopology_To_v1beta2_WorkersTopology(a.(*WorkersTopology), b.(*v1beta2.WorkersTopology), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1beta2.WorkersTopology)(nil), (*WorkersTopology)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_WorkersTopology_To_v1beta1_WorkersTopology(a.(*v1beta2.WorkersTopology), b.(*WorkersTopology), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1.Condition)(nil), (*Condition)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_Condition_To_v1beta1_Condition(a.(*v1.Condition), b.(*Condition), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*corev1.ObjectReference)(nil), (*v1beta2.ContractVersionedObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_ObjectReference_To_v1beta2_ContractVersionedObjectReference(a.(*corev1.ObjectReference), b.(*v1beta2.ContractVersionedObjectReference), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*corev1.ObjectReference)(nil), (*v1beta2.MachineHealthCheckRemediationTemplateReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_ObjectReference_To_v1beta2_MachineHealthCheckRemediationTemplateReference(a.(*corev1.ObjectReference), b.(*v1beta2.MachineHealthCheckRemediationTemplateReference), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*corev1.ObjectReference)(nil), (*v1beta2.MachineNodeReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_ObjectReference_To_v1beta2_MachineNodeReference(a.(*corev1.ObjectReference), b.(*v1beta2.MachineNodeReference), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*Bootstrap)(nil), (*v1beta2.Bootstrap)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_Bootstrap_To_v1beta2_Bootstrap(a.(*Bootstrap), b.(*v1beta2.Bootstrap), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*ClusterClassSpec)(nil), (*v1beta2.ClusterClassSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_ClusterClassSpec_To_v1beta2_ClusterClassSpec(a.(*ClusterClassSpec), b.(*v1beta2.ClusterClassSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*ClusterClassStatusVariableDefinition)(nil), (*v1beta2.ClusterClassStatusVariableDefinition)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_ClusterClassStatusVariableDefinition_To_v1beta2_ClusterClassStatusVariableDefinition(a.(*ClusterClassStatusVariableDefinition), b.(*v1beta2.ClusterClassStatusVariableDefinition), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*ClusterClassStatus)(nil), (*v1beta2.ClusterClassStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_ClusterClassStatus_To_v1beta2_ClusterClassStatus(a.(*ClusterClassStatus), b.(*v1beta2.ClusterClassStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*ClusterClassVariable)(nil), (*v1beta2.ClusterClassVariable)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_ClusterClassVariable_To_v1beta2_ClusterClassVariable(a.(*ClusterClassVariable), b.(*v1beta2.ClusterClassVariable), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*ClusterNetwork)(nil), (*v1beta2.ClusterNetwork)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_ClusterNetwork_To_v1beta2_ClusterNetwork(a.(*ClusterNetwork), b.(*v1beta2.ClusterNetwork), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*ClusterSpec)(nil), (*v1beta2.ClusterSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_ClusterSpec_To_v1beta2_ClusterSpec(a.(*ClusterSpec), b.(*v1beta2.ClusterSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*ClusterStatus)(nil), (*v1beta2.ClusterStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_ClusterStatus_To_v1beta2_ClusterStatus(a.(*ClusterStatus), b.(*v1beta2.ClusterStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*ClusterVariable)(nil), (*v1beta2.ClusterVariable)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_ClusterVariable_To_v1beta2_ClusterVariable(a.(*ClusterVariable), b.(*v1beta2.ClusterVariable), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*Condition)(nil), (*v1.Condition)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_Condition_To_v1_Condition(a.(*Condition), b.(*v1.Condition), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*ControlPlaneClass)(nil), (*v1beta2.ControlPlaneClass)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_ControlPlaneClass_To_v1beta2_ControlPlaneClass(a.(*ControlPlaneClass), b.(*v1beta2.ControlPlaneClass), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*ControlPlaneTopology)(nil), (*v1beta2.ControlPlaneTopology)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_ControlPlaneTopology_To_v1beta2_ControlPlaneTopology(a.(*ControlPlaneTopology), b.(*v1beta2.ControlPlaneTopology), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*ExternalPatchDefinition)(nil), (*v1beta2.ExternalPatchDefinition)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_ExternalPatchDefinition_To_v1beta2_ExternalPatchDefinition(a.(*ExternalPatchDefinition), b.(*v1beta2.ExternalPatchDefinition), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*JSONSchemaProps)(nil), (*v1beta2.JSONSchemaProps)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_JSONSchemaProps_To_v1beta2_JSONSchemaProps(a.(*JSONSchemaProps), b.(*v1beta2.JSONSchemaProps), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*LocalObjectTemplate)(nil), (*v1beta2.ControlPlaneClassMachineInfrastructureTemplate)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_LocalObjectTemplate_To_v1beta2_ControlPlaneClassMachineInfrastructureTemplate(a.(*LocalObjectTemplate), b.(*v1beta2.ControlPlaneClassMachineInfrastructureTemplate), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*LocalObjectTemplate)(nil), (*v1beta2.InfrastructureClass)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_LocalObjectTemplate_To_v1beta2_InfrastructureClass(a.(*LocalObjectTemplate), b.(*v1beta2.InfrastructureClass), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*LocalObjectTemplate)(nil), (*v1beta2.MachineDeploymentClassBootstrapTemplate)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_LocalObjectTemplate_To_v1beta2_MachineDeploymentClassBootstrapTemplate(a.(*LocalObjectTemplate), b.(*v1beta2.MachineDeploymentClassBootstrapTemplate), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*LocalObjectTemplate)(nil), (*v1beta2.MachineDeploymentClassInfrastructureTemplate)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_LocalObjectTemplate_To_v1beta2_MachineDeploymentClassInfrastructureTemplate(a.(*LocalObjectTemplate), b.(*v1beta2.MachineDeploymentClassInfrastructureTemplate), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*LocalObjectTemplate)(nil), (*v1beta2.MachinePoolClassBootstrapTemplate)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_LocalObjectTemplate_To_v1beta2_MachinePoolClassBootstrapTemplate(a.(*LocalObjectTemplate), b.(*v1beta2.MachinePoolClassBootstrapTemplate), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*LocalObjectTemplate)(nil), (*v1beta2.MachinePoolClassInfrastructureTemplate)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_LocalObjectTemplate_To_v1beta2_MachinePoolClassInfrastructureTemplate(a.(*LocalObjectTemplate), b.(*v1beta2.MachinePoolClassInfrastructureTemplate), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*MachineDeletionStatus)(nil), (*v1beta2.MachineDeletionStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineDeletionStatus_To_v1beta2_MachineDeletionStatus(a.(*MachineDeletionStatus), b.(*v1beta2.MachineDeletionStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*MachineDeploymentClass)(nil), (*v1beta2.MachineDeploymentClass)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineDeploymentClass_To_v1beta2_MachineDeploymentClass(a.(*MachineDeploymentClass), b.(*v1beta2.MachineDeploymentClass), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*MachineDeploymentSpec)(nil), (*v1beta2.MachineDeploymentSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineDeploymentSpec_To_v1beta2_MachineDeploymentSpec(a.(*MachineDeploymentSpec), b.(*v1beta2.MachineDeploymentSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*MachineDeploymentStatus)(nil), (*v1beta2.MachineDeploymentStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineDeploymentStatus_To_v1beta2_MachineDeploymentStatus(a.(*MachineDeploymentStatus), b.(*v1beta2.MachineDeploymentStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*MachineDeploymentTopology)(nil), (*v1beta2.MachineDeploymentTopology)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineDeploymentTopology_To_v1beta2_MachineDeploymentTopology(a.(*MachineDeploymentTopology), b.(*v1beta2.MachineDeploymentTopology), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*MachineHealthCheckSpec)(nil), (*v1beta2.MachineHealthCheckSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineHealthCheckSpec_To_v1beta2_MachineHealthCheckSpec(a.(*MachineHealthCheckSpec), b.(*v1beta2.MachineHealthCheckSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*MachineHealthCheckStatus)(nil), (*v1beta2.MachineHealthCheckStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineHealthCheckStatus_To_v1beta2_MachineHealthCheckStatus(a.(*MachineHealthCheckStatus), b.(*v1beta2.MachineHealthCheckStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*MachinePoolClass)(nil), (*v1beta2.MachinePoolClass)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachinePoolClass_To_v1beta2_MachinePoolClass(a.(*MachinePoolClass), b.(*v1beta2.MachinePoolClass), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*MachinePoolSpec)(nil), (*v1beta2.MachinePoolSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachinePoolSpec_To_v1beta2_MachinePoolSpec(a.(*MachinePoolSpec), b.(*v1beta2.MachinePoolSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*MachinePoolStatus)(nil), (*v1beta2.MachinePoolStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachinePoolStatus_To_v1beta2_MachinePoolStatus(a.(*MachinePoolStatus), b.(*v1beta2.MachinePoolStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*MachinePoolTopology)(nil), (*v1beta2.MachinePoolTopology)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachinePoolTopology_To_v1beta2_MachinePoolTopology(a.(*MachinePoolTopology), b.(*v1beta2.MachinePoolTopology), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*MachineSetSpec)(nil), (*v1beta2.MachineSetSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineSetSpec_To_v1beta2_MachineSetSpec(a.(*MachineSetSpec), b.(*v1beta2.MachineSetSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*MachineSetStatus)(nil), (*v1beta2.MachineSetStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineSetStatus_To_v1beta2_MachineSetStatus(a.(*MachineSetStatus), b.(*v1beta2.MachineSetStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*MachineSpec)(nil), (*v1beta2.MachineSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineSpec_To_v1beta2_MachineSpec(a.(*MachineSpec), b.(*v1beta2.MachineSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*MachineStatus)(nil), (*v1beta2.MachineStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_MachineStatus_To_v1beta2_MachineStatus(a.(*MachineStatus), b.(*v1beta2.MachineStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*Topology)(nil), (*v1beta2.Topology)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta1_Topology_To_v1beta2_Topology(a.(*Topology), b.(*v1beta2.Topology), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.Bootstrap)(nil), (*Bootstrap)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_Bootstrap_To_v1beta1_Bootstrap(a.(*v1beta2.Bootstrap), b.(*Bootstrap), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.ClusterClassSpec)(nil), (*ClusterClassSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_ClusterClassSpec_To_v1beta1_ClusterClassSpec(a.(*v1beta2.ClusterClassSpec), b.(*ClusterClassSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.ClusterClassStatusVariableDefinition)(nil), (*ClusterClassStatusVariableDefinition)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_ClusterClassStatusVariableDefinition_To_v1beta1_ClusterClassStatusVariableDefinition(a.(*v1beta2.ClusterClassStatusVariableDefinition), b.(*ClusterClassStatusVariableDefinition), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.ClusterClassStatus)(nil), (*ClusterClassStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_ClusterClassStatus_To_v1beta1_ClusterClassStatus(a.(*v1beta2.ClusterClassStatus), b.(*ClusterClassStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.ClusterClassVariable)(nil), (*ClusterClassVariable)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_ClusterClassVariable_To_v1beta1_ClusterClassVariable(a.(*v1beta2.ClusterClassVariable), b.(*ClusterClassVariable), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.ClusterClass)(nil), (*ClusterClass)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_ClusterClass_To_v1beta1_ClusterClass(a.(*v1beta2.ClusterClass), b.(*ClusterClass), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.ClusterNetwork)(nil), (*ClusterNetwork)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_ClusterNetwork_To_v1beta1_ClusterNetwork(a.(*v1beta2.ClusterNetwork), b.(*ClusterNetwork), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.ClusterSpec)(nil), (*ClusterSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_ClusterSpec_To_v1beta1_ClusterSpec(a.(*v1beta2.ClusterSpec), b.(*ClusterSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.ClusterStatus)(nil), (*ClusterStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_ClusterStatus_To_v1beta1_ClusterStatus(a.(*v1beta2.ClusterStatus), b.(*ClusterStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.ContractVersionedObjectReference)(nil), (*corev1.ObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_ContractVersionedObjectReference_To_v1_ObjectReference(a.(*v1beta2.ContractVersionedObjectReference), b.(*corev1.ObjectReference), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.ControlPlaneClassMachineInfrastructureTemplate)(nil), (*LocalObjectTemplate)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_ControlPlaneClassMachineInfrastructureTemplate_To_v1beta1_LocalObjectTemplate(a.(*v1beta2.ControlPlaneClassMachineInfrastructureTemplate), b.(*LocalObjectTemplate), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.ControlPlaneClass)(nil), (*ControlPlaneClass)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_ControlPlaneClass_To_v1beta1_ControlPlaneClass(a.(*v1beta2.ControlPlaneClass), b.(*ControlPlaneClass), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.ControlPlaneTopology)(nil), (*ControlPlaneTopology)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_ControlPlaneTopology_To_v1beta1_ControlPlaneTopology(a.(*v1beta2.ControlPlaneTopology), b.(*ControlPlaneTopology), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.ExternalPatchDefinition)(nil), (*ExternalPatchDefinition)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_ExternalPatchDefinition_To_v1beta1_ExternalPatchDefinition(a.(*v1beta2.ExternalPatchDefinition), b.(*ExternalPatchDefinition), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.InfrastructureClass)(nil), (*LocalObjectTemplate)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_InfrastructureClass_To_v1beta1_LocalObjectTemplate(a.(*v1beta2.InfrastructureClass), b.(*LocalObjectTemplate), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.JSONSchemaProps)(nil), (*JSONSchemaProps)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_JSONSchemaProps_To_v1beta1_JSONSchemaProps(a.(*v1beta2.JSONSchemaProps), b.(*JSONSchemaProps), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.MachineDeletionStatus)(nil), (*MachineDeletionStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineDeletionStatus_To_v1beta1_MachineDeletionStatus(a.(*v1beta2.MachineDeletionStatus), b.(*MachineDeletionStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.MachineDeploymentClassBootstrapTemplate)(nil), (*LocalObjectTemplate)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineDeploymentClassBootstrapTemplate_To_v1beta1_LocalObjectTemplate(a.(*v1beta2.MachineDeploymentClassBootstrapTemplate), b.(*LocalObjectTemplate), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.MachineDeploymentClassInfrastructureTemplate)(nil), (*LocalObjectTemplate)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineDeploymentClassInfrastructureTemplate_To_v1beta1_LocalObjectTemplate(a.(*v1beta2.MachineDeploymentClassInfrastructureTemplate), b.(*LocalObjectTemplate), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.MachineDeploymentClass)(nil), (*MachineDeploymentClass)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineDeploymentClass_To_v1beta1_MachineDeploymentClass(a.(*v1beta2.MachineDeploymentClass), b.(*MachineDeploymentClass), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.MachineDeploymentSpec)(nil), (*MachineDeploymentSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineDeploymentSpec_To_v1beta1_MachineDeploymentSpec(a.(*v1beta2.MachineDeploymentSpec), b.(*MachineDeploymentSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.MachineDeploymentStatus)(nil), (*MachineDeploymentStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineDeploymentStatus_To_v1beta1_MachineDeploymentStatus(a.(*v1beta2.MachineDeploymentStatus), b.(*MachineDeploymentStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.MachineDeploymentTopology)(nil), (*MachineDeploymentTopology)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineDeploymentTopology_To_v1beta1_MachineDeploymentTopology(a.(*v1beta2.MachineDeploymentTopology), b.(*MachineDeploymentTopology), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.MachineHealthCheckRemediationTemplateReference)(nil), (*corev1.ObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineHealthCheckRemediationTemplateReference_To_v1_ObjectReference(a.(*v1beta2.MachineHealthCheckRemediationTemplateReference), b.(*corev1.ObjectReference), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.MachineHealthCheckSpec)(nil), (*MachineHealthCheckSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineHealthCheckSpec_To_v1beta1_MachineHealthCheckSpec(a.(*v1beta2.MachineHealthCheckSpec), b.(*MachineHealthCheckSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.MachineHealthCheckStatus)(nil), (*MachineHealthCheckStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineHealthCheckStatus_To_v1beta1_MachineHealthCheckStatus(a.(*v1beta2.MachineHealthCheckStatus), b.(*MachineHealthCheckStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.MachineNodeReference)(nil), (*corev1.ObjectReference)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineNodeReference_To_v1_ObjectReference(a.(*v1beta2.MachineNodeReference), b.(*corev1.ObjectReference), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.MachinePoolClassBootstrapTemplate)(nil), (*LocalObjectTemplate)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachinePoolClassBootstrapTemplate_To_v1beta1_LocalObjectTemplate(a.(*v1beta2.MachinePoolClassBootstrapTemplate), b.(*LocalObjectTemplate), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.MachinePoolClassInfrastructureTemplate)(nil), (*LocalObjectTemplate)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachinePoolClassInfrastructureTemplate_To_v1beta1_LocalObjectTemplate(a.(*v1beta2.MachinePoolClassInfrastructureTemplate), b.(*LocalObjectTemplate), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.MachinePoolClass)(nil), (*MachinePoolClass)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachinePoolClass_To_v1beta1_MachinePoolClass(a.(*v1beta2.MachinePoolClass), b.(*MachinePoolClass), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.MachinePoolStatus)(nil), (*MachinePoolStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachinePoolStatus_To_v1beta1_MachinePoolStatus(a.(*v1beta2.MachinePoolStatus), b.(*MachinePoolStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.MachinePoolTopology)(nil), (*MachinePoolTopology)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachinePoolTopology_To_v1beta1_MachinePoolTopology(a.(*v1beta2.MachinePoolTopology), b.(*MachinePoolTopology), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.MachineSetSpec)(nil), (*MachineSetSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineSetSpec_To_v1beta1_MachineSetSpec(a.(*v1beta2.MachineSetSpec), b.(*MachineSetSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.MachineSetStatus)(nil), (*MachineSetStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineSetStatus_To_v1beta1_MachineSetStatus(a.(*v1beta2.MachineSetStatus), b.(*MachineSetStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.MachineSpec)(nil), (*MachineSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineSpec_To_v1beta1_MachineSpec(a.(*v1beta2.MachineSpec), b.(*MachineSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.MachineStatus)(nil), (*MachineStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_MachineStatus_To_v1beta1_MachineStatus(a.(*v1beta2.MachineStatus), b.(*MachineStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddConversionFunc((*v1beta2.Topology)(nil), (*Topology)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta2_Topology_To_v1beta1_Topology(a.(*v1beta2.Topology), b.(*Topology), scope)
	}); err != nil {
		return err
	}
	return nil
}

func autoConvert_v1beta1_APIEndpoint_To_v1beta2_APIEndpoint(in *APIEndpoint, out *v1beta2.APIEndpoint, s conversion.Scope) error {
	out.Host = in.Host
	out.Port = in.Port
	return nil
}

// Convert_v1beta1_APIEndpoint_To_v1beta2_APIEndpoint is an autogenerated conversion function.
func Convert_v1beta1_APIEndpoint_To_v1beta2_APIEndpoint(in *APIEndpoint, out *v1beta2.APIEndpoint, s conversion.Scope) error {
	return autoConvert_v1beta1_APIEndpoint_To_v1beta2_APIEndpoint(in, out, s)
}

func autoConvert_v1beta2_APIEndpoint_To_v1beta1_APIEndpoint(in *v1beta2.APIEndpoint, out *APIEndpoint, s conversion.Scope) error {
	out.Host = in.Host
	out.Port = in.Port
	return nil
}

// Convert_v1beta2_APIEndpoint_To_v1beta1_APIEndpoint is an autogenerated conversion function.
func Convert_v1beta2_APIEndpoint_To_v1beta1_APIEndpoint(in *v1beta2.APIEndpoint, out *APIEndpoint, s conversion.Scope) error {
	return autoConvert_v1beta2_APIEndpoint_To_v1beta1_APIEndpoint(in, out, s)
}

func autoConvert_v1beta1_Bootstrap_To_v1beta2_Bootstrap(in *Bootstrap, out *v1beta2.Bootstrap, s conversion.Scope) error {
	// WARNING: in.ConfigRef requires manual conversion: inconvertible types (*k8s.io/api/core/v1.ObjectReference vs sigs.k8s.io/cluster-api/api/core/v1beta2.ContractVersionedObjectReference)
	out.DataSecretName = (*string)(unsafe.Pointer(in.DataSecretName))
	return nil
}

func autoConvert_v1beta2_Bootstrap_To_v1beta1_Bootstrap(in *v1beta2.Bootstrap, out *Bootstrap, s conversion.Scope) error {
	// WARNING: in.ConfigRef requires manual conversion: inconvertible types (sigs.k8s.io/cluster-api/api/core/v1beta2.ContractVersionedObjectReference vs *k8s.io/api/core/v1.ObjectReference)
	out.DataSecretName = (*string)(unsafe.Pointer(in.DataSecretName))
	return nil
}

func autoConvert_v1beta1_Cluster_To_v1beta2_Cluster(in *Cluster, out *v1beta2.Cluster, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1beta1_ClusterSpec_To_v1beta2_ClusterSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_v1beta1_ClusterStatus_To_v1beta2_ClusterStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1beta1_Cluster_To_v1beta2_Cluster is an autogenerated conversion function.
func Convert_v1beta1_Cluster_To_v1beta2_Cluster(in *Cluster, out *v1beta2.Cluster, s conversion.Scope) error {
	return autoConvert_v1beta1_Cluster_To_v1beta2_Cluster(in, out, s)
}

func autoConvert_v1beta2_Cluster_To_v1beta1_Cluster(in *v1beta2.Cluster, out *Cluster, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1beta2_ClusterSpec_To_v1beta1_ClusterSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_v1beta2_ClusterStatus_To_v1beta1_ClusterStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1beta2_Cluster_To_v1beta1_Cluster is an autogenerated conversion function.
func Convert_v1beta2_Cluster_To_v1beta1_Cluster(in *v1beta2.Cluster, out *Cluster, s conversion.Scope) error {
	return autoConvert_v1beta2_Cluster_To_v1beta1_Cluster(in, out, s)
}

func autoConvert_v1beta1_ClusterAvailabilityGate_To_v1beta2_ClusterAvailabilityGate(in *ClusterAvailabilityGate, out *v1beta2.ClusterAvailabilityGate, s conversion.Scope) error {
	out.ConditionType = in.ConditionType
	out.Polarity = v1beta2.ConditionPolarity(in.Polarity)
	return nil
}

// Convert_v1beta1_ClusterAvailabilityGate_To_v1beta2_ClusterAvailabilityGate is an autogenerated conversion function.
func Convert_v1beta1_ClusterAvailabilityGate_To_v1beta2_ClusterAvailabilityGate(in *ClusterAvailabilityGate, out *v1beta2.ClusterAvailabilityGate, s conversion.Scope) error {
	return autoConvert_v1beta1_ClusterAvailabilityGate_To_v1beta2_ClusterAvailabilityGate(in, out, s)
}

func autoConvert_v1beta2_ClusterAvailabilityGate_To_v1beta1_ClusterAvailabilityGate(in *v1beta2.ClusterAvailabilityGate, out *ClusterAvailabilityGate, s conversion.Scope) error {
	out.ConditionType = in.ConditionType
	out.Polarity = ConditionPolarity(in.Polarity)
	return nil
}

// Convert_v1beta2_ClusterAvailabilityGate_To_v1beta1_ClusterAvailabilityGate is an autogenerated conversion function.
func Convert_v1beta2_ClusterAvailabilityGate_To_v1beta1_ClusterAvailabilityGate(in *v1beta2.ClusterAvailabilityGate, out *ClusterAvailabilityGate, s conversion.Scope) error {
	return autoConvert_v1beta2_ClusterAvailabilityGate_To_v1beta1_ClusterAvailabilityGate(in, out, s)
}

func autoConvert_v1beta1_ClusterClass_To_v1beta2_ClusterClass(in *ClusterClass, out *v1beta2.ClusterClass, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1beta1_ClusterClassSpec_To_v1beta2_ClusterClassSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_v1beta1_ClusterClassStatus_To_v1beta2_ClusterClassStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1beta1_ClusterClass_To_v1beta2_ClusterClass is an autogenerated conversion function.
func Convert_v1beta1_ClusterClass_To_v1beta2_ClusterClass(in *ClusterClass, out *v1beta2.ClusterClass, s conversion.Scope) error {
	return autoConvert_v1beta1_ClusterClass_To_v1beta2_ClusterClass(in, out, s)
}

func autoConvert_v1beta2_ClusterClass_To_v1beta1_ClusterClass(in *v1beta2.ClusterClass, out *ClusterClass, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1beta2_ClusterClassSpec_To_v1beta1_ClusterClassSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_v1beta2_ClusterClassStatus_To_v1beta1_ClusterClassStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	return nil
}

func autoConvert_v1beta1_ClusterClassList_To_v1beta2_ClusterClassList(in *ClusterClassList, out *v1beta2.ClusterClassList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	if in.Items != nil {
		in, out := &in.Items, &out.Items
		*out = make([]v1beta2.ClusterClass, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_ClusterClass_To_v1beta2_ClusterClass(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Items = nil
	}
	return nil
}

// Convert_v1beta1_ClusterClassList_To_v1beta2_ClusterClassList is an autogenerated conversion function.
func Convert_v1beta1_ClusterClassList_To_v1beta2_ClusterClassList(in *ClusterClassList, out *v1beta2.ClusterClassList, s conversion.Scope) error {
	return autoConvert_v1beta1_ClusterClassList_To_v1beta2_ClusterClassList(in, out, s)
}

func autoConvert_v1beta2_ClusterClassList_To_v1beta1_ClusterClassList(in *v1beta2.ClusterClassList, out *ClusterClassList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	if in.Items != nil {
		in, out := &in.Items, &out.Items
		*out = make([]ClusterClass, len(*in))
		for i := range *in {
			if err := Convert_v1beta2_ClusterClass_To_v1beta1_ClusterClass(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Items = nil
	}
	return nil
}

// Convert_v1beta2_ClusterClassList_To_v1beta1_ClusterClassList is an autogenerated conversion function.
func Convert_v1beta2_ClusterClassList_To_v1beta1_ClusterClassList(in *v1beta2.ClusterClassList, out *ClusterClassList, s conversion.Scope) error {
	return autoConvert_v1beta2_ClusterClassList_To_v1beta1_ClusterClassList(in, out, s)
}

func autoConvert_v1beta1_ClusterClassPatch_To_v1beta2_ClusterClassPatch(in *ClusterClassPatch, out *v1beta2.ClusterClassPatch, s conversion.Scope) error {
	out.Name = in.Name
	out.Description = in.Description
	if err := v1.Convert_Pointer_string_To_string(&in.EnabledIf, &out.EnabledIf, s); err != nil {
		return err
	}
	if in.Definitions != nil {
		in, out := &in.Definitions, &out.Definitions
		*out = make([]v1beta2.PatchDefinition, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_PatchDefinition_To_v1beta2_PatchDefinition(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Definitions = nil
	}
	if in.External != nil {
		in, out := &in.External, &out.External
		*out = new(v1beta2.ExternalPatchDefinition)
		if err := Convert_v1beta1_ExternalPatchDefinition_To_v1beta2_ExternalPatchDefinition(*in, *out, s); err != nil {
			return err
		}
	} else {
		out.External = nil
	}
	return nil
}

// Convert_v1beta1_ClusterClassPatch_To_v1beta2_ClusterClassPatch is an autogenerated conversion function.
func Convert_v1beta1_ClusterClassPatch_To_v1beta2_ClusterClassPatch(in *ClusterClassPatch, out *v1beta2.ClusterClassPatch, s conversion.Scope) error {
	return autoConvert_v1beta1_ClusterClassPatch_To_v1beta2_ClusterClassPatch(in, out, s)
}

func autoConvert_v1beta2_ClusterClassPatch_To_v1beta1_ClusterClassPatch(in *v1beta2.ClusterClassPatch, out *ClusterClassPatch, s conversion.Scope) error {
	out.Name = in.Name
	out.Description = in.Description
	if err := v1.Convert_string_To_Pointer_string(&in.EnabledIf, &out.EnabledIf, s); err != nil {
		return err
	}
	if in.Definitions != nil {
		in, out := &in.Definitions, &out.Definitions
		*out = make([]PatchDefinition, len(*in))
		for i := range *in {
			if err := Convert_v1beta2_PatchDefinition_To_v1beta1_PatchDefinition(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Definitions = nil
	}
	if in.External != nil {
		in, out := &in.External, &out.External
		*out = new(ExternalPatchDefinition)
		if err := Convert_v1beta2_ExternalPatchDefinition_To_v1beta1_ExternalPatchDefinition(*in, *out, s); err != nil {
			return err
		}
	} else {
		out.External = nil
	}
	return nil
}

// Convert_v1beta2_ClusterClassPatch_To_v1beta1_ClusterClassPatch is an autogenerated conversion function.
func Convert_v1beta2_ClusterClassPatch_To_v1beta1_ClusterClassPatch(in *v1beta2.ClusterClassPatch, out *ClusterClassPatch, s conversion.Scope) error {
	return autoConvert_v1beta2_ClusterClassPatch_To_v1beta1_ClusterClassPatch(in, out, s)
}

func autoConvert_v1beta1_ClusterClassSpec_To_v1beta2_ClusterClassSpec(in *ClusterClassSpec, out *v1beta2.ClusterClassSpec, s conversion.Scope) error {
	out.AvailabilityGates = *(*[]v1beta2.ClusterAvailabilityGate)(unsafe.Pointer(&in.AvailabilityGates))
	if err := Convert_v1beta1_LocalObjectTemplate_To_v1beta2_InfrastructureClass(&in.Infrastructure, &out.Infrastructure, s); err != nil {
		return err
	}
	// WARNING: in.InfrastructureNamingStrategy requires manual conversion: does not exist in peer-type
	if err := Convert_v1beta1_ControlPlaneClass_To_v1beta2_ControlPlaneClass(&in.ControlPlane, &out.ControlPlane, s); err != nil {
		return err
	}
	if err := Convert_v1beta1_WorkersClass_To_v1beta2_WorkersClass(&in.Workers, &out.Workers, s); err != nil {
		return err
	}
	if in.Variables != nil {
		in, out := &in.Variables, &out.Variables
		*out = make([]v1beta2.ClusterClassVariable, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_ClusterClassVariable_To_v1beta2_ClusterClassVariable(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Variables = nil
	}
	if in.Patches != nil {
		in, out := &in.Patches, &out.Patches
		*out = make([]v1beta2.ClusterClassPatch, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_ClusterClassPatch_To_v1beta2_ClusterClassPatch(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Patches = nil
	}
	return nil
}

func autoConvert_v1beta2_ClusterClassSpec_To_v1beta1_ClusterClassSpec(in *v1beta2.ClusterClassSpec, out *ClusterClassSpec, s conversion.Scope) error {
	out.AvailabilityGates = *(*[]ClusterAvailabilityGate)(unsafe.Pointer(&in.AvailabilityGates))
	if err := Convert_v1beta2_InfrastructureClass_To_v1beta1_LocalObjectTemplate(&in.Infrastructure, &out.Infrastructure, s); err != nil {
		return err
	}
	if err := Convert_v1beta2_ControlPlaneClass_To_v1beta1_ControlPlaneClass(&in.ControlPlane, &out.ControlPlane, s); err != nil {
		return err
	}
	if err := Convert_v1beta2_WorkersClass_To_v1beta1_WorkersClass(&in.Workers, &out.Workers, s); err != nil {
		return err
	}
	if in.Variables != nil {
		in, out := &in.Variables, &out.Variables
		*out = make([]ClusterClassVariable, len(*in))
		for i := range *in {
			if err := Convert_v1beta2_ClusterClassVariable_To_v1beta1_ClusterClassVariable(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Variables = nil
	}
	if in.Patches != nil {
		in, out := &in.Patches, &out.Patches
		*out = make([]ClusterClassPatch, len(*in))
		for i := range *in {
			if err := Convert_v1beta2_ClusterClassPatch_To_v1beta1_ClusterClassPatch(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Patches = nil
	}
	// WARNING: in.Upgrade requires manual conversion: does not exist in peer-type
	// WARNING: in.KubernetesVersions requires manual conversion: does not exist in peer-type
	return nil
}

func autoConvert_v1beta1_ClusterClassStatus_To_v1beta2_ClusterClassStatus(in *ClusterClassStatus, out *v1beta2.ClusterClassStatus, s conversion.Scope) error {
	if in.Variables != nil {
		in, out := &in.Variables, &out.Variables
		*out = make([]v1beta2.ClusterClassStatusVariable, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_ClusterClassStatusVariable_To_v1beta2_ClusterClassStatusVariable(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Variables = nil
	}
	if in.Conditions != nil {
		in, out := &in.Conditions, &out.Conditions
		*out = make([]v1.Condition, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_Condition_To_v1_Condition(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Conditions = nil
	}
	out.ObservedGeneration = in.ObservedGeneration
	// WARNING: in.V1Beta2 requires manual conversion: does not exist in peer-type
	return nil
}

func autoConvert_v1beta2_ClusterClassStatus_To_v1beta1_ClusterClassStatus(in *v1beta2.ClusterClassStatus, out *ClusterClassStatus, s conversion.Scope) error {
	if in.Conditions != nil {
		in, out := &in.Conditions, &out.Conditions
		*out = make(Conditions, len(*in))
		for i := range *in {
			if err := Convert_v1_Condition_To_v1beta1_Condition(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Conditions = nil
	}
	if in.Variables != nil {
		in, out := &in.Variables, &out.Variables
		*out = make([]ClusterClassStatusVariable, len(*in))
		for i := range *in {
			if err := Convert_v1beta2_ClusterClassStatusVariable_To_v1beta1_ClusterClassStatusVariable(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Variables = nil
	}
	out.ObservedGeneration = in.ObservedGeneration
	// WARNING: in.Deprecated requires manual conversion: does not exist in peer-type
	return nil
}

func autoConvert_v1beta1_ClusterClassStatusVariable_To_v1beta2_ClusterClassStatusVariable(in *ClusterClassStatusVariable, out *v1beta2.ClusterClassStatusVariable, s conversion.Scope) error {
	out.Name = in.Name
	if err := v1.Convert_bool_To_Pointer_bool(&in.DefinitionsConflict, &out.DefinitionsConflict, s); err != nil {
		return err
	}
	if in.Definitions != nil {
		in, out := &in.Definitions, &out.Definitions
		*out = make([]v1beta2.ClusterClassStatusVariableDefinition, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_ClusterClassStatusVariableDefinition_To_v1beta2_ClusterClassStatusVariableDefinition(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Definitions = nil
	}
	return nil
}

// Convert_v1beta1_ClusterClassStatusVariable_To_v1beta2_ClusterClassStatusVariable is an autogenerated conversion function.
func Convert_v1beta1_ClusterClassStatusVariable_To_v1beta2_ClusterClassStatusVariable(in *ClusterClassStatusVariable, out *v1beta2.ClusterClassStatusVariable, s conversion.Scope) error {
	return autoConvert_v1beta1_ClusterClassStatusVariable_To_v1beta2_ClusterClassStatusVariable(in, out, s)
}

func autoConvert_v1beta2_ClusterClassStatusVariable_To_v1beta1_ClusterClassStatusVariable(in *v1beta2.ClusterClassStatusVariable, out *ClusterClassStatusVariable, s conversion.Scope) error {
	out.Name = in.Name
	if err := v1.Convert_Pointer_bool_To_bool(&in.DefinitionsConflict, &out.DefinitionsConflict, s); err != nil {
		return err
	}
	if in.Definitions != nil {
		in, out := &in.Definitions, &out.Definitions
		*out = make([]ClusterClassStatusVariableDefinition, len(*in))
		for i := range *in {
			if err := Convert_v1beta2_ClusterClassStatusVariableDefinition_To_v1beta1_ClusterClassStatusVariableDefinition(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Definitions = nil
	}
	return nil
}

// Convert_v1beta2_ClusterClassStatusVariable_To_v1beta1_ClusterClassStatusVariable is an autogenerated conversion function.
func Convert_v1beta2_ClusterClassStatusVariable_To_v1beta1_ClusterClassStatusVariable(in *v1beta2.ClusterClassStatusVariable, out *ClusterClassStatusVariable, s conversion.Scope) error {
	return autoConvert_v1beta2_ClusterClassStatusVariable_To_v1beta1_ClusterClassStatusVariable(in, out, s)
}

func autoConvert_v1beta1_ClusterClassStatusVariableDefinition_To_v1beta2_ClusterClassStatusVariableDefinition(in *ClusterClassStatusVariableDefinition, out *v1beta2.ClusterClassStatusVariableDefinition, s conversion.Scope) error {
	out.From = in.From
	if err := v1.Convert_bool_To_Pointer_bool(&in.Required, &out.Required, s); err != nil {
		return err
	}
	// WARNING: in.Metadata requires manual conversion: does not exist in peer-type
	if err := Convert_v1beta1_VariableSchema_To_v1beta2_VariableSchema(&in.Schema, &out.Schema, s); err != nil {
		return err
	}
	return nil
}

func autoConvert_v1beta2_ClusterClassStatusVariableDefinition_To_v1beta1_ClusterClassStatusVariableDefinition(in *v1beta2.ClusterClassStatusVariableDefinition, out *ClusterClassStatusVariableDefinition, s conversion.Scope) error {
	out.From = in.From
	if err := v1.Convert_Pointer_bool_To_bool(&in.Required, &out.Required, s); err != nil {
		return err
	}
	// WARNING: in.DeprecatedV1Beta1Metadata requires manual conversion: does not exist in peer-type
	if err := Convert_v1beta2_VariableSchema_To_v1beta1_VariableSchema(&in.Schema, &out.Schema, s); err != nil {
		return err
	}
	return nil
}

func autoConvert_v1beta1_ClusterClassVariable_To_v1beta2_ClusterClassVariable(in *ClusterClassVariable, out *v1beta2.ClusterClassVariable, s conversion.Scope) error {
	out.Name = in.Name
	if err := v1.Convert_bool_To_Pointer_bool(&in.Required, &out.Required, s); err != nil {
		return err
	}
	// WARNING: in.Metadata requires manual conversion: does not exist in peer-type
	if err := Convert_v1beta1_VariableSchema_To_v1beta2_VariableSchema(&in.Schema, &out.Schema, s); err != nil {
		return err
	}
	return nil
}

func autoConvert_v1beta2_ClusterClassVariable_To_v1beta1_ClusterClassVariable(in *v1beta2.ClusterClassVariable, out *ClusterClassVariable, s conversion.Scope) error {
	out.Name = in.Name
	if err := v1.Convert_Pointer_bool_To_bool(&in.Required, &out.Required, s); err != nil {
		return err
	}
	// WARNING: in.DeprecatedV1Beta1Metadata requires manual conversion: does not exist in peer-type
	if err := Convert_v1beta2_VariableSchema_To_v1beta1_VariableSchema(&in.Schema, &out.Schema, s); err != nil {
		return err
	}
	return nil
}

func autoConvert_v1beta1_ClusterClassVariableMetadata_To_v1beta2_ClusterClassVariableMetadata(in *ClusterClassVariableMetadata, out *v1beta2.ClusterClassVariableMetadata, s conversion.Scope) error {
	out.Labels = *(*map[string]string)(unsafe.Pointer(&in.Labels))
	out.Annotations = *(*map[string]string)(unsafe.Pointer(&in.Annotations))
	return nil
}

// Convert_v1beta1_ClusterClassVariableMetadata_To_v1beta2_ClusterClassVariableMetadata is an autogenerated conversion function.
func Convert_v1beta1_ClusterClassVariableMetadata_To_v1beta2_ClusterClassVariableMetadata(in *ClusterClassVariableMetadata, out *v1beta2.ClusterClassVariableMetadata, s conversion.Scope) error {
	return autoConvert_v1beta1_ClusterClassVariableMetadata_To_v1beta2_ClusterClassVariableMetadata(in, out, s)
}

func autoConvert_v1beta2_ClusterClassVariableMetadata_To_v1beta1_ClusterClassVariableMetadata(in *v1beta2.ClusterClassVariableMetadata, out *ClusterClassVariableMetadata, s conversion.Scope) error {
	out.Labels = *(*map[string]string)(unsafe.Pointer(&in.Labels))
	out.Annotations = *(*map[string]string)(unsafe.Pointer(&in.Annotations))
	return nil
}

// Convert_v1beta2_ClusterClassVariableMetadata_To_v1beta1_ClusterClassVariableMetadata is an autogenerated conversion function.
func Convert_v1beta2_ClusterClassVariableMetadata_To_v1beta1_ClusterClassVariableMetadata(in *v1beta2.ClusterClassVariableMetadata, out *ClusterClassVariableMetadata, s conversion.Scope) error {
	return autoConvert_v1beta2_ClusterClassVariableMetadata_To_v1beta1_ClusterClassVariableMetadata(in, out, s)
}

func autoConvert_v1beta1_ClusterControlPlaneStatus_To_v1beta2_ClusterControlPlaneStatus(in *ClusterControlPlaneStatus, out *v1beta2.ClusterControlPlaneStatus, s conversion.Scope) error {
	out.DesiredReplicas = (*int32)(unsafe.Pointer(in.DesiredReplicas))
	out.Replicas = (*int32)(unsafe.Pointer(in.Replicas))
	out.UpToDateReplicas = (*int32)(unsafe.Pointer(in.UpToDateReplicas))
	out.ReadyReplicas = (*int32)(unsafe.Pointer(in.ReadyReplicas))
	out.AvailableReplicas = (*int32)(unsafe.Pointer(in.AvailableReplicas))
	return nil
}

// Convert_v1beta1_ClusterControlPlaneStatus_To_v1beta2_ClusterControlPlaneStatus is an autogenerated conversion function.
func Convert_v1beta1_ClusterControlPlaneStatus_To_v1beta2_ClusterControlPlaneStatus(in *ClusterControlPlaneStatus, out *v1beta2.ClusterControlPlaneStatus, s conversion.Scope) error {
	return autoConvert_v1beta1_ClusterControlPlaneStatus_To_v1beta2_ClusterControlPlaneStatus(in, out, s)
}

func autoConvert_v1beta2_ClusterControlPlaneStatus_To_v1beta1_ClusterControlPlaneStatus(in *v1beta2.ClusterControlPlaneStatus, out *ClusterControlPlaneStatus, s conversion.Scope) error {
	out.DesiredReplicas = (*int32)(unsafe.Pointer(in.DesiredReplicas))
	out.Replicas = (*int32)(unsafe.Pointer(in.Replicas))
	out.UpToDateReplicas = (*int32)(unsafe.Pointer(in.UpToDateReplicas))
	out.ReadyReplicas = (*int32)(unsafe.Pointer(in.ReadyReplicas))
	out.AvailableReplicas = (*int32)(unsafe.Pointer(in.AvailableReplicas))
	return nil
}

// Convert_v1beta2_ClusterControlPlaneStatus_To_v1beta1_ClusterControlPlaneStatus is an autogenerated conversion function.
func Convert_v1beta2_ClusterControlPlaneStatus_To_v1beta1_ClusterControlPlaneStatus(in *v1beta2.ClusterControlPlaneStatus, out *ClusterControlPlaneStatus, s conversion.Scope) error {
	return autoConvert_v1beta2_ClusterControlPlaneStatus_To_v1beta1_ClusterControlPlaneStatus(in, out, s)
}

func autoConvert_v1beta1_ClusterList_To_v1beta2_ClusterList(in *ClusterList, out *v1beta2.ClusterList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	if in.Items != nil {
		in, out := &in.Items, &out.Items
		*out = make([]v1beta2.Cluster, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_Cluster_To_v1beta2_Cluster(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Items = nil
	}
	return nil
}

// Convert_v1beta1_ClusterList_To_v1beta2_ClusterList is an autogenerated conversion function.
func Convert_v1beta1_ClusterList_To_v1beta2_ClusterList(in *ClusterList, out *v1beta2.ClusterList, s conversion.Scope) error {
	return autoConvert_v1beta1_ClusterList_To_v1beta2_ClusterList(in, out, s)
}

func autoConvert_v1beta2_ClusterList_To_v1beta1_ClusterList(in *v1beta2.ClusterList, out *ClusterList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	if in.Items != nil {
		in, out := &in.Items, &out.Items
		*out = make([]Cluster, len(*in))
		for i := range *in {
			if err := Convert_v1beta2_Cluster_To_v1beta1_Cluster(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Items = nil
	}
	return nil
}

// Convert_v1beta2_ClusterList_To_v1beta1_ClusterList is an autogenerated conversion function.
func Convert_v1beta2_ClusterList_To_v1beta1_ClusterList(in *v1beta2.ClusterList, out *ClusterList, s conversion.Scope) error {
	return autoConvert_v1beta2_ClusterList_To_v1beta1_ClusterList(in, out, s)
}

func autoConvert_v1beta1_ClusterNetwork_To_v1beta2_ClusterNetwork(in *ClusterNetwork, out *v1beta2.ClusterNetwork, s conversion.Scope) error {
	if err := v1.Convert_Pointer_int32_To_int32(&in.APIServerPort, &out.APIServerPort, s); err != nil {
		return err
	}
	// WARNING: in.Services requires manual conversion: inconvertible types (*sigs.k8s.io/cluster-api/api/core/v1beta1.NetworkRanges vs sigs.k8s.io/cluster-api/api/core/v1beta2.NetworkRanges)
	// WARNING: in.Pods requires manual conversion: inconvertible types (*sigs.k8s.io/cluster-api/api/core/v1beta1.NetworkRanges vs sigs.k8s.io/cluster-api/api/core/v1beta2.NetworkRanges)
	out.ServiceDomain = in.ServiceDomain
	return nil
}

func autoConvert_v1beta2_ClusterNetwork_To_v1beta1_ClusterNetwork(in *v1beta2.ClusterNetwork, out *ClusterNetwork, s conversion.Scope) error {
	if err := v1.Convert_int32_To_Pointer_int32(&in.APIServerPort, &out.APIServerPort, s); err != nil {
		return err
	}
	// WARNING: in.Services requires manual conversion: inconvertible types (sigs.k8s.io/cluster-api/api/core/v1beta2.NetworkRanges vs *sigs.k8s.io/cluster-api/api/core/v1beta1.NetworkRanges)
	// WARNING: in.Pods requires manual conversion: inconvertible types (sigs.k8s.io/cluster-api/api/core/v1beta2.NetworkRanges vs *sigs.k8s.io/cluster-api/api/core/v1beta1.NetworkRanges)
	out.ServiceDomain = in.ServiceDomain
	return nil
}

func autoConvert_v1beta1_ClusterSpec_To_v1beta2_ClusterSpec(in *ClusterSpec, out *v1beta2.ClusterSpec, s conversion.Scope) error {
	if err := v1.Convert_bool_To_Pointer_bool(&in.Paused, &out.Paused, s); err != nil {
		return err
	}
	// WARNING: in.ClusterNetwork requires manual conversion: inconvertible types (*sigs.k8s.io/cluster-api/api/core/v1beta1.ClusterNetwork vs sigs.k8s.io/cluster-api/api/core/v1beta2.ClusterNetwork)
	if err := Convert_v1beta1_APIEndpoint_To_v1beta2_APIEndpoint(&in.ControlPlaneEndpoint, &out.ControlPlaneEndpoint, s); err != nil {
		return err
	}
	// WARNING: in.ControlPlaneRef requires manual conversion: inconvertible types (*k8s.io/api/core/v1.ObjectReference vs sigs.k8s.io/cluster-api/api/core/v1beta2.ContractVersionedObjectReference)
	// WARNING: in.InfrastructureRef requires manual conversion: inconvertible types (*k8s.io/api/core/v1.ObjectReference vs sigs.k8s.io/cluster-api/api/core/v1beta2.ContractVersionedObjectReference)
	// WARNING: in.Topology requires manual conversion: inconvertible types (*sigs.k8s.io/cluster-api/api/core/v1beta1.Topology vs sigs.k8s.io/cluster-api/api/core/v1beta2.Topology)
	out.AvailabilityGates = *(*[]v1beta2.ClusterAvailabilityGate)(unsafe.Pointer(&in.AvailabilityGates))
	return nil
}

func autoConvert_v1beta2_ClusterSpec_To_v1beta1_ClusterSpec(in *v1beta2.ClusterSpec, out *ClusterSpec, s conversion.Scope) error {
	if err := v1.Convert_Pointer_bool_To_bool(&in.Paused, &out.Paused, s); err != nil {
		return err
	}
	// WARNING: in.ClusterNetwork requires manual conversion: inconvertible types (sigs.k8s.io/cluster-api/api/core/v1beta2.ClusterNetwork vs *sigs.k8s.io/cluster-api/api/core/v1beta1.ClusterNetwork)
	if err := Convert_v1beta2_APIEndpoint_To_v1beta1_APIEndpoint(&in.ControlPlaneEndpoint, &out.ControlPlaneEndpoint, s); err != nil {
		return err
	}
	// WARNING: in.ControlPlaneRef requires manual conversion: inconvertible types (sigs.k8s.io/cluster-api/api/core/v1beta2.ContractVersionedObjectReference vs *k8s.io/api/core/v1.ObjectReference)
	// WARNING: in.InfrastructureRef requires manual conversion: inconvertible types (sigs.k8s.io/cluster-api/api/core/v1beta2.ContractVersionedObjectReference vs *k8s.io/api/core/v1.ObjectReference)
	// WARNING: in.Topology requires manual conversion: inconvertible types (sigs.k8s.io/cluster-api/api/core/v1beta2.Topology vs *sigs.k8s.io/cluster-api/api/core/v1beta1.Topology)
	out.AvailabilityGates = *(*[]ClusterAvailabilityGate)(unsafe.Pointer(&in.AvailabilityGates))
	return nil
}

func autoConvert_v1beta1_ClusterStatus_To_v1beta2_ClusterStatus(in *ClusterStatus, out *v1beta2.ClusterStatus, s conversion.Scope) error {
	// WARNING: in.FailureDomains requires manual conversion: inconvertible types (sigs.k8s.io/cluster-api/api/core/v1beta1.FailureDomains vs []sigs.k8s.io/cluster-api/api/core/v1beta2.FailureDomain)
	// WARNING: in.FailureReason requires manual conversion: does not exist in peer-type
	// WARNING: in.FailureMessage requires manual conversion: does not exist in peer-type
	out.Phase = in.Phase
	// WARNING: in.InfrastructureReady requires manual conversion: does not exist in peer-type
	// WARNING: in.ControlPlaneReady requires manual conversion: does not exist in peer-type
	if in.Conditions != nil {
		in, out := &in.Conditions, &out.Conditions
		*out = make([]v1.Condition, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_Condition_To_v1_Condition(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Conditions = nil
	}
	out.ObservedGeneration = in.ObservedGeneration
	// WARNING: in.V1Beta2 requires manual conversion: does not exist in peer-type
	return nil
}

func autoConvert_v1beta2_ClusterStatus_To_v1beta1_ClusterStatus(in *v1beta2.ClusterStatus, out *ClusterStatus, s conversion.Scope) error {
	if in.Conditions != nil {
		in, out := &in.Conditions, &out.Conditions
		*out = make(Conditions, len(*in))
		for i := range *in {
			if err := Convert_v1_Condition_To_v1beta1_Condition(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Conditions = nil
	}
	// WARNING: in.Initialization requires manual conversion: does not exist in peer-type
	// WARNING: in.ControlPlane requires manual conversion: does not exist in peer-type
	// WARNING: in.Workers requires manual conversion: does not exist in peer-type
	// WARNING: in.FailureDomains requires manual conversion: inconvertible types ([]sigs.k8s.io/cluster-api/api/core/v1beta2.FailureDomain vs sigs.k8s.io/cluster-api/api/core/v1beta1.FailureDomains)
	out.Phase = in.Phase
	out.ObservedGeneration = in.ObservedGeneration
	// WARNING: in.Deprecated requires manual conversion: does not exist in peer-type
	return nil
}

func autoConvert_v1beta1_ClusterVariable_To_v1beta2_ClusterVariable(in *ClusterVariable, out *v1beta2.ClusterVariable, s conversion.Scope) error {
	out.Name = in.Name
	// WARNING: in.DefinitionFrom requires manual conversion: does not exist in peer-type
	out.Value = in.Value
	return nil
}

func autoConvert_v1beta2_ClusterVariable_To_v1beta1_ClusterVariable(in *v1beta2.ClusterVariable, out *ClusterVariable, s conversion.Scope) error {
	out.Name = in.Name
	out.Value = in.Value
	return nil
}

// Convert_v1beta2_ClusterVariable_To_v1beta1_ClusterVariable is an autogenerated conversion function.
func Convert_v1beta2_ClusterVariable_To_v1beta1_ClusterVariable(in *v1beta2.ClusterVariable, out *ClusterVariable, s conversion.Scope) error {
	return autoConvert_v1beta2_ClusterVariable_To_v1beta1_ClusterVariable(in, out, s)
}

func autoConvert_v1beta1_Condition_To_v1beta2_Condition(in *Condition, out *v1beta2.Condition, s conversion.Scope) error {
	out.Type = v1beta2.ConditionType(in.Type)
	out.Status = corev1.ConditionStatus(in.Status)
	out.Severity = v1beta2.ConditionSeverity(in.Severity)
	out.LastTransitionTime = in.LastTransitionTime
	out.Reason = in.Reason
	out.Message = in.Message
	return nil
}

// Convert_v1beta1_Condition_To_v1beta2_Condition is an autogenerated conversion function.
func Convert_v1beta1_Condition_To_v1beta2_Condition(in *Condition, out *v1beta2.Condition, s conversion.Scope) error {
	return autoConvert_v1beta1_Condition_To_v1beta2_Condition(in, out, s)
}

func autoConvert_v1beta2_Condition_To_v1beta1_Condition(in *v1beta2.Condition, out *Condition, s conversion.Scope) error {
	out.Type = ConditionType(in.Type)
	out.Status = corev1.ConditionStatus(in.Status)
	out.Severity = ConditionSeverity(in.Severity)
	out.LastTransitionTime = in.LastTransitionTime
	out.Reason = in.Reason
	out.Message = in.Message
	return nil
}

// Convert_v1beta2_Condition_To_v1beta1_Condition is an autogenerated conversion function.
func Convert_v1beta2_Condition_To_v1beta1_Condition(in *v1beta2.Condition, out *Condition, s conversion.Scope) error {
	return autoConvert_v1beta2_Condition_To_v1beta1_Condition(in, out, s)
}

func autoConvert_v1beta1_ControlPlaneClass_To_v1beta2_ControlPlaneClass(in *ControlPlaneClass, out *v1beta2.ControlPlaneClass, s conversion.Scope) error {
	if err := Convert_v1beta1_ObjectMeta_To_v1beta2_ObjectMeta(&in.Metadata, &out.Metadata, s); err != nil {
		return err
	}
	// WARNING: in.LocalObjectTemplate requires manual conversion: does not exist in peer-type
	// WARNING: in.MachineInfrastructure requires manual conversion: inconvertible types (*sigs.k8s.io/cluster-api/api/core/v1beta1.LocalObjectTemplate vs sigs.k8s.io/cluster-api/api/core/v1beta2.ControlPlaneClassMachineInfrastructureTemplate)
	// WARNING: in.MachineHealthCheck requires manual conversion: does not exist in peer-type
	// WARNING: in.NamingStrategy requires manual conversion: does not exist in peer-type
	// WARNING: in.NodeDrainTimeout requires manual conversion: does not exist in peer-type
	// WARNING: in.NodeVolumeDetachTimeout requires manual conversion: does not exist in peer-type
	// WARNING: in.NodeDeletionTimeout requires manual conversion: does not exist in peer-type
	out.ReadinessGates = *(*[]v1beta2.MachineReadinessGate)(unsafe.Pointer(&in.ReadinessGates))
	return nil
}

func autoConvert_v1beta2_ControlPlaneClass_To_v1beta1_ControlPlaneClass(in *v1beta2.ControlPlaneClass, out *ControlPlaneClass, s conversion.Scope) error {
	if err := Convert_v1beta2_ObjectMeta_To_v1beta1_ObjectMeta(&in.Metadata, &out.Metadata, s); err != nil {
		return err
	}
	// WARNING: in.TemplateRef requires manual conversion: does not exist in peer-type
	// WARNING: in.MachineInfrastructure requires manual conversion: inconvertible types (sigs.k8s.io/cluster-api/api/core/v1beta2.ControlPlaneClassMachineInfrastructureTemplate vs *sigs.k8s.io/cluster-api/api/core/v1beta1.LocalObjectTemplate)
	// WARNING: in.HealthCheck requires manual conversion: does not exist in peer-type
	// WARNING: in.Naming requires manual conversion: does not exist in peer-type
	// WARNING: in.Deletion requires manual conversion: does not exist in peer-type
	// WARNING: in.Taints requires manual conversion: does not exist in peer-type
	out.ReadinessGates = *(*[]MachineReadinessGate)(unsafe.Pointer(&in.ReadinessGates))
	return nil
}

func autoConvert_v1beta1_ControlPlaneTopology_To_v1beta2_ControlPlaneTopology(in *ControlPlaneTopology, out *v1beta2.ControlPlaneTopology, s conversion.Scope) error {
	if err := Convert_v1beta1_ObjectMeta_To_v1beta2_ObjectMeta(&in.Metadata, &out.Metadata, s); err != nil {
		return err
	}
	out.Replicas = (*int32)(unsafe.Pointer(in.Replicas))
	// WARNING: in.MachineHealthCheck requires manual conversion: does not exist in peer-type
	// WARNING: in.NodeDrainTimeout requires manual conversion: does not exist in peer-type
	// WARNING: in.NodeVolumeDetachTimeout requires manual conversion: does not exist in peer-type
	// WARNING: in.NodeDeletionTimeout requires manual conversion: does not exist in peer-type
	out.ReadinessGates = *(*[]v1beta2.MachineReadinessGate)(unsafe.Pointer(&in.ReadinessGates))
	// WARNING: in.Variables requires manual conversion: inconvertible types (*sigs.k8s.io/cluster-api/api/core/v1beta1.ControlPlaneVariables vs sigs.k8s.io/cluster-api/api/core/v1beta2.ControlPlaneVariables)
	return nil
}

func autoConvert_v1beta2_ControlPlaneTopology_To_v1beta1_ControlPlaneTopology(in *v1beta2.ControlPlaneTopology, out *ControlPlaneTopology, s conversion.Scope) error {
	if err := Convert_v1beta2_ObjectMeta_To_v1beta1_ObjectMeta(&in.Metadata, &out.Metadata, s); err != nil {
		return err
	}
	out.Replicas = (*int32)(unsafe.Pointer(in.Replicas))
	// WARNING: in.HealthCheck requires manual conversion: does not exist in peer-type
	// WARNING: in.Deletion requires manual conversion: does not exist in peer-type
	// WARNING: in.Taints requires manual conversion: does not exist in peer-type
	out.ReadinessGates = *(*[]MachineReadinessGate)(unsafe.Pointer(&in.ReadinessGates))
	// WARNING: in.Variables requires manual conversion: inconvertible types (sigs.k8s.io/cluster-api/api/core/v1beta2.ControlPlaneVariables vs *sigs.k8s.io/cluster-api/api/core/v1beta1.ControlPlaneVariables)
	return nil
}

func autoConvert_v1beta1_ControlPlaneVariables_To_v1beta2_ControlPlaneVariables(in *ControlPlaneVariables, out *v1beta2.ControlPlaneVariables, s conversion.Scope) error {
	if in.Overrides != nil {
		in, out := &in.Overrides, &out.Overrides
		*out = make([]v1beta2.ClusterVariable, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_ClusterVariable_To_v1beta2_ClusterVariable(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Overrides = nil
	}
	return nil
}

// Convert_v1beta1_ControlPlaneVariables_To_v1beta2_ControlPlaneVariables is an autogenerated conversion function.
func Convert_v1beta1_ControlPlaneVariables_To_v1beta2_ControlPlaneVariables(in *ControlPlaneVariables, out *v1beta2.ControlPlaneVariables, s conversion.Scope) error {
	return autoConvert_v1beta1_ControlPlaneVariables_To_v1beta2_ControlPlaneVariables(in, out, s)
}

func autoConvert_v1beta2_ControlPlaneVariables_To_v1beta1_ControlPlaneVariables(in *v1beta2.ControlPlaneVariables, out *ControlPlaneVariables, s conversion.Scope) error {
	if in.Overrides != nil {
		in, out := &in.Overrides, &out.Overrides
		*out = make([]ClusterVariable, len(*in))
		for i := range *in {
			if err := Convert_v1beta2_ClusterVariable_To_v1beta1_ClusterVariable(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Overrides = nil
	}
	return nil
}

// Convert_v1beta2_ControlPlaneVariables_To_v1beta1_ControlPlaneVariables is an autogenerated conversion function.
func Convert_v1beta2_ControlPlaneVariables_To_v1beta1_ControlPlaneVariables(in *v1beta2.ControlPlaneVariables, out *ControlPlaneVariables, s conversion.Scope) error {
	return autoConvert_v1beta2_ControlPlaneVariables_To_v1beta1_ControlPlaneVariables(in, out, s)
}

func autoConvert_v1beta1_ExternalPatchDefinition_To_v1beta2_ExternalPatchDefinition(in *ExternalPatchDefinition, out *v1beta2.ExternalPatchDefinition, s conversion.Scope) error {
	// WARNING: in.GenerateExtension requires manual conversion: does not exist in peer-type
	// WARNING: in.ValidateExtension requires manual conversion: does not exist in peer-type
	if err := v1.Convert_Pointer_string_To_string(&in.DiscoverVariablesExtension, &out.DiscoverVariablesExtension, s); err != nil {
		return err
	}
	out.Settings = *(*map[string]string)(unsafe.Pointer(&in.Settings))
	return nil
}

func autoConvert_v1beta2_ExternalPatchDefinition_To_v1beta1_ExternalPatchDefinition(in *v1beta2.ExternalPatchDefinition, out *ExternalPatchDefinition, s conversion.Scope) error {
	// WARNING: in.GeneratePatchesExtension requires manual conversion: does not exist in peer-type
	// WARNING: in.ValidateTopologyExtension requires manual conversion: does not exist in peer-type
	if err := v1.Convert_string_To_Pointer_string(&in.DiscoverVariablesExtension, &out.DiscoverVariablesExtension, s); err != nil {
		return err
	}
	out.Settings = *(*map[string]string)(unsafe.Pointer(&in.Settings))
	return nil
}

func autoConvert_v1beta1_JSONPatch_To_v1beta2_JSONPatch(in *JSONPatch, out *v1beta2.JSONPatch, s conversion.Scope) error {
	out.Op = in.Op
	out.Path = in.Path
	out.Value = (*apiextensionsv1.JSON)(unsafe.Pointer(in.Value))
	if in.ValueFrom != nil {
		in, out := &in.ValueFrom, &out.ValueFrom
		*out = new(v1beta2.JSONPatchValue)
		if err := Convert_v1beta1_JSONPatchValue_To_v1beta2_JSONPatchValue(*in, *out, s); err != nil {
			return err
		}
	} else {
		out.ValueFrom = nil
	}
	return nil
}

// Convert_v1beta1_JSONPatch_To_v1beta2_JSONPatch is an autogenerated conversion function.
func Convert_v1beta1_JSONPatch_To_v1beta2_JSONPatch(in *JSONPatch, out *v1beta2.JSONPatch, s conversion.Scope) error {
	return autoConvert_v1beta1_JSONPatch_To_v1beta2_JSONPatch(in, out, s)
}

func autoConvert_v1beta2_JSONPatch_To_v1beta1_JSONPatch(in *v1beta2.JSONPatch, out *JSONPatch, s conversion.Scope) error {
	out.Op = in.Op
	out.Path = in.Path
	out.Value = (*apiextensionsv1.JSON)(unsafe.Pointer(in.Value))
	if in.ValueFrom != nil {
		in, out := &in.ValueFrom, &out.ValueFrom
		*out = new(JSONPatchValue)
		if err := Convert_v1beta2_JSONPatchValue_To_v1beta1_JSONPatchValue(*in, *out, s); err != nil {
			return err
		}
	} else {
		out.ValueFrom = nil
	}
	return nil
}

// Convert_v1beta2_JSONPatch_To_v1beta1_JSONPatch is an autogenerated conversion function.
func Convert_v1beta2_JSONPatch_To_v1beta1_JSONPatch(in *v1beta2.JSONPatch, out *JSONPatch, s conversion.Scope) error {
	return autoConvert_v1beta2_JSONPatch_To_v1beta1_JSONPatch(in, out, s)
}

func autoConvert_v1beta1_JSONPatchValue_To_v1beta2_JSONPatchValue(in *JSONPatchValue, out *v1beta2.JSONPatchValue, s conversion.Scope) error {
	if err := v1.Convert_Pointer_string_To_string(&in.Variable, &out.Variable, s); err != nil {
		return err
	}
	if err := v1.Convert_Pointer_string_To_string(&in.Template, &out.Template, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1beta1_JSONPatchValue_To_v1beta2_JSONPatchValue is an autogenerated conversion function.
func Convert_v1beta1_JSONPatchValue_To_v1beta2_JSONPatchValue(in *JSONPatchValue, out *v1beta2.JSONPatchValue, s conversion.Scope) error {
	return autoConvert_v1beta1_JSONPatchValue_To_v1beta2_JSONPatchValue(in, out, s)
}

func autoConvert_v1beta2_JSONPatchValue_To_v1beta1_JSONPatchValue(in *v1beta2.JSONPatchValue, out *JSONPatchValue, s conversion.Scope) error {
	if err := v1.Convert_string_To_Pointer_string(&in.Variable, &out.Variable, s); err != nil {
		return err
	}
	if err := v1.Convert_string_To_Pointer_string(&in.Template, &out.Template, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1beta2_JSONPatchValue_To_v1beta1_JSONPatchValue is an autogenerated conversion function.
func Convert_v1beta2_JSONPatchValue_To_v1beta1_JSONPatchValue(in *v1beta2.JSONPatchValue, out *JSONPatchValue, s conversion.Scope) error {
	return autoConvert_v1beta2_JSONPatchValue_To_v1beta1_JSONPatchValue(in, out, s)
}

func autoConvert_v1beta1_JSONSchemaProps_To_v1beta2_JSONSchemaProps(in *JSONSchemaProps, out *v1beta2.JSONSchemaProps, s conversion.Scope) error {
	out.Description = in.Description
	out.Example = (*apiextensionsv1.JSON)(unsafe.Pointer(in.Example))
	out.Type = in.Type
	if in.Properties != nil {
		in, out := &in.Properties, &out.Properties
		*out = make(map[string]v1beta2.JSONSchemaProps, len(*in))
		for key, val := range *in {
			newVal := new(v1beta2.JSONSchemaProps)
			if err := Convert_v1beta1_JSONSchemaProps_To_v1beta2_JSONSchemaProps(&val, newVal, s); err != nil {
				return err
			}
			(*out)[key] = *newVal
		}
	} else {
		out.Properties = nil
	}
	if in.AdditionalProperties != nil {
		in, out := &in.AdditionalProperties, &out.AdditionalProperties
		*out = new(v1beta2.JSONSchemaProps)
		if err := Convert_v1beta1_JSONSchemaProps_To_v1beta2_JSONSchemaProps(*in, *out, s); err != nil {
			return err
		}
	} else {
		out.AdditionalProperties = nil
	}
	out.MaxProperties = (*int64)(unsafe.Pointer(in.MaxProperties))
	out.MinProperties = (*int64)(unsafe.Pointer(in.MinProperties))
	out.Required = *(*[]string)(unsafe.Pointer(&in.Required))
	if in.Items != nil {
		in, out := &in.Items, &out.Items
		*out = new(v1beta2.JSONSchemaProps)
		if err := Convert_v1beta1_JSONSchemaProps_To_v1beta2_JSONSchemaProps(*in, *out, s); err != nil {
			return err
		}
	} else {
		out.Items = nil
	}
	out.MaxItems = (*int64)(unsafe.Pointer(in.MaxItems))
	out.MinItems = (*int64)(unsafe.Pointer(in.MinItems))
	if err := v1.Convert_bool_To_Pointer_bool(&in.UniqueItems, &out.UniqueItems, s); err != nil {
		return err
	}
	out.Format = in.Format
	out.MaxLength = (*int64)(unsafe.Pointer(in.MaxLength))
	out.MinLength = (*int64)(unsafe.Pointer(in.MinLength))
	out.Pattern = in.Pattern
	out.Maximum = (*int64)(unsafe.Pointer(in.Maximum))
	if err := v1.Convert_bool_To_Pointer_bool(&in.ExclusiveMaximum, &out.ExclusiveMaximum, s); err != nil {
		return err
	}
	out.Minimum = (*int64)(unsafe.Pointer(in.Minimum))
	if err := v1.Convert_bool_To_Pointer_bool(&in.ExclusiveMinimum, &out.ExclusiveMinimum, s); err != nil {
		return err
	}
	if err := v1.Convert_bool_To_Pointer_bool(&in.XPreserveUnknownFields, &out.XPreserveUnknownFields, s); err != nil {
		return err
	}
	out.Enum = *(*[]apiextensionsv1.JSON)(unsafe.Pointer(&in.Enum))
	out.Default = (*apiextensionsv1.JSON)(unsafe.Pointer(in.Default))
	out.XValidations = *(*[]v1beta2.ValidationRule)(unsafe.Pointer(&in.XValidations))
	// WARNING: in.XMetadata requires manual conversion: inconvertible types (*sigs.k8s.io/cluster-api/api/core/v1beta1.VariableSchemaMetadata vs sigs.k8s.io/cluster-api/api/core/v1beta2.VariableSchemaMetadata)
	if err := v1.Convert_bool_To_Pointer_bool(&in.XIntOrString, &out.XIntOrString, s); err != nil {
		return err
	}
	if in.AllOf != nil {
		in, out := &in.AllOf, &out.AllOf
		*out = make([]v1beta2.JSONSchemaProps, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_JSONSchemaProps_To_v1beta2_JSONSchemaProps(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.AllOf = nil
	}
	if in.OneOf != nil {
		in, out := &in.OneOf, &out.OneOf
		*out = make([]v1beta2.JSONSchemaProps, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_JSONSchemaProps_To_v1beta2_JSONSchemaProps(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.OneOf = nil
	}
	if in.AnyOf != nil {
		in, out := &in.AnyOf, &out.AnyOf
		*out = make([]v1beta2.JSONSchemaProps, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_JSONSchemaProps_To_v1beta2_JSONSchemaProps(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.AnyOf = nil
	}
	if in.Not != nil {
		in, out := &in.Not, &out.Not
		*out = new(v1beta2.JSONSchemaProps)
		if err := Convert_v1beta1_JSONSchemaProps_To_v1beta2_JSONSchemaProps(*in, *out, s); err != nil {
			return err
		}
	} else {
		out.Not = nil
	}
	return nil
}

func autoConvert_v1beta2_JSONSchemaProps_To_v1beta1_JSONSchemaProps(in *v1beta2.JSONSchemaProps, out *JSONSchemaProps, s conversion.Scope) error {
	out.Description = in.Description
	out.Example = (*apiextensionsv1.JSON)(unsafe.Pointer(in.Example))
	out.Type = in.Type
	if in.Properties != nil {
		in, out := &in.Properties, &out.Properties
		*out = make(map[string]JSONSchemaProps, len(*in))
		for key, val := range *in {
			newVal := new(JSONSchemaProps)
			if err := Convert_v1beta2_JSONSchemaProps_To_v1beta1_JSONSchemaProps(&val, newVal, s); err != nil {
				return err
			}
			(*out)[key] = *newVal
		}
	} else {
		out.Properties = nil
	}
	if in.AdditionalProperties != nil {
		in, out := &in.AdditionalProperties, &out.AdditionalProperties
		*out = new(JSONSchemaProps)
		if err := Convert_v1beta2_JSONSchemaProps_To_v1beta1_JSONSchemaProps(*in, *out, s); err != nil {
			return err
		}
	} else {
		out.AdditionalProperties = nil
	}
	out.MaxProperties = (*int64)(unsafe.Pointer(in.MaxProperties))
	out.MinProperties = (*int64)(unsafe.Pointer(in.MinProperties))
	out.Required = *(*[]string)(unsafe.Pointer(&in.Required))
	if in.Items != nil {
		in, out := &in.Items, &out.Items
		*out = new(JSONSchemaProps)
		if err := Convert_v1beta2_JSONSchemaProps_To_v1beta1_JSONSchemaProps(*in, *out, s); err != nil {
			return err
		}
	} else {
		out.Items = nil
	}
	out.MaxItems = (*int64)(unsafe.Pointer(in.MaxItems))
	out.MinItems = (*int64)(unsafe.Pointer(in.MinItems))
	if err := v1.Convert_Pointer_bool_To_bool(&in.UniqueItems, &out.UniqueItems, s); err != nil {
		return err
	}
	out.Format = in.Format
	out.MaxLength = (*int64)(unsafe.Pointer(in.MaxLength))
	out.MinLength = (*int64)(unsafe.Pointer(in.MinLength))
	out.Pattern = in.Pattern
	out.Maximum = (*int64)(unsafe.Pointer(in.Maximum))
	if err := v1.Convert_Pointer_bool_To_bool(&in.ExclusiveMaximum, &out.ExclusiveMaximum, s); err != nil {
		return err
	}
	out.Minimum = (*int64)(unsafe.Pointer(in.Minimum))
	if err := v1.Convert_Pointer_bool_To_bool(&in.ExclusiveMinimum, &out.ExclusiveMinimum, s); err != nil {
		return err
	}
	if err := v1.Convert_Pointer_bool_To_bool(&in.XPreserveUnknownFields, &out.XPreserveUnknownFields, s); err != nil {
		return err
	}
	out.Enum = *(*[]apiextensionsv1.JSON)(unsafe.Pointer(&in.Enum))
	out.Default = (*apiextensionsv1.JSON)(unsafe.Pointer(in.Default))
	out.XValidations = *(*[]ValidationRule)(unsafe.Pointer(&in.XValidations))
	// WARNING: in.XMetadata requires manual conversion: inconvertible types (sigs.k8s.io/cluster-api/api/core/v1beta2.VariableSchemaMetadata vs *sigs.k8s.io/cluster-api/api/core/v1beta1.VariableSchemaMetadata)
	if err := v1.Convert_Pointer_bool_To_bool(&in.XIntOrString, &out.XIntOrString, s); err != nil {
		return err
	}
	if in.AllOf != nil {
		in, out := &in.AllOf, &out.AllOf
		*out = make([]JSONSchemaProps, len(*in))
		for i := range *in {
			if err := Convert_v1beta2_JSONSchemaProps_To_v1beta1_JSONSchemaProps(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.AllOf = nil
	}
	if in.OneOf != nil {
		in, out := &in.OneOf, &out.OneOf
		*out = make([]JSONSchemaProps, len(*in))
		for i := range *in {
			if err := Convert_v1beta2_JSONSchemaProps_To_v1beta1_JSONSchemaProps(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.OneOf = nil
	}
	if in.AnyOf != nil {
		in, out := &in.AnyOf, &out.AnyOf
		*out = make([]JSONSchemaProps, len(*in))
		for i := range *in {
			if err := Convert_v1beta2_JSONSchemaProps_To_v1beta1_JSONSchemaProps(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.AnyOf = nil
	}
	if in.Not != nil {
		in, out := &in.Not, &out.Not
		*out = new(JSONSchemaProps)
		if err := Convert_v1beta2_JSONSchemaProps_To_v1beta1_JSONSchemaProps(*in, *out, s); err != nil {
			return err
		}
	} else {
		out.Not = nil
	}
	return nil
}

func autoConvert_v1beta1_Machine_To_v1beta2_Machine(in *Machine, out *v1beta2.Machine, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1beta1_MachineSpec_To_v1beta2_MachineSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_v1beta1_MachineStatus_To_v1beta2_MachineStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1beta1_Machine_To_v1beta2_Machine is an autogenerated conversion function.
func Convert_v1beta1_Machine_To_v1beta2_Machine(in *Machine, out *v1beta2.Machine, s conversion.Scope) error {
	return autoConvert_v1beta1_Machine_To_v1beta2_Machine(in, out, s)
}

func autoConvert_v1beta2_Machine_To_v1beta1_Machine(in *v1beta2.Machine, out *Machine, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1beta2_MachineSpec_To_v1beta1_MachineSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_v1beta2_MachineStatus_To_v1beta1_MachineStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1beta2_Machine_To_v1beta1_Machine is an autogenerated conversion function.
func Convert_v1beta2_Machine_To_v1beta1_Machine(in *v1beta2.Machine, out *Machine, s conversion.Scope) error {
	return autoConvert_v1beta2_Machine_To_v1beta1_Machine(in, out, s)
}

func autoConvert_v1beta1_MachineAddress_To_v1beta2_MachineAddress(in *MachineAddress, out *v1beta2.MachineAddress, s conversion.Scope) error {
	out.Type = v1beta2.MachineAddressType(in.Type)
	out.Address = in.Address
	return nil
}

// Convert_v1beta1_MachineAddress_To_v1beta2_MachineAddress is an autogenerated conversion function.
func Convert_v1beta1_MachineAddress_To_v1beta2_MachineAddress(in *MachineAddress, out *v1beta2.MachineAddress, s conversion.Scope) error {
	return autoConvert_v1beta1_MachineAddress_To_v1beta2_MachineAddress(in, out, s)
}

func autoConvert_v1beta2_MachineAddress_To_v1beta1_MachineAddress(in *v1beta2.MachineAddress, out *MachineAddress, s conversion.Scope) error {
	out.Type = MachineAddressType(in.Type)
	out.Address = in.Address
	return nil
}

// Convert_v1beta2_MachineAddress_To_v1beta1_MachineAddress is an autogenerated conversion function.
func Convert_v1beta2_MachineAddress_To_v1beta1_MachineAddress(in *v1beta2.MachineAddress, out *MachineAddress, s conversion.Scope) error {
	return autoConvert_v1beta2_MachineAddress_To_v1beta1_MachineAddress(in, out, s)
}

func autoConvert_v1beta1_MachineDeletionStatus_To_v1beta2_MachineDeletionStatus(in *MachineDeletionStatus, out *v1beta2.MachineDeletionStatus, s conversion.Scope) error {
	// WARNING: in.NodeDrainStartTime requires manual conversion: inconvertible types (*k8s.io/apimachinery/pkg/apis/meta/v1.Time vs k8s.io/apimachinery/pkg/apis/meta/v1.Time)
	// WARNING: in.WaitForNodeVolumeDetachStartTime requires manual conversion: inconvertible types (*k8s.io/apimachinery/pkg/apis/meta/v1.Time vs k8s.io/apimachinery/pkg/apis/meta/v1.Time)
	return nil
}

func autoConvert_v1beta2_MachineDeletionStatus_To_v1beta1_MachineDeletionStatus(in *v1beta2.MachineDeletionStatus, out *MachineDeletionStatus, s conversion.Scope) error {
	// WARNING: in.NodeDrainStartTime requires manual conversion: inconvertible types (k8s.io/apimachinery/pkg/apis/meta/v1.Time vs *k8s.io/apimachinery/pkg/apis/meta/v1.Time)
	// WARNING: in.WaitForNodeVolumeDetachStartTime requires manual conversion: inconvertible types (k8s.io/apimachinery/pkg/apis/meta/v1.Time vs *k8s.io/apimachinery/pkg/apis/meta/v1.Time)
	return nil
}

func autoConvert_v1beta1_MachineDeployment_To_v1beta2_MachineDeployment(in *MachineDeployment, out *v1beta2.MachineDeployment, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1beta1_MachineDeploymentSpec_To_v1beta2_MachineDeploymentSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_v1beta1_MachineDeploymentStatus_To_v1beta2_MachineDeploymentStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1beta1_MachineDeployment_To_v1beta2_MachineDeployment is an autogenerated conversion function.
func Convert_v1beta1_MachineDeployment_To_v1beta2_MachineDeployment(in *MachineDeployment, out *v1beta2.MachineDeployment, s conversion.Scope) error {
	return autoConvert_v1beta1_MachineDeployment_To_v1beta2_MachineDeployment(in, out, s)
}

func autoConvert_v1beta2_MachineDeployment_To_v1beta1_MachineDeployment(in *v1beta2.MachineDeployment, out *MachineDeployment, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1beta2_MachineDeploymentSpec_To_v1beta1_MachineDeploymentSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_v1beta2_MachineDeploymentStatus_To_v1beta1_MachineDeploymentStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1beta2_MachineDeployment_To_v1beta1_MachineDeployment is an autogenerated conversion function.
func Convert_v1beta2_MachineDeployment_To_v1beta1_MachineDeployment(in *v1beta2.MachineDeployment, out *MachineDeployment, s conversion.Scope) error {
	return autoConvert_v1beta2_MachineDeployment_To_v1beta1_MachineDeployment(in, out, s)
}

func autoConvert_v1beta1_MachineDeploymentClass_To_v1beta2_MachineDeploymentClass(in *MachineDeploymentClass, out *v1beta2.MachineDeploymentClass, s conversion.Scope) error {
	out.Class = in.Class
	// WARNING: in.Template requires manual conversion: does not exist in peer-type
	// WARNING: in.MachineHealthCheck requires manual conversion: does not exist in peer-type
	if err := v1.Convert_Pointer_string_To_string(&in.FailureDomain, &out.FailureDomain, s); err != nil {
		return err
	}
	// WARNING: in.NamingStrategy requires manual conversion: does not exist in peer-type
	// WARNING: in.NodeDrainTimeout requires manual conversion: does not exist in peer-type
	// WARNING: in.NodeVolumeDetachTimeout requires manual conversion: does not exist in peer-type
	// WARNING: in.NodeDeletionTimeout requires manual conversion: does not exist in peer-type
	out.MinReadySeconds = (*int32)(unsafe.Pointer(in.MinReadySeconds))
	out.ReadinessGates = *(*[]v1beta2.MachineReadinessGate)(unsafe.Pointer(&in.ReadinessGates))
	// WARNING: in.Strategy requires manual conversion: does not exist in peer-type
	return nil
}

func autoConvert_v1beta2_MachineDeploymentClass_To_v1beta1_MachineDeploymentClass(in *v1beta2.MachineDeploymentClass, out *MachineDeploymentClass, s conversion.Scope) error {
	// WARNING: in.Metadata requires manual conversion: does not exist in peer-type
	out.Class = in.Class
	// WARNING: in.Bootstrap requires manual conversion: does not exist in peer-type
	// WARNING: in.Infrastructure requires manual conversion: does not exist in peer-type
	// WARNING: in.HealthCheck requires manual conversion: does not exist in peer-type
	if err := v1.Convert_string_To_Pointer_string(&in.FailureDomain, &out.FailureDomain, s); err != nil {
		return err
	}
	// WARNING: in.Naming requires manual conversion: does not exist in peer-type
	// WARNING: in.Deletion requires manual conversion: does not exist in peer-type
	// WARNING: in.Taints requires manual conversion: does not exist in peer-type
	out.MinReadySeconds = (*int32)(unsafe.Pointer(in.MinReadySeconds))
	out.ReadinessGates = *(*[]MachineReadinessGate)(unsafe.Pointer(&in.ReadinessGates))
	// WARNING: in.Rollout requires manual conversion: does not exist in peer-type
	return nil
}

func autoConvert_v1beta1_MachineDeploymentList_To_v1beta2_MachineDeploymentList(in *MachineDeploymentList, out *v1beta2.MachineDeploymentList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	if in.Items != nil {
		in, out := &in.Items, &out.Items
		*out = make([]v1beta2.MachineDeployment, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_MachineDeployment_To_v1beta2_MachineDeployment(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Items = nil
	}
	return nil
}

// Convert_v1beta1_MachineDeploymentList_To_v1beta2_MachineDeploymentList is an autogenerated conversion function.
func Convert_v1beta1_MachineDeploymentList_To_v1beta2_MachineDeploymentList(in *MachineDeploymentList, out *v1beta2.MachineDeploymentList, s conversion.Scope) error {
	return autoConvert_v1beta1_MachineDeploymentList_To_v1beta2_MachineDeploymentList(in, out, s)
}

func autoConvert_v1beta2_MachineDeploymentList_To_v1beta1_MachineDeploymentList(in *v1beta2.MachineDeploymentList, out *MachineDeploymentList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	if in.Items != nil {
		in, out := &in.Items, &out.Items
		*out = make([]MachineDeployment, len(*in))
		for i := range *in {
			if err := Convert_v1beta2_MachineDeployment_To_v1beta1_MachineDeployment(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Items = nil
	}
	return nil
}

// Convert_v1beta2_MachineDeploymentList_To_v1beta1_MachineDeploymentList is an autogenerated conversion function.
func Convert_v1beta2_MachineDeploymentList_To_v1beta1_MachineDeploymentList(in *v1beta2.MachineDeploymentList, out *MachineDeploymentList, s conversion.Scope) error {
	return autoConvert_v1beta2_MachineDeploymentList_To_v1beta1_MachineDeploymentList(in, out, s)
}

func autoConvert_v1beta1_MachineDeploymentSpec_To_v1beta2_MachineDeploymentSpec(in *MachineDeploymentSpec, out *v1beta2.MachineDeploymentSpec, s conversion.Scope) error {
	out.ClusterName = in.ClusterName
	out.Replicas = (*int32)(unsafe.Pointer(in.Replicas))
	// WARNING: in.RolloutAfter requires manual conversion: does not exist in peer-type
	out.Selector = in.Selector
	if err := Convert_v1beta1_MachineTemplateSpec_To_v1beta2_MachineTemplateSpec(&in.Template, &out.Template, s); err != nil {
		return err
	}
	// WARNING: in.Strategy requires manual conversion: does not exist in peer-type
	// WARNING: in.MachineNamingStrategy requires manual conversion: does not exist in peer-type
	// WARNING: in.MinReadySeconds requires manual conversion: does not exist in peer-type
	// WARNING: in.RevisionHistoryLimit requires manual conversion: does not exist in peer-type
	if err := v1.Convert_bool_To_Pointer_bool(&in.Paused, &out.Paused, s); err != nil {
		return err
	}
	// WARNING: in.ProgressDeadlineSeconds requires manual conversion: does not exist in peer-type
	return nil
}

func autoConvert_v1beta2_MachineDeploymentSpec_To_v1beta1_MachineDeploymentSpec(in *v1beta2.MachineDeploymentSpec, out *MachineDeploymentSpec, s conversion.Scope) error {
	out.ClusterName = in.ClusterName
	out.Replicas = (*int32)(unsafe.Pointer(in.Replicas))
	// WARNING: in.Rollout requires manual conversion: does not exist in peer-type
	out.Selector = in.Selector
	if err := Convert_v1beta2_MachineTemplateSpec_To_v1beta1_MachineTemplateSpec(&in.Template, &out.Template, s); err != nil {
		return err
	}
	// WARNING: in.MachineNaming requires manual conversion: does not exist in peer-type
	// WARNING: in.Remediation requires manual conversion: does not exist in peer-type
	// WARNING: in.Deletion requires manual conversion: does not exist in peer-type
	if err := v1.Convert_Pointer_bool_To_bool(&in.Paused, &out.Paused, s); err != nil {
		return err
	}
	return nil
}

func autoConvert_v1beta1_MachineDeploymentStatus_To_v1beta2_MachineDeploymentStatus(in *MachineDeploymentStatus, out *v1beta2.MachineDeploymentStatus, s conversion.Scope) error {
	out.ObservedGeneration = in.ObservedGeneration
	out.Selector = in.Selector
	if err := v1.Convert_int32_To_Pointer_int32(&in.Replicas, &out.Replicas, s); err != nil {
		return err
	}
	// WARNING: in.UpdatedReplicas requires manual conversion: does not exist in peer-type
	if err := v1.Convert_int32_To_Pointer_int32(&in.ReadyReplicas, &out.ReadyReplicas, s); err != nil {
		return err
	}
	if err := v1.Convert_int32_To_Pointer_int32(&in.AvailableReplicas, &out.AvailableReplicas, s); err != nil {
		return err
	}
	// WARNING: in.UnavailableReplicas requires manual conversion: does not exist in peer-type
	out.Phase = in.Phase
	if in.Conditions != nil {
		in, out := &in.Conditions, &out.Conditions
		*out = make([]v1.Condition, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_Condition_To_v1_Condition(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Conditions = nil
	}
	// WARNING: in.V1Beta2 requires manual conversion: does not exist in peer-type
	return nil
}

func autoConvert_v1beta2_MachineDeploymentStatus_To_v1beta1_MachineDeploymentStatus(in *v1beta2.MachineDeploymentStatus, out *MachineDeploymentStatus, s conversion.Scope) error {
	if in.Conditions != nil {
		in, out := &in.Conditions, &out.Conditions
		*out = make(Conditions, len(*in))
		for i := range *in {
			if err := Convert_v1_Condition_To_v1beta1_Condition(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Conditions = nil
	}
	out.ObservedGeneration = in.ObservedGeneration
	out.Selector = in.Selector
	if err := v1.Convert_Pointer_int32_To_int32(&in.Replicas, &out.Replicas, s); err != nil {
		return err
	}
	if err := v1.Convert_Pointer_int32_To_int32(&in.ReadyReplicas, &out.ReadyReplicas, s); err != nil {
		return err
	}
	if err := v1.Convert_Pointer_int32_To_int32(&in.AvailableReplicas, &out.AvailableReplicas, s); err != nil {
		return err
	}
	// WARNING: in.UpToDateReplicas requires manual conversion: does not exist in peer-type
	out.Phase = in.Phase
	// WARNING: in.Deprecated requires manual conversion: does not exist in peer-type
	return nil
}

func autoConvert_v1beta1_MachineDeploymentTopology_To_v1beta2_MachineDeploymentTopology(in *MachineDeploymentTopology, out *v1beta2.MachineDeploymentTopology, s conversion.Scope) error {
	if err := Convert_v1beta1_ObjectMeta_To_v1beta2_ObjectMeta(&in.Metadata, &out.Metadata, s); err != nil {
		return err
	}
	out.Class = in.Class
	out.Name = in.Name
	if err := v1.Convert_Pointer_string_To_string(&in.FailureDomain, &out.FailureDomain, s); err != nil {
		return err
	}
	out.Replicas = (*int32)(unsafe.Pointer(in.Replicas))
	// WARNING: in.MachineHealthCheck requires manual conversion: does not exist in peer-type
	// WARNING: in.NodeDrainTimeout requires manual conversion: does not exist in peer-type
	// WARNING: in.NodeVolumeDetachTimeout requires manual conversion: does not exist in peer-type
	// WARNING: in.NodeDeletionTimeout requires manual conversion: does not exist in peer-type
	out.MinReadySeconds = (*int32)(unsafe.Pointer(in.MinReadySeconds))
	out.ReadinessGates = *(*[]v1beta2.MachineReadinessGate)(unsafe.Pointer(&in.ReadinessGates))
	// WARNING: in.Strategy requires manual conversion: does not exist in peer-type
	// WARNING: in.Variables requires manual conversion: inconvertible types (*sigs.k8s.io/cluster-api/api/core/v1beta1.MachineDeploymentVariables vs sigs.k8s.io/cluster-api/api/core/v1beta2.MachineDeploymentVariables)
	return nil
}

func autoConvert_v1beta2_MachineDeploymentTopology_To_v1beta1_MachineDeploymentTopology(in *v1beta2.MachineDeploymentTopology, out *MachineDeploymentTopology, s conversion.Scope) error {
	if err := Convert_v1beta2_ObjectMeta_To_v1beta1_ObjectMeta(&in.Metadata, &out.Metadata, s); err != nil {
		return err
	}
	out.Class = in.Class
	out.Name = in.Name
	if err := v1.Convert_string_To_Pointer_string(&in.FailureDomain, &out.FailureDomain, s); err != nil {
		return err
	}
	out.Replicas = (*int32)(unsafe.Pointer(in.Replicas))
	// WARNING: in.HealthCheck requires manual conversion: does not exist in peer-type
	// WARNING: in.Deletion requires manual conversion: does not exist in peer-type
	// WARNING: in.Taints requires manual conversion: does not exist in peer-type
	out.MinReadySeconds = (*int32)(unsafe.Pointer(in.MinReadySeconds))
	out.ReadinessGates = *(*[]MachineReadinessGate)(unsafe.Pointer(&in.ReadinessGates))
	// WARNING: in.Rollout requires manual conversion: does not exist in peer-type
	// WARNING: in.Variables requires manual conversion: inconvertible types (sigs.k8s.io/cluster-api/api/core/v1beta2.MachineDeploymentVariables vs *sigs.k8s.io/cluster-api/api/core/v1beta1.MachineDeploymentVariables)
	return nil
}

func autoConvert_v1beta1_MachineDeploymentVariables_To_v1beta2_MachineDeploymentVariables(in *MachineDeploymentVariables, out *v1beta2.MachineDeploymentVariables, s conversion.Scope) error {
	if in.Overrides != nil {
		in, out := &in.Overrides, &out.Overrides
		*out = make([]v1beta2.ClusterVariable, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_ClusterVariable_To_v1beta2_ClusterVariable(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Overrides = nil
	}
	return nil
}

// Convert_v1beta1_MachineDeploymentVariables_To_v1beta2_MachineDeploymentVariables is an autogenerated conversion function.
func Convert_v1beta1_MachineDeploymentVariables_To_v1beta2_MachineDeploymentVariables(in *MachineDeploymentVariables, out *v1beta2.MachineDeploymentVariables, s conversion.Scope) error {
	return autoConvert_v1beta1_MachineDeploymentVariables_To_v1beta2_MachineDeploymentVariables(in, out, s)
}

func autoConvert_v1beta2_MachineDeploymentVariables_To_v1beta1_MachineDeploymentVariables(in *v1beta2.MachineDeploymentVariables, out *MachineDeploymentVariables, s conversion.Scope) error {
	if in.Overrides != nil {
		in, out := &in.Overrides, &out.Overrides
		*out = make([]ClusterVariable, len(*in))
		for i := range *in {
			if err := Convert_v1beta2_ClusterVariable_To_v1beta1_ClusterVariable(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Overrides = nil
	}
	return nil
}

// Convert_v1beta2_MachineDeploymentVariables_To_v1beta1_MachineDeploymentVariables is an autogenerated conversion function.
func Convert_v1beta2_MachineDeploymentVariables_To_v1beta1_MachineDeploymentVariables(in *v1beta2.MachineDeploymentVariables, out *MachineDeploymentVariables, s conversion.Scope) error {
	return autoConvert_v1beta2_MachineDeploymentVariables_To_v1beta1_MachineDeploymentVariables(in, out, s)
}

func autoConvert_v1beta1_MachineDrainRule_To_v1beta2_MachineDrainRule(in *MachineDrainRule, out *v1beta2.MachineDrainRule, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1beta1_MachineDrainRuleSpec_To_v1beta2_MachineDrainRuleSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1beta1_MachineDrainRule_To_v1beta2_MachineDrainRule is an autogenerated conversion function.
func Convert_v1beta1_MachineDrainRule_To_v1beta2_MachineDrainRule(in *MachineDrainRule, out *v1beta2.MachineDrainRule, s conversion.Scope) error {
	return autoConvert_v1beta1_MachineDrainRule_To_v1beta2_MachineDrainRule(in, out, s)
}

func autoConvert_v1beta2_MachineDrainRule_To_v1beta1_MachineDrainRule(in *v1beta2.MachineDrainRule, out *MachineDrainRule, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1beta2_MachineDrainRuleSpec_To_v1beta1_MachineDrainRuleSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1beta2_MachineDrainRule_To_v1beta1_MachineDrainRule is an autogenerated conversion function.
func Convert_v1beta2_MachineDrainRule_To_v1beta1_MachineDrainRule(in *v1beta2.MachineDrainRule, out *MachineDrainRule, s conversion.Scope) error {
	return autoConvert_v1beta2_MachineDrainRule_To_v1beta1_MachineDrainRule(in, out, s)
}

func autoConvert_v1beta1_MachineDrainRuleDrainConfig_To_v1beta2_MachineDrainRuleDrainConfig(in *MachineDrainRuleDrainConfig, out *v1beta2.MachineDrainRuleDrainConfig, s conversion.Scope) error {
	out.Behavior = v1beta2.MachineDrainRuleDrainBehavior(in.Behavior)
	out.Order = (*int32)(unsafe.Pointer(in.Order))
	return nil
}

// Convert_v1beta1_MachineDrainRuleDrainConfig_To_v1beta2_MachineDrainRuleDrainConfig is an autogenerated conversion function.
func Convert_v1beta1_MachineDrainRuleDrainConfig_To_v1beta2_MachineDrainRuleDrainConfig(in *MachineDrainRuleDrainConfig, out *v1beta2.MachineDrainRuleDrainConfig, s conversion.Scope) error {
	return autoConvert_v1beta1_MachineDrainRuleDrainConfig_To_v1beta2_MachineDrainRuleDrainConfig(in, out, s)
}

func autoConvert_v1beta2_MachineDrainRuleDrainConfig_To_v1beta1_MachineDrainRuleDrainConfig(in *v1beta2.MachineDrainRuleDrainConfig, out *MachineDrainRuleDrainConfig, s conversion.Scope) error {
	out.Behavior = MachineDrainRuleDrainBehavior(in.Behavior)
	out.Order = (*int32)(unsafe.Pointer(in.Order))
	return nil
}

// Convert_v1beta2_MachineDrainRuleDrainConfig_To_v1beta1_MachineDrainRuleDrainConfig is an autogenerated conversion function.
func Convert_v1beta2_MachineDrainRuleDrainConfig_To_v1beta1_MachineDrainRuleDrainConfig(in *v1beta2.MachineDrainRuleDrainConfig, out *MachineDrainRuleDrainConfig, s conversion.Scope) error {
	return autoConvert_v1beta2_MachineDrainRuleDrainConfig_To_v1beta1_MachineDrainRuleDrainConfig(in, out, s)
}

func autoConvert_v1beta1_MachineDrainRuleList_To_v1beta2_MachineDrainRuleList(in *MachineDrainRuleList, out *v1beta2.MachineDrainRuleList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	out.Items = *(*[]v1beta2.MachineDrainRule)(unsafe.Pointer(&in.Items))
	return nil
}

// Convert_v1beta1_MachineDrainRuleList_To_v1beta2_MachineDrainRuleList is an autogenerated conversion function.
func Convert_v1beta1_MachineDrainRuleList_To_v1beta2_MachineDrainRuleList(in *MachineDrainRuleList, out *v1beta2.MachineDrainRuleList, s conversion.Scope) error {
	return autoConvert_v1beta1_MachineDrainRuleList_To_v1beta2_MachineDrainRuleList(in, out, s)
}

func autoConvert_v1beta2_MachineDrainRuleList_To_v1beta1_MachineDrainRuleList(in *v1beta2.MachineDrainRuleList, out *MachineDrainRuleList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	out.Items = *(*[]MachineDrainRule)(unsafe.Pointer(&in.Items))
	return nil
}

// Convert_v1beta2_MachineDrainRuleList_To_v1beta1_MachineDrainRuleList is an autogenerated conversion function.
func Convert_v1beta2_MachineDrainRuleList_To_v1beta1_MachineDrainRuleList(in *v1beta2.MachineDrainRuleList, out *MachineDrainRuleList, s conversion.Scope) error {
	return autoConvert_v1beta2_MachineDrainRuleList_To_v1beta1_MachineDrainRuleList(in, out, s)
}

func autoConvert_v1beta1_MachineDrainRuleMachineSelector_To_v1beta2_MachineDrainRuleMachineSelector(in *MachineDrainRuleMachineSelector, out *v1beta2.MachineDrainRuleMachineSelector, s conversion.Scope) error {
	out.Selector = (*v1.LabelSelector)(unsafe.Pointer(in.Selector))
	out.ClusterSelector = (*v1.LabelSelector)(unsafe.Pointer(in.ClusterSelector))
	return nil
}

// Convert_v1beta1_MachineDrainRuleMachineSelector_To_v1beta2_MachineDrainRuleMachineSelector is an autogenerated conversion function.
func Convert_v1beta1_MachineDrainRuleMachineSelector_To_v1beta2_MachineDrainRuleMachineSelector(in *MachineDrainRuleMachineSelector, out *v1beta2.MachineDrainRuleMachineSelector, s conversion.Scope) error {
	return autoConvert_v1beta1_MachineDrainRuleMachineSelector_To_v1beta2_MachineDrainRuleMachineSelector(in, out, s)
}

func autoConvert_v1beta2_MachineDrainRuleMachineSelector_To_v1beta1_MachineDrainRuleMachineSelector(in *v1beta2.MachineDrainRuleMachineSelector, out *MachineDrainRuleMachineSelector, s conversion.Scope) error {
	out.Selector = (*v1.LabelSelector)(unsafe.Pointer(in.Selector))
	out.ClusterSelector = (*v1.LabelSelector)(unsafe.Pointer(in.ClusterSelector))
	return nil
}

// Convert_v1beta2_MachineDrainRuleMachineSelector_To_v1beta1_MachineDrainRuleMachineSelector is an autogenerated conversion function.
func Convert_v1beta2_MachineDrainRuleMachineSelector_To_v1beta1_MachineDrainRuleMachineSelector(in *v1beta2.MachineDrainRuleMachineSelector, out *MachineDrainRuleMachineSelector, s conversion.Scope) error {
	return autoConvert_v1beta2_MachineDrainRuleMachineSelector_To_v1beta1_MachineDrainRuleMachineSelector(in, out, s)
}

func autoConvert_v1beta1_MachineDrainRulePodSelector_To_v1beta2_MachineDrainRulePodSelector(in *MachineDrainRulePodSelector, out *v1beta2.MachineDrainRulePodSelector, s conversion.Scope) error {
	out.Selector = (*v1.LabelSelector)(unsafe.Pointer(in.Selector))
	out.NamespaceSelector = (*v1.LabelSelector)(unsafe.Pointer(in.NamespaceSelector))
	return nil
}

// Convert_v1beta1_MachineDrainRulePodSelector_To_v1beta2_MachineDrainRulePodSelector is an autogenerated conversion function.
func Convert_v1beta1_MachineDrainRulePodSelector_To_v1beta2_MachineDrainRulePodSelector(in *MachineDrainRulePodSelector, out *v1beta2.MachineDrainRulePodSelector, s conversion.Scope) error {
	return autoConvert_v1beta1_MachineDrainRulePodSelector_To_v1beta2_MachineDrainRulePodSelector(in, out, s)
}

func autoConvert_v1beta2_MachineDrainRulePodSelector_To_v1beta1_MachineDrainRulePodSelector(in *v1beta2.MachineDrainRulePodSelector, out *MachineDrainRulePodSelector, s conversion.Scope) error {
	out.Selector = (*v1.LabelSelector)(unsafe.Pointer(in.Selector))
	out.NamespaceSelector = (*v1.LabelSelector)(unsafe.Pointer(in.NamespaceSelector))
	return nil
}

// Convert_v1beta2_MachineDrainRulePodSelector_To_v1beta1_MachineDrainRulePodSelector is an autogenerated conversion function.
func Convert_v1beta2_MachineDrainRulePodSelector_To_v1beta1_MachineDrainRulePodSelector(in *v1beta2.MachineDrainRulePodSelector, out *MachineDrainRulePodSelector, s conversion.Scope) error {
	return autoConvert_v1beta2_MachineDrainRulePodSelector_To_v1beta1_MachineDrainRulePodSelector(in, out, s)
}

func autoConvert_v1beta1_MachineDrainRuleSpec_To_v1beta2_MachineDrainRuleSpec(in *MachineDrainRuleSpec, out *v1beta2.MachineDrainRuleSpec, s conversion.Scope) error {
	if err := Convert_v1beta1_MachineDrainRuleDrainConfig_To_v1beta2_MachineDrainRuleDrainConfig(&in.Drain, &out.Drain, s); err != nil {
		return err
	}
	out.Machines = *(*[]v1beta2.MachineDrainRuleMachineSelector)(unsafe.Pointer(&in.Machines))
	out.Pods = *(*[]v1beta2.MachineDrainRulePodSelector)(unsafe.Pointer(&in.Pods))
	return nil
}

// Convert_v1beta1_MachineDrainRuleSpec_To_v1beta2_MachineDrainRuleSpec is an autogenerated conversion function.
func Convert_v1beta1_MachineDrainRuleSpec_To_v1beta2_MachineDrainRuleSpec(in *MachineDrainRuleSpec, out *v1beta2.MachineDrainRuleSpec, s conversion.Scope) error {
	return autoConvert_v1beta1_MachineDrainRuleSpec_To_v1beta2_MachineDrainRuleSpec(in, out, s)
}

func autoConvert_v1beta2_MachineDrainRuleSpec_To_v1beta1_MachineDrainRuleSpec(in *v1beta2.MachineDrainRuleSpec, out *MachineDrainRuleSpec, s conversion.Scope) error {
	if err := Convert_v1beta2_MachineDrainRuleDrainConfig_To_v1beta1_MachineDrainRuleDrainConfig(&in.Drain, &out.Drain, s); err != nil {
		return err
	}
	out.Machines = *(*[]MachineDrainRuleMachineSelector)(unsafe.Pointer(&in.Machines))
	out.Pods = *(*[]MachineDrainRulePodSelector)(unsafe.Pointer(&in.Pods))
	return nil
}

// Convert_v1beta2_MachineDrainRuleSpec_To_v1beta1_MachineDrainRuleSpec is an autogenerated conversion function.
func Convert_v1beta2_MachineDrainRuleSpec_To_v1beta1_MachineDrainRuleSpec(in *v1beta2.MachineDrainRuleSpec, out *MachineDrainRuleSpec, s conversion.Scope) error {
	return autoConvert_v1beta2_MachineDrainRuleSpec_To_v1beta1_MachineDrainRuleSpec(in, out, s)
}

func autoConvert_v1beta1_MachineHealthCheck_To_v1beta2_MachineHealthCheck(in *MachineHealthCheck, out *v1beta2.MachineHealthCheck, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1beta1_MachineHealthCheckSpec_To_v1beta2_MachineHealthCheckSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_v1beta1_MachineHealthCheckStatus_To_v1beta2_MachineHealthCheckStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1beta1_MachineHealthCheck_To_v1beta2_MachineHealthCheck is an autogenerated conversion function.
func Convert_v1beta1_MachineHealthCheck_To_v1beta2_MachineHealthCheck(in *MachineHealthCheck, out *v1beta2.MachineHealthCheck, s conversion.Scope) error {
	return autoConvert_v1beta1_MachineHealthCheck_To_v1beta2_MachineHealthCheck(in, out, s)
}

func autoConvert_v1beta2_MachineHealthCheck_To_v1beta1_MachineHealthCheck(in *v1beta2.MachineHealthCheck, out *MachineHealthCheck, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1beta2_MachineHealthCheckSpec_To_v1beta1_MachineHealthCheckSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_v1beta2_MachineHealthCheckStatus_To_v1beta1_MachineHealthCheckStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1beta2_MachineHealthCheck_To_v1beta1_MachineHealthCheck is an autogenerated conversion function.
func Convert_v1beta2_MachineHealthCheck_To_v1beta1_MachineHealthCheck(in *v1beta2.MachineHealthCheck, out *MachineHealthCheck, s conversion.Scope) error {
	return autoConvert_v1beta2_MachineHealthCheck_To_v1beta1_MachineHealthCheck(in, out, s)
}

func autoConvert_v1beta1_MachineHealthCheckList_To_v1beta2_MachineHealthCheckList(in *MachineHealthCheckList, out *v1beta2.MachineHealthCheckList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	if in.Items != nil {
		in, out := &in.Items, &out.Items
		*out = make([]v1beta2.MachineHealthCheck, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_MachineHealthCheck_To_v1beta2_MachineHealthCheck(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Items = nil
	}
	return nil
}

// Convert_v1beta1_MachineHealthCheckList_To_v1beta2_MachineHealthCheckList is an autogenerated conversion function.
func Convert_v1beta1_MachineHealthCheckList_To_v1beta2_MachineHealthCheckList(in *MachineHealthCheckList, out *v1beta2.MachineHealthCheckList, s conversion.Scope) error {
	return autoConvert_v1beta1_MachineHealthCheckList_To_v1beta2_MachineHealthCheckList(in, out, s)
}

func autoConvert_v1beta2_MachineHealthCheckList_To_v1beta1_MachineHealthCheckList(in *v1beta2.MachineHealthCheckList, out *MachineHealthCheckList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	if in.Items != nil {
		in, out := &in.Items, &out.Items
		*out = make([]MachineHealthCheck, len(*in))
		for i := range *in {
			if err := Convert_v1beta2_MachineHealthCheck_To_v1beta1_MachineHealthCheck(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Items = nil
	}
	return nil
}

// Convert_v1beta2_MachineHealthCheckList_To_v1beta1_MachineHealthCheckList is an autogenerated conversion function.
func Convert_v1beta2_MachineHealthCheckList_To_v1beta1_MachineHealthCheckList(in *v1beta2.MachineHealthCheckList, out *MachineHealthCheckList, s conversion.Scope) error {
	return autoConvert_v1beta2_MachineHealthCheckList_To_v1beta1_MachineHealthCheckList(in, out, s)
}

func autoConvert_v1beta1_MachineHealthCheckSpec_To_v1beta2_MachineHealthCheckSpec(in *MachineHealthCheckSpec, out *v1beta2.MachineHealthCheckSpec, s conversion.Scope) error {
	out.ClusterName = in.ClusterName
	out.Selector = in.Selector
	// WARNING: in.UnhealthyConditions requires manual conversion: does not exist in peer-type
	// WARNING: in.MaxUnhealthy requires manual conversion: does not exist in peer-type
	// WARNING: in.UnhealthyRange requires manual conversion: does not exist in peer-type
	// WARNING: in.NodeStartupTimeout requires manual conversion: does not exist in peer-type
	// WARNING: in.RemediationTemplate requires manual conversion: does not exist in peer-type
	return nil
}

func autoConvert_v1beta2_MachineHealthCheckSpec_To_v1beta1_MachineHealthCheckSpec(in *v1beta2.MachineHealthCheckSpec, out *MachineHealthCheckSpec, s conversion.Scope) error {
	out.ClusterName = in.ClusterName
	out.Selector = in.Selector
	// WARNING: in.Checks requires manual conversion: does not exist in peer-type
	// WARNING: in.Remediation requires manual conversion: does not exist in peer-type
	return nil
}

func autoConvert_v1beta1_MachineHealthCheckStatus_To_v1beta2_MachineHealthCheckStatus(in *MachineHealthCheckStatus, out *v1beta2.MachineHealthCheckStatus, s conversion.Scope) error {
	if err := v1.Convert_int32_To_Pointer_int32(&in.ExpectedMachines, &out.ExpectedMachines, s); err != nil {
		return err
	}
	if err := v1.Convert_int32_To_Pointer_int32(&in.CurrentHealthy, &out.CurrentHealthy, s); err != nil {
		return err
	}
	if err := v1.Convert_int32_To_Pointer_int32(&in.RemediationsAllowed, &out.RemediationsAllowed, s); err != nil {
		return err
	}
	out.ObservedGeneration = in.ObservedGeneration
	out.Targets = *(*[]string)(unsafe.Pointer(&in.Targets))
	if in.Conditions != nil {
		in, out := &in.Conditions, &out.Conditions
		*out = make([]v1.Condition, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_Condition_To_v1_Condition(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Conditions = nil
	}
	// WARNING: in.V1Beta2 requires manual conversion: does not exist in peer-type
	return nil
}

func autoConvert_v1beta2_MachineHealthCheckStatus_To_v1beta1_MachineHealthCheckStatus(in *v1beta2.MachineHealthCheckStatus, out *MachineHealthCheckStatus, s conversion.Scope) error {
	if in.Conditions != nil {
		in, out := &in.Conditions, &out.Conditions
		*out = make(Conditions, len(*in))
		for i := range *in {
			if err := Convert_v1_Condition_To_v1beta1_Condition(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Conditions = nil
	}
	if err := v1.Convert_Pointer_int32_To_int32(&in.ExpectedMachines, &out.ExpectedMachines, s); err != nil {
		return err
	}
	if err := v1.Convert_Pointer_int32_To_int32(&in.CurrentHealthy, &out.CurrentHealthy, s); err != nil {
		return err
	}
	if err := v1.Convert_Pointer_int32_To_int32(&in.RemediationsAllowed, &out.RemediationsAllowed, s); err != nil {
		return err
	}
	out.ObservedGeneration = in.ObservedGeneration
	out.Targets = *(*[]string)(unsafe.Pointer(&in.Targets))
	// WARNING: in.Deprecated requires manual conversion: does not exist in peer-type
	return nil
}

func autoConvert_v1beta1_MachineList_To_v1beta2_MachineList(in *MachineList, out *v1beta2.MachineList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	if in.Items != nil {
		in, out := &in.Items, &out.Items
		*out = make([]v1beta2.Machine, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_Machine_To_v1beta2_Machine(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Items = nil
	}
	return nil
}

// Convert_v1beta1_MachineList_To_v1beta2_MachineList is an autogenerated conversion function.
func Convert_v1beta1_MachineList_To_v1beta2_MachineList(in *MachineList, out *v1beta2.MachineList, s conversion.Scope) error {
	return autoConvert_v1beta1_MachineList_To_v1beta2_MachineList(in, out, s)
}

func autoConvert_v1beta2_MachineList_To_v1beta1_MachineList(in *v1beta2.MachineList, out *MachineList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	if in.Items != nil {
		in, out := &in.Items, &out.Items
		*out = make([]Machine, len(*in))
		for i := range *in {
			if err := Convert_v1beta2_Machine_To_v1beta1_Machine(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Items = nil
	}
	return nil
}

// Convert_v1beta2_MachineList_To_v1beta1_MachineList is an autogenerated conversion function.
func Convert_v1beta2_MachineList_To_v1beta1_MachineList(in *v1beta2.MachineList, out *MachineList, s conversion.Scope) error {
	return autoConvert_v1beta2_MachineList_To_v1beta1_MachineList(in, out, s)
}

func autoConvert_v1beta1_MachinePool_To_v1beta2_MachinePool(in *MachinePool, out *v1beta2.MachinePool, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1beta1_MachinePoolSpec_To_v1beta2_MachinePoolSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_v1beta1_MachinePoolStatus_To_v1beta2_MachinePoolStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1beta1_MachinePool_To_v1beta2_MachinePool is an autogenerated conversion function.
func Convert_v1beta1_MachinePool_To_v1beta2_MachinePool(in *MachinePool, out *v1beta2.MachinePool, s conversion.Scope) error {
	return autoConvert_v1beta1_MachinePool_To_v1beta2_MachinePool(in, out, s)
}

func autoConvert_v1beta2_MachinePool_To_v1beta1_MachinePool(in *v1beta2.MachinePool, out *MachinePool, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1beta2_MachinePoolSpec_To_v1beta1_MachinePoolSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_v1beta2_MachinePoolStatus_To_v1beta1_MachinePoolStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1beta2_MachinePool_To_v1beta1_MachinePool is an autogenerated conversion function.
func Convert_v1beta2_MachinePool_To_v1beta1_MachinePool(in *v1beta2.MachinePool, out *MachinePool, s conversion.Scope) error {
	return autoConvert_v1beta2_MachinePool_To_v1beta1_MachinePool(in, out, s)
}

func autoConvert_v1beta1_MachinePoolClass_To_v1beta2_MachinePoolClass(in *MachinePoolClass, out *v1beta2.MachinePoolClass, s conversion.Scope) error {
	out.Class = in.Class
	// WARNING: in.Template requires manual conversion: does not exist in peer-type
	out.FailureDomains = *(*[]string)(unsafe.Pointer(&in.FailureDomains))
	// WARNING: in.NamingStrategy requires manual conversion: does not exist in peer-type
	// WARNING: in.NodeDrainTimeout requires manual conversion: does not exist in peer-type
	// WARNING: in.NodeVolumeDetachTimeout requires manual conversion: does not exist in peer-type
	// WARNING: in.NodeDeletionTimeout requires manual conversion: does not exist in peer-type
	out.MinReadySeconds = (*int32)(unsafe.Pointer(in.MinReadySeconds))
	return nil
}

func autoConvert_v1beta2_MachinePoolClass_To_v1beta1_MachinePoolClass(in *v1beta2.MachinePoolClass, out *MachinePoolClass, s conversion.Scope) error {
	// WARNING: in.Metadata requires manual conversion: does not exist in peer-type
	out.Class = in.Class
	// WARNING: in.Bootstrap requires manual conversion: does not exist in peer-type
	// WARNING: in.Infrastructure requires manual conversion: does not exist in peer-type
	out.FailureDomains = *(*[]string)(unsafe.Pointer(&in.FailureDomains))
	// WARNING: in.Naming requires manual conversion: does not exist in peer-type
	// WARNING: in.Deletion requires manual conversion: does not exist in peer-type
	// WARNING: in.Taints requires manual conversion: does not exist in peer-type
	out.MinReadySeconds = (*int32)(unsafe.Pointer(in.MinReadySeconds))
	return nil
}

func autoConvert_v1beta1_MachinePoolList_To_v1beta2_MachinePoolList(in *MachinePoolList, out *v1beta2.MachinePoolList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	if in.Items != nil {
		in, out := &in.Items, &out.Items
		*out = make([]v1beta2.MachinePool, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_MachinePool_To_v1beta2_MachinePool(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Items = nil
	}
	return nil
}

// Convert_v1beta1_MachinePoolList_To_v1beta2_MachinePoolList is an autogenerated conversion function.
func Convert_v1beta1_MachinePoolList_To_v1beta2_MachinePoolList(in *MachinePoolList, out *v1beta2.MachinePoolList, s conversion.Scope) error {
	return autoConvert_v1beta1_MachinePoolList_To_v1beta2_MachinePoolList(in, out, s)
}

func autoConvert_v1beta2_MachinePoolList_To_v1beta1_MachinePoolList(in *v1beta2.MachinePoolList, out *MachinePoolList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	if in.Items != nil {
		in, out := &in.Items, &out.Items
		*out = make([]MachinePool, len(*in))
		for i := range *in {
			if err := Convert_v1beta2_MachinePool_To_v1beta1_MachinePool(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Items = nil
	}
	return nil
}

// Convert_v1beta2_MachinePoolList_To_v1beta1_MachinePoolList is an autogenerated conversion function.
func Convert_v1beta2_MachinePoolList_To_v1beta1_MachinePoolList(in *v1beta2.MachinePoolList, out *MachinePoolList, s conversion.Scope) error {
	return autoConvert_v1beta2_MachinePoolList_To_v1beta1_MachinePoolList(in, out, s)
}

func autoConvert_v1beta1_MachinePoolSpec_To_v1beta2_MachinePoolSpec(in *MachinePoolSpec, out *v1beta2.MachinePoolSpec, s conversion.Scope) error {
	out.ClusterName = in.ClusterName
	out.Replicas = (*int32)(unsafe.Pointer(in.Replicas))
	if err := Convert_v1beta1_MachineTemplateSpec_To_v1beta2_MachineTemplateSpec(&in.Template, &out.Template, s); err != nil {
		return err
	}
	// WARNING: in.MinReadySeconds requires manual conversion: does not exist in peer-type
	out.ProviderIDList = *(*[]string)(unsafe.Pointer(&in.ProviderIDList))
	out.FailureDomains = *(*[]string)(unsafe.Pointer(&in.FailureDomains))
	return nil
}

func autoConvert_v1beta2_MachinePoolSpec_To_v1beta1_MachinePoolSpec(in *v1beta2.MachinePoolSpec, out *MachinePoolSpec, s conversion.Scope) error {
	out.ClusterName = in.ClusterName
	out.Replicas = (*int32)(unsafe.Pointer(in.Replicas))
	if err := Convert_v1beta2_MachineTemplateSpec_To_v1beta1_MachineTemplateSpec(&in.Template, &out.Template, s); err != nil {
		return err
	}
	out.ProviderIDList = *(*[]string)(unsafe.Pointer(&in.ProviderIDList))
	out.FailureDomains = *(*[]string)(unsafe.Pointer(&in.FailureDomains))
	return nil
}

// Convert_v1beta2_MachinePoolSpec_To_v1beta1_MachinePoolSpec is an autogenerated conversion function.
func Convert_v1beta2_MachinePoolSpec_To_v1beta1_MachinePoolSpec(in *v1beta2.MachinePoolSpec, out *MachinePoolSpec, s conversion.Scope) error {
	return autoConvert_v1beta2_MachinePoolSpec_To_v1beta1_MachinePoolSpec(in, out, s)
}

func autoConvert_v1beta1_MachinePoolStatus_To_v1beta2_MachinePoolStatus(in *MachinePoolStatus, out *v1beta2.MachinePoolStatus, s conversion.Scope) error {
	out.NodeRefs = *(*[]corev1.ObjectReference)(unsafe.Pointer(&in.NodeRefs))
	if err := v1.Convert_int32_To_Pointer_int32(&in.Replicas, &out.Replicas, s); err != nil {
		return err
	}
	if err := v1.Convert_int32_To_Pointer_int32(&in.ReadyReplicas, &out.ReadyReplicas, s); err != nil {
		return err
	}
	if err := v1.Convert_int32_To_Pointer_int32(&in.AvailableReplicas, &out.AvailableReplicas, s); err != nil {
		return err
	}
	// WARNING: in.UnavailableReplicas requires manual conversion: does not exist in peer-type
	// WARNING: in.FailureReason requires manual conversion: does not exist in peer-type
	// WARNING: in.FailureMessage requires manual conversion: does not exist in peer-type
	out.Phase = in.Phase
	// WARNING: in.BootstrapReady requires manual conversion: does not exist in peer-type
	// WARNING: in.InfrastructureReady requires manual conversion: does not exist in peer-type
	out.ObservedGeneration = in.ObservedGeneration
	if in.Conditions != nil {
		in, out := &in.Conditions, &out.Conditions
		*out = make([]v1.Condition, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_Condition_To_v1_Condition(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Conditions = nil
	}
	// WARNING: in.V1Beta2 requires manual conversion: does not exist in peer-type
	return nil
}

func autoConvert_v1beta2_MachinePoolStatus_To_v1beta1_MachinePoolStatus(in *v1beta2.MachinePoolStatus, out *MachinePoolStatus, s conversion.Scope) error {
	if in.Conditions != nil {
		in, out := &in.Conditions, &out.Conditions
		*out = make(Conditions, len(*in))
		for i := range *in {
			if err := Convert_v1_Condition_To_v1beta1_Condition(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Conditions = nil
	}
	// WARNING: in.Initialization requires manual conversion: does not exist in peer-type
	out.NodeRefs = *(*[]corev1.ObjectReference)(unsafe.Pointer(&in.NodeRefs))
	if err := v1.Convert_Pointer_int32_To_int32(&in.Replicas, &out.Replicas, s); err != nil {
		return err
	}
	if err := v1.Convert_Pointer_int32_To_int32(&in.ReadyReplicas, &out.ReadyReplicas, s); err != nil {
		return err
	}
	if err := v1.Convert_Pointer_int32_To_int32(&in.AvailableReplicas, &out.AvailableReplicas, s); err != nil {
		return err
	}
	// WARNING: in.UpToDateReplicas requires manual conversion: does not exist in peer-type
	out.Phase = in.Phase
	out.ObservedGeneration = in.ObservedGeneration
	// WARNING: in.Deprecated requires manual conversion: does not exist in peer-type
	return nil
}

func autoConvert_v1beta1_MachinePoolTopology_To_v1beta2_MachinePoolTopology(in *MachinePoolTopology, out *v1beta2.MachinePoolTopology, s conversion.Scope) error {
	if err := Convert_v1beta1_ObjectMeta_To_v1beta2_ObjectMeta(&in.Metadata, &out.Metadata, s); err != nil {
		return err
	}
	out.Class = in.Class
	out.Name = in.Name
	out.FailureDomains = *(*[]string)(unsafe.Pointer(&in.FailureDomains))
	// WARNING: in.NodeDrainTimeout requires manual conversion: does not exist in peer-type
	// WARNING: in.NodeVolumeDetachTimeout requires manual conversion: does not exist in peer-type
	// WARNING: in.NodeDeletionTimeout requires manual conversion: does not exist in peer-type
	out.MinReadySeconds = (*int32)(unsafe.Pointer(in.MinReadySeconds))
	out.Replicas = (*int32)(unsafe.Pointer(in.Replicas))
	// WARNING: in.Variables requires manual conversion: inconvertible types (*sigs.k8s.io/cluster-api/api/core/v1beta1.MachinePoolVariables vs sigs.k8s.io/cluster-api/api/core/v1beta2.MachinePoolVariables)
	return nil
}

func autoConvert_v1beta2_MachinePoolTopology_To_v1beta1_MachinePoolTopology(in *v1beta2.MachinePoolTopology, out *MachinePoolTopology, s conversion.Scope) error {
	if err := Convert_v1beta2_ObjectMeta_To_v1beta1_ObjectMeta(&in.Metadata, &out.Metadata, s); err != nil {
		return err
	}
	out.Class = in.Class
	out.Name = in.Name
	out.FailureDomains = *(*[]string)(unsafe.Pointer(&in.FailureDomains))
	// WARNING: in.Deletion requires manual conversion: does not exist in peer-type
	// WARNING: in.Taints requires manual conversion: does not exist in peer-type
	out.MinReadySeconds = (*int32)(unsafe.Pointer(in.MinReadySeconds))
	out.Replicas = (*int32)(unsafe.Pointer(in.Replicas))
	// WARNING: in.Variables requires manual conversion: inconvertible types (sigs.k8s.io/cluster-api/api/core/v1beta2.MachinePoolVariables vs *sigs.k8s.io/cluster-api/api/core/v1beta1.MachinePoolVariables)
	return nil
}

func autoConvert_v1beta1_MachinePoolVariables_To_v1beta2_MachinePoolVariables(in *MachinePoolVariables, out *v1beta2.MachinePoolVariables, s conversion.Scope) error {
	if in.Overrides != nil {
		in, out := &in.Overrides, &out.Overrides
		*out = make([]v1beta2.ClusterVariable, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_ClusterVariable_To_v1beta2_ClusterVariable(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Overrides = nil
	}
	return nil
}

// Convert_v1beta1_MachinePoolVariables_To_v1beta2_MachinePoolVariables is an autogenerated conversion function.
func Convert_v1beta1_MachinePoolVariables_To_v1beta2_MachinePoolVariables(in *MachinePoolVariables, out *v1beta2.MachinePoolVariables, s conversion.Scope) error {
	return autoConvert_v1beta1_MachinePoolVariables_To_v1beta2_MachinePoolVariables(in, out, s)
}

func autoConvert_v1beta2_MachinePoolVariables_To_v1beta1_MachinePoolVariables(in *v1beta2.MachinePoolVariables, out *MachinePoolVariables, s conversion.Scope) error {
	if in.Overrides != nil {
		in, out := &in.Overrides, &out.Overrides
		*out = make([]ClusterVariable, len(*in))
		for i := range *in {
			if err := Convert_v1beta2_ClusterVariable_To_v1beta1_ClusterVariable(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Overrides = nil
	}
	return nil
}

// Convert_v1beta2_MachinePoolVariables_To_v1beta1_MachinePoolVariables is an autogenerated conversion function.
func Convert_v1beta2_MachinePoolVariables_To_v1beta1_MachinePoolVariables(in *v1beta2.MachinePoolVariables, out *MachinePoolVariables, s conversion.Scope) error {
	return autoConvert_v1beta2_MachinePoolVariables_To_v1beta1_MachinePoolVariables(in, out, s)
}

func autoConvert_v1beta1_MachineReadinessGate_To_v1beta2_MachineReadinessGate(in *MachineReadinessGate, out *v1beta2.MachineReadinessGate, s conversion.Scope) error {
	out.ConditionType = in.ConditionType
	out.Polarity = v1beta2.ConditionPolarity(in.Polarity)
	return nil
}

// Convert_v1beta1_MachineReadinessGate_To_v1beta2_MachineReadinessGate is an autogenerated conversion function.
func Convert_v1beta1_MachineReadinessGate_To_v1beta2_MachineReadinessGate(in *MachineReadinessGate, out *v1beta2.MachineReadinessGate, s conversion.Scope) error {
	return autoConvert_v1beta1_MachineReadinessGate_To_v1beta2_MachineReadinessGate(in, out, s)
}

func autoConvert_v1beta2_MachineReadinessGate_To_v1beta1_MachineReadinessGate(in *v1beta2.MachineReadinessGate, out *MachineReadinessGate, s conversion.Scope) error {
	out.ConditionType = in.ConditionType
	out.Polarity = ConditionPolarity(in.Polarity)
	return nil
}

// Convert_v1beta2_MachineReadinessGate_To_v1beta1_MachineReadinessGate is an autogenerated conversion function.
func Convert_v1beta2_MachineReadinessGate_To_v1beta1_MachineReadinessGate(in *v1beta2.MachineReadinessGate, out *MachineReadinessGate, s conversion.Scope) error {
	return autoConvert_v1beta2_MachineReadinessGate_To_v1beta1_MachineReadinessGate(in, out, s)
}

func autoConvert_v1beta1_MachineSet_To_v1beta2_MachineSet(in *MachineSet, out *v1beta2.MachineSet, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1beta1_MachineSetSpec_To_v1beta2_MachineSetSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_v1beta1_MachineSetStatus_To_v1beta2_MachineSetStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1beta1_MachineSet_To_v1beta2_MachineSet is an autogenerated conversion function.
func Convert_v1beta1_MachineSet_To_v1beta2_MachineSet(in *MachineSet, out *v1beta2.MachineSet, s conversion.Scope) error {
	return autoConvert_v1beta1_MachineSet_To_v1beta2_MachineSet(in, out, s)
}

func autoConvert_v1beta2_MachineSet_To_v1beta1_MachineSet(in *v1beta2.MachineSet, out *MachineSet, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1beta2_MachineSetSpec_To_v1beta1_MachineSetSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_v1beta2_MachineSetStatus_To_v1beta1_MachineSetStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1beta2_MachineSet_To_v1beta1_MachineSet is an autogenerated conversion function.
func Convert_v1beta2_MachineSet_To_v1beta1_MachineSet(in *v1beta2.MachineSet, out *MachineSet, s conversion.Scope) error {
	return autoConvert_v1beta2_MachineSet_To_v1beta1_MachineSet(in, out, s)
}

func autoConvert_v1beta1_MachineSetList_To_v1beta2_MachineSetList(in *MachineSetList, out *v1beta2.MachineSetList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	if in.Items != nil {
		in, out := &in.Items, &out.Items
		*out = make([]v1beta2.MachineSet, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_MachineSet_To_v1beta2_MachineSet(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Items = nil
	}
	return nil
}

// Convert_v1beta1_MachineSetList_To_v1beta2_MachineSetList is an autogenerated conversion function.
func Convert_v1beta1_MachineSetList_To_v1beta2_MachineSetList(in *MachineSetList, out *v1beta2.MachineSetList, s conversion.Scope) error {
	return autoConvert_v1beta1_MachineSetList_To_v1beta2_MachineSetList(in, out, s)
}

func autoConvert_v1beta2_MachineSetList_To_v1beta1_MachineSetList(in *v1beta2.MachineSetList, out *MachineSetList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	if in.Items != nil {
		in, out := &in.Items, &out.Items
		*out = make([]MachineSet, len(*in))
		for i := range *in {
			if err := Convert_v1beta2_MachineSet_To_v1beta1_MachineSet(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Items = nil
	}
	return nil
}

// Convert_v1beta2_MachineSetList_To_v1beta1_MachineSetList is an autogenerated conversion function.
func Convert_v1beta2_MachineSetList_To_v1beta1_MachineSetList(in *v1beta2.MachineSetList, out *MachineSetList, s conversion.Scope) error {
	return autoConvert_v1beta2_MachineSetList_To_v1beta1_MachineSetList(in, out, s)
}

func autoConvert_v1beta1_MachineSetSpec_To_v1beta2_MachineSetSpec(in *MachineSetSpec, out *v1beta2.MachineSetSpec, s conversion.Scope) error {
	out.ClusterName = in.ClusterName
	out.Replicas = (*int32)(unsafe.Pointer(in.Replicas))
	// WARNING: in.MinReadySeconds requires manual conversion: does not exist in peer-type
	// WARNING: in.DeletePolicy requires manual conversion: does not exist in peer-type
	out.Selector = in.Selector
	if err := Convert_v1beta1_MachineTemplateSpec_To_v1beta2_MachineTemplateSpec(&in.Template, &out.Template, s); err != nil {
		return err
	}
	// WARNING: in.MachineNamingStrategy requires manual conversion: does not exist in peer-type
	return nil
}

func autoConvert_v1beta2_MachineSetSpec_To_v1beta1_MachineSetSpec(in *v1beta2.MachineSetSpec, out *MachineSetSpec, s conversion.Scope) error {
	out.ClusterName = in.ClusterName
	out.Replicas = (*int32)(unsafe.Pointer(in.Replicas))
	out.Selector = in.Selector
	if err := Convert_v1beta2_MachineTemplateSpec_To_v1beta1_MachineTemplateSpec(&in.Template, &out.Template, s); err != nil {
		return err
	}
	// WARNING: in.MachineNaming requires manual conversion: does not exist in peer-type
	// WARNING: in.Deletion requires manual conversion: does not exist in peer-type
	return nil
}

func autoConvert_v1beta1_MachineSetStatus_To_v1beta2_MachineSetStatus(in *MachineSetStatus, out *v1beta2.MachineSetStatus, s conversion.Scope) error {
	out.Selector = in.Selector
	if err := v1.Convert_int32_To_Pointer_int32(&in.Replicas, &out.Replicas, s); err != nil {
		return err
	}
	// WARNING: in.FullyLabeledReplicas requires manual conversion: does not exist in peer-type
	if err := v1.Convert_int32_To_Pointer_int32(&in.ReadyReplicas, &out.ReadyReplicas, s); err != nil {
		return err
	}
	if err := v1.Convert_int32_To_Pointer_int32(&in.AvailableReplicas, &out.AvailableReplicas, s); err != nil {
		return err
	}
	out.ObservedGeneration = in.ObservedGeneration
	// WARNING: in.FailureReason requires manual conversion: does not exist in peer-type
	// WARNING: in.FailureMessage requires manual conversion: does not exist in peer-type
	if in.Conditions != nil {
		in, out := &in.Conditions, &out.Conditions
		*out = make([]v1.Condition, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_Condition_To_v1_Condition(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Conditions = nil
	}
	// WARNING: in.V1Beta2 requires manual conversion: does not exist in peer-type
	return nil
}

func autoConvert_v1beta2_MachineSetStatus_To_v1beta1_MachineSetStatus(in *v1beta2.MachineSetStatus, out *MachineSetStatus, s conversion.Scope) error {
	if in.Conditions != nil {
		in, out := &in.Conditions, &out.Conditions
		*out = make(Conditions, len(*in))
		for i := range *in {
			if err := Convert_v1_Condition_To_v1beta1_Condition(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Conditions = nil
	}
	out.Selector = in.Selector
	if err := v1.Convert_Pointer_int32_To_int32(&in.Replicas, &out.Replicas, s); err != nil {
		return err
	}
	if err := v1.Convert_Pointer_int32_To_int32(&in.ReadyReplicas, &out.ReadyReplicas, s); err != nil {
		return err
	}
	if err := v1.Convert_Pointer_int32_To_int32(&in.AvailableReplicas, &out.AvailableReplicas, s); err != nil {
		return err
	}
	// WARNING: in.UpToDateReplicas requires manual conversion: does not exist in peer-type
	out.ObservedGeneration = in.ObservedGeneration
	// WARNING: in.Deprecated requires manual conversion: does not exist in peer-type
	return nil
}

func autoConvert_v1beta1_MachineSpec_To_v1beta2_MachineSpec(in *MachineSpec, out *v1beta2.MachineSpec, s conversion.Scope) error {
	out.ClusterName = in.ClusterName
	if err := Convert_v1beta1_Bootstrap_To_v1beta2_Bootstrap(&in.Bootstrap, &out.Bootstrap, s); err != nil {
		return err
	}
	if err := Convert_v1_ObjectReference_To_v1beta2_ContractVersionedObjectReference(&in.InfrastructureRef, &out.InfrastructureRef, s); err != nil {
		return err
	}
	if err := v1.Convert_Pointer_string_To_string(&in.Version, &out.Version, s); err != nil {
		return err
	}
	if err := v1.Convert_Pointer_string_To_string(&in.ProviderID, &out.ProviderID, s); err != nil {
		return err
	}
	if err := v1.Convert_Pointer_string_To_string(&in.FailureDomain, &out.FailureDomain, s); err != nil {
		return err
	}
	out.ReadinessGates = *(*[]v1beta2.MachineReadinessGate)(unsafe.Pointer(&in.ReadinessGates))
	// WARNING: in.NodeDrainTimeout requires manual conversion: does not exist in peer-type
	// WARNING: in.NodeVolumeDetachTimeout requires manual conversion: does not exist in peer-type
	// WARNING: in.NodeDeletionTimeout requires manual conversion: does not exist in peer-type
	return nil
}

func autoConvert_v1beta2_MachineSpec_To_v1beta1_MachineSpec(in *v1beta2.MachineSpec, out *MachineSpec, s conversion.Scope) error {
	out.ClusterName = in.ClusterName
	if err := Convert_v1beta2_Bootstrap_To_v1beta1_Bootstrap(&in.Bootstrap, &out.Bootstrap, s); err != nil {
		return err
	}
	if err := Convert_v1beta2_ContractVersionedObjectReference_To_v1_ObjectReference(&in.InfrastructureRef, &out.InfrastructureRef, s); err != nil {
		return err
	}
	if err := v1.Convert_string_To_Pointer_string(&in.Version, &out.Version, s); err != nil {
		return err
	}
	if err := v1.Convert_string_To_Pointer_string(&in.ProviderID, &out.ProviderID, s); err != nil {
		return err
	}
	if err := v1.Convert_string_To_Pointer_string(&in.FailureDomain, &out.FailureDomain, s); err != nil {
		return err
	}
	// WARNING: in.MinReadySeconds requires manual conversion: does not exist in peer-type
	out.ReadinessGates = *(*[]MachineReadinessGate)(unsafe.Pointer(&in.ReadinessGates))
	// WARNING: in.Deletion requires manual conversion: does not exist in peer-type
	// WARNING: in.Taints requires manual conversion: does not exist in peer-type
	return nil
}

func autoConvert_v1beta1_MachineStatus_To_v1beta2_MachineStatus(in *MachineStatus, out *v1beta2.MachineStatus, s conversion.Scope) error {
	// WARNING: in.NodeRef requires manual conversion: inconvertible types (*k8s.io/api/core/v1.ObjectReference vs sigs.k8s.io/cluster-api/api/core/v1beta2.MachineNodeReference)
	out.NodeInfo = (*corev1.NodeSystemInfo)(unsafe.Pointer(in.NodeInfo))
	// WARNING: in.LastUpdated requires manual conversion: inconvertible types (*k8s.io/apimachinery/pkg/apis/meta/v1.Time vs k8s.io/apimachinery/pkg/apis/meta/v1.Time)
	// WARNING: in.FailureReason requires manual conversion: does not exist in peer-type
	// WARNING: in.FailureMessage requires manual conversion: does not exist in peer-type
	out.Addresses = *(*v1beta2.MachineAddresses)(unsafe.Pointer(&in.Addresses))
	out.Phase = in.Phase
	// WARNING: in.CertificatesExpiryDate requires manual conversion: inconvertible types (*k8s.io/apimachinery/pkg/apis/meta/v1.Time vs k8s.io/apimachinery/pkg/apis/meta/v1.Time)
	// WARNING: in.BootstrapReady requires manual conversion: does not exist in peer-type
	// WARNING: in.InfrastructureReady requires manual conversion: does not exist in peer-type
	out.ObservedGeneration = in.ObservedGeneration
	if in.Conditions != nil {
		in, out := &in.Conditions, &out.Conditions
		*out = make([]v1.Condition, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_Condition_To_v1_Condition(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Conditions = nil
	}
	if in.Deletion != nil {
		in, out := &in.Deletion, &out.Deletion
		*out = new(v1beta2.MachineDeletionStatus)
		if err := Convert_v1beta1_MachineDeletionStatus_To_v1beta2_MachineDeletionStatus(*in, *out, s); err != nil {
			return err
		}
	} else {
		out.Deletion = nil
	}
	// WARNING: in.V1Beta2 requires manual conversion: does not exist in peer-type
	return nil
}

func autoConvert_v1beta2_MachineStatus_To_v1beta1_MachineStatus(in *v1beta2.MachineStatus, out *MachineStatus, s conversion.Scope) error {
	if in.Conditions != nil {
		in, out := &in.Conditions, &out.Conditions
		*out = make(Conditions, len(*in))
		for i := range *in {
			if err := Convert_v1_Condition_To_v1beta1_Condition(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Conditions = nil
	}
	// WARNING: in.Initialization requires manual conversion: does not exist in peer-type
	// WARNING: in.NodeRef requires manual conversion: inconvertible types (sigs.k8s.io/cluster-api/api/core/v1beta2.MachineNodeReference vs *k8s.io/api/core/v1.ObjectReference)
	out.NodeInfo = (*corev1.NodeSystemInfo)(unsafe.Pointer(in.NodeInfo))
	// WARNING: in.LastUpdated requires manual conversion: inconvertible types (k8s.io/apimachinery/pkg/apis/meta/v1.Time vs *k8s.io/apimachinery/pkg/apis/meta/v1.Time)
	out.Addresses = *(*MachineAddresses)(unsafe.Pointer(&in.Addresses))
	out.Phase = in.Phase
	// WARNING: in.CertificatesExpiryDate requires manual conversion: inconvertible types (k8s.io/apimachinery/pkg/apis/meta/v1.Time vs *k8s.io/apimachinery/pkg/apis/meta/v1.Time)
	out.ObservedGeneration = in.ObservedGeneration
	if in.Deletion != nil {
		in, out := &in.Deletion, &out.Deletion
		*out = new(MachineDeletionStatus)
		if err := Convert_v1beta2_MachineDeletionStatus_To_v1beta1_MachineDeletionStatus(*in, *out, s); err != nil {
			return err
		}
	} else {
		out.Deletion = nil
	}
	// WARNING: in.Deprecated requires manual conversion: does not exist in peer-type
	return nil
}

func autoConvert_v1beta1_MachineTemplateSpec_To_v1beta2_MachineTemplateSpec(in *MachineTemplateSpec, out *v1beta2.MachineTemplateSpec, s conversion.Scope) error {
	if err := Convert_v1beta1_ObjectMeta_To_v1beta2_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
		return err
	}
	if err := Convert_v1beta1_MachineSpec_To_v1beta2_MachineSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1beta1_MachineTemplateSpec_To_v1beta2_MachineTemplateSpec is an autogenerated conversion function.
func Convert_v1beta1_MachineTemplateSpec_To_v1beta2_MachineTemplateSpec(in *MachineTemplateSpec, out *v1beta2.MachineTemplateSpec, s conversion.Scope) error {
	return autoConvert_v1beta1_MachineTemplateSpec_To_v1beta2_MachineTemplateSpec(in, out, s)
}

func autoConvert_v1beta2_MachineTemplateSpec_To_v1beta1_MachineTemplateSpec(in *v1beta2.MachineTemplateSpec, out *MachineTemplateSpec, s conversion.Scope) error {
	if err := Convert_v1beta2_ObjectMeta_To_v1beta1_ObjectMeta(&in.ObjectMeta, &out.ObjectMeta, s); err != nil {
		return err
	}
	if err := Convert_v1beta2_MachineSpec_To_v1beta1_MachineSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1beta2_MachineTemplateSpec_To_v1beta1_MachineTemplateSpec is an autogenerated conversion function.
func Convert_v1beta2_MachineTemplateSpec_To_v1beta1_MachineTemplateSpec(in *v1beta2.MachineTemplateSpec, out *MachineTemplateSpec, s conversion.Scope) error {
	return autoConvert_v1beta2_MachineTemplateSpec_To_v1beta1_MachineTemplateSpec(in, out, s)
}

func autoConvert_v1beta1_NetworkRanges_To_v1beta2_NetworkRanges(in *NetworkRanges, out *v1beta2.NetworkRanges, s conversion.Scope) error {
	out.CIDRBlocks = *(*[]string)(unsafe.Pointer(&in.CIDRBlocks))
	return nil
}

// Convert_v1beta1_NetworkRanges_To_v1beta2_NetworkRanges is an autogenerated conversion function.
func Convert_v1beta1_NetworkRanges_To_v1beta2_NetworkRanges(in *NetworkRanges, out *v1beta2.NetworkRanges, s conversion.Scope) error {
	return autoConvert_v1beta1_NetworkRanges_To_v1beta2_NetworkRanges(in, out, s)
}

func autoConvert_v1beta2_NetworkRanges_To_v1beta1_NetworkRanges(in *v1beta2.NetworkRanges, out *NetworkRanges, s conversion.Scope) error {
	out.CIDRBlocks = *(*[]string)(unsafe.Pointer(&in.CIDRBlocks))
	return nil
}

// Convert_v1beta2_NetworkRanges_To_v1beta1_NetworkRanges is an autogenerated conversion function.
func Convert_v1beta2_NetworkRanges_To_v1beta1_NetworkRanges(in *v1beta2.NetworkRanges, out *NetworkRanges, s conversion.Scope) error {
	return autoConvert_v1beta2_NetworkRanges_To_v1beta1_NetworkRanges(in, out, s)
}

func autoConvert_v1beta1_ObjectMeta_To_v1beta2_ObjectMeta(in *ObjectMeta, out *v1beta2.ObjectMeta, s conversion.Scope) error {
	out.Labels = *(*map[string]string)(unsafe.Pointer(&in.Labels))
	out.Annotations = *(*map[string]string)(unsafe.Pointer(&in.Annotations))
	return nil
}

// Convert_v1beta1_ObjectMeta_To_v1beta2_ObjectMeta is an autogenerated conversion function.
func Convert_v1beta1_ObjectMeta_To_v1beta2_ObjectMeta(in *ObjectMeta, out *v1beta2.ObjectMeta, s conversion.Scope) error {
	return autoConvert_v1beta1_ObjectMeta_To_v1beta2_ObjectMeta(in, out, s)
}

func autoConvert_v1beta2_ObjectMeta_To_v1beta1_ObjectMeta(in *v1beta2.ObjectMeta, out *ObjectMeta, s conversion.Scope) error {
	out.Labels = *(*map[string]string)(unsafe.Pointer(&in.Labels))
	out.Annotations = *(*map[string]string)(unsafe.Pointer(&in.Annotations))
	return nil
}

// Convert_v1beta2_ObjectMeta_To_v1beta1_ObjectMeta is an autogenerated conversion function.
func Convert_v1beta2_ObjectMeta_To_v1beta1_ObjectMeta(in *v1beta2.ObjectMeta, out *ObjectMeta, s conversion.Scope) error {
	return autoConvert_v1beta2_ObjectMeta_To_v1beta1_ObjectMeta(in, out, s)
}

func autoConvert_v1beta1_PatchDefinition_To_v1beta2_PatchDefinition(in *PatchDefinition, out *v1beta2.PatchDefinition, s conversion.Scope) error {
	if err := Convert_v1beta1_PatchSelector_To_v1beta2_PatchSelector(&in.Selector, &out.Selector, s); err != nil {
		return err
	}
	if in.JSONPatches != nil {
		in, out := &in.JSONPatches, &out.JSONPatches
		*out = make([]v1beta2.JSONPatch, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_JSONPatch_To_v1beta2_JSONPatch(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.JSONPatches = nil
	}
	return nil
}

// Convert_v1beta1_PatchDefinition_To_v1beta2_PatchDefinition is an autogenerated conversion function.
func Convert_v1beta1_PatchDefinition_To_v1beta2_PatchDefinition(in *PatchDefinition, out *v1beta2.PatchDefinition, s conversion.Scope) error {
	return autoConvert_v1beta1_PatchDefinition_To_v1beta2_PatchDefinition(in, out, s)
}

func autoConvert_v1beta2_PatchDefinition_To_v1beta1_PatchDefinition(in *v1beta2.PatchDefinition, out *PatchDefinition, s conversion.Scope) error {
	if err := Convert_v1beta2_PatchSelector_To_v1beta1_PatchSelector(&in.Selector, &out.Selector, s); err != nil {
		return err
	}
	if in.JSONPatches != nil {
		in, out := &in.JSONPatches, &out.JSONPatches
		*out = make([]JSONPatch, len(*in))
		for i := range *in {
			if err := Convert_v1beta2_JSONPatch_To_v1beta1_JSONPatch(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.JSONPatches = nil
	}
	return nil
}

// Convert_v1beta2_PatchDefinition_To_v1beta1_PatchDefinition is an autogenerated conversion function.
func Convert_v1beta2_PatchDefinition_To_v1beta1_PatchDefinition(in *v1beta2.PatchDefinition, out *PatchDefinition, s conversion.Scope) error {
	return autoConvert_v1beta2_PatchDefinition_To_v1beta1_PatchDefinition(in, out, s)
}

func autoConvert_v1beta1_PatchSelector_To_v1beta2_PatchSelector(in *PatchSelector, out *v1beta2.PatchSelector, s conversion.Scope) error {
	out.APIVersion = in.APIVersion
	out.Kind = in.Kind
	if err := Convert_v1beta1_PatchSelectorMatch_To_v1beta2_PatchSelectorMatch(&in.MatchResources, &out.MatchResources, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1beta1_PatchSelector_To_v1beta2_PatchSelector is an autogenerated conversion function.
func Convert_v1beta1_PatchSelector_To_v1beta2_PatchSelector(in *PatchSelector, out *v1beta2.PatchSelector, s conversion.Scope) error {
	return autoConvert_v1beta1_PatchSelector_To_v1beta2_PatchSelector(in, out, s)
}

func autoConvert_v1beta2_PatchSelector_To_v1beta1_PatchSelector(in *v1beta2.PatchSelector, out *PatchSelector, s conversion.Scope) error {
	out.APIVersion = in.APIVersion
	out.Kind = in.Kind
	if err := Convert_v1beta2_PatchSelectorMatch_To_v1beta1_PatchSelectorMatch(&in.MatchResources, &out.MatchResources, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1beta2_PatchSelector_To_v1beta1_PatchSelector is an autogenerated conversion function.
func Convert_v1beta2_PatchSelector_To_v1beta1_PatchSelector(in *v1beta2.PatchSelector, out *PatchSelector, s conversion.Scope) error {
	return autoConvert_v1beta2_PatchSelector_To_v1beta1_PatchSelector(in, out, s)
}

func autoConvert_v1beta1_PatchSelectorMatch_To_v1beta2_PatchSelectorMatch(in *PatchSelectorMatch, out *v1beta2.PatchSelectorMatch, s conversion.Scope) error {
	if err := v1.Convert_bool_To_Pointer_bool(&in.ControlPlane, &out.ControlPlane, s); err != nil {
		return err
	}
	if err := v1.Convert_bool_To_Pointer_bool(&in.InfrastructureCluster, &out.InfrastructureCluster, s); err != nil {
		return err
	}
	out.MachineDeploymentClass = (*v1beta2.PatchSelectorMatchMachineDeploymentClass)(unsafe.Pointer(in.MachineDeploymentClass))
	out.MachinePoolClass = (*v1beta2.PatchSelectorMatchMachinePoolClass)(unsafe.Pointer(in.MachinePoolClass))
	return nil
}

// Convert_v1beta1_PatchSelectorMatch_To_v1beta2_PatchSelectorMatch is an autogenerated conversion function.
func Convert_v1beta1_PatchSelectorMatch_To_v1beta2_PatchSelectorMatch(in *PatchSelectorMatch, out *v1beta2.PatchSelectorMatch, s conversion.Scope) error {
	return autoConvert_v1beta1_PatchSelectorMatch_To_v1beta2_PatchSelectorMatch(in, out, s)
}

func autoConvert_v1beta2_PatchSelectorMatch_To_v1beta1_PatchSelectorMatch(in *v1beta2.PatchSelectorMatch, out *PatchSelectorMatch, s conversion.Scope) error {
	if err := v1.Convert_Pointer_bool_To_bool(&in.ControlPlane, &out.ControlPlane, s); err != nil {
		return err
	}
	if err := v1.Convert_Pointer_bool_To_bool(&in.InfrastructureCluster, &out.InfrastructureCluster, s); err != nil {
		return err
	}
	out.MachineDeploymentClass = (*PatchSelectorMatchMachineDeploymentClass)(unsafe.Pointer(in.MachineDeploymentClass))
	out.MachinePoolClass = (*PatchSelectorMatchMachinePoolClass)(unsafe.Pointer(in.MachinePoolClass))
	return nil
}

// Convert_v1beta2_PatchSelectorMatch_To_v1beta1_PatchSelectorMatch is an autogenerated conversion function.
func Convert_v1beta2_PatchSelectorMatch_To_v1beta1_PatchSelectorMatch(in *v1beta2.PatchSelectorMatch, out *PatchSelectorMatch, s conversion.Scope) error {
	return autoConvert_v1beta2_PatchSelectorMatch_To_v1beta1_PatchSelectorMatch(in, out, s)
}

func autoConvert_v1beta1_PatchSelectorMatchMachineDeploymentClass_To_v1beta2_PatchSelectorMatchMachineDeploymentClass(in *PatchSelectorMatchMachineDeploymentClass, out *v1beta2.PatchSelectorMatchMachineDeploymentClass, s conversion.Scope) error {
	out.Names = *(*[]string)(unsafe.Pointer(&in.Names))
	return nil
}

// Convert_v1beta1_PatchSelectorMatchMachineDeploymentClass_To_v1beta2_PatchSelectorMatchMachineDeploymentClass is an autogenerated conversion function.
func Convert_v1beta1_PatchSelectorMatchMachineDeploymentClass_To_v1beta2_PatchSelectorMatchMachineDeploymentClass(in *PatchSelectorMatchMachineDeploymentClass, out *v1beta2.PatchSelectorMatchMachineDeploymentClass, s conversion.Scope) error {
	return autoConvert_v1beta1_PatchSelectorMatchMachineDeploymentClass_To_v1beta2_PatchSelectorMatchMachineDeploymentClass(in, out, s)
}

func autoConvert_v1beta2_PatchSelectorMatchMachineDeploymentClass_To_v1beta1_PatchSelectorMatchMachineDeploymentClass(in *v1beta2.PatchSelectorMatchMachineDeploymentClass, out *PatchSelectorMatchMachineDeploymentClass, s conversion.Scope) error {
	out.Names = *(*[]string)(unsafe.Pointer(&in.Names))
	return nil
}

// Convert_v1beta2_PatchSelectorMatchMachineDeploymentClass_To_v1beta1_PatchSelectorMatchMachineDeploymentClass is an autogenerated conversion function.
func Convert_v1beta2_PatchSelectorMatchMachineDeploymentClass_To_v1beta1_PatchSelectorMatchMachineDeploymentClass(in *v1beta2.PatchSelectorMatchMachineDeploymentClass, out *PatchSelectorMatchMachineDeploymentClass, s conversion.Scope) error {
	return autoConvert_v1beta2_PatchSelectorMatchMachineDeploymentClass_To_v1beta1_PatchSelectorMatchMachineDeploymentClass(in, out, s)
}

func autoConvert_v1beta1_PatchSelectorMatchMachinePoolClass_To_v1beta2_PatchSelectorMatchMachinePoolClass(in *PatchSelectorMatchMachinePoolClass, out *v1beta2.PatchSelectorMatchMachinePoolClass, s conversion.Scope) error {
	out.Names = *(*[]string)(unsafe.Pointer(&in.Names))
	return nil
}

// Convert_v1beta1_PatchSelectorMatchMachinePoolClass_To_v1beta2_PatchSelectorMatchMachinePoolClass is an autogenerated conversion function.
func Convert_v1beta1_PatchSelectorMatchMachinePoolClass_To_v1beta2_PatchSelectorMatchMachinePoolClass(in *PatchSelectorMatchMachinePoolClass, out *v1beta2.PatchSelectorMatchMachinePoolClass, s conversion.Scope) error {
	return autoConvert_v1beta1_PatchSelectorMatchMachinePoolClass_To_v1beta2_PatchSelectorMatchMachinePoolClass(in, out, s)
}

func autoConvert_v1beta2_PatchSelectorMatchMachinePoolClass_To_v1beta1_PatchSelectorMatchMachinePoolClass(in *v1beta2.PatchSelectorMatchMachinePoolClass, out *PatchSelectorMatchMachinePoolClass, s conversion.Scope) error {
	out.Names = *(*[]string)(unsafe.Pointer(&in.Names))
	return nil
}

// Convert_v1beta2_PatchSelectorMatchMachinePoolClass_To_v1beta1_PatchSelectorMatchMachinePoolClass is an autogenerated conversion function.
func Convert_v1beta2_PatchSelectorMatchMachinePoolClass_To_v1beta1_PatchSelectorMatchMachinePoolClass(in *v1beta2.PatchSelectorMatchMachinePoolClass, out *PatchSelectorMatchMachinePoolClass, s conversion.Scope) error {
	return autoConvert_v1beta2_PatchSelectorMatchMachinePoolClass_To_v1beta1_PatchSelectorMatchMachinePoolClass(in, out, s)
}

func autoConvert_v1beta1_Topology_To_v1beta2_Topology(in *Topology, out *v1beta2.Topology, s conversion.Scope) error {
	// WARNING: in.Class requires manual conversion: does not exist in peer-type
	// WARNING: in.ClassNamespace requires manual conversion: does not exist in peer-type
	out.Version = in.Version
	// WARNING: in.RolloutAfter requires manual conversion: does not exist in peer-type
	if err := Convert_v1beta1_ControlPlaneTopology_To_v1beta2_ControlPlaneTopology(&in.ControlPlane, &out.ControlPlane, s); err != nil {
		return err
	}
	// WARNING: in.Workers requires manual conversion: inconvertible types (*sigs.k8s.io/cluster-api/api/core/v1beta1.WorkersTopology vs sigs.k8s.io/cluster-api/api/core/v1beta2.WorkersTopology)
	if in.Variables != nil {
		in, out := &in.Variables, &out.Variables
		*out = make([]v1beta2.ClusterVariable, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_ClusterVariable_To_v1beta2_ClusterVariable(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Variables = nil
	}
	return nil
}

func autoConvert_v1beta2_Topology_To_v1beta1_Topology(in *v1beta2.Topology, out *Topology, s conversion.Scope) error {
	// WARNING: in.ClassRef requires manual conversion: does not exist in peer-type
	out.Version = in.Version
	if err := Convert_v1beta2_ControlPlaneTopology_To_v1beta1_ControlPlaneTopology(&in.ControlPlane, &out.ControlPlane, s); err != nil {
		return err
	}
	// WARNING: in.Workers requires manual conversion: inconvertible types (sigs.k8s.io/cluster-api/api/core/v1beta2.WorkersTopology vs *sigs.k8s.io/cluster-api/api/core/v1beta1.WorkersTopology)
	if in.Variables != nil {
		in, out := &in.Variables, &out.Variables
		*out = make([]ClusterVariable, len(*in))
		for i := range *in {
			if err := Convert_v1beta2_ClusterVariable_To_v1beta1_ClusterVariable(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Variables = nil
	}
	return nil
}

func autoConvert_v1beta1_ValidationRule_To_v1beta2_ValidationRule(in *ValidationRule, out *v1beta2.ValidationRule, s conversion.Scope) error {
	out.Rule = in.Rule
	out.Message = in.Message
	out.MessageExpression = in.MessageExpression
	out.Reason = v1beta2.FieldValueErrorReason(in.Reason)
	out.FieldPath = in.FieldPath
	return nil
}

// Convert_v1beta1_ValidationRule_To_v1beta2_ValidationRule is an autogenerated conversion function.
func Convert_v1beta1_ValidationRule_To_v1beta2_ValidationRule(in *ValidationRule, out *v1beta2.ValidationRule, s conversion.Scope) error {
	return autoConvert_v1beta1_ValidationRule_To_v1beta2_ValidationRule(in, out, s)
}

func autoConvert_v1beta2_ValidationRule_To_v1beta1_ValidationRule(in *v1beta2.ValidationRule, out *ValidationRule, s conversion.Scope) error {
	out.Rule = in.Rule
	out.Message = in.Message
	out.MessageExpression = in.MessageExpression
	out.Reason = FieldValueErrorReason(in.Reason)
	out.FieldPath = in.FieldPath
	return nil
}

// Convert_v1beta2_ValidationRule_To_v1beta1_ValidationRule is an autogenerated conversion function.
func Convert_v1beta2_ValidationRule_To_v1beta1_ValidationRule(in *v1beta2.ValidationRule, out *ValidationRule, s conversion.Scope) error {
	return autoConvert_v1beta2_ValidationRule_To_v1beta1_ValidationRule(in, out, s)
}

func autoConvert_v1beta1_VariableSchema_To_v1beta2_VariableSchema(in *VariableSchema, out *v1beta2.VariableSchema, s conversion.Scope) error {
	if err := Convert_v1beta1_JSONSchemaProps_To_v1beta2_JSONSchemaProps(&in.OpenAPIV3Schema, &out.OpenAPIV3Schema, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1beta1_VariableSchema_To_v1beta2_VariableSchema is an autogenerated conversion function.
func Convert_v1beta1_VariableSchema_To_v1beta2_VariableSchema(in *VariableSchema, out *v1beta2.VariableSchema, s conversion.Scope) error {
	return autoConvert_v1beta1_VariableSchema_To_v1beta2_VariableSchema(in, out, s)
}

func autoConvert_v1beta2_VariableSchema_To_v1beta1_VariableSchema(in *v1beta2.VariableSchema, out *VariableSchema, s conversion.Scope) error {
	if err := Convert_v1beta2_JSONSchemaProps_To_v1beta1_JSONSchemaProps(&in.OpenAPIV3Schema, &out.OpenAPIV3Schema, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1beta2_VariableSchema_To_v1beta1_VariableSchema is an autogenerated conversion function.
func Convert_v1beta2_VariableSchema_To_v1beta1_VariableSchema(in *v1beta2.VariableSchema, out *VariableSchema, s conversion.Scope) error {
	return autoConvert_v1beta2_VariableSchema_To_v1beta1_VariableSchema(in, out, s)
}

func autoConvert_v1beta1_VariableSchemaMetadata_To_v1beta2_VariableSchemaMetadata(in *VariableSchemaMetadata, out *v1beta2.VariableSchemaMetadata, s conversion.Scope) error {
	out.Labels = *(*map[string]string)(unsafe.Pointer(&in.Labels))
	out.Annotations = *(*map[string]string)(unsafe.Pointer(&in.Annotations))
	return nil
}

// Convert_v1beta1_VariableSchemaMetadata_To_v1beta2_VariableSchemaMetadata is an autogenerated conversion function.
func Convert_v1beta1_VariableSchemaMetadata_To_v1beta2_VariableSchemaMetadata(in *VariableSchemaMetadata, out *v1beta2.VariableSchemaMetadata, s conversion.Scope) error {
	return autoConvert_v1beta1_VariableSchemaMetadata_To_v1beta2_VariableSchemaMetadata(in, out, s)
}

func autoConvert_v1beta2_VariableSchemaMetadata_To_v1beta1_VariableSchemaMetadata(in *v1beta2.VariableSchemaMetadata, out *VariableSchemaMetadata, s conversion.Scope) error {
	out.Labels = *(*map[string]string)(unsafe.Pointer(&in.Labels))
	out.Annotations = *(*map[string]string)(unsafe.Pointer(&in.Annotations))
	return nil
}

// Convert_v1beta2_VariableSchemaMetadata_To_v1beta1_VariableSchemaMetadata is an autogenerated conversion function.
func Convert_v1beta2_VariableSchemaMetadata_To_v1beta1_VariableSchemaMetadata(in *v1beta2.VariableSchemaMetadata, out *VariableSchemaMetadata, s conversion.Scope) error {
	return autoConvert_v1beta2_VariableSchemaMetadata_To_v1beta1_VariableSchemaMetadata(in, out, s)
}

func autoConvert_v1beta1_WorkersClass_To_v1beta2_WorkersClass(in *WorkersClass, out *v1beta2.WorkersClass, s conversion.Scope) error {
	if in.MachineDeployments != nil {
		in, out := &in.MachineDeployments, &out.MachineDeployments
		*out = make([]v1beta2.MachineDeploymentClass, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_MachineDeploymentClass_To_v1beta2_MachineDeploymentClass(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.MachineDeployments = nil
	}
	if in.MachinePools != nil {
		in, out := &in.MachinePools, &out.MachinePools
		*out = make([]v1beta2.MachinePoolClass, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_MachinePoolClass_To_v1beta2_MachinePoolClass(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.MachinePools = nil
	}
	return nil
}

// Convert_v1beta1_WorkersClass_To_v1beta2_WorkersClass is an autogenerated conversion function.
func Convert_v1beta1_WorkersClass_To_v1beta2_WorkersClass(in *WorkersClass, out *v1beta2.WorkersClass, s conversion.Scope) error {
	return autoConvert_v1beta1_WorkersClass_To_v1beta2_WorkersClass(in, out, s)
}

func autoConvert_v1beta2_WorkersClass_To_v1beta1_WorkersClass(in *v1beta2.WorkersClass, out *WorkersClass, s conversion.Scope) error {
	if in.MachineDeployments != nil {
		in, out := &in.MachineDeployments, &out.MachineDeployments
		*out = make([]MachineDeploymentClass, len(*in))
		for i := range *in {
			if err := Convert_v1beta2_MachineDeploymentClass_To_v1beta1_MachineDeploymentClass(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.MachineDeployments = nil
	}
	if in.MachinePools != nil {
		in, out := &in.MachinePools, &out.MachinePools
		*out = make([]MachinePoolClass, len(*in))
		for i := range *in {
			if err := Convert_v1beta2_MachinePoolClass_To_v1beta1_MachinePoolClass(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.MachinePools = nil
	}
	return nil
}

// Convert_v1beta2_WorkersClass_To_v1beta1_WorkersClass is an autogenerated conversion function.
func Convert_v1beta2_WorkersClass_To_v1beta1_WorkersClass(in *v1beta2.WorkersClass, out *WorkersClass, s conversion.Scope) error {
	return autoConvert_v1beta2_WorkersClass_To_v1beta1_WorkersClass(in, out, s)
}

func autoConvert_v1beta1_WorkersStatus_To_v1beta2_WorkersStatus(in *WorkersStatus, out *v1beta2.WorkersStatus, s conversion.Scope) error {
	out.DesiredReplicas = (*int32)(unsafe.Pointer(in.DesiredReplicas))
	out.Replicas = (*int32)(unsafe.Pointer(in.Replicas))
	out.UpToDateReplicas = (*int32)(unsafe.Pointer(in.UpToDateReplicas))
	out.ReadyReplicas = (*int32)(unsafe.Pointer(in.ReadyReplicas))
	out.AvailableReplicas = (*int32)(unsafe.Pointer(in.AvailableReplicas))
	return nil
}

// Convert_v1beta1_WorkersStatus_To_v1beta2_WorkersStatus is an autogenerated conversion function.
func Convert_v1beta1_WorkersStatus_To_v1beta2_WorkersStatus(in *WorkersStatus, out *v1beta2.WorkersStatus, s conversion.Scope) error {
	return autoConvert_v1beta1_WorkersStatus_To_v1beta2_WorkersStatus(in, out, s)
}

func autoConvert_v1beta2_WorkersStatus_To_v1beta1_WorkersStatus(in *v1beta2.WorkersStatus, out *WorkersStatus, s conversion.Scope) error {
	out.DesiredReplicas = (*int32)(unsafe.Pointer(in.DesiredReplicas))
	out.Replicas = (*int32)(unsafe.Pointer(in.Replicas))
	out.UpToDateReplicas = (*int32)(unsafe.Pointer(in.UpToDateReplicas))
	out.ReadyReplicas = (*int32)(unsafe.Pointer(in.ReadyReplicas))
	out.AvailableReplicas = (*int32)(unsafe.Pointer(in.AvailableReplicas))
	return nil
}

// Convert_v1beta2_WorkersStatus_To_v1beta1_WorkersStatus is an autogenerated conversion function.
func Convert_v1beta2_WorkersStatus_To_v1beta1_WorkersStatus(in *v1beta2.WorkersStatus, out *WorkersStatus, s conversion.Scope) error {
	return autoConvert_v1beta2_WorkersStatus_To_v1beta1_WorkersStatus(in, out, s)
}

func autoConvert_v1beta1_WorkersTopology_To_v1beta2_WorkersTopology(in *WorkersTopology, out *v1beta2.WorkersTopology, s conversion.Scope) error {
	if in.MachineDeployments != nil {
		in, out := &in.MachineDeployments, &out.MachineDeployments
		*out = make([]v1beta2.MachineDeploymentTopology, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_MachineDeploymentTopology_To_v1beta2_MachineDeploymentTopology(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.MachineDeployments = nil
	}
	if in.MachinePools != nil {
		in, out := &in.MachinePools, &out.MachinePools
		*out = make([]v1beta2.MachinePoolTopology, len(*in))
		for i := range *in {
			if err := Convert_v1beta1_MachinePoolTopology_To_v1beta2_MachinePoolTopology(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.MachinePools = nil
	}
	return nil
}

// Convert_v1beta1_WorkersTopology_To_v1beta2_WorkersTopology is an autogenerated conversion function.
func Convert_v1beta1_WorkersTopology_To_v1beta2_WorkersTopology(in *WorkersTopology, out *v1beta2.WorkersTopology, s conversion.Scope) error {
	return autoConvert_v1beta1_WorkersTopology_To_v1beta2_WorkersTopology(in, out, s)
}

func autoConvert_v1beta2_WorkersTopology_To_v1beta1_WorkersTopology(in *v1beta2.WorkersTopology, out *WorkersTopology, s conversion.Scope) error {
	if in.MachineDeployments != nil {
		in, out := &in.MachineDeployments, &out.MachineDeployments
		*out = make([]MachineDeploymentTopology, len(*in))
		for i := range *in {
			if err := Convert_v1beta2_MachineDeploymentTopology_To_v1beta1_MachineDeploymentTopology(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.MachineDeployments = nil
	}
	if in.MachinePools != nil {
		in, out := &in.MachinePools, &out.MachinePools
		*out = make([]MachinePoolTopology, len(*in))
		for i := range *in {
			if err := Convert_v1beta2_MachinePoolTopology_To_v1beta1_MachinePoolTopology(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.MachinePools = nil
	}
	return nil
}

// Convert_v1beta2_WorkersTopology_To_v1beta1_WorkersTopology is an autogenerated conversion function.
func Convert_v1beta2_WorkersTopology_To_v1beta1_WorkersTopology(in *v1beta2.WorkersTopology, out *WorkersTopology, s conversion.Scope) error {
	return autoConvert_v1beta2_WorkersTopology_To_v1beta1_WorkersTopology(in, out, s)
}