namespace_types_gen.go

// Code generated by azure-service-operator-codegen. DO NOT EDIT.
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT license.
package v1alpha1api20211101

import (
	"fmt"
	alpha20211101s "github.com/Azure/azure-service-operator/v2/api/eventhub/v1alpha1api20211101storage"
	"github.com/Azure/azure-service-operator/v2/internal/reflecthelpers"
	"github.com/Azure/azure-service-operator/v2/pkg/genruntime"
	"github.com/Azure/azure-service-operator/v2/pkg/genruntime/conditions"
	"github.com/pkg/errors"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/runtime/schema"
	kerrors "k8s.io/apimachinery/pkg/util/errors"
	"sigs.k8s.io/controller-runtime/pkg/conversion"
	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
)

// +kubebuilder:object:root=true
// +kubebuilder:subresource:status
// +kubebuilder:printcolumn:name="Ready",type="string",JSONPath=".status.conditions[?(@.type=='Ready')].status"
// +kubebuilder:printcolumn:name="Severity",type="string",JSONPath=".status.conditions[?(@.type=='Ready')].severity"
// +kubebuilder:printcolumn:name="Reason",type="string",JSONPath=".status.conditions[?(@.type=='Ready')].reason"
// +kubebuilder:printcolumn:name="Message",type="string",JSONPath=".status.conditions[?(@.type=='Ready')].message"
// Deprecated version of Namespace. Use v1beta20211101.Namespace instead
type Namespace struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	Spec              Namespace_Spec   `json:"spec,omitempty"`
	Status            Namespace_STATUS `json:"status,omitempty"`
}

var _ conditions.Conditioner = &Namespace{}

// GetConditions returns the conditions of the resource
func (namespace *Namespace) GetConditions() conditions.Conditions {
	return namespace.Status.Conditions
}

// SetConditions sets the conditions on the resource status
func (namespace *Namespace) SetConditions(conditions conditions.Conditions) {
	namespace.Status.Conditions = conditions
}

var _ conversion.Convertible = &Namespace{}

// ConvertFrom populates our Namespace from the provided hub Namespace
func (namespace *Namespace) ConvertFrom(hub conversion.Hub) error {
	// intermediate variable for conversion
	var source alpha20211101s.Namespace

	err := source.ConvertFrom(hub)
	if err != nil {
		return errors.Wrap(err, "converting from hub to source")
	}

	err = namespace.AssignProperties_From_Namespace(&source)
	if err != nil {
		return errors.Wrap(err, "converting from source to namespace")
	}

	return nil
}

// ConvertTo populates the provided hub Namespace from our Namespace
func (namespace *Namespace) ConvertTo(hub conversion.Hub) error {
	// intermediate variable for conversion
	var destination alpha20211101s.Namespace
	err := namespace.AssignProperties_To_Namespace(&destination)
	if err != nil {
		return errors.Wrap(err, "converting to destination from namespace")
	}
	err = destination.ConvertTo(hub)
	if err != nil {
		return errors.Wrap(err, "converting from destination to hub")
	}

	return nil
}

// +kubebuilder:webhook:path=/mutate-eventhub-azure-com-v1alpha1api20211101-namespace,mutating=true,sideEffects=None,matchPolicy=Exact,failurePolicy=fail,groups=eventhub.azure.com,resources=namespaces,verbs=create;update,versions=v1alpha1api20211101,name=default.v1alpha1api20211101.namespaces.eventhub.azure.com,admissionReviewVersions=v1

var _ admission.Defaulter = &Namespace{}

// Default applies defaults to the Namespace resource
func (namespace *Namespace) Default() {
	namespace.defaultImpl()
	var temp any = namespace
	if runtimeDefaulter, ok := temp.(genruntime.Defaulter); ok {
		runtimeDefaulter.CustomDefault()
	}
}

// defaultAzureName defaults the Azure name of the resource to the Kubernetes name
func (namespace *Namespace) defaultAzureName() {
	if namespace.Spec.AzureName == "" {
		namespace.Spec.AzureName = namespace.Name
	}
}

// defaultImpl applies the code generated defaults to the Namespace resource
func (namespace *Namespace) defaultImpl() { namespace.defaultAzureName() }

var _ genruntime.KubernetesResource = &Namespace{}

// AzureName returns the Azure name of the resource
func (namespace *Namespace) AzureName() string {
	return namespace.Spec.AzureName
}

// GetAPIVersion returns the ARM API version of the resource. This is always "2021-11-01"
func (namespace Namespace) GetAPIVersion() string {
	return string(APIVersion_Value)
}

// GetResourceScope returns the scope of the resource
func (namespace *Namespace) GetResourceScope() genruntime.ResourceScope {
	return genruntime.ResourceScopeResourceGroup
}

// GetSpec returns the specification of this resource
func (namespace *Namespace) GetSpec() genruntime.ConvertibleSpec {
	return &namespace.Spec
}

// GetStatus returns the status of this resource
func (namespace *Namespace) GetStatus() genruntime.ConvertibleStatus {
	return &namespace.Status
}

// GetType returns the ARM Type of the resource. This is always "Microsoft.EventHub/namespaces"
func (namespace *Namespace) GetType() string {
	return "Microsoft.EventHub/namespaces"
}

// NewEmptyStatus returns a new empty (blank) status
func (namespace *Namespace) NewEmptyStatus() genruntime.ConvertibleStatus {
	return &Namespace_STATUS{}
}

// Owner returns the ResourceReference of the owner
func (namespace *Namespace) Owner() *genruntime.ResourceReference {
	group, kind := genruntime.LookupOwnerGroupKind(namespace.Spec)
	return &genruntime.ResourceReference{
		Group: group,
		Kind:  kind,
		Name:  namespace.Spec.Owner.Name,
	}
}

// SetStatus sets the status of this resource
func (namespace *Namespace) SetStatus(status genruntime.ConvertibleStatus) error {
	// If we have exactly the right type of status, assign it
	if st, ok := status.(*Namespace_STATUS); ok {
		namespace.Status = *st
		return nil
	}

	// Convert status to required version
	var st Namespace_STATUS
	err := status.ConvertStatusTo(&st)
	if err != nil {
		return errors.Wrap(err, "failed to convert status")
	}

	namespace.Status = st
	return nil
}

// +kubebuilder:webhook:path=/validate-eventhub-azure-com-v1alpha1api20211101-namespace,mutating=false,sideEffects=None,matchPolicy=Exact,failurePolicy=fail,groups=eventhub.azure.com,resources=namespaces,verbs=create;update,versions=v1alpha1api20211101,name=validate.v1alpha1api20211101.namespaces.eventhub.azure.com,admissionReviewVersions=v1

var _ admission.Validator = &Namespace{}

// ValidateCreate validates the creation of the resource
func (namespace *Namespace) ValidateCreate() error {
	validations := namespace.createValidations()
	var temp any = namespace
	if runtimeValidator, ok := temp.(genruntime.Validator); ok {
		validations = append(validations, runtimeValidator.CreateValidations()...)
	}
	var errs []error
	for _, validation := range validations {
		err := validation()
		if err != nil {
			errs = append(errs, err)
		}
	}
	return kerrors.NewAggregate(errs)
}

// ValidateDelete validates the deletion of the resource
func (namespace *Namespace) ValidateDelete() error {
	validations := namespace.deleteValidations()
	var temp any = namespace
	if runtimeValidator, ok := temp.(genruntime.Validator); ok {
		validations = append(validations, runtimeValidator.DeleteValidations()...)
	}
	var errs []error
	for _, validation := range validations {
		err := validation()
		if err != nil {
			errs = append(errs, err)
		}
	}
	return kerrors.NewAggregate(errs)
}

// ValidateUpdate validates an update of the resource
func (namespace *Namespace) ValidateUpdate(old runtime.Object) error {
	validations := namespace.updateValidations()
	var temp any = namespace
	if runtimeValidator, ok := temp.(genruntime.Validator); ok {
		validations = append(validations, runtimeValidator.UpdateValidations()...)
	}
	var errs []error
	for _, validation := range validations {
		err := validation(old)
		if err != nil {
			errs = append(errs, err)
		}
	}
	return kerrors.NewAggregate(errs)
}

// createValidations validates the creation of the resource
func (namespace *Namespace) createValidations() []func() error {
	return []func() error{namespace.validateResourceReferences}
}

// deleteValidations validates the deletion of the resource
func (namespace *Namespace) deleteValidations() []func() error {
	return nil
}

// updateValidations validates the update of the resource
func (namespace *Namespace) updateValidations() []func(old runtime.Object) error {
	return []func(old runtime.Object) error{
		func(old runtime.Object) error {
			return namespace.validateResourceReferences()
		},
		namespace.validateWriteOnceProperties}
}

// validateResourceReferences validates all resource references
func (namespace *Namespace) validateResourceReferences() error {
	refs, err := reflecthelpers.FindResourceReferences(&namespace.Spec)
	if err != nil {
		return err
	}
	return genruntime.ValidateResourceReferences(refs)
}

// validateWriteOnceProperties validates all WriteOnce properties
func (namespace *Namespace) validateWriteOnceProperties(old runtime.Object) error {
	oldObj, ok := old.(*Namespace)
	if !ok {
		return nil
	}

	return genruntime.ValidateWriteOnceProperties(oldObj, namespace)
}

// AssignProperties_From_Namespace populates our Namespace from the provided source Namespace
func (namespace *Namespace) AssignProperties_From_Namespace(source *alpha20211101s.Namespace) error {

	// ObjectMeta
	namespace.ObjectMeta = *source.ObjectMeta.DeepCopy()

	// Spec
	var spec Namespace_Spec
	err := spec.AssignProperties_From_Namespace_Spec(&source.Spec)
	if err != nil {
		return errors.Wrap(err, "calling AssignProperties_From_Namespace_Spec() to populate field Spec")
	}
	namespace.Spec = spec

	// Status
	var status Namespace_STATUS
	err = status.AssignProperties_From_Namespace_STATUS(&source.Status)
	if err != nil {
		return errors.Wrap(err, "calling AssignProperties_From_Namespace_STATUS() to populate field Status")
	}
	namespace.Status = status

	// No error
	return nil
}

// AssignProperties_To_Namespace populates the provided destination Namespace from our Namespace
func (namespace *Namespace) AssignProperties_To_Namespace(destination *alpha20211101s.Namespace) error {

	// ObjectMeta
	destination.ObjectMeta = *namespace.ObjectMeta.DeepCopy()

	// Spec
	var spec alpha20211101s.Namespace_Spec
	err := namespace.Spec.AssignProperties_To_Namespace_Spec(&spec)
	if err != nil {
		return errors.Wrap(err, "calling AssignProperties_To_Namespace_Spec() to populate field Spec")
	}
	destination.Spec = spec

	// Status
	var status alpha20211101s.Namespace_STATUS
	err = namespace.Status.AssignProperties_To_Namespace_STATUS(&status)
	if err != nil {
		return errors.Wrap(err, "calling AssignProperties_To_Namespace_STATUS() to populate field Status")
	}
	destination.Status = status

	// No error
	return nil
}

// OriginalGVK returns a GroupValueKind for the original API version used to create the resource
func (namespace *Namespace) OriginalGVK() *schema.GroupVersionKind {
	return &schema.GroupVersionKind{
		Group:   GroupVersion.Group,
		Version: namespace.Spec.OriginalVersion(),
		Kind:    "Namespace",
	}
}

// +kubebuilder:object:root=true
// Deprecated version of Namespace. Use v1beta20211101.Namespace instead
type NamespaceList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Namespace `json:"items"`
}

// Deprecated version of APIVersion. Use v1beta20211101.APIVersion instead
// +kubebuilder:validation:Enum={"2021-11-01"}
type APIVersion string

const APIVersion_Value = APIVersion("2021-11-01")

type Namespace_Spec struct {
	AlternateName *string `json:"alternateName,omitempty"`

	// +kubebuilder:validation:MaxLength=50
	// +kubebuilder:validation:MinLength=6
	// AzureName: The name of the resource in Azure. This is often the same as the name of the resource in Kubernetes but it
	// doesn't have to be.
	AzureName              string                        `json:"azureName,omitempty"`
	ClusterArmReference    *genruntime.ResourceReference `armReference:"ClusterArmId" json:"clusterArmReference,omitempty"`
	DisableLocalAuth       *bool                         `json:"disableLocalAuth,omitempty"`
	Encryption             *Encryption                   `json:"encryption,omitempty"`
	Identity               *Identity                     `json:"identity,omitempty"`
	IsAutoInflateEnabled   *bool                         `json:"isAutoInflateEnabled,omitempty"`
	KafkaEnabled           *bool                         `json:"kafkaEnabled,omitempty"`
	Location               *string                       `json:"location,omitempty"`
	MaximumThroughputUnits *int                          `json:"maximumThroughputUnits,omitempty"`

	// +kubebuilder:validation:Required
	// Owner: The owner of the resource. The owner controls where the resource goes when it is deployed. The owner also
	// controls the resources lifecycle. When the owner is deleted the resource will also be deleted. Owner is expected to be a
	// reference to a resources.azure.com/ResourceGroup resource
	Owner         *genruntime.KnownResourceReference `group:"resources.azure.com" json:"owner,omitempty" kind:"ResourceGroup"`
	Sku           *Sku                               `json:"sku,omitempty"`
	Tags          map[string]string                  `json:"tags,omitempty"`
	ZoneRedundant *bool                              `json:"zoneRedundant,omitempty"`
}

var _ genruntime.ARMTransformer = &Namespace_Spec{}

// ConvertToARM converts from a Kubernetes CRD object to an ARM object
func (namespace *Namespace_Spec) ConvertToARM(resolved genruntime.ConvertToARMResolvedDetails) (interface{}, error) {
	if namespace == nil {
		return nil, nil
	}
	result := &Namespace_Spec_ARM{}

	// Set property ‘Identity’:
	if namespace.Identity != nil {
		identity_ARM, err := (*namespace.Identity).ConvertToARM(resolved)
		if err != nil {
			return nil, err
		}
		identity := *identity_ARM.(*Identity_ARM)
		result.Identity = &identity
	}

	// Set property ‘Location’:
	if namespace.Location != nil {
		location := *namespace.Location
		result.Location = &location
	}

	// Set property ‘Name’:
	result.Name = resolved.Name

	// Set property ‘Properties’:
	if namespace.AlternateName != nil ||
		namespace.ClusterArmReference != nil ||
		namespace.DisableLocalAuth != nil ||
		namespace.Encryption != nil ||
		namespace.IsAutoInflateEnabled != nil ||
		namespace.KafkaEnabled != nil ||
		namespace.MaximumThroughputUnits != nil ||
		namespace.ZoneRedundant != nil {
		result.Properties = &Namespace_Properties_Spec_ARM{}
	}
	if namespace.AlternateName != nil {
		alternateName := *namespace.AlternateName
		result.Properties.AlternateName = &alternateName
	}
	if namespace.ClusterArmReference != nil {
		clusterArmIdARMID, err := resolved.ResolvedReferences.Lookup(*namespace.ClusterArmReference)
		if err != nil {
			return nil, err
		}
		clusterArmId := clusterArmIdARMID
		result.Properties.ClusterArmId = &clusterArmId
	}
	if namespace.DisableLocalAuth != nil {
		disableLocalAuth := *namespace.DisableLocalAuth
		result.Properties.DisableLocalAuth = &disableLocalAuth
	}
	if namespace.Encryption != nil {
		encryption_ARM, err := (*namespace.Encryption).ConvertToARM(resolved)
		if err != nil {
			return nil, err
		}
		encryption := *encryption_ARM.(*Encryption_ARM)
		result.Properties.Encryption = &encryption
	}
	if namespace.IsAutoInflateEnabled != nil {
		isAutoInflateEnabled := *namespace.IsAutoInflateEnabled
		result.Properties.IsAutoInflateEnabled = &isAutoInflateEnabled
	}
	if namespace.KafkaEnabled != nil {
		kafkaEnabled := *namespace.KafkaEnabled
		result.Properties.KafkaEnabled = &kafkaEnabled
	}
	if namespace.MaximumThroughputUnits != nil {
		maximumThroughputUnits := *namespace.MaximumThroughputUnits
		result.Properties.MaximumThroughputUnits = &maximumThroughputUnits
	}
	if namespace.ZoneRedundant != nil {
		zoneRedundant := *namespace.ZoneRedundant
		result.Properties.ZoneRedundant = &zoneRedundant
	}

	// Set property ‘Sku’:
	if namespace.Sku != nil {
		sku_ARM, err := (*namespace.Sku).ConvertToARM(resolved)
		if err != nil {
			return nil, err
		}
		sku := *sku_ARM.(*Sku_ARM)
		result.Sku = &sku
	}

	// Set property ‘Tags’:
	if namespace.Tags != nil {
		result.Tags = make(map[string]string, len(namespace.Tags))
		for key, value := range namespace.Tags {
			result.Tags[key] = value
		}
	}
	return result, nil
}

// NewEmptyARMValue returns an empty ARM value suitable for deserializing into
func (namespace *Namespace_Spec) NewEmptyARMValue() genruntime.ARMResourceStatus {
	return &Namespace_Spec_ARM{}
}

// PopulateFromARM populates a Kubernetes CRD object from an Azure ARM object
func (namespace *Namespace_Spec) PopulateFromARM(owner genruntime.ArbitraryOwnerReference, armInput interface{}) error {
	typedInput, ok := armInput.(Namespace_Spec_ARM)
	if !ok {
		return fmt.Errorf("unexpected type supplied for PopulateFromARM() function. Expected Namespace_Spec_ARM, got %T", armInput)
	}

	// Set property ‘AlternateName’:
	// copying flattened property:
	if typedInput.Properties != nil {
		if typedInput.Properties.AlternateName != nil {
			alternateName := *typedInput.Properties.AlternateName
			namespace.AlternateName = &alternateName
		}
	}

	// Set property ‘AzureName’:
	namespace.SetAzureName(genruntime.ExtractKubernetesResourceNameFromARMName(typedInput.Name))

	// no assignment for property ‘ClusterArmReference’

	// Set property ‘DisableLocalAuth’:
	// copying flattened property:
	if typedInput.Properties != nil {
		if typedInput.Properties.DisableLocalAuth != nil {
			disableLocalAuth := *typedInput.Properties.DisableLocalAuth
			namespace.DisableLocalAuth = &disableLocalAuth
		}
	}

	// Set property ‘Encryption’:
	// copying flattened property:
	if typedInput.Properties != nil {
		if typedInput.Properties.Encryption != nil {
			var encryption1 Encryption
			err := encryption1.PopulateFromARM(owner, *typedInput.Properties.Encryption)
			if err != nil {
				return err
			}
			encryption := encryption1
			namespace.Encryption = &encryption
		}
	}

	// Set property ‘Identity’:
	if typedInput.Identity != nil {
		var identity1 Identity
		err := identity1.PopulateFromARM(owner, *typedInput.Identity)
		if err != nil {
			return err
		}
		identity := identity1
		namespace.Identity = &identity
	}

	// Set property ‘IsAutoInflateEnabled’:
	// copying flattened property:
	if typedInput.Properties != nil {
		if typedInput.Properties.IsAutoInflateEnabled != nil {
			isAutoInflateEnabled := *typedInput.Properties.IsAutoInflateEnabled
			namespace.IsAutoInflateEnabled = &isAutoInflateEnabled
		}
	}

	// Set property ‘KafkaEnabled’:
	// copying flattened property:
	if typedInput.Properties != nil {
		if typedInput.Properties.KafkaEnabled != nil {
			kafkaEnabled := *typedInput.Properties.KafkaEnabled
			namespace.KafkaEnabled = &kafkaEnabled
		}
	}

	// Set property ‘Location’:
	if typedInput.Location != nil {
		location := *typedInput.Location
		namespace.Location = &location
	}

	// Set property ‘MaximumThroughputUnits’:
	// copying flattened property:
	if typedInput.Properties != nil {
		if typedInput.Properties.MaximumThroughputUnits != nil {
			maximumThroughputUnits := *typedInput.Properties.MaximumThroughputUnits
			namespace.MaximumThroughputUnits = &maximumThroughputUnits
		}
	}

	// Set property ‘Owner’:
	namespace.Owner = &genruntime.KnownResourceReference{Name: owner.Name}

	// Set property ‘Sku’:
	if typedInput.Sku != nil {
		var sku1 Sku
		err := sku1.PopulateFromARM(owner, *typedInput.Sku)
		if err != nil {
			return err
		}
		sku := sku1
		namespace.Sku = &sku
	}

	// Set property ‘Tags’:
	if typedInput.Tags != nil {
		namespace.Tags = make(map[string]string, len(typedInput.Tags))
		for key, value := range typedInput.Tags {
			namespace.Tags[key] = value
		}
	}

	// Set property ‘ZoneRedundant’:
	// copying flattened property:
	if typedInput.Properties != nil {
		if typedInput.Properties.ZoneRedundant != nil {
			zoneRedundant := *typedInput.Properties.ZoneRedundant
			namespace.ZoneRedundant = &zoneRedundant
		}
	}

	// No error
	return nil
}

var _ genruntime.ConvertibleSpec = &Namespace_Spec{}

// ConvertSpecFrom populates our Namespace_Spec from the provided source
func (namespace *Namespace_Spec) ConvertSpecFrom(source genruntime.ConvertibleSpec) error {
	src, ok := source.(*alpha20211101s.Namespace_Spec)
	if ok {
		// Populate our instance from source
		return namespace.AssignProperties_From_Namespace_Spec(src)
	}

	// Convert to an intermediate form
	src = &alpha20211101s.Namespace_Spec{}
	err := src.ConvertSpecFrom(source)
	if err != nil {
		return errors.Wrap(err, "initial step of conversion in ConvertSpecFrom()")
	}

	// Update our instance from src
	err = namespace.AssignProperties_From_Namespace_Spec(src)
	if err != nil {
		return errors.Wrap(err, "final step of conversion in ConvertSpecFrom()")
	}

	return nil
}

// ConvertSpecTo populates the provided destination from our Namespace_Spec
func (namespace *Namespace_Spec) ConvertSpecTo(destination genruntime.ConvertibleSpec) error {
	dst, ok := destination.(*alpha20211101s.Namespace_Spec)
	if ok {
		// Populate destination from our instance
		return namespace.AssignProperties_To_Namespace_Spec(dst)
	}

	// Convert to an intermediate form
	dst = &alpha20211101s.Namespace_Spec{}
	err := namespace.AssignProperties_To_Namespace_Spec(dst)
	if err != nil {
		return errors.Wrap(err, "initial step of conversion in ConvertSpecTo()")
	}

	// Update dst from our instance
	err = dst.ConvertSpecTo(destination)
	if err != nil {
		return errors.Wrap(err, "final step of conversion in ConvertSpecTo()")
	}

	return nil
}

// AssignProperties_From_Namespace_Spec populates our Namespace_Spec from the provided source Namespace_Spec
func (namespace *Namespace_Spec) AssignProperties_From_Namespace_Spec(source *alpha20211101s.Namespace_Spec) error {

	// AlternateName
	namespace.AlternateName = genruntime.ClonePointerToString(source.AlternateName)

	// AzureName
	namespace.AzureName = source.AzureName

	// ClusterArmReference
	if source.ClusterArmReference != nil {
		clusterArmReference := source.ClusterArmReference.Copy()
		namespace.ClusterArmReference = &clusterArmReference
	} else {
		namespace.ClusterArmReference = nil
	}

	// DisableLocalAuth
	if source.DisableLocalAuth != nil {
		disableLocalAuth := *source.DisableLocalAuth
		namespace.DisableLocalAuth = &disableLocalAuth
	} else {
		namespace.DisableLocalAuth = nil
	}

	// Encryption
	if source.Encryption != nil {
		var encryption Encryption
		err := encryption.AssignProperties_From_Encryption(source.Encryption)
		if err != nil {
			return errors.Wrap(err, "calling AssignProperties_From_Encryption() to populate field Encryption")
		}
		namespace.Encryption = &encryption
	} else {
		namespace.Encryption = nil
	}

	// Identity
	if source.Identity != nil {
		var identity Identity
		err := identity.AssignProperties_From_Identity(source.Identity)
		if err != nil {
			return errors.Wrap(err, "calling AssignProperties_From_Identity() to populate field Identity")
		}
		namespace.Identity = &identity
	} else {
		namespace.Identity = nil
	}

	// IsAutoInflateEnabled
	if source.IsAutoInflateEnabled != nil {
		isAutoInflateEnabled := *source.IsAutoInflateEnabled
		namespace.IsAutoInflateEnabled = &isAutoInflateEnabled
	} else {
		namespace.IsAutoInflateEnabled = nil
	}

	// KafkaEnabled
	if source.KafkaEnabled != nil {
		kafkaEnabled := *source.KafkaEnabled
		namespace.KafkaEnabled = &kafkaEnabled
	} else {
		namespace.KafkaEnabled = nil
	}

	// Location
	namespace.Location = genruntime.ClonePointerToString(source.Location)

	// MaximumThroughputUnits
	namespace.MaximumThroughputUnits = genruntime.ClonePointerToInt(source.MaximumThroughputUnits)

	// Owner
	if source.Owner != nil {
		owner := source.Owner.Copy()
		namespace.Owner = &owner
	} else {
		namespace.Owner = nil
	}

	// Sku
	if source.Sku != nil {
		var sku Sku
		err := sku.AssignProperties_From_Sku(source.Sku)
		if err != nil {
			return errors.Wrap(err, "calling AssignProperties_From_Sku() to populate field Sku")
		}
		namespace.Sku = &sku
	} else {
		namespace.Sku = nil
	}

	// Tags
	namespace.Tags = genruntime.CloneMapOfStringToString(source.Tags)

	// ZoneRedundant
	if source.ZoneRedundant != nil {
		zoneRedundant := *source.ZoneRedundant
		namespace.ZoneRedundant = &zoneRedundant
	} else {
		namespace.ZoneRedundant = nil
	}

	// No error
	return nil
}

// AssignProperties_To_Namespace_Spec populates the provided destination Namespace_Spec from our Namespace_Spec
func (namespace *Namespace_Spec) AssignProperties_To_Namespace_Spec(destination *alpha20211101s.Namespace_Spec) error {
	// Create a new property bag
	propertyBag := genruntime.NewPropertyBag()

	// AlternateName
	destination.AlternateName = genruntime.ClonePointerToString(namespace.AlternateName)

	// AzureName
	destination.AzureName = namespace.AzureName

	// ClusterArmReference
	if namespace.ClusterArmReference != nil {
		clusterArmReference := namespace.ClusterArmReference.Copy()
		destination.ClusterArmReference = &clusterArmReference
	} else {
		destination.ClusterArmReference = nil
	}

	// DisableLocalAuth
	if namespace.DisableLocalAuth != nil {
		disableLocalAuth := *namespace.DisableLocalAuth
		destination.DisableLocalAuth = &disableLocalAuth
	} else {
		destination.DisableLocalAuth = nil
	}

	// Encryption
	if namespace.Encryption != nil {
		var encryption alpha20211101s.Encryption
		err := namespace.Encryption.AssignProperties_To_Encryption(&encryption)
		if err != nil {
			return errors.Wrap(err, "calling AssignProperties_To_Encryption() to populate field Encryption")
		}
		destination.Encryption = &encryption
	} else {
		destination.Encryption = nil
	}

	// Identity
	if namespace.Identity != nil {
		var identity alpha20211101s.Identity
		err := namespace.Identity.AssignProperties_To_Identity(&identity)
		if err != nil {
			return errors.Wrap(err, "calling AssignProperties_To_Identity() to populate field Identity")
		}
		destination.Identity = &identity
	} else {
		destination.Identity = nil
	}

	// IsAutoInflateEnabled
	if namespace.IsAutoInflateEnabled != nil {
		isAutoInflateEnabled := *namespace.IsAutoInflateEnabled
		destination.IsAutoInflateEnabled = &isAutoInflateEnabled
	} else {
		destination.IsAutoInflateEnabled = nil
	}

	// KafkaEnabled
	if namespace.KafkaEnabled != nil {
		kafkaEnabled := *namespace.KafkaEnabled
		destination.KafkaEnabled = &kafkaEnabled
	} else {
		destination.KafkaEnabled = nil
	}

	// Location
	destination.Location = genruntime.ClonePointerToString(namespace.Location)

	// MaximumThroughputUnits
	destination.MaximumThroughputUnits = genruntime.ClonePointerToInt(namespace.MaximumThroughputUnits)

	// OriginalVersion
	destination.OriginalVersion = namespace.OriginalVersion()

	// Owner
	if namespace.Owner != nil {
		owner := namespace.Owner.Copy()
		destination.Owner = &owner
	} else {
		destination.Owner = nil
	}

	// Sku
	if namespace.Sku != nil {
		var sku alpha20211101s.Sku
		err := namespace.Sku.AssignProperties_To_Sku(&sku)
		if err != nil {
			return errors.Wrap(err, "calling AssignProperties_To_Sku() to populate field Sku")
		}
		destination.Sku = &sku
	} else {
		destination.Sku = nil
	}

	// Tags
	destination.Tags = genruntime.CloneMapOfStringToString(namespace.Tags)

	// ZoneRedundant
	if namespace.ZoneRedundant != nil {
		zoneRedundant := *namespace.ZoneRedundant
		destination.ZoneRedundant = &zoneRedundant
	} else {
		destination.ZoneRedundant = nil
	}

	// Update the property bag
	if len(propertyBag) > 0 {
		destination.PropertyBag = propertyBag
	} else {
		destination.PropertyBag = nil
	}

	// No error
	return nil
}

// OriginalVersion returns the original API version used to create the resource.
func (namespace *Namespace_Spec) OriginalVersion() string {
	return GroupVersion.Version
}

// SetAzureName sets the Azure name of the resource
func (namespace *Namespace_Spec) SetAzureName(azureName string) { namespace.AzureName = azureName }

// Deprecated version of Namespace_STATUS. Use v1beta20211101.Namespace_STATUS instead
type Namespace_STATUS struct {
	AlternateName *string `json:"alternateName,omitempty"`
	ClusterArmId  *string `json:"clusterArmId,omitempty"`

	// Conditions: The observed state of the resource
	Conditions                 []conditions.Condition             `json:"conditions,omitempty"`
	CreatedAt                  *string                            `json:"createdAt,omitempty"`
	DisableLocalAuth           *bool                              `json:"disableLocalAuth,omitempty"`
	Encryption                 *Encryption_STATUS                 `json:"encryption,omitempty"`
	Id                         *string                            `json:"id,omitempty"`
	Identity                   *Identity_STATUS                   `json:"identity,omitempty"`
	IsAutoInflateEnabled       *bool                              `json:"isAutoInflateEnabled,omitempty"`
	KafkaEnabled               *bool                              `json:"kafkaEnabled,omitempty"`
	Location                   *string                            `json:"location,omitempty"`
	MaximumThroughputUnits     *int                               `json:"maximumThroughputUnits,omitempty"`
	MetricId                   *string                            `json:"metricId,omitempty"`
	Name                       *string                            `json:"name,omitempty"`
	PrivateEndpointConnections []PrivateEndpointConnection_STATUS `json:"privateEndpointConnections,omitempty"`
	ProvisioningState          *string                            `json:"provisioningState,omitempty"`
	ServiceBusEndpoint         *string                            `json:"serviceBusEndpoint,omitempty"`
	Sku                        *Sku_STATUS                        `json:"sku,omitempty"`
	Status                     *string                            `json:"status,omitempty"`
	SystemData                 *SystemData_STATUS                 `json:"systemData,omitempty"`
	Tags                       map[string]string                  `json:"tags,omitempty"`
	Type                       *string                            `json:"type,omitempty"`
	UpdatedAt                  *string                            `json:"updatedAt,omitempty"`
	ZoneRedundant              *bool                              `json:"zoneRedundant,omitempty"`
}

var _ genruntime.ConvertibleStatus = &Namespace_STATUS{}

// ConvertStatusFrom populates our Namespace_STATUS from the provided source
func (namespace *Namespace_STATUS) ConvertStatusFrom(source genruntime.ConvertibleStatus) error {
	src, ok := source.(*alpha20211101s.Namespace_STATUS)
	if ok {
		// Populate our instance from source
		return namespace.AssignProperties_From_Namespace_STATUS(src)
	}

	// Convert to an intermediate form
	src = &alpha20211101s.Namespace_STATUS{}
	err := src.ConvertStatusFrom(source)
	if err != nil {
		return errors.Wrap(err, "initial step of conversion in ConvertStatusFrom()")
	}

	// Update our instance from src
	err = namespace.AssignProperties_From_Namespace_STATUS(src)
	if err != nil {
		return errors.Wrap(err, "final step of conversion in ConvertStatusFrom()")
	}

	return nil
}

// ConvertStatusTo populates the provided destination from our Namespace_STATUS
func (namespace *Namespace_STATUS) ConvertStatusTo(destination genruntime.ConvertibleStatus) error {
	dst, ok := destination.(*alpha20211101s.Namespace_STATUS)
	if ok {
		// Populate destination from our instance
		return namespace.AssignProperties_To_Namespace_STATUS(dst)
	}

	// Convert to an intermediate form
	dst = &alpha20211101s.Namespace_STATUS{}
	err := namespace.AssignProperties_To_Namespace_STATUS(dst)
	if err != nil {
		return errors.Wrap(err, "initial step of conversion in ConvertStatusTo()")
	}

	// Update dst from our instance
	err = dst.ConvertStatusTo(destination)
	if err != nil {
		return errors.Wrap(err, "final step of conversion in ConvertStatusTo()")
	}

	return nil
}

var _ genruntime.FromARMConverter = &Namespace_STATUS{}

// NewEmptyARMValue returns an empty ARM value suitable for deserializing into
func (namespace *Namespace_STATUS) NewEmptyARMValue() genruntime.ARMResourceStatus {
	return &Namespace_STATUS_ARM{}
}

// PopulateFromARM populates a Kubernetes CRD object from an Azure ARM object
func (namespace *Namespace_STATUS) PopulateFromARM(owner genruntime.ArbitraryOwnerReference, armInput interface{}) error {
	typedInput, ok := armInput.(Namespace_STATUS_ARM)
	if !ok {
		return fmt.Errorf("unexpected type supplied for PopulateFromARM() function. Expected Namespace_STATUS_ARM, got %T", armInput)
	}

	// Set property ‘AlternateName’:
	// copying flattened property:
	if typedInput.Properties != nil {
		if typedInput.Properties.AlternateName != nil {
			alternateName := *typedInput.Properties.AlternateName
			namespace.AlternateName = &alternateName
		}
	}

	// Set property ‘ClusterArmId’:
	// copying flattened property:
	if typedInput.Properties != nil {
		if typedInput.Properties.ClusterArmId != nil {
			clusterArmId := *typedInput.Properties.ClusterArmId
			namespace.ClusterArmId = &clusterArmId
		}
	}

	// no assignment for property ‘Conditions’

	// Set property ‘CreatedAt’:
	// copying flattened property:
	if typedInput.Properties != nil {
		if typedInput.Properties.CreatedAt != nil {
			createdAt := *typedInput.Properties.CreatedAt
			namespace.CreatedAt = &createdAt
		}
	}

	// Set property ‘DisableLocalAuth’:
	// copying flattened property:
	if typedInput.Properties != nil {
		if typedInput.Properties.DisableLocalAuth != nil {
			disableLocalAuth := *typedInput.Properties.DisableLocalAuth
			namespace.DisableLocalAuth = &disableLocalAuth
		}
	}

	// Set property ‘Encryption’:
	// copying flattened property:
	if typedInput.Properties != nil {
		if typedInput.Properties.Encryption != nil {
			var encryption1 Encryption_STATUS
			err := encryption1.PopulateFromARM(owner, *typedInput.Properties.Encryption)
			if err != nil {
				return err
			}
			encryption := encryption1
			namespace.Encryption = &encryption
		}
	}

	// Set property ‘Id’:
	if typedInput.Id != nil {
		id := *typedInput.Id
		namespace.Id = &id
	}

	// Set property ‘Identity’:
	if typedInput.Identity != nil {
		var identity1 Identity_STATUS
		err := identity1.PopulateFromARM(owner, *typedInput.Identity)
		if err != nil {
			return err
		}
		identity := identity1
		namespace.Identity = &identity
	}

	// Set property ‘IsAutoInflateEnabled’:
	// copying flattened property:
	if typedInput.Properties != nil {
		if typedInput.Properties.IsAutoInflateEnabled != nil {
			isAutoInflateEnabled := *typedInput.Properties.IsAutoInflateEnabled
			namespace.IsAutoInflateEnabled = &isAutoInflateEnabled
		}
	}

	// Set property ‘KafkaEnabled’:
	// copying flattened property:
	if typedInput.Properties != nil {
		if typedInput.Properties.KafkaEnabled != nil {
			kafkaEnabled := *typedInput.Properties.KafkaEnabled
			namespace.KafkaEnabled = &kafkaEnabled
		}
	}

	// Set property ‘Location’:
	if typedInput.Location != nil {
		location := *typedInput.Location
		namespace.Location = &location
	}

	// Set property ‘MaximumThroughputUnits’:
	// copying flattened property:
	if typedInput.Properties != nil {
		if typedInput.Properties.MaximumThroughputUnits != nil {
			maximumThroughputUnits := *typedInput.Properties.MaximumThroughputUnits
			namespace.MaximumThroughputUnits = &maximumThroughputUnits
		}
	}

	// Set property ‘MetricId’:
	// copying flattened property:
	if typedInput.Properties != nil {
		if typedInput.Properties.MetricId != nil {
			metricId := *typedInput.Properties.MetricId
			namespace.MetricId = &metricId
		}
	}

	// Set property ‘Name’:
	if typedInput.Name != nil {
		name := *typedInput.Name
		namespace.Name = &name
	}

	// Set property ‘PrivateEndpointConnections’:
	// copying flattened property:
	if typedInput.Properties != nil {
		for _, item := range typedInput.Properties.PrivateEndpointConnections {
			var item1 PrivateEndpointConnection_STATUS
			err := item1.PopulateFromARM(owner, item)
			if err != nil {
				return err
			}
			namespace.PrivateEndpointConnections = append(namespace.PrivateEndpointConnections, item1)
		}
	}

	// Set property ‘ProvisioningState’:
	// copying flattened property:
	if typedInput.Properties != nil {
		if typedInput.Properties.ProvisioningState != nil {
			provisioningState := *typedInput.Properties.ProvisioningState
			namespace.ProvisioningState = &provisioningState
		}
	}

	// Set property ‘ServiceBusEndpoint’:
	// copying flattened property:
	if typedInput.Properties != nil {
		if typedInput.Properties.ServiceBusEndpoint != nil {
			serviceBusEndpoint := *typedInput.Properties.ServiceBusEndpoint
			namespace.ServiceBusEndpoint = &serviceBusEndpoint
		}
	}

	// Set property ‘Sku’:
	if typedInput.Sku != nil {
		var sku1 Sku_STATUS
		err := sku1.PopulateFromARM(owner, *typedInput.Sku)
		if err != nil {
			return err
		}
		sku := sku1
		namespace.Sku = &sku
	}

	// Set property ‘Status’:
	// copying flattened property:
	if typedInput.Properties != nil {
		if typedInput.Properties.Status != nil {
			status := *typedInput.Properties.Status
			namespace.Status = &status
		}
	}

	// Set property ‘SystemData’:
	if typedInput.SystemData != nil {
		var systemData1 SystemData_STATUS
		err := systemData1.PopulateFromARM(owner, *typedInput.SystemData)
		if err != nil {
			return err
		}
		systemData := systemData1
		namespace.SystemData = &systemData
	}

	// Set property ‘Tags’:
	if typedInput.Tags != nil {
		namespace.Tags = make(map[string]string, len(typedInput.Tags))
		for key, value := range typedInput.Tags {
			namespace.Tags[key] = value
		}
	}

	// Set property ‘Type’:
	if typedInput.Type != nil {
		typeVar := *typedInput.Type
		namespace.Type = &typeVar
	}

	// Set property ‘UpdatedAt’:
	// copying flattened property:
	if typedInput.Properties != nil {
		if typedInput.Properties.UpdatedAt != nil {
			updatedAt := *typedInput.Properties.UpdatedAt
			namespace.UpdatedAt = &updatedAt
		}
	}

	// Set property ‘ZoneRedundant’:
	// copying flattened property:
	if typedInput.Properties != nil {
		if typedInput.Properties.ZoneRedundant != nil {
			zoneRedundant := *typedInput.Properties.ZoneRedundant
			namespace.ZoneRedundant = &zoneRedundant
		}
	}

	// No error
	return nil
}

// AssignProperties_From_Namespace_STATUS populates our Namespace_STATUS from the provided source Namespace_STATUS
func (namespace *Namespace_STATUS) AssignProperties_From_Namespace_STATUS(source *alpha20211101s.Namespace_STATUS) error {

	// AlternateName
	namespace.AlternateName = genruntime.ClonePointerToString(source.AlternateName)

	// ClusterArmId
	namespace.ClusterArmId = genruntime.ClonePointerToString(source.ClusterArmId)

	// Conditions
	namespace.Conditions = genruntime.CloneSliceOfCondition(source.Conditions)

	// CreatedAt
	namespace.CreatedAt = genruntime.ClonePointerToString(source.CreatedAt)

	// DisableLocalAuth
	if source.DisableLocalAuth != nil {
		disableLocalAuth := *source.DisableLocalAuth
		namespace.DisableLocalAuth = &disableLocalAuth
	} else {
		namespace.DisableLocalAuth = nil
	}

	// Encryption
	if source.Encryption != nil {
		var encryption Encryption_STATUS
		err := encryption.AssignProperties_From_Encryption_STATUS(source.Encryption)
		if err != nil {
			return errors.Wrap(err, "calling AssignProperties_From_Encryption_STATUS() to populate field Encryption")
		}
		namespace.Encryption = &encryption
	} else {
		namespace.Encryption = nil
	}

	// Id
	namespace.Id = genruntime.ClonePointerToString(source.Id)

	// Identity
	if source.Identity != nil {
		var identity Identity_STATUS
		err := identity.AssignProperties_From_Identity_STATUS(source.Identity)
		if err != nil {
			return errors.Wrap(err, "calling AssignProperties_From_Identity_STATUS() to populate field Identity")
		}
		namespace.Identity = &identity
	} else {
		namespace.Identity = nil
	}

	// IsAutoInflateEnabled
	if source.IsAutoInflateEnabled != nil {
		isAutoInflateEnabled := *source.IsAutoInflateEnabled
		namespace.IsAutoInflateEnabled = &isAutoInflateEnabled
	} else {
		namespace.IsAutoInflateEnabled = nil
	}

	// KafkaEnabled
	if source.KafkaEnabled != nil {
		kafkaEnabled := *source.KafkaEnabled
		namespace.KafkaEnabled = &kafkaEnabled
	} else {
		namespace.KafkaEnabled = nil
	}

	// Location
	namespace.Location = genruntime.ClonePointerToString(source.Location)

	// MaximumThroughputUnits
	namespace.MaximumThroughputUnits = genruntime.ClonePointerToInt(source.MaximumThroughputUnits)

	// MetricId
	namespace.MetricId = genruntime.ClonePointerToString(source.MetricId)

	// Name
	namespace.Name = genruntime.ClonePointerToString(source.Name)

	// PrivateEndpointConnections
	if source.PrivateEndpointConnections != nil {
		privateEndpointConnectionList := make([]PrivateEndpointConnection_STATUS, len(source.PrivateEndpointConnections))
		for privateEndpointConnectionIndex, privateEndpointConnectionItem := range source.PrivateEndpointConnections {
			// Shadow the loop variable to avoid aliasing
			privateEndpointConnectionItem := privateEndpointConnectionItem
			var privateEndpointConnection PrivateEndpointConnection_STATUS
			err := privateEndpointConnection.AssignProperties_From_PrivateEndpointConnection_STATUS(&privateEndpointConnectionItem)
			if err != nil {
				return errors.Wrap(err, "calling AssignProperties_From_PrivateEndpointConnection_STATUS() to populate field PrivateEndpointConnections")
			}
			privateEndpointConnectionList[privateEndpointConnectionIndex] = privateEndpointConnection
		}
		namespace.PrivateEndpointConnections = privateEndpointConnectionList
	} else {
		namespace.PrivateEndpointConnections = nil
	}

	// ProvisioningState
	namespace.ProvisioningState = genruntime.ClonePointerToString(source.ProvisioningState)

	// ServiceBusEndpoint
	namespace.ServiceBusEndpoint = genruntime.ClonePointerToString(source.ServiceBusEndpoint)

	// Sku
	if source.Sku != nil {
		var sku Sku_STATUS
		err := sku.AssignProperties_From_Sku_STATUS(source.Sku)
		if err != nil {
			return errors.Wrap(err, "calling AssignProperties_From_Sku_STATUS() to populate field Sku")
		}
		namespace.Sku = &sku
	} else {
		namespace.Sku = nil
	}

	// Status
	namespace.Status = genruntime.ClonePointerToString(source.Status)

	// SystemData
	if source.SystemData != nil {
		var systemDatum SystemData_STATUS
		err := systemDatum.AssignProperties_From_SystemData_STATUS(source.SystemData)
		if err != nil {
			return errors.Wrap(err, "calling AssignProperties_From_SystemData_STATUS() to populate field SystemData")
		}
		namespace.SystemData = &systemDatum
	} else {
		namespace.SystemData = nil
	}

	// Tags
	namespace.Tags = genruntime.CloneMapOfStringToString(source.Tags)

	// Type
	namespace.Type = genruntime.ClonePointerToString(source.Type)

	// UpdatedAt
	namespace.UpdatedAt = genruntime.ClonePointerToString(source.UpdatedAt)

	// ZoneRedundant
	if source.ZoneRedundant != nil {
		zoneRedundant := *source.ZoneRedundant
		namespace.ZoneRedundant = &zoneRedundant
	} else {
		namespace.ZoneRedundant = nil
	}

	// No error
	return nil
}

// AssignProperties_To_Namespace_STATUS populates the provided destination Namespace_STATUS from our Namespace_STATUS
func (namespace *Namespace_STATUS) AssignProperties_To_Namespace_STATUS(destination *alpha20211101s.Namespace_STATUS) error {
	// Create a new property bag
	propertyBag := genruntime.NewPropertyBag()

	// AlternateName
	destination.AlternateName = genruntime.ClonePointerToString(namespace.AlternateName)

	// ClusterArmId
	destination.ClusterArmId = genruntime.ClonePointerToString(namespace.ClusterArmId)

	// Conditions
	destination.Conditions = genruntime.CloneSliceOfCondition(namespace.Conditions)

	// CreatedAt
	destination.CreatedAt = genruntime.ClonePointerToString(namespace.CreatedAt)

	// DisableLocalAuth
	if namespace.DisableLocalAuth != nil {
		disableLocalAuth := *namespace.DisableLocalAuth
		destination.DisableLocalAuth = &disableLocalAuth
	} else {
		destination.DisableLocalAuth = nil
	}

	// Encryption
	if namespace.Encryption != nil {
		var encryption alpha20211101s.Encryption_STATUS
		err := namespace.Encryption.AssignProperties_To_Encryption_STATUS(&encryption)
		if err != nil {
			return errors.Wrap(err, "calling AssignProperties_To_Encryption_STATUS() to populate field Encryption")
		}
		destination.Encryption = &encryption
	} else {
		destination.Encryption = nil
	}

	// Id
	destination.Id = genruntime.ClonePointerToString(namespace.Id)

	// Identity
	if namespace.Identity != nil {
		var identity alpha20211101s.Identity_STATUS
		err := namespace.Identity.AssignProperties_To_Identity_STATUS(&identity)
		if err != nil {
			return errors.Wrap(err, "calling AssignProperties_To_Identity_STATUS() to populate field Identity")
		}
		destination.Identity = &identity
	} else {
		destination.Identity = nil
	}

	// IsAutoInflateEnabled
	if namespace.IsAutoInflateEnabled != nil {
		isAutoInflateEnabled := *namespace.IsAutoInflateEnabled
		destination.IsAutoInflateEnabled = &isAutoInflateEnabled
	} else {
		destination.IsAutoInflateEnabled = nil
	}

	// KafkaEnabled
	if namespace.KafkaEnabled != nil {
		kafkaEnabled := *namespace.KafkaEnabled
		destination.KafkaEnabled = &kafkaEnabled
	} else {
		destination.KafkaEnabled = nil
	}

	// Location
	destination.Location = genruntime.ClonePointerToString(namespace.Location)

	// MaximumThroughputUnits
	destination.MaximumThroughputUnits = genruntime.ClonePointerToInt(namespace.MaximumThroughputUnits)

	// MetricId
	destination.MetricId = genruntime.ClonePointerToString(namespace.MetricId)

	// Name
	destination.Name = genruntime.ClonePointerToString(namespace.Name)

	// PrivateEndpointConnections
	if namespace.PrivateEndpointConnections != nil {
		privateEndpointConnectionList := make([]alpha20211101s.PrivateEndpointConnection_STATUS, len(namespace.PrivateEndpointConnections))
		for privateEndpointConnectionIndex, privateEndpointConnectionItem := range namespace.PrivateEndpointConnections {
			// Shadow the loop variable to avoid aliasing
			privateEndpointConnectionItem := privateEndpointConnectionItem
			var privateEndpointConnection alpha20211101s.PrivateEndpointConnection_STATUS
			err := privateEndpointConnectionItem.AssignProperties_To_PrivateEndpointConnection_STATUS(&privateEndpointConnection)
			if err != nil {
				return errors.Wrap(err, "calling AssignProperties_To_PrivateEndpointConnection_STATUS() to populate field PrivateEndpointConnections")
			}
			privateEndpointConnectionList[privateEndpointConnectionIndex] = privateEndpointConnection
		}
		destination.PrivateEndpointConnections = privateEndpointConnectionList
	} else {
		destination.PrivateEndpointConnections = nil
	}

	// ProvisioningState
	destination.ProvisioningState = genruntime.ClonePointerToString(namespace.ProvisioningState)

	// ServiceBusEndpoint
	destination.ServiceBusEndpoint = genruntime.ClonePointerToString(namespace.ServiceBusEndpoint)

	// Sku
	if namespace.Sku != nil {
		var sku alpha20211101s.Sku_STATUS
		err := namespace.Sku.AssignProperties_To_Sku_STATUS(&sku)
		if err != nil {
			return errors.Wrap(err, "calling AssignProperties_To_Sku_STATUS() to populate field Sku")
		}
		destination.Sku = &sku
	} else {
		destination.Sku = nil
	}

	// Status
	destination.Status = genruntime.ClonePointerToString(namespace.Status)

	// SystemData
	if namespace.SystemData != nil {
		var systemDatum alpha20211101s.SystemData_STATUS
		err := namespace.SystemData.AssignProperties_To_SystemData_STATUS(&systemDatum)
		if err != nil {
			return errors.Wrap(err, "calling AssignProperties_To_SystemData_STATUS() to populate field SystemData")
		}
		destination.SystemData = &systemDatum
	} else {
		destination.SystemData = nil
	}

	// Tags
	destination.Tags = genruntime.CloneMapOfStringToString(namespace.Tags)

	// Type
	destination.Type = genruntime.ClonePointerToString(namespace.Type)

	// UpdatedAt
	destination.UpdatedAt = genruntime.ClonePointerToString(namespace.UpdatedAt)

	// ZoneRedundant
	if namespace.ZoneRedundant != nil {
		zoneRedundant := *namespace.ZoneRedundant
		destination.ZoneRedundant = &zoneRedundant
	} else {
		destination.ZoneRedundant = nil
	}

	// Update the property bag
	if len(propertyBag) > 0 {
		destination.PropertyBag = propertyBag
	} else {
		destination.PropertyBag = nil
	}

	// No error
	return nil
}

// Deprecated version of Encryption. Use v1beta20211101.Encryption instead
type Encryption struct {
	KeySource                       *Encryption_KeySource `json:"keySource,omitempty"`
	KeyVaultProperties              []KeyVaultProperties  `json:"keyVaultProperties,omitempty"`
	RequireInfrastructureEncryption *bool                 `json:"requireInfrastructureEncryption,omitempty"`
}

var _ genruntime.ARMTransformer = &Encryption{}

// ConvertToARM converts from a Kubernetes CRD object to an ARM object
func (encryption *Encryption) ConvertToARM(resolved genruntime.ConvertToARMResolvedDetails) (interface{}, error) {
	if encryption == nil {
		return nil, nil
	}
	result := &Encryption_ARM{}

	// Set property ‘KeySource’:
	if encryption.KeySource != nil {
		keySource := *encryption.KeySource
		result.KeySource = &keySource
	}

	// Set property ‘KeyVaultProperties’:
	for _, item := range encryption.KeyVaultProperties {
		item_ARM, err := item.ConvertToARM(resolved)
		if err != nil {
			return nil, err
		}
		result.KeyVaultProperties = append(result.KeyVaultProperties, *item_ARM.(*KeyVaultProperties_ARM))
	}

	// Set property ‘RequireInfrastructureEncryption’:
	if encryption.RequireInfrastructureEncryption != nil {
		requireInfrastructureEncryption := *encryption.RequireInfrastructureEncryption
		result.RequireInfrastructureEncryption = &requireInfrastructureEncryption
	}
	return result, nil
}

// NewEmptyARMValue returns an empty ARM value suitable for deserializing into
func (encryption *Encryption) NewEmptyARMValue() genruntime.ARMResourceStatus {
	return &Encryption_ARM{}
}

// PopulateFromARM populates a Kubernetes CRD object from an Azure ARM object
func (encryption *Encryption) PopulateFromARM(owner genruntime.ArbitraryOwnerReference, armInput interface{}) error {
	typedInput, ok := armInput.(Encryption_ARM)
	if !ok {
		return fmt.Errorf("unexpected type supplied for PopulateFromARM() function. Expected Encryption_ARM, got %T", armInput)
	}

	// Set property ‘KeySource’:
	if typedInput.KeySource != nil {
		keySource := *typedInput.KeySource
		encryption.KeySource = &keySource
	}

	// Set property ‘KeyVaultProperties’:
	for _, item := range typedInput.KeyVaultProperties {
		var item1 KeyVaultProperties
		err := item1.PopulateFromARM(owner, item)
		if err != nil {
			return err
		}
		encryption.KeyVaultProperties = append(encryption.KeyVaultProperties, item1)
	}

	// Set property ‘RequireInfrastructureEncryption’:
	if typedInput.RequireInfrastructureEncryption != nil {
		requireInfrastructureEncryption := *typedInput.RequireInfrastructureEncryption
		encryption.RequireInfrastructureEncryption = &requireInfrastructureEncryption
	}

	// No error
	return nil
}

// AssignProperties_From_Encryption populates our Encryption from the provided source Encryption
func (encryption *Encryption) AssignProperties_From_Encryption(source *alpha20211101s.Encryption) error {

	// KeySource
	if source.KeySource != nil {
		keySource := Encryption_KeySource(*source.KeySource)
		encryption.KeySource = &keySource
	} else {
		encryption.KeySource = nil
	}

	// KeyVaultProperties
	if source.KeyVaultProperties != nil {
		keyVaultPropertyList := make([]KeyVaultProperties, len(source.KeyVaultProperties))
		for keyVaultPropertyIndex, keyVaultPropertyItem := range source.KeyVaultProperties {
			// Shadow the loop variable to avoid aliasing
			keyVaultPropertyItem := keyVaultPropertyItem
			var keyVaultProperty KeyVaultProperties
			err := keyVaultProperty.AssignProperties_From_KeyVaultProperties(&keyVaultPropertyItem)
			if err != nil {
				return errors.Wrap(err, "calling AssignProperties_From_KeyVaultProperties() to populate field KeyVaultProperties")
			}
			keyVaultPropertyList[keyVaultPropertyIndex] = keyVaultProperty
		}
		encryption.KeyVaultProperties = keyVaultPropertyList
	} else {
		encryption.KeyVaultProperties = nil
	}

	// RequireInfrastructureEncryption
	if source.RequireInfrastructureEncryption != nil {
		requireInfrastructureEncryption := *source.RequireInfrastructureEncryption
		encryption.RequireInfrastructureEncryption = &requireInfrastructureEncryption
	} else {
		encryption.RequireInfrastructureEncryption = nil
	}

	// No error
	return nil
}

// AssignProperties_To_Encryption populates the provided destination Encryption from our Encryption
func (encryption *Encryption) AssignProperties_To_Encryption(destination *alpha20211101s.Encryption) error {
	// Create a new property bag
	propertyBag := genruntime.NewPropertyBag()

	// KeySource
	if encryption.KeySource != nil {
		keySource := string(*encryption.KeySource)
		destination.KeySource = &keySource
	} else {
		destination.KeySource = nil
	}

	// KeyVaultProperties
	if encryption.KeyVaultProperties != nil {
		keyVaultPropertyList := make([]alpha20211101s.KeyVaultProperties, len(encryption.KeyVaultProperties))
		for keyVaultPropertyIndex, keyVaultPropertyItem := range encryption.KeyVaultProperties {
			// Shadow the loop variable to avoid aliasing
			keyVaultPropertyItem := keyVaultPropertyItem
			var keyVaultProperty alpha20211101s.KeyVaultProperties
			err := keyVaultPropertyItem.AssignProperties_To_KeyVaultProperties(&keyVaultProperty)
			if err != nil {
				return errors.Wrap(err, "calling AssignProperties_To_KeyVaultProperties() to populate field KeyVaultProperties")
			}
			keyVaultPropertyList[keyVaultPropertyIndex] = keyVaultProperty
		}
		destination.KeyVaultProperties = keyVaultPropertyList
	} else {
		destination.KeyVaultProperties = nil
	}

	// RequireInfrastructureEncryption
	if encryption.RequireInfrastructureEncryption != nil {
		requireInfrastructureEncryption := *encryption.RequireInfrastructureEncryption
		destination.RequireInfrastructureEncryption = &requireInfrastructureEncryption
	} else {
		destination.RequireInfrastructureEncryption = nil
	}

	// Update the property bag
	if len(propertyBag) > 0 {
		destination.PropertyBag = propertyBag
	} else {
		destination.PropertyBag = nil
	}

	// No error
	return nil
}

// Deprecated version of Encryption_STATUS. Use v1beta20211101.Encryption_STATUS instead
type Encryption_STATUS struct {
	KeySource                       *Encryption_KeySource_STATUS `json:"keySource,omitempty"`
	KeyVaultProperties              []KeyVaultProperties_STATUS  `json:"keyVaultProperties,omitempty"`
	RequireInfrastructureEncryption *bool                        `json:"requireInfrastructureEncryption,omitempty"`
}

var _ genruntime.FromARMConverter = &Encryption_STATUS{}

// NewEmptyARMValue returns an empty ARM value suitable for deserializing into
func (encryption *Encryption_STATUS) NewEmptyARMValue() genruntime.ARMResourceStatus {
	return &Encryption_STATUS_ARM{}
}

// PopulateFromARM populates a Kubernetes CRD object from an Azure ARM object
func (encryption *Encryption_STATUS) PopulateFromARM(owner genruntime.ArbitraryOwnerReference, armInput interface{}) error {
	typedInput, ok := armInput.(Encryption_STATUS_ARM)
	if !ok {
		return fmt.Errorf("unexpected type supplied for PopulateFromARM() function. Expected Encryption_STATUS_ARM, got %T", armInput)
	}

	// Set property ‘KeySource’:
	if typedInput.KeySource != nil {
		keySource := *typedInput.KeySource
		encryption.KeySource = &keySource
	}

	// Set property ‘KeyVaultProperties’:
	for _, item := range typedInput.KeyVaultProperties {
		var item1 KeyVaultProperties_STATUS
		err := item1.PopulateFromARM(owner, item)
		if err != nil {
			return err
		}
		encryption.KeyVaultProperties = append(encryption.KeyVaultProperties, item1)
	}

	// Set property ‘RequireInfrastructureEncryption’:
	if typedInput.RequireInfrastructureEncryption != nil {
		requireInfrastructureEncryption := *typedInput.RequireInfrastructureEncryption
		encryption.RequireInfrastructureEncryption = &requireInfrastructureEncryption
	}

	// No error
	return nil
}

// AssignProperties_From_Encryption_STATUS populates our Encryption_STATUS from the provided source Encryption_STATUS
func (encryption *Encryption_STATUS) AssignProperties_From_Encryption_STATUS(source *alpha20211101s.Encryption_STATUS) error {

	// KeySource
	if source.KeySource != nil {
		keySource := Encryption_KeySource_STATUS(*source.KeySource)
		encryption.KeySource = &keySource
	} else {
		encryption.KeySource = nil
	}

	// KeyVaultProperties
	if source.KeyVaultProperties != nil {
		keyVaultPropertyList := make([]KeyVaultProperties_STATUS, len(source.KeyVaultProperties))
		for keyVaultPropertyIndex, keyVaultPropertyItem := range source.KeyVaultProperties {
			// Shadow the loop variable to avoid aliasing
			keyVaultPropertyItem := keyVaultPropertyItem
			var keyVaultProperty KeyVaultProperties_STATUS
			err := keyVaultProperty.AssignProperties_From_KeyVaultProperties_STATUS(&keyVaultPropertyItem)
			if err != nil {
				return errors.Wrap(err, "calling AssignProperties_From_KeyVaultProperties_STATUS() to populate field KeyVaultProperties")
			}
			keyVaultPropertyList[keyVaultPropertyIndex] = keyVaultProperty
		}
		encryption.KeyVaultProperties = keyVaultPropertyList
	} else {
		encryption.KeyVaultProperties = nil
	}

	// RequireInfrastructureEncryption
	if source.RequireInfrastructureEncryption != nil {
		requireInfrastructureEncryption := *source.RequireInfrastructureEncryption
		encryption.RequireInfrastructureEncryption = &requireInfrastructureEncryption
	} else {
		encryption.RequireInfrastructureEncryption = nil
	}

	// No error
	return nil
}

// AssignProperties_To_Encryption_STATUS populates the provided destination Encryption_STATUS from our Encryption_STATUS
func (encryption *Encryption_STATUS) AssignProperties_To_Encryption_STATUS(destination *alpha20211101s.Encryption_STATUS) error {
	// Create a new property bag
	propertyBag := genruntime.NewPropertyBag()

	// KeySource
	if encryption.KeySource != nil {
		keySource := string(*encryption.KeySource)
		destination.KeySource = &keySource
	} else {
		destination.KeySource = nil
	}

	// KeyVaultProperties
	if encryption.KeyVaultProperties != nil {
		keyVaultPropertyList := make([]alpha20211101s.KeyVaultProperties_STATUS, len(encryption.KeyVaultProperties))
		for keyVaultPropertyIndex, keyVaultPropertyItem := range encryption.KeyVaultProperties {
			// Shadow the loop variable to avoid aliasing
			keyVaultPropertyItem := keyVaultPropertyItem
			var keyVaultProperty alpha20211101s.KeyVaultProperties_STATUS
			err := keyVaultPropertyItem.AssignProperties_To_KeyVaultProperties_STATUS(&keyVaultProperty)
			if err != nil {
				return errors.Wrap(err, "calling AssignProperties_To_KeyVaultProperties_STATUS() to populate field KeyVaultProperties")
			}
			keyVaultPropertyList[keyVaultPropertyIndex] = keyVaultProperty
		}
		destination.KeyVaultProperties = keyVaultPropertyList
	} else {
		destination.KeyVaultProperties = nil
	}

	// RequireInfrastructureEncryption
	if encryption.RequireInfrastructureEncryption != nil {
		requireInfrastructureEncryption := *encryption.RequireInfrastructureEncryption
		destination.RequireInfrastructureEncryption = &requireInfrastructureEncryption
	} else {
		destination.RequireInfrastructureEncryption = nil
	}

	// Update the property bag
	if len(propertyBag) > 0 {
		destination.PropertyBag = propertyBag
	} else {
		destination.PropertyBag = nil
	}

	// No error
	return nil
}

// Deprecated version of Identity. Use v1beta20211101.Identity instead
type Identity struct {
	Type *Identity_Type `json:"type,omitempty"`
}

var _ genruntime.ARMTransformer = &Identity{}

// ConvertToARM converts from a Kubernetes CRD object to an ARM object
func (identity *Identity) ConvertToARM(resolved genruntime.ConvertToARMResolvedDetails) (interface{}, error) {
	if identity == nil {
		return nil, nil
	}
	result := &Identity_ARM{}

	// Set property ‘Type’:
	if identity.Type != nil {
		typeVar := *identity.Type
		result.Type = &typeVar
	}
	return result, nil
}

// NewEmptyARMValue returns an empty ARM value suitable for deserializing into
func (identity *Identity) NewEmptyARMValue() genruntime.ARMResourceStatus {
	return &Identity_ARM{}
}

// PopulateFromARM populates a Kubernetes CRD object from an Azure ARM object
func (identity *Identity) PopulateFromARM(owner genruntime.ArbitraryOwnerReference, armInput interface{}) error {
	typedInput, ok := armInput.(Identity_ARM)
	if !ok {
		return fmt.Errorf("unexpected type supplied for PopulateFromARM() function. Expected Identity_ARM, got %T", armInput)
	}

	// Set property ‘Type’:
	if typedInput.Type != nil {
		typeVar := *typedInput.Type
		identity.Type = &typeVar
	}

	// No error
	return nil
}

// AssignProperties_From_Identity populates our Identity from the provided source Identity
func (identity *Identity) AssignProperties_From_Identity(source *alpha20211101s.Identity) error {

	// Type
	if source.Type != nil {
		typeVar := Identity_Type(*source.Type)
		identity.Type = &typeVar
	} else {
		identity.Type = nil
	}

	// No error
	return nil
}

// AssignProperties_To_Identity populates the provided destination Identity from our Identity
func (identity *Identity) AssignProperties_To_Identity(destination *alpha20211101s.Identity) error {
	// Create a new property bag
	propertyBag := genruntime.NewPropertyBag()

	// Type
	if identity.Type != nil {
		typeVar := string(*identity.Type)
		destination.Type = &typeVar
	} else {
		destination.Type = nil
	}

	// Update the property bag
	if len(propertyBag) > 0 {
		destination.PropertyBag = propertyBag
	} else {
		destination.PropertyBag = nil
	}

	// No error
	return nil
}

// Deprecated version of Identity_STATUS. Use v1beta20211101.Identity_STATUS instead
type Identity_STATUS struct {
	PrincipalId            *string                                `json:"principalId,omitempty"`
	TenantId               *string                                `json:"tenantId,omitempty"`
	Type                   *Identity_Type_STATUS                  `json:"type,omitempty"`
	UserAssignedIdentities map[string]UserAssignedIdentity_STATUS `json:"userAssignedIdentities,omitempty"`
}

var _ genruntime.FromARMConverter = &Identity_STATUS{}

// NewEmptyARMValue returns an empty ARM value suitable for deserializing into
func (identity *Identity_STATUS) NewEmptyARMValue() genruntime.ARMResourceStatus {
	return &Identity_STATUS_ARM{}
}

// PopulateFromARM populates a Kubernetes CRD object from an Azure ARM object
func (identity *Identity_STATUS) PopulateFromARM(owner genruntime.ArbitraryOwnerReference, armInput interface{}) error {
	typedInput, ok := armInput.(Identity_STATUS_ARM)
	if !ok {
		return fmt.Errorf("unexpected type supplied for PopulateFromARM() function. Expected Identity_STATUS_ARM, got %T", armInput)
	}

	// Set property ‘PrincipalId’:
	if typedInput.PrincipalId != nil {
		principalId := *typedInput.PrincipalId
		identity.PrincipalId = &principalId
	}

	// Set property ‘TenantId’:
	if typedInput.TenantId != nil {
		tenantId := *typedInput.TenantId
		identity.TenantId = &tenantId
	}

	// Set property ‘Type’:
	if typedInput.Type != nil {
		typeVar := *typedInput.Type
		identity.Type = &typeVar
	}

	// Set property ‘UserAssignedIdentities’:
	if typedInput.UserAssignedIdentities != nil {
		identity.UserAssignedIdentities = make(map[string]UserAssignedIdentity_STATUS, len(typedInput.UserAssignedIdentities))
		for key, value := range typedInput.UserAssignedIdentities {
			var value1 UserAssignedIdentity_STATUS
			err := value1.PopulateFromARM(owner, value)
			if err != nil {
				return err
			}
			identity.UserAssignedIdentities[key] = value1
		}
	}

	// No error
	return nil
}

// AssignProperties_From_Identity_STATUS populates our Identity_STATUS from the provided source Identity_STATUS
func (identity *Identity_STATUS) AssignProperties_From_Identity_STATUS(source *alpha20211101s.Identity_STATUS) error {

	// PrincipalId
	identity.PrincipalId = genruntime.ClonePointerToString(source.PrincipalId)

	// TenantId
	identity.TenantId = genruntime.ClonePointerToString(source.TenantId)

	// Type
	if source.Type != nil {
		typeVar := Identity_Type_STATUS(*source.Type)
		identity.Type = &typeVar
	} else {
		identity.Type = nil
	}

	// UserAssignedIdentities
	if source.UserAssignedIdentities != nil {
		userAssignedIdentityMap := make(map[string]UserAssignedIdentity_STATUS, len(source.UserAssignedIdentities))
		for userAssignedIdentityKey, userAssignedIdentityValue := range source.UserAssignedIdentities {
			// Shadow the loop variable to avoid aliasing
			userAssignedIdentityValue := userAssignedIdentityValue
			var userAssignedIdentity UserAssignedIdentity_STATUS
			err := userAssignedIdentity.AssignProperties_From_UserAssignedIdentity_STATUS(&userAssignedIdentityValue)
			if err != nil {
				return errors.Wrap(err, "calling AssignProperties_From_UserAssignedIdentity_STATUS() to populate field UserAssignedIdentities")
			}
			userAssignedIdentityMap[userAssignedIdentityKey] = userAssignedIdentity
		}
		identity.UserAssignedIdentities = userAssignedIdentityMap
	} else {
		identity.UserAssignedIdentities = nil
	}

	// No error
	return nil
}

// AssignProperties_To_Identity_STATUS populates the provided destination Identity_STATUS from our Identity_STATUS
func (identity *Identity_STATUS) AssignProperties_To_Identity_STATUS(destination *alpha20211101s.Identity_STATUS) error {
	// Create a new property bag
	propertyBag := genruntime.NewPropertyBag()

	// PrincipalId
	destination.PrincipalId = genruntime.ClonePointerToString(identity.PrincipalId)

	// TenantId
	destination.TenantId = genruntime.ClonePointerToString(identity.TenantId)

	// Type
	if identity.Type != nil {
		typeVar := string(*identity.Type)
		destination.Type = &typeVar
	} else {
		destination.Type = nil
	}

	// UserAssignedIdentities
	if identity.UserAssignedIdentities != nil {
		userAssignedIdentityMap := make(map[string]alpha20211101s.UserAssignedIdentity_STATUS, len(identity.UserAssignedIdentities))
		for userAssignedIdentityKey, userAssignedIdentityValue := range identity.UserAssignedIdentities {
			// Shadow the loop variable to avoid aliasing
			userAssignedIdentityValue := userAssignedIdentityValue
			var userAssignedIdentity alpha20211101s.UserAssignedIdentity_STATUS
			err := userAssignedIdentityValue.AssignProperties_To_UserAssignedIdentity_STATUS(&userAssignedIdentity)
			if err != nil {
				return errors.Wrap(err, "calling AssignProperties_To_UserAssignedIdentity_STATUS() to populate field UserAssignedIdentities")
			}
			userAssignedIdentityMap[userAssignedIdentityKey] = userAssignedIdentity
		}
		destination.UserAssignedIdentities = userAssignedIdentityMap
	} else {
		destination.UserAssignedIdentities = nil
	}

	// Update the property bag
	if len(propertyBag) > 0 {
		destination.PropertyBag = propertyBag
	} else {
		destination.PropertyBag = nil
	}

	// No error
	return nil
}

// Deprecated version of PrivateEndpointConnection_STATUS. Use v1beta20211101.PrivateEndpointConnection_STATUS instead
type PrivateEndpointConnection_STATUS struct {
	Id *string `json:"id,omitempty"`
}

var _ genruntime.FromARMConverter = &PrivateEndpointConnection_STATUS{}

// NewEmptyARMValue returns an empty ARM value suitable for deserializing into
func (connection *PrivateEndpointConnection_STATUS) NewEmptyARMValue() genruntime.ARMResourceStatus {
	return &PrivateEndpointConnection_STATUS_ARM{}
}

// PopulateFromARM populates a Kubernetes CRD object from an Azure ARM object
func (connection *PrivateEndpointConnection_STATUS) PopulateFromARM(owner genruntime.ArbitraryOwnerReference, armInput interface{}) error {
	typedInput, ok := armInput.(PrivateEndpointConnection_STATUS_ARM)
	if !ok {
		return fmt.Errorf("unexpected type supplied for PopulateFromARM() function. Expected PrivateEndpointConnection_STATUS_ARM, got %T", armInput)
	}

	// Set property ‘Id’:
	if typedInput.Id != nil {
		id := *typedInput.Id
		connection.Id = &id
	}

	// No error
	return nil
}

// AssignProperties_From_PrivateEndpointConnection_STATUS populates our PrivateEndpointConnection_STATUS from the provided source PrivateEndpointConnection_STATUS
func (connection *PrivateEndpointConnection_STATUS) AssignProperties_From_PrivateEndpointConnection_STATUS(source *alpha20211101s.PrivateEndpointConnection_STATUS) error {

	// Id
	connection.Id = genruntime.ClonePointerToString(source.Id)

	// No error
	return nil
}

// AssignProperties_To_PrivateEndpointConnection_STATUS populates the provided destination PrivateEndpointConnection_STATUS from our PrivateEndpointConnection_STATUS
func (connection *PrivateEndpointConnection_STATUS) AssignProperties_To_PrivateEndpointConnection_STATUS(destination *alpha20211101s.PrivateEndpointConnection_STATUS) error {
	// Create a new property bag
	propertyBag := genruntime.NewPropertyBag()

	// Id
	destination.Id = genruntime.ClonePointerToString(connection.Id)

	// Update the property bag
	if len(propertyBag) > 0 {
		destination.PropertyBag = propertyBag
	} else {
		destination.PropertyBag = nil
	}

	// No error
	return nil
}

// Deprecated version of Sku. Use v1beta20211101.Sku instead
type Sku struct {
	// +kubebuilder:validation:Minimum=0
	Capacity *int `json:"capacity,omitempty"`

	// +kubebuilder:validation:Required
	Name *Sku_Name `json:"name,omitempty"`
	Tier *Sku_Tier `json:"tier,omitempty"`
}

var _ genruntime.ARMTransformer = &Sku{}

// ConvertToARM converts from a Kubernetes CRD object to an ARM object
func (sku *Sku) ConvertToARM(resolved genruntime.ConvertToARMResolvedDetails) (interface{}, error) {
	if sku == nil {
		return nil, nil
	}
	result := &Sku_ARM{}

	// Set property ‘Capacity’:
	if sku.Capacity != nil {
		capacity := *sku.Capacity
		result.Capacity = &capacity
	}

	// Set property ‘Name’:
	if sku.Name != nil {
		name := *sku.Name
		result.Name = &name
	}

	// Set property ‘Tier’:
	if sku.Tier != nil {
		tier := *sku.Tier
		result.Tier = &tier
	}
	return result, nil
}

// NewEmptyARMValue returns an empty ARM value suitable for deserializing into
func (sku *Sku) NewEmptyARMValue() genruntime.ARMResourceStatus {
	return &Sku_ARM{}
}

// PopulateFromARM populates a Kubernetes CRD object from an Azure ARM object
func (sku *Sku) PopulateFromARM(owner genruntime.ArbitraryOwnerReference, armInput interface{}) error {
	typedInput, ok := armInput.(Sku_ARM)
	if !ok {
		return fmt.Errorf("unexpected type supplied for PopulateFromARM() function. Expected Sku_ARM, got %T", armInput)
	}

	// Set property ‘Capacity’:
	if typedInput.Capacity != nil {
		capacity := *typedInput.Capacity
		sku.Capacity = &capacity
	}

	// Set property ‘Name’:
	if typedInput.Name != nil {
		name := *typedInput.Name
		sku.Name = &name
	}

	// Set property ‘Tier’:
	if typedInput.Tier != nil {
		tier := *typedInput.Tier
		sku.Tier = &tier
	}

	// No error
	return nil
}

// AssignProperties_From_Sku populates our Sku from the provided source Sku
func (sku *Sku) AssignProperties_From_Sku(source *alpha20211101s.Sku) error {

	// Capacity
	if source.Capacity != nil {
		capacity := *source.Capacity
		sku.Capacity = &capacity
	} else {
		sku.Capacity = nil
	}

	// Name
	if source.Name != nil {
		name := Sku_Name(*source.Name)
		sku.Name = &name
	} else {
		sku.Name = nil
	}

	// Tier
	if source.Tier != nil {
		tier := Sku_Tier(*source.Tier)
		sku.Tier = &tier
	} else {
		sku.Tier = nil
	}

	// No error
	return nil
}

// AssignProperties_To_Sku populates the provided destination Sku from our Sku
func (sku *Sku) AssignProperties_To_Sku(destination *alpha20211101s.Sku) error {
	// Create a new property bag
	propertyBag := genruntime.NewPropertyBag()

	// Capacity
	if sku.Capacity != nil {
		capacity := *sku.Capacity
		destination.Capacity = &capacity
	} else {
		destination.Capacity = nil
	}

	// Name
	if sku.Name != nil {
		name := string(*sku.Name)
		destination.Name = &name
	} else {
		destination.Name = nil
	}

	// Tier
	if sku.Tier != nil {
		tier := string(*sku.Tier)
		destination.Tier = &tier
	} else {
		destination.Tier = nil
	}

	// Update the property bag
	if len(propertyBag) > 0 {
		destination.PropertyBag = propertyBag
	} else {
		destination.PropertyBag = nil
	}

	// No error
	return nil
}

// Deprecated version of Sku_STATUS. Use v1beta20211101.Sku_STATUS instead
type Sku_STATUS struct {
	Capacity *int             `json:"capacity,omitempty"`
	Name     *Sku_Name_STATUS `json:"name,omitempty"`
	Tier     *Sku_Tier_STATUS `json:"tier,omitempty"`
}

var _ genruntime.FromARMConverter = &Sku_STATUS{}

// NewEmptyARMValue returns an empty ARM value suitable for deserializing into
func (sku *Sku_STATUS) NewEmptyARMValue() genruntime.ARMResourceStatus {
	return &Sku_STATUS_ARM{}
}

// PopulateFromARM populates a Kubernetes CRD object from an Azure ARM object
func (sku *Sku_STATUS) PopulateFromARM(owner genruntime.ArbitraryOwnerReference, armInput interface{}) error {
	typedInput, ok := armInput.(Sku_STATUS_ARM)
	if !ok {
		return fmt.Errorf("unexpected type supplied for PopulateFromARM() function. Expected Sku_STATUS_ARM, got %T", armInput)
	}

	// Set property ‘Capacity’:
	if typedInput.Capacity != nil {
		capacity := *typedInput.Capacity
		sku.Capacity = &capacity
	}

	// Set property ‘Name’:
	if typedInput.Name != nil {
		name := *typedInput.Name
		sku.Name = &name
	}

	// Set property ‘Tier’:
	if typedInput.Tier != nil {
		tier := *typedInput.Tier
		sku.Tier = &tier
	}

	// No error
	return nil
}

// AssignProperties_From_Sku_STATUS populates our Sku_STATUS from the provided source Sku_STATUS
func (sku *Sku_STATUS) AssignProperties_From_Sku_STATUS(source *alpha20211101s.Sku_STATUS) error {

	// Capacity
	sku.Capacity = genruntime.ClonePointerToInt(source.Capacity)

	// Name
	if source.Name != nil {
		name := Sku_Name_STATUS(*source.Name)
		sku.Name = &name
	} else {
		sku.Name = nil
	}

	// Tier
	if source.Tier != nil {
		tier := Sku_Tier_STATUS(*source.Tier)
		sku.Tier = &tier
	} else {
		sku.Tier = nil
	}

	// No error
	return nil
}

// AssignProperties_To_Sku_STATUS populates the provided destination Sku_STATUS from our Sku_STATUS
func (sku *Sku_STATUS) AssignProperties_To_Sku_STATUS(destination *alpha20211101s.Sku_STATUS) error {
	// Create a new property bag
	propertyBag := genruntime.NewPropertyBag()

	// Capacity
	destination.Capacity = genruntime.ClonePointerToInt(sku.Capacity)

	// Name
	if sku.Name != nil {
		name := string(*sku.Name)
		destination.Name = &name
	} else {
		destination.Name = nil
	}

	// Tier
	if sku.Tier != nil {
		tier := string(*sku.Tier)
		destination.Tier = &tier
	} else {
		destination.Tier = nil
	}

	// Update the property bag
	if len(propertyBag) > 0 {
		destination.PropertyBag = propertyBag
	} else {
		destination.PropertyBag = nil
	}

	// No error
	return nil
}

// Deprecated version of SystemData_STATUS. Use v1beta20211101.SystemData_STATUS instead
type SystemData_STATUS struct {
	CreatedAt          *string                               `json:"createdAt,omitempty"`
	CreatedBy          *string                               `json:"createdBy,omitempty"`
	CreatedByType      *SystemData_CreatedByType_STATUS      `json:"createdByType,omitempty"`
	LastModifiedAt     *string                               `json:"lastModifiedAt,omitempty"`
	LastModifiedBy     *string                               `json:"lastModifiedBy,omitempty"`
	LastModifiedByType *SystemData_LastModifiedByType_STATUS `json:"lastModifiedByType,omitempty"`
}

var _ genruntime.FromARMConverter = &SystemData_STATUS{}

// NewEmptyARMValue returns an empty ARM value suitable for deserializing into
func (data *SystemData_STATUS) NewEmptyARMValue() genruntime.ARMResourceStatus {
	return &SystemData_STATUS_ARM{}
}

// PopulateFromARM populates a Kubernetes CRD object from an Azure ARM object
func (data *SystemData_STATUS) PopulateFromARM(owner genruntime.ArbitraryOwnerReference, armInput interface{}) error {
	typedInput, ok := armInput.(SystemData_STATUS_ARM)
	if !ok {
		return fmt.Errorf("unexpected type supplied for PopulateFromARM() function. Expected SystemData_STATUS_ARM, got %T", armInput)
	}

	// Set property ‘CreatedAt’:
	if typedInput.CreatedAt != nil {
		createdAt := *typedInput.CreatedAt
		data.CreatedAt = &createdAt
	}

	// Set property ‘CreatedBy’:
	if typedInput.CreatedBy != nil {
		createdBy := *typedInput.CreatedBy
		data.CreatedBy = &createdBy
	}

	// Set property ‘CreatedByType’:
	if typedInput.CreatedByType != nil {
		createdByType := *typedInput.CreatedByType
		data.CreatedByType = &createdByType
	}

	// Set property ‘LastModifiedAt’:
	if typedInput.LastModifiedAt != nil {
		lastModifiedAt := *typedInput.LastModifiedAt
		data.LastModifiedAt = &lastModifiedAt
	}

	// Set property ‘LastModifiedBy’:
	if typedInput.LastModifiedBy != nil {
		lastModifiedBy := *typedInput.LastModifiedBy
		data.LastModifiedBy = &lastModifiedBy
	}

	// Set property ‘LastModifiedByType’:
	if typedInput.LastModifiedByType != nil {
		lastModifiedByType := *typedInput.LastModifiedByType
		data.LastModifiedByType = &lastModifiedByType
	}

	// No error
	return nil
}

// AssignProperties_From_SystemData_STATUS populates our SystemData_STATUS from the provided source SystemData_STATUS
func (data *SystemData_STATUS) AssignProperties_From_SystemData_STATUS(source *alpha20211101s.SystemData_STATUS) error {

	// CreatedAt
	data.CreatedAt = genruntime.ClonePointerToString(source.CreatedAt)

	// CreatedBy
	data.CreatedBy = genruntime.ClonePointerToString(source.CreatedBy)

	// CreatedByType
	if source.CreatedByType != nil {
		createdByType := SystemData_CreatedByType_STATUS(*source.CreatedByType)
		data.CreatedByType = &createdByType
	} else {
		data.CreatedByType = nil
	}

	// LastModifiedAt
	data.LastModifiedAt = genruntime.ClonePointerToString(source.LastModifiedAt)

	// LastModifiedBy
	data.LastModifiedBy = genruntime.ClonePointerToString(source.LastModifiedBy)

	// LastModifiedByType
	if source.LastModifiedByType != nil {
		lastModifiedByType := SystemData_LastModifiedByType_STATUS(*source.LastModifiedByType)
		data.LastModifiedByType = &lastModifiedByType
	} else {
		data.LastModifiedByType = nil
	}

	// No error
	return nil
}

// AssignProperties_To_SystemData_STATUS populates the provided destination SystemData_STATUS from our SystemData_STATUS
func (data *SystemData_STATUS) AssignProperties_To_SystemData_STATUS(destination *alpha20211101s.SystemData_STATUS) error {
	// Create a new property bag
	propertyBag := genruntime.NewPropertyBag()

	// CreatedAt
	destination.CreatedAt = genruntime.ClonePointerToString(data.CreatedAt)

	// CreatedBy
	destination.CreatedBy = genruntime.ClonePointerToString(data.CreatedBy)

	// CreatedByType
	if data.CreatedByType != nil {
		createdByType := string(*data.CreatedByType)
		destination.CreatedByType = &createdByType
	} else {
		destination.CreatedByType = nil
	}

	// LastModifiedAt
	destination.LastModifiedAt = genruntime.ClonePointerToString(data.LastModifiedAt)

	// LastModifiedBy
	destination.LastModifiedBy = genruntime.ClonePointerToString(data.LastModifiedBy)

	// LastModifiedByType
	if data.LastModifiedByType != nil {
		lastModifiedByType := string(*data.LastModifiedByType)
		destination.LastModifiedByType = &lastModifiedByType
	} else {
		destination.LastModifiedByType = nil
	}

	// Update the property bag
	if len(propertyBag) > 0 {
		destination.PropertyBag = propertyBag
	} else {
		destination.PropertyBag = nil
	}

	// No error
	return nil
}

// Deprecated version of Encryption_KeySource. Use v1beta20211101.Encryption_KeySource instead
// +kubebuilder:validation:Enum={"Microsoft.KeyVault"}
type Encryption_KeySource string

const Encryption_KeySource_MicrosoftKeyVault = Encryption_KeySource("Microsoft.KeyVault")

// Deprecated version of Encryption_KeySource_STATUS. Use v1beta20211101.Encryption_KeySource_STATUS instead
type Encryption_KeySource_STATUS string

const Encryption_KeySource_STATUS_MicrosoftKeyVault = Encryption_KeySource_STATUS("Microsoft.KeyVault")

// Deprecated version of KeyVaultProperties. Use v1beta20211101.KeyVaultProperties instead
type KeyVaultProperties struct {
	Identity    *UserAssignedIdentityProperties `json:"identity,omitempty"`
	KeyName     *string                         `json:"keyName,omitempty"`
	KeyVaultUri *string                         `json:"keyVaultUri,omitempty"`
	KeyVersion  *string                         `json:"keyVersion,omitempty"`
}

var _ genruntime.ARMTransformer = &KeyVaultProperties{}

// ConvertToARM converts from a Kubernetes CRD object to an ARM object
func (properties *KeyVaultProperties) ConvertToARM(resolved genruntime.ConvertToARMResolvedDetails) (interface{}, error) {
	if properties == nil {
		return nil, nil
	}
	result := &KeyVaultProperties_ARM{}

	// Set property ‘Identity’:
	if properties.Identity != nil {
		identity_ARM, err := (*properties.Identity).ConvertToARM(resolved)
		if err != nil {
			return nil, err
		}
		identity := *identity_ARM.(*UserAssignedIdentityProperties_ARM)
		result.Identity = &identity
	}

	// Set property ‘KeyName’:
	if properties.KeyName != nil {
		keyName := *properties.KeyName
		result.KeyName = &keyName
	}

	// Set property ‘KeyVaultUri’:
	if properties.KeyVaultUri != nil {
		keyVaultUri := *properties.KeyVaultUri
		result.KeyVaultUri = &keyVaultUri
	}

	// Set property ‘KeyVersion’:
	if properties.KeyVersion != nil {
		keyVersion := *properties.KeyVersion
		result.KeyVersion = &keyVersion
	}
	return result, nil
}

// NewEmptyARMValue returns an empty ARM value suitable for deserializing into
func (properties *KeyVaultProperties) NewEmptyARMValue() genruntime.ARMResourceStatus {
	return &KeyVaultProperties_ARM{}
}

// PopulateFromARM populates a Kubernetes CRD object from an Azure ARM object
func (properties *KeyVaultProperties) PopulateFromARM(owner genruntime.ArbitraryOwnerReference, armInput interface{}) error {
	typedInput, ok := armInput.(KeyVaultProperties_ARM)
	if !ok {
		return fmt.Errorf("unexpected type supplied for PopulateFromARM() function. Expected KeyVaultProperties_ARM, got %T", armInput)
	}

	// Set property ‘Identity’:
	if typedInput.Identity != nil {
		var identity1 UserAssignedIdentityProperties
		err := identity1.PopulateFromARM(owner, *typedInput.Identity)
		if err != nil {
			return err
		}
		identity := identity1
		properties.Identity = &identity
	}

	// Set property ‘KeyName’:
	if typedInput.KeyName != nil {
		keyName := *typedInput.KeyName
		properties.KeyName = &keyName
	}

	// Set property ‘KeyVaultUri’:
	if typedInput.KeyVaultUri != nil {
		keyVaultUri := *typedInput.KeyVaultUri
		properties.KeyVaultUri = &keyVaultUri
	}

	// Set property ‘KeyVersion’:
	if typedInput.KeyVersion != nil {
		keyVersion := *typedInput.KeyVersion
		properties.KeyVersion = &keyVersion
	}

	// No error
	return nil
}

// AssignProperties_From_KeyVaultProperties populates our KeyVaultProperties from the provided source KeyVaultProperties
func (properties *KeyVaultProperties) AssignProperties_From_KeyVaultProperties(source *alpha20211101s.KeyVaultProperties) error {

	// Identity
	if source.Identity != nil {
		var identity UserAssignedIdentityProperties
		err := identity.AssignProperties_From_UserAssignedIdentityProperties(source.Identity)
		if err != nil {
			return errors.Wrap(err, "calling AssignProperties_From_UserAssignedIdentityProperties() to populate field Identity")
		}
		properties.Identity = &identity
	} else {
		properties.Identity = nil
	}

	// KeyName
	properties.KeyName = genruntime.ClonePointerToString(source.KeyName)

	// KeyVaultUri
	properties.KeyVaultUri = genruntime.ClonePointerToString(source.KeyVaultUri)

	// KeyVersion
	properties.KeyVersion = genruntime.ClonePointerToString(source.KeyVersion)

	// No error
	return nil
}

// AssignProperties_To_KeyVaultProperties populates the provided destination KeyVaultProperties from our KeyVaultProperties
func (properties *KeyVaultProperties) AssignProperties_To_KeyVaultProperties(destination *alpha20211101s.KeyVaultProperties) error {
	// Create a new property bag
	propertyBag := genruntime.NewPropertyBag()

	// Identity
	if properties.Identity != nil {
		var identity alpha20211101s.UserAssignedIdentityProperties
		err := properties.Identity.AssignProperties_To_UserAssignedIdentityProperties(&identity)
		if err != nil {
			return errors.Wrap(err, "calling AssignProperties_To_UserAssignedIdentityProperties() to populate field Identity")
		}
		destination.Identity = &identity
	} else {
		destination.Identity = nil
	}

	// KeyName
	destination.KeyName = genruntime.ClonePointerToString(properties.KeyName)

	// KeyVaultUri
	destination.KeyVaultUri = genruntime.ClonePointerToString(properties.KeyVaultUri)

	// KeyVersion
	destination.KeyVersion = genruntime.ClonePointerToString(properties.KeyVersion)

	// Update the property bag
	if len(propertyBag) > 0 {
		destination.PropertyBag = propertyBag
	} else {
		destination.PropertyBag = nil
	}

	// No error
	return nil
}

// Deprecated version of KeyVaultProperties_STATUS. Use v1beta20211101.KeyVaultProperties_STATUS instead
type KeyVaultProperties_STATUS struct {
	Identity    *UserAssignedIdentityProperties_STATUS `json:"identity,omitempty"`
	KeyName     *string                                `json:"keyName,omitempty"`
	KeyVaultUri *string                                `json:"keyVaultUri,omitempty"`
	KeyVersion  *string                                `json:"keyVersion,omitempty"`
}

var _ genruntime.FromARMConverter = &KeyVaultProperties_STATUS{}

// NewEmptyARMValue returns an empty ARM value suitable for deserializing into
func (properties *KeyVaultProperties_STATUS) NewEmptyARMValue() genruntime.ARMResourceStatus {
	return &KeyVaultProperties_STATUS_ARM{}
}

// PopulateFromARM populates a Kubernetes CRD object from an Azure ARM object
func (properties *KeyVaultProperties_STATUS) PopulateFromARM(owner genruntime.ArbitraryOwnerReference, armInput interface{}) error {
	typedInput, ok := armInput.(KeyVaultProperties_STATUS_ARM)
	if !ok {
		return fmt.Errorf("unexpected type supplied for PopulateFromARM() function. Expected KeyVaultProperties_STATUS_ARM, got %T", armInput)
	}

	// Set property ‘Identity’:
	if typedInput.Identity != nil {
		var identity1 UserAssignedIdentityProperties_STATUS
		err := identity1.PopulateFromARM(owner, *typedInput.Identity)
		if err != nil {
			return err
		}
		identity := identity1
		properties.Identity = &identity
	}

	// Set property ‘KeyName’:
	if typedInput.KeyName != nil {
		keyName := *typedInput.KeyName
		properties.KeyName = &keyName
	}

	// Set property ‘KeyVaultUri’:
	if typedInput.KeyVaultUri != nil {
		keyVaultUri := *typedInput.KeyVaultUri
		properties.KeyVaultUri = &keyVaultUri
	}

	// Set property ‘KeyVersion’:
	if typedInput.KeyVersion != nil {
		keyVersion := *typedInput.KeyVersion
		properties.KeyVersion = &keyVersion
	}

	// No error
	return nil
}

// AssignProperties_From_KeyVaultProperties_STATUS populates our KeyVaultProperties_STATUS from the provided source KeyVaultProperties_STATUS
func (properties *KeyVaultProperties_STATUS) AssignProperties_From_KeyVaultProperties_STATUS(source *alpha20211101s.KeyVaultProperties_STATUS) error {

	// Identity
	if source.Identity != nil {
		var identity UserAssignedIdentityProperties_STATUS
		err := identity.AssignProperties_From_UserAssignedIdentityProperties_STATUS(source.Identity)
		if err != nil {
			return errors.Wrap(err, "calling AssignProperties_From_UserAssignedIdentityProperties_STATUS() to populate field Identity")
		}
		properties.Identity = &identity
	} else {
		properties.Identity = nil
	}

	// KeyName
	properties.KeyName = genruntime.ClonePointerToString(source.KeyName)

	// KeyVaultUri
	properties.KeyVaultUri = genruntime.ClonePointerToString(source.KeyVaultUri)

	// KeyVersion
	properties.KeyVersion = genruntime.ClonePointerToString(source.KeyVersion)

	// No error
	return nil
}

// AssignProperties_To_KeyVaultProperties_STATUS populates the provided destination KeyVaultProperties_STATUS from our KeyVaultProperties_STATUS
func (properties *KeyVaultProperties_STATUS) AssignProperties_To_KeyVaultProperties_STATUS(destination *alpha20211101s.KeyVaultProperties_STATUS) error {
	// Create a new property bag
	propertyBag := genruntime.NewPropertyBag()

	// Identity
	if properties.Identity != nil {
		var identity alpha20211101s.UserAssignedIdentityProperties_STATUS
		err := properties.Identity.AssignProperties_To_UserAssignedIdentityProperties_STATUS(&identity)
		if err != nil {
			return errors.Wrap(err, "calling AssignProperties_To_UserAssignedIdentityProperties_STATUS() to populate field Identity")
		}
		destination.Identity = &identity
	} else {
		destination.Identity = nil
	}

	// KeyName
	destination.KeyName = genruntime.ClonePointerToString(properties.KeyName)

	// KeyVaultUri
	destination.KeyVaultUri = genruntime.ClonePointerToString(properties.KeyVaultUri)

	// KeyVersion
	destination.KeyVersion = genruntime.ClonePointerToString(properties.KeyVersion)

	// Update the property bag
	if len(propertyBag) > 0 {
		destination.PropertyBag = propertyBag
	} else {
		destination.PropertyBag = nil
	}

	// No error
	return nil
}

// Deprecated version of UserAssignedIdentity_STATUS. Use v1beta20211101.UserAssignedIdentity_STATUS instead
type UserAssignedIdentity_STATUS struct {
	ClientId    *string `json:"clientId,omitempty"`
	PrincipalId *string `json:"principalId,omitempty"`
}

var _ genruntime.FromARMConverter = &UserAssignedIdentity_STATUS{}

// NewEmptyARMValue returns an empty ARM value suitable for deserializing into
func (identity *UserAssignedIdentity_STATUS) NewEmptyARMValue() genruntime.ARMResourceStatus {
	return &UserAssignedIdentity_STATUS_ARM{}
}

// PopulateFromARM populates a Kubernetes CRD object from an Azure ARM object
func (identity *UserAssignedIdentity_STATUS) PopulateFromARM(owner genruntime.ArbitraryOwnerReference, armInput interface{}) error {
	typedInput, ok := armInput.(UserAssignedIdentity_STATUS_ARM)
	if !ok {
		return fmt.Errorf("unexpected type supplied for PopulateFromARM() function. Expected UserAssignedIdentity_STATUS_ARM, got %T", armInput)
	}

	// Set property ‘ClientId’:
	if typedInput.ClientId != nil {
		clientId := *typedInput.ClientId
		identity.ClientId = &clientId
	}

	// Set property ‘PrincipalId’:
	if typedInput.PrincipalId != nil {
		principalId := *typedInput.PrincipalId
		identity.PrincipalId = &principalId
	}

	// No error
	return nil
}

// AssignProperties_From_UserAssignedIdentity_STATUS populates our UserAssignedIdentity_STATUS from the provided source UserAssignedIdentity_STATUS
func (identity *UserAssignedIdentity_STATUS) AssignProperties_From_UserAssignedIdentity_STATUS(source *alpha20211101s.UserAssignedIdentity_STATUS) error {

	// ClientId
	identity.ClientId = genruntime.ClonePointerToString(source.ClientId)

	// PrincipalId
	identity.PrincipalId = genruntime.ClonePointerToString(source.PrincipalId)

	// No error
	return nil
}

// AssignProperties_To_UserAssignedIdentity_STATUS populates the provided destination UserAssignedIdentity_STATUS from our UserAssignedIdentity_STATUS
func (identity *UserAssignedIdentity_STATUS) AssignProperties_To_UserAssignedIdentity_STATUS(destination *alpha20211101s.UserAssignedIdentity_STATUS) error {
	// Create a new property bag
	propertyBag := genruntime.NewPropertyBag()

	// ClientId
	destination.ClientId = genruntime.ClonePointerToString(identity.ClientId)

	// PrincipalId
	destination.PrincipalId = genruntime.ClonePointerToString(identity.PrincipalId)

	// Update the property bag
	if len(propertyBag) > 0 {
		destination.PropertyBag = propertyBag
	} else {
		destination.PropertyBag = nil
	}

	// No error
	return nil
}

// Deprecated version of UserAssignedIdentityProperties. Use v1beta20211101.UserAssignedIdentityProperties instead
type UserAssignedIdentityProperties struct {
	UserAssignedIdentityReference *genruntime.ResourceReference `armReference:"UserAssignedIdentity" json:"userAssignedIdentityReference,omitempty"`
}

var _ genruntime.ARMTransformer = &UserAssignedIdentityProperties{}

// ConvertToARM converts from a Kubernetes CRD object to an ARM object
func (properties *UserAssignedIdentityProperties) ConvertToARM(resolved genruntime.ConvertToARMResolvedDetails) (interface{}, error) {
	if properties == nil {
		return nil, nil
	}
	result := &UserAssignedIdentityProperties_ARM{}

	// Set property ‘UserAssignedIdentity’:
	if properties.UserAssignedIdentityReference != nil {
		userAssignedIdentityReferenceARMID, err := resolved.ResolvedReferences.Lookup(*properties.UserAssignedIdentityReference)
		if err != nil {
			return nil, err
		}
		userAssignedIdentityReference := userAssignedIdentityReferenceARMID
		result.UserAssignedIdentity = &userAssignedIdentityReference
	}
	return result, nil
}

// NewEmptyARMValue returns an empty ARM value suitable for deserializing into
func (properties *UserAssignedIdentityProperties) NewEmptyARMValue() genruntime.ARMResourceStatus {
	return &UserAssignedIdentityProperties_ARM{}
}

// PopulateFromARM populates a Kubernetes CRD object from an Azure ARM object
func (properties *UserAssignedIdentityProperties) PopulateFromARM(owner genruntime.ArbitraryOwnerReference, armInput interface{}) error {
	_, ok := armInput.(UserAssignedIdentityProperties_ARM)
	if !ok {
		return fmt.Errorf("unexpected type supplied for PopulateFromARM() function. Expected UserAssignedIdentityProperties_ARM, got %T", armInput)
	}

	// no assignment for property ‘UserAssignedIdentityReference’

	// No error
	return nil
}

// AssignProperties_From_UserAssignedIdentityProperties populates our UserAssignedIdentityProperties from the provided source UserAssignedIdentityProperties
func (properties *UserAssignedIdentityProperties) AssignProperties_From_UserAssignedIdentityProperties(source *alpha20211101s.UserAssignedIdentityProperties) error {

	// UserAssignedIdentityReference
	if source.UserAssignedIdentityReference != nil {
		userAssignedIdentityReference := source.UserAssignedIdentityReference.Copy()
		properties.UserAssignedIdentityReference = &userAssignedIdentityReference
	} else {
		properties.UserAssignedIdentityReference = nil
	}

	// No error
	return nil
}

// AssignProperties_To_UserAssignedIdentityProperties populates the provided destination UserAssignedIdentityProperties from our UserAssignedIdentityProperties
func (properties *UserAssignedIdentityProperties) AssignProperties_To_UserAssignedIdentityProperties(destination *alpha20211101s.UserAssignedIdentityProperties) error {
	// Create a new property bag
	propertyBag := genruntime.NewPropertyBag()

	// UserAssignedIdentityReference
	if properties.UserAssignedIdentityReference != nil {
		userAssignedIdentityReference := properties.UserAssignedIdentityReference.Copy()
		destination.UserAssignedIdentityReference = &userAssignedIdentityReference
	} else {
		destination.UserAssignedIdentityReference = nil
	}

	// Update the property bag
	if len(propertyBag) > 0 {
		destination.PropertyBag = propertyBag
	} else {
		destination.PropertyBag = nil
	}

	// No error
	return nil
}

// Deprecated version of UserAssignedIdentityProperties_STATUS. Use v1beta20211101.UserAssignedIdentityProperties_STATUS instead
type UserAssignedIdentityProperties_STATUS struct {
	UserAssignedIdentity *string `json:"userAssignedIdentity,omitempty"`
}

var _ genruntime.FromARMConverter = &UserAssignedIdentityProperties_STATUS{}

// NewEmptyARMValue returns an empty ARM value suitable for deserializing into
func (properties *UserAssignedIdentityProperties_STATUS) NewEmptyARMValue() genruntime.ARMResourceStatus {
	return &UserAssignedIdentityProperties_STATUS_ARM{}
}

// PopulateFromARM populates a Kubernetes CRD object from an Azure ARM object
func (properties *UserAssignedIdentityProperties_STATUS) PopulateFromARM(owner genruntime.ArbitraryOwnerReference, armInput interface{}) error {
	typedInput, ok := armInput.(UserAssignedIdentityProperties_STATUS_ARM)
	if !ok {
		return fmt.Errorf("unexpected type supplied for PopulateFromARM() function. Expected UserAssignedIdentityProperties_STATUS_ARM, got %T", armInput)
	}

	// Set property ‘UserAssignedIdentity’:
	if typedInput.UserAssignedIdentity != nil {
		userAssignedIdentity := *typedInput.UserAssignedIdentity
		properties.UserAssignedIdentity = &userAssignedIdentity
	}

	// No error
	return nil
}

// AssignProperties_From_UserAssignedIdentityProperties_STATUS populates our UserAssignedIdentityProperties_STATUS from the provided source UserAssignedIdentityProperties_STATUS
func (properties *UserAssignedIdentityProperties_STATUS) AssignProperties_From_UserAssignedIdentityProperties_STATUS(source *alpha20211101s.UserAssignedIdentityProperties_STATUS) error {

	// UserAssignedIdentity
	properties.UserAssignedIdentity = genruntime.ClonePointerToString(source.UserAssignedIdentity)

	// No error
	return nil
}

// AssignProperties_To_UserAssignedIdentityProperties_STATUS populates the provided destination UserAssignedIdentityProperties_STATUS from our UserAssignedIdentityProperties_STATUS
func (properties *UserAssignedIdentityProperties_STATUS) AssignProperties_To_UserAssignedIdentityProperties_STATUS(destination *alpha20211101s.UserAssignedIdentityProperties_STATUS) error {
	// Create a new property bag
	propertyBag := genruntime.NewPropertyBag()

	// UserAssignedIdentity
	destination.UserAssignedIdentity = genruntime.ClonePointerToString(properties.UserAssignedIdentity)

	// Update the property bag
	if len(propertyBag) > 0 {
		destination.PropertyBag = propertyBag
	} else {
		destination.PropertyBag = nil
	}

	// No error
	return nil
}

func init() {
	SchemeBuilder.Register(&Namespace{}, &NamespaceList{})
}