zz_generated.conversion.go

// +build !ignore_autogenerated

/*
Copyright 2021 The OpenEBS Authors

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

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

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

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

package v1

import (
	unsafe "unsafe"

	v1 "github.com/openebs/api/v2/pkg/apis/cstor/v1"
	cstor "github.com/openebs/api/v2/pkg/internalapis/apis/cstor"
	corev1 "k8s.io/api/core/v1"
	conversion "k8s.io/apimachinery/pkg/conversion"
	runtime "k8s.io/apimachinery/pkg/runtime"
)

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

// RegisterConversions adds conversion functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterConversions(s *runtime.Scheme) error {
	if err := s.AddGeneratedConversionFunc((*v1.CStorBackup)(nil), (*cstor.CStorBackup)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorBackup_To_cstor_CStorBackup(a.(*v1.CStorBackup), b.(*cstor.CStorBackup), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorBackup)(nil), (*v1.CStorBackup)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorBackup_To_v1_CStorBackup(a.(*cstor.CStorBackup), b.(*v1.CStorBackup), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorBackupList)(nil), (*cstor.CStorBackupList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorBackupList_To_cstor_CStorBackupList(a.(*v1.CStorBackupList), b.(*cstor.CStorBackupList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorBackupList)(nil), (*v1.CStorBackupList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorBackupList_To_v1_CStorBackupList(a.(*cstor.CStorBackupList), b.(*v1.CStorBackupList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorBackupSpec)(nil), (*cstor.CStorBackupSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorBackupSpec_To_cstor_CStorBackupSpec(a.(*v1.CStorBackupSpec), b.(*cstor.CStorBackupSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorBackupSpec)(nil), (*v1.CStorBackupSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorBackupSpec_To_v1_CStorBackupSpec(a.(*cstor.CStorBackupSpec), b.(*v1.CStorBackupSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorCompletedBackup)(nil), (*cstor.CStorCompletedBackup)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorCompletedBackup_To_cstor_CStorCompletedBackup(a.(*v1.CStorCompletedBackup), b.(*cstor.CStorCompletedBackup), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorCompletedBackup)(nil), (*v1.CStorCompletedBackup)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorCompletedBackup_To_v1_CStorCompletedBackup(a.(*cstor.CStorCompletedBackup), b.(*v1.CStorCompletedBackup), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorCompletedBackupList)(nil), (*cstor.CStorCompletedBackupList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorCompletedBackupList_To_cstor_CStorCompletedBackupList(a.(*v1.CStorCompletedBackupList), b.(*cstor.CStorCompletedBackupList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorCompletedBackupList)(nil), (*v1.CStorCompletedBackupList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorCompletedBackupList_To_v1_CStorCompletedBackupList(a.(*cstor.CStorCompletedBackupList), b.(*v1.CStorCompletedBackupList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorCompletedBackupSpec)(nil), (*cstor.CStorCompletedBackupSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorCompletedBackupSpec_To_cstor_CStorCompletedBackupSpec(a.(*v1.CStorCompletedBackupSpec), b.(*cstor.CStorCompletedBackupSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorCompletedBackupSpec)(nil), (*v1.CStorCompletedBackupSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorCompletedBackupSpec_To_v1_CStorCompletedBackupSpec(a.(*cstor.CStorCompletedBackupSpec), b.(*v1.CStorCompletedBackupSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorPoolCluster)(nil), (*cstor.CStorPoolCluster)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorPoolCluster_To_cstor_CStorPoolCluster(a.(*v1.CStorPoolCluster), b.(*cstor.CStorPoolCluster), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorPoolCluster)(nil), (*v1.CStorPoolCluster)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorPoolCluster_To_v1_CStorPoolCluster(a.(*cstor.CStorPoolCluster), b.(*v1.CStorPoolCluster), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorPoolClusterCondition)(nil), (*cstor.CStorPoolClusterCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorPoolClusterCondition_To_cstor_CStorPoolClusterCondition(a.(*v1.CStorPoolClusterCondition), b.(*cstor.CStorPoolClusterCondition), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorPoolClusterCondition)(nil), (*v1.CStorPoolClusterCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorPoolClusterCondition_To_v1_CStorPoolClusterCondition(a.(*cstor.CStorPoolClusterCondition), b.(*v1.CStorPoolClusterCondition), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorPoolClusterList)(nil), (*cstor.CStorPoolClusterList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorPoolClusterList_To_cstor_CStorPoolClusterList(a.(*v1.CStorPoolClusterList), b.(*cstor.CStorPoolClusterList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorPoolClusterList)(nil), (*v1.CStorPoolClusterList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorPoolClusterList_To_v1_CStorPoolClusterList(a.(*cstor.CStorPoolClusterList), b.(*v1.CStorPoolClusterList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorPoolClusterSpec)(nil), (*cstor.CStorPoolClusterSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorPoolClusterSpec_To_cstor_CStorPoolClusterSpec(a.(*v1.CStorPoolClusterSpec), b.(*cstor.CStorPoolClusterSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorPoolClusterSpec)(nil), (*v1.CStorPoolClusterSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorPoolClusterSpec_To_v1_CStorPoolClusterSpec(a.(*cstor.CStorPoolClusterSpec), b.(*v1.CStorPoolClusterSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorPoolClusterStatus)(nil), (*cstor.CStorPoolClusterStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorPoolClusterStatus_To_cstor_CStorPoolClusterStatus(a.(*v1.CStorPoolClusterStatus), b.(*cstor.CStorPoolClusterStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorPoolClusterStatus)(nil), (*v1.CStorPoolClusterStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorPoolClusterStatus_To_v1_CStorPoolClusterStatus(a.(*cstor.CStorPoolClusterStatus), b.(*v1.CStorPoolClusterStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorPoolInstance)(nil), (*cstor.CStorPoolInstance)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorPoolInstance_To_cstor_CStorPoolInstance(a.(*v1.CStorPoolInstance), b.(*cstor.CStorPoolInstance), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorPoolInstance)(nil), (*v1.CStorPoolInstance)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorPoolInstance_To_v1_CStorPoolInstance(a.(*cstor.CStorPoolInstance), b.(*v1.CStorPoolInstance), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorPoolInstanceBlockDevice)(nil), (*cstor.CStorPoolInstanceBlockDevice)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorPoolInstanceBlockDevice_To_cstor_CStorPoolInstanceBlockDevice(a.(*v1.CStorPoolInstanceBlockDevice), b.(*cstor.CStorPoolInstanceBlockDevice), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorPoolInstanceBlockDevice)(nil), (*v1.CStorPoolInstanceBlockDevice)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorPoolInstanceBlockDevice_To_v1_CStorPoolInstanceBlockDevice(a.(*cstor.CStorPoolInstanceBlockDevice), b.(*v1.CStorPoolInstanceBlockDevice), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorPoolInstanceCapacity)(nil), (*cstor.CStorPoolInstanceCapacity)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorPoolInstanceCapacity_To_cstor_CStorPoolInstanceCapacity(a.(*v1.CStorPoolInstanceCapacity), b.(*cstor.CStorPoolInstanceCapacity), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorPoolInstanceCapacity)(nil), (*v1.CStorPoolInstanceCapacity)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorPoolInstanceCapacity_To_v1_CStorPoolInstanceCapacity(a.(*cstor.CStorPoolInstanceCapacity), b.(*v1.CStorPoolInstanceCapacity), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorPoolInstanceCondition)(nil), (*cstor.CStorPoolInstanceCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorPoolInstanceCondition_To_cstor_CStorPoolInstanceCondition(a.(*v1.CStorPoolInstanceCondition), b.(*cstor.CStorPoolInstanceCondition), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorPoolInstanceCondition)(nil), (*v1.CStorPoolInstanceCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorPoolInstanceCondition_To_v1_CStorPoolInstanceCondition(a.(*cstor.CStorPoolInstanceCondition), b.(*v1.CStorPoolInstanceCondition), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorPoolInstanceList)(nil), (*cstor.CStorPoolInstanceList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorPoolInstanceList_To_cstor_CStorPoolInstanceList(a.(*v1.CStorPoolInstanceList), b.(*cstor.CStorPoolInstanceList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorPoolInstanceList)(nil), (*v1.CStorPoolInstanceList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorPoolInstanceList_To_v1_CStorPoolInstanceList(a.(*cstor.CStorPoolInstanceList), b.(*v1.CStorPoolInstanceList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorPoolInstanceSpec)(nil), (*cstor.CStorPoolInstanceSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorPoolInstanceSpec_To_cstor_CStorPoolInstanceSpec(a.(*v1.CStorPoolInstanceSpec), b.(*cstor.CStorPoolInstanceSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorPoolInstanceSpec)(nil), (*v1.CStorPoolInstanceSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorPoolInstanceSpec_To_v1_CStorPoolInstanceSpec(a.(*cstor.CStorPoolInstanceSpec), b.(*v1.CStorPoolInstanceSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorPoolInstanceStatus)(nil), (*cstor.CStorPoolInstanceStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorPoolInstanceStatus_To_cstor_CStorPoolInstanceStatus(a.(*v1.CStorPoolInstanceStatus), b.(*cstor.CStorPoolInstanceStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorPoolInstanceStatus)(nil), (*v1.CStorPoolInstanceStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorPoolInstanceStatus_To_v1_CStorPoolInstanceStatus(a.(*cstor.CStorPoolInstanceStatus), b.(*v1.CStorPoolInstanceStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorRestore)(nil), (*cstor.CStorRestore)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorRestore_To_cstor_CStorRestore(a.(*v1.CStorRestore), b.(*cstor.CStorRestore), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorRestore)(nil), (*v1.CStorRestore)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorRestore_To_v1_CStorRestore(a.(*cstor.CStorRestore), b.(*v1.CStorRestore), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorRestoreList)(nil), (*cstor.CStorRestoreList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorRestoreList_To_cstor_CStorRestoreList(a.(*v1.CStorRestoreList), b.(*cstor.CStorRestoreList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorRestoreList)(nil), (*v1.CStorRestoreList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorRestoreList_To_v1_CStorRestoreList(a.(*cstor.CStorRestoreList), b.(*v1.CStorRestoreList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorRestoreSpec)(nil), (*cstor.CStorRestoreSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorRestoreSpec_To_cstor_CStorRestoreSpec(a.(*v1.CStorRestoreSpec), b.(*cstor.CStorRestoreSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorRestoreSpec)(nil), (*v1.CStorRestoreSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorRestoreSpec_To_v1_CStorRestoreSpec(a.(*cstor.CStorRestoreSpec), b.(*v1.CStorRestoreSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorSnapshotInfo)(nil), (*cstor.CStorSnapshotInfo)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorSnapshotInfo_To_cstor_CStorSnapshotInfo(a.(*v1.CStorSnapshotInfo), b.(*cstor.CStorSnapshotInfo), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorSnapshotInfo)(nil), (*v1.CStorSnapshotInfo)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorSnapshotInfo_To_v1_CStorSnapshotInfo(a.(*cstor.CStorSnapshotInfo), b.(*v1.CStorSnapshotInfo), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorVolume)(nil), (*cstor.CStorVolume)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorVolume_To_cstor_CStorVolume(a.(*v1.CStorVolume), b.(*cstor.CStorVolume), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorVolume)(nil), (*v1.CStorVolume)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorVolume_To_v1_CStorVolume(a.(*cstor.CStorVolume), b.(*v1.CStorVolume), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorVolumeAttachment)(nil), (*cstor.CStorVolumeAttachment)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorVolumeAttachment_To_cstor_CStorVolumeAttachment(a.(*v1.CStorVolumeAttachment), b.(*cstor.CStorVolumeAttachment), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorVolumeAttachment)(nil), (*v1.CStorVolumeAttachment)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorVolumeAttachment_To_v1_CStorVolumeAttachment(a.(*cstor.CStorVolumeAttachment), b.(*v1.CStorVolumeAttachment), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorVolumeAttachmentList)(nil), (*cstor.CStorVolumeAttachmentList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorVolumeAttachmentList_To_cstor_CStorVolumeAttachmentList(a.(*v1.CStorVolumeAttachmentList), b.(*cstor.CStorVolumeAttachmentList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorVolumeAttachmentList)(nil), (*v1.CStorVolumeAttachmentList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorVolumeAttachmentList_To_v1_CStorVolumeAttachmentList(a.(*cstor.CStorVolumeAttachmentList), b.(*v1.CStorVolumeAttachmentList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorVolumeAttachmentSpec)(nil), (*cstor.CStorVolumeAttachmentSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorVolumeAttachmentSpec_To_cstor_CStorVolumeAttachmentSpec(a.(*v1.CStorVolumeAttachmentSpec), b.(*cstor.CStorVolumeAttachmentSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorVolumeAttachmentSpec)(nil), (*v1.CStorVolumeAttachmentSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorVolumeAttachmentSpec_To_v1_CStorVolumeAttachmentSpec(a.(*cstor.CStorVolumeAttachmentSpec), b.(*v1.CStorVolumeAttachmentSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorVolumeCondition)(nil), (*cstor.CStorVolumeCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorVolumeCondition_To_cstor_CStorVolumeCondition(a.(*v1.CStorVolumeCondition), b.(*cstor.CStorVolumeCondition), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorVolumeCondition)(nil), (*v1.CStorVolumeCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorVolumeCondition_To_v1_CStorVolumeCondition(a.(*cstor.CStorVolumeCondition), b.(*v1.CStorVolumeCondition), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorVolumeConfig)(nil), (*cstor.CStorVolumeConfig)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorVolumeConfig_To_cstor_CStorVolumeConfig(a.(*v1.CStorVolumeConfig), b.(*cstor.CStorVolumeConfig), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorVolumeConfig)(nil), (*v1.CStorVolumeConfig)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorVolumeConfig_To_v1_CStorVolumeConfig(a.(*cstor.CStorVolumeConfig), b.(*v1.CStorVolumeConfig), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorVolumeConfigCondition)(nil), (*cstor.CStorVolumeConfigCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorVolumeConfigCondition_To_cstor_CStorVolumeConfigCondition(a.(*v1.CStorVolumeConfigCondition), b.(*cstor.CStorVolumeConfigCondition), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorVolumeConfigCondition)(nil), (*v1.CStorVolumeConfigCondition)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorVolumeConfigCondition_To_v1_CStorVolumeConfigCondition(a.(*cstor.CStorVolumeConfigCondition), b.(*v1.CStorVolumeConfigCondition), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorVolumeConfigList)(nil), (*cstor.CStorVolumeConfigList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorVolumeConfigList_To_cstor_CStorVolumeConfigList(a.(*v1.CStorVolumeConfigList), b.(*cstor.CStorVolumeConfigList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorVolumeConfigList)(nil), (*v1.CStorVolumeConfigList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorVolumeConfigList_To_v1_CStorVolumeConfigList(a.(*cstor.CStorVolumeConfigList), b.(*v1.CStorVolumeConfigList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorVolumeConfigPublish)(nil), (*cstor.CStorVolumeConfigPublish)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorVolumeConfigPublish_To_cstor_CStorVolumeConfigPublish(a.(*v1.CStorVolumeConfigPublish), b.(*cstor.CStorVolumeConfigPublish), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorVolumeConfigPublish)(nil), (*v1.CStorVolumeConfigPublish)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorVolumeConfigPublish_To_v1_CStorVolumeConfigPublish(a.(*cstor.CStorVolumeConfigPublish), b.(*v1.CStorVolumeConfigPublish), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorVolumeConfigSpec)(nil), (*cstor.CStorVolumeConfigSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorVolumeConfigSpec_To_cstor_CStorVolumeConfigSpec(a.(*v1.CStorVolumeConfigSpec), b.(*cstor.CStorVolumeConfigSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorVolumeConfigSpec)(nil), (*v1.CStorVolumeConfigSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorVolumeConfigSpec_To_v1_CStorVolumeConfigSpec(a.(*cstor.CStorVolumeConfigSpec), b.(*v1.CStorVolumeConfigSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorVolumeConfigStatus)(nil), (*cstor.CStorVolumeConfigStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorVolumeConfigStatus_To_cstor_CStorVolumeConfigStatus(a.(*v1.CStorVolumeConfigStatus), b.(*cstor.CStorVolumeConfigStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorVolumeConfigStatus)(nil), (*v1.CStorVolumeConfigStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorVolumeConfigStatus_To_v1_CStorVolumeConfigStatus(a.(*cstor.CStorVolumeConfigStatus), b.(*v1.CStorVolumeConfigStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorVolumeList)(nil), (*cstor.CStorVolumeList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorVolumeList_To_cstor_CStorVolumeList(a.(*v1.CStorVolumeList), b.(*cstor.CStorVolumeList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorVolumeList)(nil), (*v1.CStorVolumeList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorVolumeList_To_v1_CStorVolumeList(a.(*cstor.CStorVolumeList), b.(*v1.CStorVolumeList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorVolumePolicy)(nil), (*cstor.CStorVolumePolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorVolumePolicy_To_cstor_CStorVolumePolicy(a.(*v1.CStorVolumePolicy), b.(*cstor.CStorVolumePolicy), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorVolumePolicy)(nil), (*v1.CStorVolumePolicy)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorVolumePolicy_To_v1_CStorVolumePolicy(a.(*cstor.CStorVolumePolicy), b.(*v1.CStorVolumePolicy), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorVolumePolicyList)(nil), (*cstor.CStorVolumePolicyList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorVolumePolicyList_To_cstor_CStorVolumePolicyList(a.(*v1.CStorVolumePolicyList), b.(*cstor.CStorVolumePolicyList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorVolumePolicyList)(nil), (*v1.CStorVolumePolicyList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorVolumePolicyList_To_v1_CStorVolumePolicyList(a.(*cstor.CStorVolumePolicyList), b.(*v1.CStorVolumePolicyList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorVolumePolicySpec)(nil), (*cstor.CStorVolumePolicySpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorVolumePolicySpec_To_cstor_CStorVolumePolicySpec(a.(*v1.CStorVolumePolicySpec), b.(*cstor.CStorVolumePolicySpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorVolumePolicySpec)(nil), (*v1.CStorVolumePolicySpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorVolumePolicySpec_To_v1_CStorVolumePolicySpec(a.(*cstor.CStorVolumePolicySpec), b.(*v1.CStorVolumePolicySpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorVolumePolicyStatus)(nil), (*cstor.CStorVolumePolicyStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorVolumePolicyStatus_To_cstor_CStorVolumePolicyStatus(a.(*v1.CStorVolumePolicyStatus), b.(*cstor.CStorVolumePolicyStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorVolumePolicyStatus)(nil), (*v1.CStorVolumePolicyStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorVolumePolicyStatus_To_v1_CStorVolumePolicyStatus(a.(*cstor.CStorVolumePolicyStatus), b.(*v1.CStorVolumePolicyStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorVolumeReplica)(nil), (*cstor.CStorVolumeReplica)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorVolumeReplica_To_cstor_CStorVolumeReplica(a.(*v1.CStorVolumeReplica), b.(*cstor.CStorVolumeReplica), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorVolumeReplica)(nil), (*v1.CStorVolumeReplica)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorVolumeReplica_To_v1_CStorVolumeReplica(a.(*cstor.CStorVolumeReplica), b.(*v1.CStorVolumeReplica), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorVolumeReplicaCapacityDetails)(nil), (*cstor.CStorVolumeReplicaCapacityDetails)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorVolumeReplicaCapacityDetails_To_cstor_CStorVolumeReplicaCapacityDetails(a.(*v1.CStorVolumeReplicaCapacityDetails), b.(*cstor.CStorVolumeReplicaCapacityDetails), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorVolumeReplicaCapacityDetails)(nil), (*v1.CStorVolumeReplicaCapacityDetails)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorVolumeReplicaCapacityDetails_To_v1_CStorVolumeReplicaCapacityDetails(a.(*cstor.CStorVolumeReplicaCapacityDetails), b.(*v1.CStorVolumeReplicaCapacityDetails), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorVolumeReplicaDetails)(nil), (*cstor.CStorVolumeReplicaDetails)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorVolumeReplicaDetails_To_cstor_CStorVolumeReplicaDetails(a.(*v1.CStorVolumeReplicaDetails), b.(*cstor.CStorVolumeReplicaDetails), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorVolumeReplicaDetails)(nil), (*v1.CStorVolumeReplicaDetails)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorVolumeReplicaDetails_To_v1_CStorVolumeReplicaDetails(a.(*cstor.CStorVolumeReplicaDetails), b.(*v1.CStorVolumeReplicaDetails), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorVolumeReplicaList)(nil), (*cstor.CStorVolumeReplicaList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorVolumeReplicaList_To_cstor_CStorVolumeReplicaList(a.(*v1.CStorVolumeReplicaList), b.(*cstor.CStorVolumeReplicaList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorVolumeReplicaList)(nil), (*v1.CStorVolumeReplicaList)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorVolumeReplicaList_To_v1_CStorVolumeReplicaList(a.(*cstor.CStorVolumeReplicaList), b.(*v1.CStorVolumeReplicaList), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorVolumeReplicaSpec)(nil), (*cstor.CStorVolumeReplicaSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorVolumeReplicaSpec_To_cstor_CStorVolumeReplicaSpec(a.(*v1.CStorVolumeReplicaSpec), b.(*cstor.CStorVolumeReplicaSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorVolumeReplicaSpec)(nil), (*v1.CStorVolumeReplicaSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorVolumeReplicaSpec_To_v1_CStorVolumeReplicaSpec(a.(*cstor.CStorVolumeReplicaSpec), b.(*v1.CStorVolumeReplicaSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorVolumeReplicaStatus)(nil), (*cstor.CStorVolumeReplicaStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorVolumeReplicaStatus_To_cstor_CStorVolumeReplicaStatus(a.(*v1.CStorVolumeReplicaStatus), b.(*cstor.CStorVolumeReplicaStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorVolumeReplicaStatus)(nil), (*v1.CStorVolumeReplicaStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorVolumeReplicaStatus_To_v1_CStorVolumeReplicaStatus(a.(*cstor.CStorVolumeReplicaStatus), b.(*v1.CStorVolumeReplicaStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorVolumeSpec)(nil), (*cstor.CStorVolumeSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorVolumeSpec_To_cstor_CStorVolumeSpec(a.(*v1.CStorVolumeSpec), b.(*cstor.CStorVolumeSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorVolumeSpec)(nil), (*v1.CStorVolumeSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorVolumeSpec_To_v1_CStorVolumeSpec(a.(*cstor.CStorVolumeSpec), b.(*v1.CStorVolumeSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CStorVolumeStatus)(nil), (*cstor.CStorVolumeStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CStorVolumeStatus_To_cstor_CStorVolumeStatus(a.(*v1.CStorVolumeStatus), b.(*cstor.CStorVolumeStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CStorVolumeStatus)(nil), (*v1.CStorVolumeStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CStorVolumeStatus_To_v1_CStorVolumeStatus(a.(*cstor.CStorVolumeStatus), b.(*v1.CStorVolumeStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CVStatus)(nil), (*cstor.CVStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CVStatus_To_cstor_CVStatus(a.(*v1.CVStatus), b.(*cstor.CVStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CVStatus)(nil), (*v1.CVStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CVStatus_To_v1_CVStatus(a.(*cstor.CVStatus), b.(*v1.CVStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.CVStatusResponse)(nil), (*cstor.CVStatusResponse)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_CVStatusResponse_To_cstor_CVStatusResponse(a.(*v1.CVStatusResponse), b.(*cstor.CVStatusResponse), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.CVStatusResponse)(nil), (*v1.CVStatusResponse)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_CVStatusResponse_To_v1_CVStatusResponse(a.(*cstor.CVStatusResponse), b.(*v1.CVStatusResponse), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.ISCSIInfo)(nil), (*cstor.ISCSIInfo)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_ISCSIInfo_To_cstor_ISCSIInfo(a.(*v1.ISCSIInfo), b.(*cstor.ISCSIInfo), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.ISCSIInfo)(nil), (*v1.ISCSIInfo)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_ISCSIInfo_To_v1_ISCSIInfo(a.(*cstor.ISCSIInfo), b.(*v1.ISCSIInfo), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.PoolConfig)(nil), (*cstor.PoolConfig)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_PoolConfig_To_cstor_PoolConfig(a.(*v1.PoolConfig), b.(*cstor.PoolConfig), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.PoolConfig)(nil), (*v1.PoolConfig)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_PoolConfig_To_v1_PoolConfig(a.(*cstor.PoolConfig), b.(*v1.PoolConfig), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.PoolSpec)(nil), (*cstor.PoolSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_PoolSpec_To_cstor_PoolSpec(a.(*v1.PoolSpec), b.(*cstor.PoolSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.PoolSpec)(nil), (*v1.PoolSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_PoolSpec_To_v1_PoolSpec(a.(*cstor.PoolSpec), b.(*v1.PoolSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.Provision)(nil), (*cstor.Provision)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_Provision_To_cstor_Provision(a.(*v1.Provision), b.(*cstor.Provision), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.Provision)(nil), (*v1.Provision)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_Provision_To_v1_Provision(a.(*cstor.Provision), b.(*v1.Provision), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.RaidGroup)(nil), (*cstor.RaidGroup)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_RaidGroup_To_cstor_RaidGroup(a.(*v1.RaidGroup), b.(*cstor.RaidGroup), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.RaidGroup)(nil), (*v1.RaidGroup)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_RaidGroup_To_v1_RaidGroup(a.(*cstor.RaidGroup), b.(*v1.RaidGroup), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.ReplicaPoolInfo)(nil), (*cstor.ReplicaPoolInfo)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_ReplicaPoolInfo_To_cstor_ReplicaPoolInfo(a.(*v1.ReplicaPoolInfo), b.(*cstor.ReplicaPoolInfo), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.ReplicaPoolInfo)(nil), (*v1.ReplicaPoolInfo)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_ReplicaPoolInfo_To_v1_ReplicaPoolInfo(a.(*cstor.ReplicaPoolInfo), b.(*v1.ReplicaPoolInfo), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.ReplicaSpec)(nil), (*cstor.ReplicaSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_ReplicaSpec_To_cstor_ReplicaSpec(a.(*v1.ReplicaSpec), b.(*cstor.ReplicaSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.ReplicaSpec)(nil), (*v1.ReplicaSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_ReplicaSpec_To_v1_ReplicaSpec(a.(*cstor.ReplicaSpec), b.(*v1.ReplicaSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.ReplicaStatus)(nil), (*cstor.ReplicaStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_ReplicaStatus_To_cstor_ReplicaStatus(a.(*v1.ReplicaStatus), b.(*cstor.ReplicaStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.ReplicaStatus)(nil), (*v1.ReplicaStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_ReplicaStatus_To_v1_ReplicaStatus(a.(*cstor.ReplicaStatus), b.(*v1.ReplicaStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.TargetSpec)(nil), (*cstor.TargetSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_TargetSpec_To_cstor_TargetSpec(a.(*v1.TargetSpec), b.(*cstor.TargetSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.TargetSpec)(nil), (*v1.TargetSpec)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_TargetSpec_To_v1_TargetSpec(a.(*cstor.TargetSpec), b.(*v1.TargetSpec), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.VersionDetails)(nil), (*cstor.VersionDetails)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_VersionDetails_To_cstor_VersionDetails(a.(*v1.VersionDetails), b.(*cstor.VersionDetails), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.VersionDetails)(nil), (*v1.VersionDetails)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_VersionDetails_To_v1_VersionDetails(a.(*cstor.VersionDetails), b.(*v1.VersionDetails), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.VersionStatus)(nil), (*cstor.VersionStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_VersionStatus_To_cstor_VersionStatus(a.(*v1.VersionStatus), b.(*cstor.VersionStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.VersionStatus)(nil), (*v1.VersionStatus)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_VersionStatus_To_v1_VersionStatus(a.(*cstor.VersionStatus), b.(*v1.VersionStatus), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.VolumeInfo)(nil), (*cstor.VolumeInfo)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_VolumeInfo_To_cstor_VolumeInfo(a.(*v1.VolumeInfo), b.(*cstor.VolumeInfo), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.VolumeInfo)(nil), (*v1.VolumeInfo)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_VolumeInfo_To_v1_VolumeInfo(a.(*cstor.VolumeInfo), b.(*v1.VolumeInfo), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.VolumeProvision)(nil), (*cstor.VolumeProvision)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_VolumeProvision_To_cstor_VolumeProvision(a.(*v1.VolumeProvision), b.(*cstor.VolumeProvision), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.VolumeProvision)(nil), (*v1.VolumeProvision)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_VolumeProvision_To_v1_VolumeProvision(a.(*cstor.VolumeProvision), b.(*v1.VolumeProvision), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.ZFSCapacityAttributes)(nil), (*cstor.ZFSCapacityAttributes)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1_ZFSCapacityAttributes_To_cstor_ZFSCapacityAttributes(a.(*v1.ZFSCapacityAttributes), b.(*cstor.ZFSCapacityAttributes), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*cstor.ZFSCapacityAttributes)(nil), (*v1.ZFSCapacityAttributes)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_cstor_ZFSCapacityAttributes_To_v1_ZFSCapacityAttributes(a.(*cstor.ZFSCapacityAttributes), b.(*v1.ZFSCapacityAttributes), scope)
	}); err != nil {
		return err
	}
	return nil
}

func autoConvert_v1_CStorBackup_To_cstor_CStorBackup(in *v1.CStorBackup, out *cstor.CStorBackup, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1_CStorBackupSpec_To_cstor_CStorBackupSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	out.Status = cstor.CStorBackupStatus(in.Status)
	return nil
}

// Convert_v1_CStorBackup_To_cstor_CStorBackup is an autogenerated conversion function.
func Convert_v1_CStorBackup_To_cstor_CStorBackup(in *v1.CStorBackup, out *cstor.CStorBackup, s conversion.Scope) error {
	return autoConvert_v1_CStorBackup_To_cstor_CStorBackup(in, out, s)
}

func autoConvert_cstor_CStorBackup_To_v1_CStorBackup(in *cstor.CStorBackup, out *v1.CStorBackup, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_cstor_CStorBackupSpec_To_v1_CStorBackupSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	out.Status = v1.CStorBackupStatus(in.Status)
	return nil
}

// Convert_cstor_CStorBackup_To_v1_CStorBackup is an autogenerated conversion function.
func Convert_cstor_CStorBackup_To_v1_CStorBackup(in *cstor.CStorBackup, out *v1.CStorBackup, s conversion.Scope) error {
	return autoConvert_cstor_CStorBackup_To_v1_CStorBackup(in, out, s)
}

func autoConvert_v1_CStorBackupList_To_cstor_CStorBackupList(in *v1.CStorBackupList, out *cstor.CStorBackupList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	out.Items = *(*[]cstor.CStorBackup)(unsafe.Pointer(&in.Items))
	return nil
}

// Convert_v1_CStorBackupList_To_cstor_CStorBackupList is an autogenerated conversion function.
func Convert_v1_CStorBackupList_To_cstor_CStorBackupList(in *v1.CStorBackupList, out *cstor.CStorBackupList, s conversion.Scope) error {
	return autoConvert_v1_CStorBackupList_To_cstor_CStorBackupList(in, out, s)
}

func autoConvert_cstor_CStorBackupList_To_v1_CStorBackupList(in *cstor.CStorBackupList, out *v1.CStorBackupList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	out.Items = *(*[]v1.CStorBackup)(unsafe.Pointer(&in.Items))
	return nil
}

// Convert_cstor_CStorBackupList_To_v1_CStorBackupList is an autogenerated conversion function.
func Convert_cstor_CStorBackupList_To_v1_CStorBackupList(in *cstor.CStorBackupList, out *v1.CStorBackupList, s conversion.Scope) error {
	return autoConvert_cstor_CStorBackupList_To_v1_CStorBackupList(in, out, s)
}

func autoConvert_v1_CStorBackupSpec_To_cstor_CStorBackupSpec(in *v1.CStorBackupSpec, out *cstor.CStorBackupSpec, s conversion.Scope) error {
	out.BackupName = in.BackupName
	out.VolumeName = in.VolumeName
	out.SnapName = in.SnapName
	out.PrevSnapName = in.PrevSnapName
	out.BackupDest = in.BackupDest
	out.LocalSnap = in.LocalSnap
	return nil
}

// Convert_v1_CStorBackupSpec_To_cstor_CStorBackupSpec is an autogenerated conversion function.
func Convert_v1_CStorBackupSpec_To_cstor_CStorBackupSpec(in *v1.CStorBackupSpec, out *cstor.CStorBackupSpec, s conversion.Scope) error {
	return autoConvert_v1_CStorBackupSpec_To_cstor_CStorBackupSpec(in, out, s)
}

func autoConvert_cstor_CStorBackupSpec_To_v1_CStorBackupSpec(in *cstor.CStorBackupSpec, out *v1.CStorBackupSpec, s conversion.Scope) error {
	out.BackupName = in.BackupName
	out.VolumeName = in.VolumeName
	out.SnapName = in.SnapName
	out.PrevSnapName = in.PrevSnapName
	out.BackupDest = in.BackupDest
	out.LocalSnap = in.LocalSnap
	return nil
}

// Convert_cstor_CStorBackupSpec_To_v1_CStorBackupSpec is an autogenerated conversion function.
func Convert_cstor_CStorBackupSpec_To_v1_CStorBackupSpec(in *cstor.CStorBackupSpec, out *v1.CStorBackupSpec, s conversion.Scope) error {
	return autoConvert_cstor_CStorBackupSpec_To_v1_CStorBackupSpec(in, out, s)
}

func autoConvert_v1_CStorCompletedBackup_To_cstor_CStorCompletedBackup(in *v1.CStorCompletedBackup, out *cstor.CStorCompletedBackup, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1_CStorCompletedBackupSpec_To_cstor_CStorCompletedBackupSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1_CStorCompletedBackup_To_cstor_CStorCompletedBackup is an autogenerated conversion function.
func Convert_v1_CStorCompletedBackup_To_cstor_CStorCompletedBackup(in *v1.CStorCompletedBackup, out *cstor.CStorCompletedBackup, s conversion.Scope) error {
	return autoConvert_v1_CStorCompletedBackup_To_cstor_CStorCompletedBackup(in, out, s)
}

func autoConvert_cstor_CStorCompletedBackup_To_v1_CStorCompletedBackup(in *cstor.CStorCompletedBackup, out *v1.CStorCompletedBackup, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_cstor_CStorCompletedBackupSpec_To_v1_CStorCompletedBackupSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	return nil
}

// Convert_cstor_CStorCompletedBackup_To_v1_CStorCompletedBackup is an autogenerated conversion function.
func Convert_cstor_CStorCompletedBackup_To_v1_CStorCompletedBackup(in *cstor.CStorCompletedBackup, out *v1.CStorCompletedBackup, s conversion.Scope) error {
	return autoConvert_cstor_CStorCompletedBackup_To_v1_CStorCompletedBackup(in, out, s)
}

func autoConvert_v1_CStorCompletedBackupList_To_cstor_CStorCompletedBackupList(in *v1.CStorCompletedBackupList, out *cstor.CStorCompletedBackupList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	out.Items = *(*[]cstor.CStorCompletedBackup)(unsafe.Pointer(&in.Items))
	return nil
}

// Convert_v1_CStorCompletedBackupList_To_cstor_CStorCompletedBackupList is an autogenerated conversion function.
func Convert_v1_CStorCompletedBackupList_To_cstor_CStorCompletedBackupList(in *v1.CStorCompletedBackupList, out *cstor.CStorCompletedBackupList, s conversion.Scope) error {
	return autoConvert_v1_CStorCompletedBackupList_To_cstor_CStorCompletedBackupList(in, out, s)
}

func autoConvert_cstor_CStorCompletedBackupList_To_v1_CStorCompletedBackupList(in *cstor.CStorCompletedBackupList, out *v1.CStorCompletedBackupList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	out.Items = *(*[]v1.CStorCompletedBackup)(unsafe.Pointer(&in.Items))
	return nil
}

// Convert_cstor_CStorCompletedBackupList_To_v1_CStorCompletedBackupList is an autogenerated conversion function.
func Convert_cstor_CStorCompletedBackupList_To_v1_CStorCompletedBackupList(in *cstor.CStorCompletedBackupList, out *v1.CStorCompletedBackupList, s conversion.Scope) error {
	return autoConvert_cstor_CStorCompletedBackupList_To_v1_CStorCompletedBackupList(in, out, s)
}

func autoConvert_v1_CStorCompletedBackupSpec_To_cstor_CStorCompletedBackupSpec(in *v1.CStorCompletedBackupSpec, out *cstor.CStorCompletedBackupSpec, s conversion.Scope) error {
	out.BackupName = in.BackupName
	out.VolumeName = in.VolumeName
	out.SecondLastSnapName = in.SecondLastSnapName
	out.LastSnapName = in.LastSnapName
	return nil
}

// Convert_v1_CStorCompletedBackupSpec_To_cstor_CStorCompletedBackupSpec is an autogenerated conversion function.
func Convert_v1_CStorCompletedBackupSpec_To_cstor_CStorCompletedBackupSpec(in *v1.CStorCompletedBackupSpec, out *cstor.CStorCompletedBackupSpec, s conversion.Scope) error {
	return autoConvert_v1_CStorCompletedBackupSpec_To_cstor_CStorCompletedBackupSpec(in, out, s)
}

func autoConvert_cstor_CStorCompletedBackupSpec_To_v1_CStorCompletedBackupSpec(in *cstor.CStorCompletedBackupSpec, out *v1.CStorCompletedBackupSpec, s conversion.Scope) error {
	out.BackupName = in.BackupName
	out.VolumeName = in.VolumeName
	out.SecondLastSnapName = in.SecondLastSnapName
	out.LastSnapName = in.LastSnapName
	return nil
}

// Convert_cstor_CStorCompletedBackupSpec_To_v1_CStorCompletedBackupSpec is an autogenerated conversion function.
func Convert_cstor_CStorCompletedBackupSpec_To_v1_CStorCompletedBackupSpec(in *cstor.CStorCompletedBackupSpec, out *v1.CStorCompletedBackupSpec, s conversion.Scope) error {
	return autoConvert_cstor_CStorCompletedBackupSpec_To_v1_CStorCompletedBackupSpec(in, out, s)
}

func autoConvert_v1_CStorPoolCluster_To_cstor_CStorPoolCluster(in *v1.CStorPoolCluster, out *cstor.CStorPoolCluster, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1_CStorPoolClusterSpec_To_cstor_CStorPoolClusterSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_v1_CStorPoolClusterStatus_To_cstor_CStorPoolClusterStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	if err := Convert_v1_VersionDetails_To_cstor_VersionDetails(&in.VersionDetails, &out.VersionDetails, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1_CStorPoolCluster_To_cstor_CStorPoolCluster is an autogenerated conversion function.
func Convert_v1_CStorPoolCluster_To_cstor_CStorPoolCluster(in *v1.CStorPoolCluster, out *cstor.CStorPoolCluster, s conversion.Scope) error {
	return autoConvert_v1_CStorPoolCluster_To_cstor_CStorPoolCluster(in, out, s)
}

func autoConvert_cstor_CStorPoolCluster_To_v1_CStorPoolCluster(in *cstor.CStorPoolCluster, out *v1.CStorPoolCluster, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_cstor_CStorPoolClusterSpec_To_v1_CStorPoolClusterSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_cstor_CStorPoolClusterStatus_To_v1_CStorPoolClusterStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	if err := Convert_cstor_VersionDetails_To_v1_VersionDetails(&in.VersionDetails, &out.VersionDetails, s); err != nil {
		return err
	}
	return nil
}

// Convert_cstor_CStorPoolCluster_To_v1_CStorPoolCluster is an autogenerated conversion function.
func Convert_cstor_CStorPoolCluster_To_v1_CStorPoolCluster(in *cstor.CStorPoolCluster, out *v1.CStorPoolCluster, s conversion.Scope) error {
	return autoConvert_cstor_CStorPoolCluster_To_v1_CStorPoolCluster(in, out, s)
}

func autoConvert_v1_CStorPoolClusterCondition_To_cstor_CStorPoolClusterCondition(in *v1.CStorPoolClusterCondition, out *cstor.CStorPoolClusterCondition, s conversion.Scope) error {
	out.Type = cstor.CSPCConditionType(in.Type)
	out.Status = corev1.ConditionStatus(in.Status)
	out.LastUpdateTime = in.LastUpdateTime
	out.LastTransitionTime = in.LastTransitionTime
	out.Reason = in.Reason
	out.Message = in.Message
	return nil
}

// Convert_v1_CStorPoolClusterCondition_To_cstor_CStorPoolClusterCondition is an autogenerated conversion function.
func Convert_v1_CStorPoolClusterCondition_To_cstor_CStorPoolClusterCondition(in *v1.CStorPoolClusterCondition, out *cstor.CStorPoolClusterCondition, s conversion.Scope) error {
	return autoConvert_v1_CStorPoolClusterCondition_To_cstor_CStorPoolClusterCondition(in, out, s)
}

func autoConvert_cstor_CStorPoolClusterCondition_To_v1_CStorPoolClusterCondition(in *cstor.CStorPoolClusterCondition, out *v1.CStorPoolClusterCondition, s conversion.Scope) error {
	out.Type = v1.CSPCConditionType(in.Type)
	out.Status = corev1.ConditionStatus(in.Status)
	out.LastUpdateTime = in.LastUpdateTime
	out.LastTransitionTime = in.LastTransitionTime
	out.Reason = in.Reason
	out.Message = in.Message
	return nil
}

// Convert_cstor_CStorPoolClusterCondition_To_v1_CStorPoolClusterCondition is an autogenerated conversion function.
func Convert_cstor_CStorPoolClusterCondition_To_v1_CStorPoolClusterCondition(in *cstor.CStorPoolClusterCondition, out *v1.CStorPoolClusterCondition, s conversion.Scope) error {
	return autoConvert_cstor_CStorPoolClusterCondition_To_v1_CStorPoolClusterCondition(in, out, s)
}

func autoConvert_v1_CStorPoolClusterList_To_cstor_CStorPoolClusterList(in *v1.CStorPoolClusterList, out *cstor.CStorPoolClusterList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	out.Items = *(*[]cstor.CStorPoolCluster)(unsafe.Pointer(&in.Items))
	return nil
}

// Convert_v1_CStorPoolClusterList_To_cstor_CStorPoolClusterList is an autogenerated conversion function.
func Convert_v1_CStorPoolClusterList_To_cstor_CStorPoolClusterList(in *v1.CStorPoolClusterList, out *cstor.CStorPoolClusterList, s conversion.Scope) error {
	return autoConvert_v1_CStorPoolClusterList_To_cstor_CStorPoolClusterList(in, out, s)
}

func autoConvert_cstor_CStorPoolClusterList_To_v1_CStorPoolClusterList(in *cstor.CStorPoolClusterList, out *v1.CStorPoolClusterList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	out.Items = *(*[]v1.CStorPoolCluster)(unsafe.Pointer(&in.Items))
	return nil
}

// Convert_cstor_CStorPoolClusterList_To_v1_CStorPoolClusterList is an autogenerated conversion function.
func Convert_cstor_CStorPoolClusterList_To_v1_CStorPoolClusterList(in *cstor.CStorPoolClusterList, out *v1.CStorPoolClusterList, s conversion.Scope) error {
	return autoConvert_cstor_CStorPoolClusterList_To_v1_CStorPoolClusterList(in, out, s)
}

func autoConvert_v1_CStorPoolClusterSpec_To_cstor_CStorPoolClusterSpec(in *v1.CStorPoolClusterSpec, out *cstor.CStorPoolClusterSpec, s conversion.Scope) error {
	out.Pools = *(*[]cstor.PoolSpec)(unsafe.Pointer(&in.Pools))
	out.DefaultResources = (*corev1.ResourceRequirements)(unsafe.Pointer(in.DefaultResources))
	out.DefaultAuxResources = (*corev1.ResourceRequirements)(unsafe.Pointer(in.DefaultAuxResources))
	out.Tolerations = *(*[]corev1.Toleration)(unsafe.Pointer(&in.Tolerations))
	out.DefaultPriorityClassName = in.DefaultPriorityClassName
	return nil
}

// Convert_v1_CStorPoolClusterSpec_To_cstor_CStorPoolClusterSpec is an autogenerated conversion function.
func Convert_v1_CStorPoolClusterSpec_To_cstor_CStorPoolClusterSpec(in *v1.CStorPoolClusterSpec, out *cstor.CStorPoolClusterSpec, s conversion.Scope) error {
	return autoConvert_v1_CStorPoolClusterSpec_To_cstor_CStorPoolClusterSpec(in, out, s)
}

func autoConvert_cstor_CStorPoolClusterSpec_To_v1_CStorPoolClusterSpec(in *cstor.CStorPoolClusterSpec, out *v1.CStorPoolClusterSpec, s conversion.Scope) error {
	out.Pools = *(*[]v1.PoolSpec)(unsafe.Pointer(&in.Pools))
	out.DefaultResources = (*corev1.ResourceRequirements)(unsafe.Pointer(in.DefaultResources))
	out.DefaultAuxResources = (*corev1.ResourceRequirements)(unsafe.Pointer(in.DefaultAuxResources))
	out.Tolerations = *(*[]corev1.Toleration)(unsafe.Pointer(&in.Tolerations))
	out.DefaultPriorityClassName = in.DefaultPriorityClassName
	return nil
}

// Convert_cstor_CStorPoolClusterSpec_To_v1_CStorPoolClusterSpec is an autogenerated conversion function.
func Convert_cstor_CStorPoolClusterSpec_To_v1_CStorPoolClusterSpec(in *cstor.CStorPoolClusterSpec, out *v1.CStorPoolClusterSpec, s conversion.Scope) error {
	return autoConvert_cstor_CStorPoolClusterSpec_To_v1_CStorPoolClusterSpec(in, out, s)
}

func autoConvert_v1_CStorPoolClusterStatus_To_cstor_CStorPoolClusterStatus(in *v1.CStorPoolClusterStatus, out *cstor.CStorPoolClusterStatus, s conversion.Scope) error {
	out.ProvisionedInstances = in.ProvisionedInstances
	out.DesiredInstances = in.DesiredInstances
	out.HealthyInstances = in.HealthyInstances
	out.Conditions = *(*[]cstor.CStorPoolClusterCondition)(unsafe.Pointer(&in.Conditions))
	return nil
}

// Convert_v1_CStorPoolClusterStatus_To_cstor_CStorPoolClusterStatus is an autogenerated conversion function.
func Convert_v1_CStorPoolClusterStatus_To_cstor_CStorPoolClusterStatus(in *v1.CStorPoolClusterStatus, out *cstor.CStorPoolClusterStatus, s conversion.Scope) error {
	return autoConvert_v1_CStorPoolClusterStatus_To_cstor_CStorPoolClusterStatus(in, out, s)
}

func autoConvert_cstor_CStorPoolClusterStatus_To_v1_CStorPoolClusterStatus(in *cstor.CStorPoolClusterStatus, out *v1.CStorPoolClusterStatus, s conversion.Scope) error {
	out.ProvisionedInstances = in.ProvisionedInstances
	out.DesiredInstances = in.DesiredInstances
	out.HealthyInstances = in.HealthyInstances
	out.Conditions = *(*[]v1.CStorPoolClusterCondition)(unsafe.Pointer(&in.Conditions))
	return nil
}

// Convert_cstor_CStorPoolClusterStatus_To_v1_CStorPoolClusterStatus is an autogenerated conversion function.
func Convert_cstor_CStorPoolClusterStatus_To_v1_CStorPoolClusterStatus(in *cstor.CStorPoolClusterStatus, out *v1.CStorPoolClusterStatus, s conversion.Scope) error {
	return autoConvert_cstor_CStorPoolClusterStatus_To_v1_CStorPoolClusterStatus(in, out, s)
}

func autoConvert_v1_CStorPoolInstance_To_cstor_CStorPoolInstance(in *v1.CStorPoolInstance, out *cstor.CStorPoolInstance, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1_CStorPoolInstanceSpec_To_cstor_CStorPoolInstanceSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_v1_CStorPoolInstanceStatus_To_cstor_CStorPoolInstanceStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	if err := Convert_v1_VersionDetails_To_cstor_VersionDetails(&in.VersionDetails, &out.VersionDetails, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1_CStorPoolInstance_To_cstor_CStorPoolInstance is an autogenerated conversion function.
func Convert_v1_CStorPoolInstance_To_cstor_CStorPoolInstance(in *v1.CStorPoolInstance, out *cstor.CStorPoolInstance, s conversion.Scope) error {
	return autoConvert_v1_CStorPoolInstance_To_cstor_CStorPoolInstance(in, out, s)
}

func autoConvert_cstor_CStorPoolInstance_To_v1_CStorPoolInstance(in *cstor.CStorPoolInstance, out *v1.CStorPoolInstance, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_cstor_CStorPoolInstanceSpec_To_v1_CStorPoolInstanceSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_cstor_CStorPoolInstanceStatus_To_v1_CStorPoolInstanceStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	if err := Convert_cstor_VersionDetails_To_v1_VersionDetails(&in.VersionDetails, &out.VersionDetails, s); err != nil {
		return err
	}
	return nil
}

// Convert_cstor_CStorPoolInstance_To_v1_CStorPoolInstance is an autogenerated conversion function.
func Convert_cstor_CStorPoolInstance_To_v1_CStorPoolInstance(in *cstor.CStorPoolInstance, out *v1.CStorPoolInstance, s conversion.Scope) error {
	return autoConvert_cstor_CStorPoolInstance_To_v1_CStorPoolInstance(in, out, s)
}

func autoConvert_v1_CStorPoolInstanceBlockDevice_To_cstor_CStorPoolInstanceBlockDevice(in *v1.CStorPoolInstanceBlockDevice, out *cstor.CStorPoolInstanceBlockDevice, s conversion.Scope) error {
	out.BlockDeviceName = in.BlockDeviceName
	out.Capacity = in.Capacity
	out.DevLink = in.DevLink
	return nil
}

// Convert_v1_CStorPoolInstanceBlockDevice_To_cstor_CStorPoolInstanceBlockDevice is an autogenerated conversion function.
func Convert_v1_CStorPoolInstanceBlockDevice_To_cstor_CStorPoolInstanceBlockDevice(in *v1.CStorPoolInstanceBlockDevice, out *cstor.CStorPoolInstanceBlockDevice, s conversion.Scope) error {
	return autoConvert_v1_CStorPoolInstanceBlockDevice_To_cstor_CStorPoolInstanceBlockDevice(in, out, s)
}

func autoConvert_cstor_CStorPoolInstanceBlockDevice_To_v1_CStorPoolInstanceBlockDevice(in *cstor.CStorPoolInstanceBlockDevice, out *v1.CStorPoolInstanceBlockDevice, s conversion.Scope) error {
	out.BlockDeviceName = in.BlockDeviceName
	out.Capacity = in.Capacity
	out.DevLink = in.DevLink
	return nil
}

// Convert_cstor_CStorPoolInstanceBlockDevice_To_v1_CStorPoolInstanceBlockDevice is an autogenerated conversion function.
func Convert_cstor_CStorPoolInstanceBlockDevice_To_v1_CStorPoolInstanceBlockDevice(in *cstor.CStorPoolInstanceBlockDevice, out *v1.CStorPoolInstanceBlockDevice, s conversion.Scope) error {
	return autoConvert_cstor_CStorPoolInstanceBlockDevice_To_v1_CStorPoolInstanceBlockDevice(in, out, s)
}

func autoConvert_v1_CStorPoolInstanceCapacity_To_cstor_CStorPoolInstanceCapacity(in *v1.CStorPoolInstanceCapacity, out *cstor.CStorPoolInstanceCapacity, s conversion.Scope) error {
	out.Used = in.Used
	out.Free = in.Free
	out.Total = in.Total
	if err := Convert_v1_ZFSCapacityAttributes_To_cstor_ZFSCapacityAttributes(&in.ZFS, &out.ZFS, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1_CStorPoolInstanceCapacity_To_cstor_CStorPoolInstanceCapacity is an autogenerated conversion function.
func Convert_v1_CStorPoolInstanceCapacity_To_cstor_CStorPoolInstanceCapacity(in *v1.CStorPoolInstanceCapacity, out *cstor.CStorPoolInstanceCapacity, s conversion.Scope) error {
	return autoConvert_v1_CStorPoolInstanceCapacity_To_cstor_CStorPoolInstanceCapacity(in, out, s)
}

func autoConvert_cstor_CStorPoolInstanceCapacity_To_v1_CStorPoolInstanceCapacity(in *cstor.CStorPoolInstanceCapacity, out *v1.CStorPoolInstanceCapacity, s conversion.Scope) error {
	out.Used = in.Used
	out.Free = in.Free
	out.Total = in.Total
	if err := Convert_cstor_ZFSCapacityAttributes_To_v1_ZFSCapacityAttributes(&in.ZFS, &out.ZFS, s); err != nil {
		return err
	}
	return nil
}

// Convert_cstor_CStorPoolInstanceCapacity_To_v1_CStorPoolInstanceCapacity is an autogenerated conversion function.
func Convert_cstor_CStorPoolInstanceCapacity_To_v1_CStorPoolInstanceCapacity(in *cstor.CStorPoolInstanceCapacity, out *v1.CStorPoolInstanceCapacity, s conversion.Scope) error {
	return autoConvert_cstor_CStorPoolInstanceCapacity_To_v1_CStorPoolInstanceCapacity(in, out, s)
}

func autoConvert_v1_CStorPoolInstanceCondition_To_cstor_CStorPoolInstanceCondition(in *v1.CStorPoolInstanceCondition, out *cstor.CStorPoolInstanceCondition, s conversion.Scope) error {
	out.Type = cstor.CSPCConditionType(in.Type)
	out.Status = corev1.ConditionStatus(in.Status)
	out.LastUpdateTime = in.LastUpdateTime
	out.LastTransitionTime = in.LastTransitionTime
	out.Reason = in.Reason
	out.Message = in.Message
	return nil
}

// Convert_v1_CStorPoolInstanceCondition_To_cstor_CStorPoolInstanceCondition is an autogenerated conversion function.
func Convert_v1_CStorPoolInstanceCondition_To_cstor_CStorPoolInstanceCondition(in *v1.CStorPoolInstanceCondition, out *cstor.CStorPoolInstanceCondition, s conversion.Scope) error {
	return autoConvert_v1_CStorPoolInstanceCondition_To_cstor_CStorPoolInstanceCondition(in, out, s)
}

func autoConvert_cstor_CStorPoolInstanceCondition_To_v1_CStorPoolInstanceCondition(in *cstor.CStorPoolInstanceCondition, out *v1.CStorPoolInstanceCondition, s conversion.Scope) error {
	out.Type = v1.CStorPoolInstanceConditionType(in.Type)
	out.Status = corev1.ConditionStatus(in.Status)
	out.LastUpdateTime = in.LastUpdateTime
	out.LastTransitionTime = in.LastTransitionTime
	out.Reason = in.Reason
	out.Message = in.Message
	return nil
}

// Convert_cstor_CStorPoolInstanceCondition_To_v1_CStorPoolInstanceCondition is an autogenerated conversion function.
func Convert_cstor_CStorPoolInstanceCondition_To_v1_CStorPoolInstanceCondition(in *cstor.CStorPoolInstanceCondition, out *v1.CStorPoolInstanceCondition, s conversion.Scope) error {
	return autoConvert_cstor_CStorPoolInstanceCondition_To_v1_CStorPoolInstanceCondition(in, out, s)
}

func autoConvert_v1_CStorPoolInstanceList_To_cstor_CStorPoolInstanceList(in *v1.CStorPoolInstanceList, out *cstor.CStorPoolInstanceList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	out.Items = *(*[]cstor.CStorPoolInstance)(unsafe.Pointer(&in.Items))
	return nil
}

// Convert_v1_CStorPoolInstanceList_To_cstor_CStorPoolInstanceList is an autogenerated conversion function.
func Convert_v1_CStorPoolInstanceList_To_cstor_CStorPoolInstanceList(in *v1.CStorPoolInstanceList, out *cstor.CStorPoolInstanceList, s conversion.Scope) error {
	return autoConvert_v1_CStorPoolInstanceList_To_cstor_CStorPoolInstanceList(in, out, s)
}

func autoConvert_cstor_CStorPoolInstanceList_To_v1_CStorPoolInstanceList(in *cstor.CStorPoolInstanceList, out *v1.CStorPoolInstanceList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	out.Items = *(*[]v1.CStorPoolInstance)(unsafe.Pointer(&in.Items))
	return nil
}

// Convert_cstor_CStorPoolInstanceList_To_v1_CStorPoolInstanceList is an autogenerated conversion function.
func Convert_cstor_CStorPoolInstanceList_To_v1_CStorPoolInstanceList(in *cstor.CStorPoolInstanceList, out *v1.CStorPoolInstanceList, s conversion.Scope) error {
	return autoConvert_cstor_CStorPoolInstanceList_To_v1_CStorPoolInstanceList(in, out, s)
}

func autoConvert_v1_CStorPoolInstanceSpec_To_cstor_CStorPoolInstanceSpec(in *v1.CStorPoolInstanceSpec, out *cstor.CStorPoolInstanceSpec, s conversion.Scope) error {
	out.HostName = in.HostName
	out.NodeSelector = *(*map[string]string)(unsafe.Pointer(&in.NodeSelector))
	if err := Convert_v1_PoolConfig_To_cstor_PoolConfig(&in.PoolConfig, &out.PoolConfig, s); err != nil {
		return err
	}
	out.DataRaidGroups = *(*[]cstor.RaidGroup)(unsafe.Pointer(&in.DataRaidGroups))
	out.WriteCacheRaidGroups = *(*[]cstor.RaidGroup)(unsafe.Pointer(&in.WriteCacheRaidGroups))
	return nil
}

// Convert_v1_CStorPoolInstanceSpec_To_cstor_CStorPoolInstanceSpec is an autogenerated conversion function.
func Convert_v1_CStorPoolInstanceSpec_To_cstor_CStorPoolInstanceSpec(in *v1.CStorPoolInstanceSpec, out *cstor.CStorPoolInstanceSpec, s conversion.Scope) error {
	return autoConvert_v1_CStorPoolInstanceSpec_To_cstor_CStorPoolInstanceSpec(in, out, s)
}

func autoConvert_cstor_CStorPoolInstanceSpec_To_v1_CStorPoolInstanceSpec(in *cstor.CStorPoolInstanceSpec, out *v1.CStorPoolInstanceSpec, s conversion.Scope) error {
	out.HostName = in.HostName
	out.NodeSelector = *(*map[string]string)(unsafe.Pointer(&in.NodeSelector))
	if err := Convert_cstor_PoolConfig_To_v1_PoolConfig(&in.PoolConfig, &out.PoolConfig, s); err != nil {
		return err
	}
	out.DataRaidGroups = *(*[]v1.RaidGroup)(unsafe.Pointer(&in.DataRaidGroups))
	out.WriteCacheRaidGroups = *(*[]v1.RaidGroup)(unsafe.Pointer(&in.WriteCacheRaidGroups))
	return nil
}

// Convert_cstor_CStorPoolInstanceSpec_To_v1_CStorPoolInstanceSpec is an autogenerated conversion function.
func Convert_cstor_CStorPoolInstanceSpec_To_v1_CStorPoolInstanceSpec(in *cstor.CStorPoolInstanceSpec, out *v1.CStorPoolInstanceSpec, s conversion.Scope) error {
	return autoConvert_cstor_CStorPoolInstanceSpec_To_v1_CStorPoolInstanceSpec(in, out, s)
}

func autoConvert_v1_CStorPoolInstanceStatus_To_cstor_CStorPoolInstanceStatus(in *v1.CStorPoolInstanceStatus, out *cstor.CStorPoolInstanceStatus, s conversion.Scope) error {
	out.Conditions = *(*[]cstor.CStorPoolInstanceCondition)(unsafe.Pointer(&in.Conditions))
	out.Phase = cstor.CStorPoolInstancePhase(in.Phase)
	if err := Convert_v1_CStorPoolInstanceCapacity_To_cstor_CStorPoolInstanceCapacity(&in.Capacity, &out.Capacity, s); err != nil {
		return err
	}
	out.ReadOnly = in.ReadOnly
	out.ProvisionedReplicas = in.ProvisionedReplicas
	out.HealthyReplicas = in.HealthyReplicas
	return nil
}

// Convert_v1_CStorPoolInstanceStatus_To_cstor_CStorPoolInstanceStatus is an autogenerated conversion function.
func Convert_v1_CStorPoolInstanceStatus_To_cstor_CStorPoolInstanceStatus(in *v1.CStorPoolInstanceStatus, out *cstor.CStorPoolInstanceStatus, s conversion.Scope) error {
	return autoConvert_v1_CStorPoolInstanceStatus_To_cstor_CStorPoolInstanceStatus(in, out, s)
}

func autoConvert_cstor_CStorPoolInstanceStatus_To_v1_CStorPoolInstanceStatus(in *cstor.CStorPoolInstanceStatus, out *v1.CStorPoolInstanceStatus, s conversion.Scope) error {
	out.Conditions = *(*[]v1.CStorPoolInstanceCondition)(unsafe.Pointer(&in.Conditions))
	out.Phase = v1.CStorPoolInstancePhase(in.Phase)
	if err := Convert_cstor_CStorPoolInstanceCapacity_To_v1_CStorPoolInstanceCapacity(&in.Capacity, &out.Capacity, s); err != nil {
		return err
	}
	out.ReadOnly = in.ReadOnly
	out.ProvisionedReplicas = in.ProvisionedReplicas
	out.HealthyReplicas = in.HealthyReplicas
	return nil
}

// Convert_cstor_CStorPoolInstanceStatus_To_v1_CStorPoolInstanceStatus is an autogenerated conversion function.
func Convert_cstor_CStorPoolInstanceStatus_To_v1_CStorPoolInstanceStatus(in *cstor.CStorPoolInstanceStatus, out *v1.CStorPoolInstanceStatus, s conversion.Scope) error {
	return autoConvert_cstor_CStorPoolInstanceStatus_To_v1_CStorPoolInstanceStatus(in, out, s)
}

func autoConvert_v1_CStorRestore_To_cstor_CStorRestore(in *v1.CStorRestore, out *cstor.CStorRestore, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1_CStorRestoreSpec_To_cstor_CStorRestoreSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	out.Status = cstor.CStorRestoreStatus(in.Status)
	return nil
}

// Convert_v1_CStorRestore_To_cstor_CStorRestore is an autogenerated conversion function.
func Convert_v1_CStorRestore_To_cstor_CStorRestore(in *v1.CStorRestore, out *cstor.CStorRestore, s conversion.Scope) error {
	return autoConvert_v1_CStorRestore_To_cstor_CStorRestore(in, out, s)
}

func autoConvert_cstor_CStorRestore_To_v1_CStorRestore(in *cstor.CStorRestore, out *v1.CStorRestore, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_cstor_CStorRestoreSpec_To_v1_CStorRestoreSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	out.Status = v1.CStorRestoreStatus(in.Status)
	return nil
}

// Convert_cstor_CStorRestore_To_v1_CStorRestore is an autogenerated conversion function.
func Convert_cstor_CStorRestore_To_v1_CStorRestore(in *cstor.CStorRestore, out *v1.CStorRestore, s conversion.Scope) error {
	return autoConvert_cstor_CStorRestore_To_v1_CStorRestore(in, out, s)
}

func autoConvert_v1_CStorRestoreList_To_cstor_CStorRestoreList(in *v1.CStorRestoreList, out *cstor.CStorRestoreList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	out.Items = *(*[]cstor.CStorRestore)(unsafe.Pointer(&in.Items))
	return nil
}

// Convert_v1_CStorRestoreList_To_cstor_CStorRestoreList is an autogenerated conversion function.
func Convert_v1_CStorRestoreList_To_cstor_CStorRestoreList(in *v1.CStorRestoreList, out *cstor.CStorRestoreList, s conversion.Scope) error {
	return autoConvert_v1_CStorRestoreList_To_cstor_CStorRestoreList(in, out, s)
}

func autoConvert_cstor_CStorRestoreList_To_v1_CStorRestoreList(in *cstor.CStorRestoreList, out *v1.CStorRestoreList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	out.Items = *(*[]v1.CStorRestore)(unsafe.Pointer(&in.Items))
	return nil
}

// Convert_cstor_CStorRestoreList_To_v1_CStorRestoreList is an autogenerated conversion function.
func Convert_cstor_CStorRestoreList_To_v1_CStorRestoreList(in *cstor.CStorRestoreList, out *v1.CStorRestoreList, s conversion.Scope) error {
	return autoConvert_cstor_CStorRestoreList_To_v1_CStorRestoreList(in, out, s)
}

func autoConvert_v1_CStorRestoreSpec_To_cstor_CStorRestoreSpec(in *v1.CStorRestoreSpec, out *cstor.CStorRestoreSpec, s conversion.Scope) error {
	out.RestoreName = in.RestoreName
	out.VolumeName = in.VolumeName
	out.RestoreSrc = in.RestoreSrc
	out.MaxRetryCount = in.MaxRetryCount
	out.RetryCount = in.RetryCount
	out.StorageClass = in.StorageClass
	out.Size = in.Size
	out.Local = in.Local
	return nil
}

// Convert_v1_CStorRestoreSpec_To_cstor_CStorRestoreSpec is an autogenerated conversion function.
func Convert_v1_CStorRestoreSpec_To_cstor_CStorRestoreSpec(in *v1.CStorRestoreSpec, out *cstor.CStorRestoreSpec, s conversion.Scope) error {
	return autoConvert_v1_CStorRestoreSpec_To_cstor_CStorRestoreSpec(in, out, s)
}

func autoConvert_cstor_CStorRestoreSpec_To_v1_CStorRestoreSpec(in *cstor.CStorRestoreSpec, out *v1.CStorRestoreSpec, s conversion.Scope) error {
	out.RestoreName = in.RestoreName
	out.VolumeName = in.VolumeName
	out.RestoreSrc = in.RestoreSrc
	out.MaxRetryCount = in.MaxRetryCount
	out.RetryCount = in.RetryCount
	out.StorageClass = in.StorageClass
	out.Size = in.Size
	out.Local = in.Local
	return nil
}

// Convert_cstor_CStorRestoreSpec_To_v1_CStorRestoreSpec is an autogenerated conversion function.
func Convert_cstor_CStorRestoreSpec_To_v1_CStorRestoreSpec(in *cstor.CStorRestoreSpec, out *v1.CStorRestoreSpec, s conversion.Scope) error {
	return autoConvert_cstor_CStorRestoreSpec_To_v1_CStorRestoreSpec(in, out, s)
}

func autoConvert_v1_CStorSnapshotInfo_To_cstor_CStorSnapshotInfo(in *v1.CStorSnapshotInfo, out *cstor.CStorSnapshotInfo, s conversion.Scope) error {
	out.LogicalReferenced = in.LogicalReferenced
	return nil
}

// Convert_v1_CStorSnapshotInfo_To_cstor_CStorSnapshotInfo is an autogenerated conversion function.
func Convert_v1_CStorSnapshotInfo_To_cstor_CStorSnapshotInfo(in *v1.CStorSnapshotInfo, out *cstor.CStorSnapshotInfo, s conversion.Scope) error {
	return autoConvert_v1_CStorSnapshotInfo_To_cstor_CStorSnapshotInfo(in, out, s)
}

func autoConvert_cstor_CStorSnapshotInfo_To_v1_CStorSnapshotInfo(in *cstor.CStorSnapshotInfo, out *v1.CStorSnapshotInfo, s conversion.Scope) error {
	out.LogicalReferenced = in.LogicalReferenced
	return nil
}

// Convert_cstor_CStorSnapshotInfo_To_v1_CStorSnapshotInfo is an autogenerated conversion function.
func Convert_cstor_CStorSnapshotInfo_To_v1_CStorSnapshotInfo(in *cstor.CStorSnapshotInfo, out *v1.CStorSnapshotInfo, s conversion.Scope) error {
	return autoConvert_cstor_CStorSnapshotInfo_To_v1_CStorSnapshotInfo(in, out, s)
}

func autoConvert_v1_CStorVolume_To_cstor_CStorVolume(in *v1.CStorVolume, out *cstor.CStorVolume, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1_CStorVolumeSpec_To_cstor_CStorVolumeSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_v1_CStorVolumeStatus_To_cstor_CStorVolumeStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	if err := Convert_v1_VersionDetails_To_cstor_VersionDetails(&in.VersionDetails, &out.VersionDetails, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1_CStorVolume_To_cstor_CStorVolume is an autogenerated conversion function.
func Convert_v1_CStorVolume_To_cstor_CStorVolume(in *v1.CStorVolume, out *cstor.CStorVolume, s conversion.Scope) error {
	return autoConvert_v1_CStorVolume_To_cstor_CStorVolume(in, out, s)
}

func autoConvert_cstor_CStorVolume_To_v1_CStorVolume(in *cstor.CStorVolume, out *v1.CStorVolume, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_cstor_CStorVolumeSpec_To_v1_CStorVolumeSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_cstor_CStorVolumeStatus_To_v1_CStorVolumeStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	if err := Convert_cstor_VersionDetails_To_v1_VersionDetails(&in.VersionDetails, &out.VersionDetails, s); err != nil {
		return err
	}
	return nil
}

// Convert_cstor_CStorVolume_To_v1_CStorVolume is an autogenerated conversion function.
func Convert_cstor_CStorVolume_To_v1_CStorVolume(in *cstor.CStorVolume, out *v1.CStorVolume, s conversion.Scope) error {
	return autoConvert_cstor_CStorVolume_To_v1_CStorVolume(in, out, s)
}

func autoConvert_v1_CStorVolumeAttachment_To_cstor_CStorVolumeAttachment(in *v1.CStorVolumeAttachment, out *cstor.CStorVolumeAttachment, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1_CStorVolumeAttachmentSpec_To_cstor_CStorVolumeAttachmentSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	out.Status = cstor.CStorVolumeAttachmentStatus(in.Status)
	return nil
}

// Convert_v1_CStorVolumeAttachment_To_cstor_CStorVolumeAttachment is an autogenerated conversion function.
func Convert_v1_CStorVolumeAttachment_To_cstor_CStorVolumeAttachment(in *v1.CStorVolumeAttachment, out *cstor.CStorVolumeAttachment, s conversion.Scope) error {
	return autoConvert_v1_CStorVolumeAttachment_To_cstor_CStorVolumeAttachment(in, out, s)
}

func autoConvert_cstor_CStorVolumeAttachment_To_v1_CStorVolumeAttachment(in *cstor.CStorVolumeAttachment, out *v1.CStorVolumeAttachment, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_cstor_CStorVolumeAttachmentSpec_To_v1_CStorVolumeAttachmentSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	out.Status = v1.CStorVolumeAttachmentStatus(in.Status)
	return nil
}

// Convert_cstor_CStorVolumeAttachment_To_v1_CStorVolumeAttachment is an autogenerated conversion function.
func Convert_cstor_CStorVolumeAttachment_To_v1_CStorVolumeAttachment(in *cstor.CStorVolumeAttachment, out *v1.CStorVolumeAttachment, s conversion.Scope) error {
	return autoConvert_cstor_CStorVolumeAttachment_To_v1_CStorVolumeAttachment(in, out, s)
}

func autoConvert_v1_CStorVolumeAttachmentList_To_cstor_CStorVolumeAttachmentList(in *v1.CStorVolumeAttachmentList, out *cstor.CStorVolumeAttachmentList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	out.Items = *(*[]cstor.CStorVolumeAttachment)(unsafe.Pointer(&in.Items))
	return nil
}

// Convert_v1_CStorVolumeAttachmentList_To_cstor_CStorVolumeAttachmentList is an autogenerated conversion function.
func Convert_v1_CStorVolumeAttachmentList_To_cstor_CStorVolumeAttachmentList(in *v1.CStorVolumeAttachmentList, out *cstor.CStorVolumeAttachmentList, s conversion.Scope) error {
	return autoConvert_v1_CStorVolumeAttachmentList_To_cstor_CStorVolumeAttachmentList(in, out, s)
}

func autoConvert_cstor_CStorVolumeAttachmentList_To_v1_CStorVolumeAttachmentList(in *cstor.CStorVolumeAttachmentList, out *v1.CStorVolumeAttachmentList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	out.Items = *(*[]v1.CStorVolumeAttachment)(unsafe.Pointer(&in.Items))
	return nil
}

// Convert_cstor_CStorVolumeAttachmentList_To_v1_CStorVolumeAttachmentList is an autogenerated conversion function.
func Convert_cstor_CStorVolumeAttachmentList_To_v1_CStorVolumeAttachmentList(in *cstor.CStorVolumeAttachmentList, out *v1.CStorVolumeAttachmentList, s conversion.Scope) error {
	return autoConvert_cstor_CStorVolumeAttachmentList_To_v1_CStorVolumeAttachmentList(in, out, s)
}

func autoConvert_v1_CStorVolumeAttachmentSpec_To_cstor_CStorVolumeAttachmentSpec(in *v1.CStorVolumeAttachmentSpec, out *cstor.CStorVolumeAttachmentSpec, s conversion.Scope) error {
	if err := Convert_v1_VolumeInfo_To_cstor_VolumeInfo(&in.Volume, &out.Volume, s); err != nil {
		return err
	}
	if err := Convert_v1_ISCSIInfo_To_cstor_ISCSIInfo(&in.ISCSI, &out.ISCSI, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1_CStorVolumeAttachmentSpec_To_cstor_CStorVolumeAttachmentSpec is an autogenerated conversion function.
func Convert_v1_CStorVolumeAttachmentSpec_To_cstor_CStorVolumeAttachmentSpec(in *v1.CStorVolumeAttachmentSpec, out *cstor.CStorVolumeAttachmentSpec, s conversion.Scope) error {
	return autoConvert_v1_CStorVolumeAttachmentSpec_To_cstor_CStorVolumeAttachmentSpec(in, out, s)
}

func autoConvert_cstor_CStorVolumeAttachmentSpec_To_v1_CStorVolumeAttachmentSpec(in *cstor.CStorVolumeAttachmentSpec, out *v1.CStorVolumeAttachmentSpec, s conversion.Scope) error {
	if err := Convert_cstor_VolumeInfo_To_v1_VolumeInfo(&in.Volume, &out.Volume, s); err != nil {
		return err
	}
	if err := Convert_cstor_ISCSIInfo_To_v1_ISCSIInfo(&in.ISCSI, &out.ISCSI, s); err != nil {
		return err
	}
	return nil
}

// Convert_cstor_CStorVolumeAttachmentSpec_To_v1_CStorVolumeAttachmentSpec is an autogenerated conversion function.
func Convert_cstor_CStorVolumeAttachmentSpec_To_v1_CStorVolumeAttachmentSpec(in *cstor.CStorVolumeAttachmentSpec, out *v1.CStorVolumeAttachmentSpec, s conversion.Scope) error {
	return autoConvert_cstor_CStorVolumeAttachmentSpec_To_v1_CStorVolumeAttachmentSpec(in, out, s)
}

func autoConvert_v1_CStorVolumeCondition_To_cstor_CStorVolumeCondition(in *v1.CStorVolumeCondition, out *cstor.CStorVolumeCondition, s conversion.Scope) error {
	out.Type = cstor.CStorVolumeConditionType(in.Type)
	out.Status = cstor.ConditionStatus(in.Status)
	out.LastProbeTime = in.LastProbeTime
	out.LastTransitionTime = in.LastTransitionTime
	out.Reason = in.Reason
	out.Message = in.Message
	return nil
}

// Convert_v1_CStorVolumeCondition_To_cstor_CStorVolumeCondition is an autogenerated conversion function.
func Convert_v1_CStorVolumeCondition_To_cstor_CStorVolumeCondition(in *v1.CStorVolumeCondition, out *cstor.CStorVolumeCondition, s conversion.Scope) error {
	return autoConvert_v1_CStorVolumeCondition_To_cstor_CStorVolumeCondition(in, out, s)
}

func autoConvert_cstor_CStorVolumeCondition_To_v1_CStorVolumeCondition(in *cstor.CStorVolumeCondition, out *v1.CStorVolumeCondition, s conversion.Scope) error {
	out.Type = v1.CStorVolumeConditionType(in.Type)
	out.Status = v1.ConditionStatus(in.Status)
	out.LastProbeTime = in.LastProbeTime
	out.LastTransitionTime = in.LastTransitionTime
	out.Reason = in.Reason
	out.Message = in.Message
	return nil
}

// Convert_cstor_CStorVolumeCondition_To_v1_CStorVolumeCondition is an autogenerated conversion function.
func Convert_cstor_CStorVolumeCondition_To_v1_CStorVolumeCondition(in *cstor.CStorVolumeCondition, out *v1.CStorVolumeCondition, s conversion.Scope) error {
	return autoConvert_cstor_CStorVolumeCondition_To_v1_CStorVolumeCondition(in, out, s)
}

func autoConvert_v1_CStorVolumeConfig_To_cstor_CStorVolumeConfig(in *v1.CStorVolumeConfig, out *cstor.CStorVolumeConfig, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1_CStorVolumeConfigSpec_To_cstor_CStorVolumeConfigSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_v1_CStorVolumeConfigPublish_To_cstor_CStorVolumeConfigPublish(&in.Publish, &out.Publish, s); err != nil {
		return err
	}
	if err := Convert_v1_CStorVolumeConfigStatus_To_cstor_CStorVolumeConfigStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	if err := Convert_v1_VersionDetails_To_cstor_VersionDetails(&in.VersionDetails, &out.VersionDetails, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1_CStorVolumeConfig_To_cstor_CStorVolumeConfig is an autogenerated conversion function.
func Convert_v1_CStorVolumeConfig_To_cstor_CStorVolumeConfig(in *v1.CStorVolumeConfig, out *cstor.CStorVolumeConfig, s conversion.Scope) error {
	return autoConvert_v1_CStorVolumeConfig_To_cstor_CStorVolumeConfig(in, out, s)
}

func autoConvert_cstor_CStorVolumeConfig_To_v1_CStorVolumeConfig(in *cstor.CStorVolumeConfig, out *v1.CStorVolumeConfig, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_cstor_CStorVolumeConfigSpec_To_v1_CStorVolumeConfigSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_cstor_CStorVolumeConfigPublish_To_v1_CStorVolumeConfigPublish(&in.Publish, &out.Publish, s); err != nil {
		return err
	}
	if err := Convert_cstor_CStorVolumeConfigStatus_To_v1_CStorVolumeConfigStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	if err := Convert_cstor_VersionDetails_To_v1_VersionDetails(&in.VersionDetails, &out.VersionDetails, s); err != nil {
		return err
	}
	return nil
}

// Convert_cstor_CStorVolumeConfig_To_v1_CStorVolumeConfig is an autogenerated conversion function.
func Convert_cstor_CStorVolumeConfig_To_v1_CStorVolumeConfig(in *cstor.CStorVolumeConfig, out *v1.CStorVolumeConfig, s conversion.Scope) error {
	return autoConvert_cstor_CStorVolumeConfig_To_v1_CStorVolumeConfig(in, out, s)
}

func autoConvert_v1_CStorVolumeConfigCondition_To_cstor_CStorVolumeConfigCondition(in *v1.CStorVolumeConfigCondition, out *cstor.CStorVolumeConfigCondition, s conversion.Scope) error {
	out.Type = cstor.CStorVolumeConfigConditionType(in.Type)
	out.LastProbeTime = in.LastProbeTime
	out.LastTransitionTime = in.LastTransitionTime
	out.Reason = in.Reason
	out.Message = in.Message
	return nil
}

// Convert_v1_CStorVolumeConfigCondition_To_cstor_CStorVolumeConfigCondition is an autogenerated conversion function.
func Convert_v1_CStorVolumeConfigCondition_To_cstor_CStorVolumeConfigCondition(in *v1.CStorVolumeConfigCondition, out *cstor.CStorVolumeConfigCondition, s conversion.Scope) error {
	return autoConvert_v1_CStorVolumeConfigCondition_To_cstor_CStorVolumeConfigCondition(in, out, s)
}

func autoConvert_cstor_CStorVolumeConfigCondition_To_v1_CStorVolumeConfigCondition(in *cstor.CStorVolumeConfigCondition, out *v1.CStorVolumeConfigCondition, s conversion.Scope) error {
	out.Type = v1.CStorVolumeConfigConditionType(in.Type)
	out.LastProbeTime = in.LastProbeTime
	out.LastTransitionTime = in.LastTransitionTime
	out.Reason = in.Reason
	out.Message = in.Message
	return nil
}

// Convert_cstor_CStorVolumeConfigCondition_To_v1_CStorVolumeConfigCondition is an autogenerated conversion function.
func Convert_cstor_CStorVolumeConfigCondition_To_v1_CStorVolumeConfigCondition(in *cstor.CStorVolumeConfigCondition, out *v1.CStorVolumeConfigCondition, s conversion.Scope) error {
	return autoConvert_cstor_CStorVolumeConfigCondition_To_v1_CStorVolumeConfigCondition(in, out, s)
}

func autoConvert_v1_CStorVolumeConfigList_To_cstor_CStorVolumeConfigList(in *v1.CStorVolumeConfigList, out *cstor.CStorVolumeConfigList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	if in.Items != nil {
		in, out := &in.Items, &out.Items
		*out = make([]cstor.CStorVolumeConfig, len(*in))
		for i := range *in {
			if err := Convert_v1_CStorVolumeConfig_To_cstor_CStorVolumeConfig(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Items = nil
	}
	return nil
}

// Convert_v1_CStorVolumeConfigList_To_cstor_CStorVolumeConfigList is an autogenerated conversion function.
func Convert_v1_CStorVolumeConfigList_To_cstor_CStorVolumeConfigList(in *v1.CStorVolumeConfigList, out *cstor.CStorVolumeConfigList, s conversion.Scope) error {
	return autoConvert_v1_CStorVolumeConfigList_To_cstor_CStorVolumeConfigList(in, out, s)
}

func autoConvert_cstor_CStorVolumeConfigList_To_v1_CStorVolumeConfigList(in *cstor.CStorVolumeConfigList, out *v1.CStorVolumeConfigList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	if in.Items != nil {
		in, out := &in.Items, &out.Items
		*out = make([]v1.CStorVolumeConfig, len(*in))
		for i := range *in {
			if err := Convert_cstor_CStorVolumeConfig_To_v1_CStorVolumeConfig(&(*in)[i], &(*out)[i], s); err != nil {
				return err
			}
		}
	} else {
		out.Items = nil
	}
	return nil
}

// Convert_cstor_CStorVolumeConfigList_To_v1_CStorVolumeConfigList is an autogenerated conversion function.
func Convert_cstor_CStorVolumeConfigList_To_v1_CStorVolumeConfigList(in *cstor.CStorVolumeConfigList, out *v1.CStorVolumeConfigList, s conversion.Scope) error {
	return autoConvert_cstor_CStorVolumeConfigList_To_v1_CStorVolumeConfigList(in, out, s)
}

func autoConvert_v1_CStorVolumeConfigPublish_To_cstor_CStorVolumeConfigPublish(in *v1.CStorVolumeConfigPublish, out *cstor.CStorVolumeConfigPublish, s conversion.Scope) error {
	out.NodeID = in.NodeID
	return nil
}

// Convert_v1_CStorVolumeConfigPublish_To_cstor_CStorVolumeConfigPublish is an autogenerated conversion function.
func Convert_v1_CStorVolumeConfigPublish_To_cstor_CStorVolumeConfigPublish(in *v1.CStorVolumeConfigPublish, out *cstor.CStorVolumeConfigPublish, s conversion.Scope) error {
	return autoConvert_v1_CStorVolumeConfigPublish_To_cstor_CStorVolumeConfigPublish(in, out, s)
}

func autoConvert_cstor_CStorVolumeConfigPublish_To_v1_CStorVolumeConfigPublish(in *cstor.CStorVolumeConfigPublish, out *v1.CStorVolumeConfigPublish, s conversion.Scope) error {
	out.NodeID = in.NodeID
	return nil
}

// Convert_cstor_CStorVolumeConfigPublish_To_v1_CStorVolumeConfigPublish is an autogenerated conversion function.
func Convert_cstor_CStorVolumeConfigPublish_To_v1_CStorVolumeConfigPublish(in *cstor.CStorVolumeConfigPublish, out *v1.CStorVolumeConfigPublish, s conversion.Scope) error {
	return autoConvert_cstor_CStorVolumeConfigPublish_To_v1_CStorVolumeConfigPublish(in, out, s)
}

func autoConvert_v1_CStorVolumeConfigSpec_To_cstor_CStorVolumeConfigSpec(in *v1.CStorVolumeConfigSpec, out *cstor.CStorVolumeConfigSpec, s conversion.Scope) error {
	out.Capacity = *(*corev1.ResourceList)(unsafe.Pointer(&in.Capacity))
	out.CStorVolumeRef = (*corev1.ObjectReference)(unsafe.Pointer(in.CStorVolumeRef))
	out.CStorVolumeSource = in.CStorVolumeSource
	if err := Convert_v1_VolumeProvision_To_cstor_VolumeProvision(&in.Provision, &out.Provision, s); err != nil {
		return err
	}
	if err := Convert_v1_CStorVolumePolicySpec_To_cstor_CStorVolumePolicySpec(&in.Policy, &out.Policy, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1_CStorVolumeConfigSpec_To_cstor_CStorVolumeConfigSpec is an autogenerated conversion function.
func Convert_v1_CStorVolumeConfigSpec_To_cstor_CStorVolumeConfigSpec(in *v1.CStorVolumeConfigSpec, out *cstor.CStorVolumeConfigSpec, s conversion.Scope) error {
	return autoConvert_v1_CStorVolumeConfigSpec_To_cstor_CStorVolumeConfigSpec(in, out, s)
}

func autoConvert_cstor_CStorVolumeConfigSpec_To_v1_CStorVolumeConfigSpec(in *cstor.CStorVolumeConfigSpec, out *v1.CStorVolumeConfigSpec, s conversion.Scope) error {
	out.Capacity = *(*corev1.ResourceList)(unsafe.Pointer(&in.Capacity))
	out.CStorVolumeRef = (*corev1.ObjectReference)(unsafe.Pointer(in.CStorVolumeRef))
	out.CStorVolumeSource = in.CStorVolumeSource
	if err := Convert_cstor_VolumeProvision_To_v1_VolumeProvision(&in.Provision, &out.Provision, s); err != nil {
		return err
	}
	if err := Convert_cstor_CStorVolumePolicySpec_To_v1_CStorVolumePolicySpec(&in.Policy, &out.Policy, s); err != nil {
		return err
	}
	return nil
}

// Convert_cstor_CStorVolumeConfigSpec_To_v1_CStorVolumeConfigSpec is an autogenerated conversion function.
func Convert_cstor_CStorVolumeConfigSpec_To_v1_CStorVolumeConfigSpec(in *cstor.CStorVolumeConfigSpec, out *v1.CStorVolumeConfigSpec, s conversion.Scope) error {
	return autoConvert_cstor_CStorVolumeConfigSpec_To_v1_CStorVolumeConfigSpec(in, out, s)
}

func autoConvert_v1_CStorVolumeConfigStatus_To_cstor_CStorVolumeConfigStatus(in *v1.CStorVolumeConfigStatus, out *cstor.CStorVolumeConfigStatus, s conversion.Scope) error {
	out.Phase = cstor.CStorVolumeConfigPhase(in.Phase)
	out.PoolInfo = *(*[]string)(unsafe.Pointer(&in.PoolInfo))
	out.Capacity = *(*corev1.ResourceList)(unsafe.Pointer(&in.Capacity))
	out.Conditions = *(*[]cstor.CStorVolumeConfigCondition)(unsafe.Pointer(&in.Conditions))
	return nil
}

// Convert_v1_CStorVolumeConfigStatus_To_cstor_CStorVolumeConfigStatus is an autogenerated conversion function.
func Convert_v1_CStorVolumeConfigStatus_To_cstor_CStorVolumeConfigStatus(in *v1.CStorVolumeConfigStatus, out *cstor.CStorVolumeConfigStatus, s conversion.Scope) error {
	return autoConvert_v1_CStorVolumeConfigStatus_To_cstor_CStorVolumeConfigStatus(in, out, s)
}

func autoConvert_cstor_CStorVolumeConfigStatus_To_v1_CStorVolumeConfigStatus(in *cstor.CStorVolumeConfigStatus, out *v1.CStorVolumeConfigStatus, s conversion.Scope) error {
	out.Phase = v1.CStorVolumeConfigPhase(in.Phase)
	out.PoolInfo = *(*[]string)(unsafe.Pointer(&in.PoolInfo))
	out.Capacity = *(*corev1.ResourceList)(unsafe.Pointer(&in.Capacity))
	out.Conditions = *(*[]v1.CStorVolumeConfigCondition)(unsafe.Pointer(&in.Conditions))
	return nil
}

// Convert_cstor_CStorVolumeConfigStatus_To_v1_CStorVolumeConfigStatus is an autogenerated conversion function.
func Convert_cstor_CStorVolumeConfigStatus_To_v1_CStorVolumeConfigStatus(in *cstor.CStorVolumeConfigStatus, out *v1.CStorVolumeConfigStatus, s conversion.Scope) error {
	return autoConvert_cstor_CStorVolumeConfigStatus_To_v1_CStorVolumeConfigStatus(in, out, s)
}

func autoConvert_v1_CStorVolumeList_To_cstor_CStorVolumeList(in *v1.CStorVolumeList, out *cstor.CStorVolumeList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	out.Items = *(*[]cstor.CStorVolume)(unsafe.Pointer(&in.Items))
	return nil
}

// Convert_v1_CStorVolumeList_To_cstor_CStorVolumeList is an autogenerated conversion function.
func Convert_v1_CStorVolumeList_To_cstor_CStorVolumeList(in *v1.CStorVolumeList, out *cstor.CStorVolumeList, s conversion.Scope) error {
	return autoConvert_v1_CStorVolumeList_To_cstor_CStorVolumeList(in, out, s)
}

func autoConvert_cstor_CStorVolumeList_To_v1_CStorVolumeList(in *cstor.CStorVolumeList, out *v1.CStorVolumeList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	out.Items = *(*[]v1.CStorVolume)(unsafe.Pointer(&in.Items))
	return nil
}

// Convert_cstor_CStorVolumeList_To_v1_CStorVolumeList is an autogenerated conversion function.
func Convert_cstor_CStorVolumeList_To_v1_CStorVolumeList(in *cstor.CStorVolumeList, out *v1.CStorVolumeList, s conversion.Scope) error {
	return autoConvert_cstor_CStorVolumeList_To_v1_CStorVolumeList(in, out, s)
}

func autoConvert_v1_CStorVolumePolicy_To_cstor_CStorVolumePolicy(in *v1.CStorVolumePolicy, out *cstor.CStorVolumePolicy, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1_CStorVolumePolicySpec_To_cstor_CStorVolumePolicySpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_v1_CStorVolumePolicyStatus_To_cstor_CStorVolumePolicyStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1_CStorVolumePolicy_To_cstor_CStorVolumePolicy is an autogenerated conversion function.
func Convert_v1_CStorVolumePolicy_To_cstor_CStorVolumePolicy(in *v1.CStorVolumePolicy, out *cstor.CStorVolumePolicy, s conversion.Scope) error {
	return autoConvert_v1_CStorVolumePolicy_To_cstor_CStorVolumePolicy(in, out, s)
}

func autoConvert_cstor_CStorVolumePolicy_To_v1_CStorVolumePolicy(in *cstor.CStorVolumePolicy, out *v1.CStorVolumePolicy, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_cstor_CStorVolumePolicySpec_To_v1_CStorVolumePolicySpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_cstor_CStorVolumePolicyStatus_To_v1_CStorVolumePolicyStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	return nil
}

// Convert_cstor_CStorVolumePolicy_To_v1_CStorVolumePolicy is an autogenerated conversion function.
func Convert_cstor_CStorVolumePolicy_To_v1_CStorVolumePolicy(in *cstor.CStorVolumePolicy, out *v1.CStorVolumePolicy, s conversion.Scope) error {
	return autoConvert_cstor_CStorVolumePolicy_To_v1_CStorVolumePolicy(in, out, s)
}

func autoConvert_v1_CStorVolumePolicyList_To_cstor_CStorVolumePolicyList(in *v1.CStorVolumePolicyList, out *cstor.CStorVolumePolicyList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	out.Items = *(*[]cstor.CStorVolumePolicy)(unsafe.Pointer(&in.Items))
	return nil
}

// Convert_v1_CStorVolumePolicyList_To_cstor_CStorVolumePolicyList is an autogenerated conversion function.
func Convert_v1_CStorVolumePolicyList_To_cstor_CStorVolumePolicyList(in *v1.CStorVolumePolicyList, out *cstor.CStorVolumePolicyList, s conversion.Scope) error {
	return autoConvert_v1_CStorVolumePolicyList_To_cstor_CStorVolumePolicyList(in, out, s)
}

func autoConvert_cstor_CStorVolumePolicyList_To_v1_CStorVolumePolicyList(in *cstor.CStorVolumePolicyList, out *v1.CStorVolumePolicyList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	out.Items = *(*[]v1.CStorVolumePolicy)(unsafe.Pointer(&in.Items))
	return nil
}

// Convert_cstor_CStorVolumePolicyList_To_v1_CStorVolumePolicyList is an autogenerated conversion function.
func Convert_cstor_CStorVolumePolicyList_To_v1_CStorVolumePolicyList(in *cstor.CStorVolumePolicyList, out *v1.CStorVolumePolicyList, s conversion.Scope) error {
	return autoConvert_cstor_CStorVolumePolicyList_To_v1_CStorVolumePolicyList(in, out, s)
}

func autoConvert_v1_CStorVolumePolicySpec_To_cstor_CStorVolumePolicySpec(in *v1.CStorVolumePolicySpec, out *cstor.CStorVolumePolicySpec, s conversion.Scope) error {
	if err := Convert_v1_Provision_To_cstor_Provision(&in.Provision, &out.Provision, s); err != nil {
		return err
	}
	if err := Convert_v1_TargetSpec_To_cstor_TargetSpec(&in.Target, &out.Target, s); err != nil {
		return err
	}
	if err := Convert_v1_ReplicaSpec_To_cstor_ReplicaSpec(&in.Replica, &out.Replica, s); err != nil {
		return err
	}
	out.ReplicaPoolInfo = *(*[]cstor.ReplicaPoolInfo)(unsafe.Pointer(&in.ReplicaPoolInfo))
	return nil
}

// Convert_v1_CStorVolumePolicySpec_To_cstor_CStorVolumePolicySpec is an autogenerated conversion function.
func Convert_v1_CStorVolumePolicySpec_To_cstor_CStorVolumePolicySpec(in *v1.CStorVolumePolicySpec, out *cstor.CStorVolumePolicySpec, s conversion.Scope) error {
	return autoConvert_v1_CStorVolumePolicySpec_To_cstor_CStorVolumePolicySpec(in, out, s)
}

func autoConvert_cstor_CStorVolumePolicySpec_To_v1_CStorVolumePolicySpec(in *cstor.CStorVolumePolicySpec, out *v1.CStorVolumePolicySpec, s conversion.Scope) error {
	if err := Convert_cstor_Provision_To_v1_Provision(&in.Provision, &out.Provision, s); err != nil {
		return err
	}
	if err := Convert_cstor_TargetSpec_To_v1_TargetSpec(&in.Target, &out.Target, s); err != nil {
		return err
	}
	if err := Convert_cstor_ReplicaSpec_To_v1_ReplicaSpec(&in.Replica, &out.Replica, s); err != nil {
		return err
	}
	out.ReplicaPoolInfo = *(*[]v1.ReplicaPoolInfo)(unsafe.Pointer(&in.ReplicaPoolInfo))
	return nil
}

// Convert_cstor_CStorVolumePolicySpec_To_v1_CStorVolumePolicySpec is an autogenerated conversion function.
func Convert_cstor_CStorVolumePolicySpec_To_v1_CStorVolumePolicySpec(in *cstor.CStorVolumePolicySpec, out *v1.CStorVolumePolicySpec, s conversion.Scope) error {
	return autoConvert_cstor_CStorVolumePolicySpec_To_v1_CStorVolumePolicySpec(in, out, s)
}

func autoConvert_v1_CStorVolumePolicyStatus_To_cstor_CStorVolumePolicyStatus(in *v1.CStorVolumePolicyStatus, out *cstor.CStorVolumePolicyStatus, s conversion.Scope) error {
	out.Phase = in.Phase
	return nil
}

// Convert_v1_CStorVolumePolicyStatus_To_cstor_CStorVolumePolicyStatus is an autogenerated conversion function.
func Convert_v1_CStorVolumePolicyStatus_To_cstor_CStorVolumePolicyStatus(in *v1.CStorVolumePolicyStatus, out *cstor.CStorVolumePolicyStatus, s conversion.Scope) error {
	return autoConvert_v1_CStorVolumePolicyStatus_To_cstor_CStorVolumePolicyStatus(in, out, s)
}

func autoConvert_cstor_CStorVolumePolicyStatus_To_v1_CStorVolumePolicyStatus(in *cstor.CStorVolumePolicyStatus, out *v1.CStorVolumePolicyStatus, s conversion.Scope) error {
	out.Phase = in.Phase
	return nil
}

// Convert_cstor_CStorVolumePolicyStatus_To_v1_CStorVolumePolicyStatus is an autogenerated conversion function.
func Convert_cstor_CStorVolumePolicyStatus_To_v1_CStorVolumePolicyStatus(in *cstor.CStorVolumePolicyStatus, out *v1.CStorVolumePolicyStatus, s conversion.Scope) error {
	return autoConvert_cstor_CStorVolumePolicyStatus_To_v1_CStorVolumePolicyStatus(in, out, s)
}

func autoConvert_v1_CStorVolumeReplica_To_cstor_CStorVolumeReplica(in *v1.CStorVolumeReplica, out *cstor.CStorVolumeReplica, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_v1_CStorVolumeReplicaSpec_To_cstor_CStorVolumeReplicaSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_v1_CStorVolumeReplicaStatus_To_cstor_CStorVolumeReplicaStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	if err := Convert_v1_VersionDetails_To_cstor_VersionDetails(&in.VersionDetails, &out.VersionDetails, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1_CStorVolumeReplica_To_cstor_CStorVolumeReplica is an autogenerated conversion function.
func Convert_v1_CStorVolumeReplica_To_cstor_CStorVolumeReplica(in *v1.CStorVolumeReplica, out *cstor.CStorVolumeReplica, s conversion.Scope) error {
	return autoConvert_v1_CStorVolumeReplica_To_cstor_CStorVolumeReplica(in, out, s)
}

func autoConvert_cstor_CStorVolumeReplica_To_v1_CStorVolumeReplica(in *cstor.CStorVolumeReplica, out *v1.CStorVolumeReplica, s conversion.Scope) error {
	out.ObjectMeta = in.ObjectMeta
	if err := Convert_cstor_CStorVolumeReplicaSpec_To_v1_CStorVolumeReplicaSpec(&in.Spec, &out.Spec, s); err != nil {
		return err
	}
	if err := Convert_cstor_CStorVolumeReplicaStatus_To_v1_CStorVolumeReplicaStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	if err := Convert_cstor_VersionDetails_To_v1_VersionDetails(&in.VersionDetails, &out.VersionDetails, s); err != nil {
		return err
	}
	return nil
}

// Convert_cstor_CStorVolumeReplica_To_v1_CStorVolumeReplica is an autogenerated conversion function.
func Convert_cstor_CStorVolumeReplica_To_v1_CStorVolumeReplica(in *cstor.CStorVolumeReplica, out *v1.CStorVolumeReplica, s conversion.Scope) error {
	return autoConvert_cstor_CStorVolumeReplica_To_v1_CStorVolumeReplica(in, out, s)
}

func autoConvert_v1_CStorVolumeReplicaCapacityDetails_To_cstor_CStorVolumeReplicaCapacityDetails(in *v1.CStorVolumeReplicaCapacityDetails, out *cstor.CStorVolumeReplicaCapacityDetails, s conversion.Scope) error {
	out.Total = in.Total
	out.Used = in.Used
	return nil
}

// Convert_v1_CStorVolumeReplicaCapacityDetails_To_cstor_CStorVolumeReplicaCapacityDetails is an autogenerated conversion function.
func Convert_v1_CStorVolumeReplicaCapacityDetails_To_cstor_CStorVolumeReplicaCapacityDetails(in *v1.CStorVolumeReplicaCapacityDetails, out *cstor.CStorVolumeReplicaCapacityDetails, s conversion.Scope) error {
	return autoConvert_v1_CStorVolumeReplicaCapacityDetails_To_cstor_CStorVolumeReplicaCapacityDetails(in, out, s)
}

func autoConvert_cstor_CStorVolumeReplicaCapacityDetails_To_v1_CStorVolumeReplicaCapacityDetails(in *cstor.CStorVolumeReplicaCapacityDetails, out *v1.CStorVolumeReplicaCapacityDetails, s conversion.Scope) error {
	out.Total = in.Total
	out.Used = in.Used
	return nil
}

// Convert_cstor_CStorVolumeReplicaCapacityDetails_To_v1_CStorVolumeReplicaCapacityDetails is an autogenerated conversion function.
func Convert_cstor_CStorVolumeReplicaCapacityDetails_To_v1_CStorVolumeReplicaCapacityDetails(in *cstor.CStorVolumeReplicaCapacityDetails, out *v1.CStorVolumeReplicaCapacityDetails, s conversion.Scope) error {
	return autoConvert_cstor_CStorVolumeReplicaCapacityDetails_To_v1_CStorVolumeReplicaCapacityDetails(in, out, s)
}

func autoConvert_v1_CStorVolumeReplicaDetails_To_cstor_CStorVolumeReplicaDetails(in *v1.CStorVolumeReplicaDetails, out *cstor.CStorVolumeReplicaDetails, s conversion.Scope) error {
	out.KnownReplicas = *(*map[cstor.ReplicaID]string)(unsafe.Pointer(&in.KnownReplicas))
	return nil
}

// Convert_v1_CStorVolumeReplicaDetails_To_cstor_CStorVolumeReplicaDetails is an autogenerated conversion function.
func Convert_v1_CStorVolumeReplicaDetails_To_cstor_CStorVolumeReplicaDetails(in *v1.CStorVolumeReplicaDetails, out *cstor.CStorVolumeReplicaDetails, s conversion.Scope) error {
	return autoConvert_v1_CStorVolumeReplicaDetails_To_cstor_CStorVolumeReplicaDetails(in, out, s)
}

func autoConvert_cstor_CStorVolumeReplicaDetails_To_v1_CStorVolumeReplicaDetails(in *cstor.CStorVolumeReplicaDetails, out *v1.CStorVolumeReplicaDetails, s conversion.Scope) error {
	out.KnownReplicas = *(*map[v1.ReplicaID]string)(unsafe.Pointer(&in.KnownReplicas))
	return nil
}

// Convert_cstor_CStorVolumeReplicaDetails_To_v1_CStorVolumeReplicaDetails is an autogenerated conversion function.
func Convert_cstor_CStorVolumeReplicaDetails_To_v1_CStorVolumeReplicaDetails(in *cstor.CStorVolumeReplicaDetails, out *v1.CStorVolumeReplicaDetails, s conversion.Scope) error {
	return autoConvert_cstor_CStorVolumeReplicaDetails_To_v1_CStorVolumeReplicaDetails(in, out, s)
}

func autoConvert_v1_CStorVolumeReplicaList_To_cstor_CStorVolumeReplicaList(in *v1.CStorVolumeReplicaList, out *cstor.CStorVolumeReplicaList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	out.Items = *(*[]cstor.CStorVolumeReplica)(unsafe.Pointer(&in.Items))
	return nil
}

// Convert_v1_CStorVolumeReplicaList_To_cstor_CStorVolumeReplicaList is an autogenerated conversion function.
func Convert_v1_CStorVolumeReplicaList_To_cstor_CStorVolumeReplicaList(in *v1.CStorVolumeReplicaList, out *cstor.CStorVolumeReplicaList, s conversion.Scope) error {
	return autoConvert_v1_CStorVolumeReplicaList_To_cstor_CStorVolumeReplicaList(in, out, s)
}

func autoConvert_cstor_CStorVolumeReplicaList_To_v1_CStorVolumeReplicaList(in *cstor.CStorVolumeReplicaList, out *v1.CStorVolumeReplicaList, s conversion.Scope) error {
	out.ListMeta = in.ListMeta
	out.Items = *(*[]v1.CStorVolumeReplica)(unsafe.Pointer(&in.Items))
	return nil
}

// Convert_cstor_CStorVolumeReplicaList_To_v1_CStorVolumeReplicaList is an autogenerated conversion function.
func Convert_cstor_CStorVolumeReplicaList_To_v1_CStorVolumeReplicaList(in *cstor.CStorVolumeReplicaList, out *v1.CStorVolumeReplicaList, s conversion.Scope) error {
	return autoConvert_cstor_CStorVolumeReplicaList_To_v1_CStorVolumeReplicaList(in, out, s)
}

func autoConvert_v1_CStorVolumeReplicaSpec_To_cstor_CStorVolumeReplicaSpec(in *v1.CStorVolumeReplicaSpec, out *cstor.CStorVolumeReplicaSpec, s conversion.Scope) error {
	out.TargetIP = in.TargetIP
	out.Capacity = in.Capacity
	out.ZvolWorkers = in.ZvolWorkers
	out.ReplicaID = in.ReplicaID
	out.Compression = in.Compression
	out.BlockSize = in.BlockSize
	return nil
}

// Convert_v1_CStorVolumeReplicaSpec_To_cstor_CStorVolumeReplicaSpec is an autogenerated conversion function.
func Convert_v1_CStorVolumeReplicaSpec_To_cstor_CStorVolumeReplicaSpec(in *v1.CStorVolumeReplicaSpec, out *cstor.CStorVolumeReplicaSpec, s conversion.Scope) error {
	return autoConvert_v1_CStorVolumeReplicaSpec_To_cstor_CStorVolumeReplicaSpec(in, out, s)
}

func autoConvert_cstor_CStorVolumeReplicaSpec_To_v1_CStorVolumeReplicaSpec(in *cstor.CStorVolumeReplicaSpec, out *v1.CStorVolumeReplicaSpec, s conversion.Scope) error {
	out.TargetIP = in.TargetIP
	out.Capacity = in.Capacity
	out.ZvolWorkers = in.ZvolWorkers
	out.ReplicaID = in.ReplicaID
	out.Compression = in.Compression
	out.BlockSize = in.BlockSize
	return nil
}

// Convert_cstor_CStorVolumeReplicaSpec_To_v1_CStorVolumeReplicaSpec is an autogenerated conversion function.
func Convert_cstor_CStorVolumeReplicaSpec_To_v1_CStorVolumeReplicaSpec(in *cstor.CStorVolumeReplicaSpec, out *v1.CStorVolumeReplicaSpec, s conversion.Scope) error {
	return autoConvert_cstor_CStorVolumeReplicaSpec_To_v1_CStorVolumeReplicaSpec(in, out, s)
}

func autoConvert_v1_CStorVolumeReplicaStatus_To_cstor_CStorVolumeReplicaStatus(in *v1.CStorVolumeReplicaStatus, out *cstor.CStorVolumeReplicaStatus, s conversion.Scope) error {
	out.Phase = cstor.CStorVolumeReplicaPhase(in.Phase)
	if err := Convert_v1_CStorVolumeReplicaCapacityDetails_To_cstor_CStorVolumeReplicaCapacityDetails(&in.Capacity, &out.Capacity, s); err != nil {
		return err
	}
	out.LastTransitionTime = in.LastTransitionTime
	out.LastUpdateTime = in.LastUpdateTime
	out.Message = in.Message
	out.Snapshots = *(*map[string]cstor.CStorSnapshotInfo)(unsafe.Pointer(&in.Snapshots))
	out.PendingSnapshots = *(*map[string]cstor.CStorSnapshotInfo)(unsafe.Pointer(&in.PendingSnapshots))
	return nil
}

// Convert_v1_CStorVolumeReplicaStatus_To_cstor_CStorVolumeReplicaStatus is an autogenerated conversion function.
func Convert_v1_CStorVolumeReplicaStatus_To_cstor_CStorVolumeReplicaStatus(in *v1.CStorVolumeReplicaStatus, out *cstor.CStorVolumeReplicaStatus, s conversion.Scope) error {
	return autoConvert_v1_CStorVolumeReplicaStatus_To_cstor_CStorVolumeReplicaStatus(in, out, s)
}

func autoConvert_cstor_CStorVolumeReplicaStatus_To_v1_CStorVolumeReplicaStatus(in *cstor.CStorVolumeReplicaStatus, out *v1.CStorVolumeReplicaStatus, s conversion.Scope) error {
	out.Phase = v1.CStorVolumeReplicaPhase(in.Phase)
	if err := Convert_cstor_CStorVolumeReplicaCapacityDetails_To_v1_CStorVolumeReplicaCapacityDetails(&in.Capacity, &out.Capacity, s); err != nil {
		return err
	}
	out.LastTransitionTime = in.LastTransitionTime
	out.LastUpdateTime = in.LastUpdateTime
	out.Message = in.Message
	out.Snapshots = *(*map[string]v1.CStorSnapshotInfo)(unsafe.Pointer(&in.Snapshots))
	out.PendingSnapshots = *(*map[string]v1.CStorSnapshotInfo)(unsafe.Pointer(&in.PendingSnapshots))
	return nil
}

// Convert_cstor_CStorVolumeReplicaStatus_To_v1_CStorVolumeReplicaStatus is an autogenerated conversion function.
func Convert_cstor_CStorVolumeReplicaStatus_To_v1_CStorVolumeReplicaStatus(in *cstor.CStorVolumeReplicaStatus, out *v1.CStorVolumeReplicaStatus, s conversion.Scope) error {
	return autoConvert_cstor_CStorVolumeReplicaStatus_To_v1_CStorVolumeReplicaStatus(in, out, s)
}

func autoConvert_v1_CStorVolumeSpec_To_cstor_CStorVolumeSpec(in *v1.CStorVolumeSpec, out *cstor.CStorVolumeSpec, s conversion.Scope) error {
	out.Capacity = in.Capacity
	out.TargetIP = in.TargetIP
	out.TargetPort = in.TargetPort
	out.Iqn = in.Iqn
	out.TargetPortal = in.TargetPortal
	out.ReplicationFactor = in.ReplicationFactor
	out.ConsistencyFactor = in.ConsistencyFactor
	out.DesiredReplicationFactor = in.DesiredReplicationFactor
	if err := Convert_v1_CStorVolumeReplicaDetails_To_cstor_CStorVolumeReplicaDetails(&in.ReplicaDetails, &out.ReplicaDetails, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1_CStorVolumeSpec_To_cstor_CStorVolumeSpec is an autogenerated conversion function.
func Convert_v1_CStorVolumeSpec_To_cstor_CStorVolumeSpec(in *v1.CStorVolumeSpec, out *cstor.CStorVolumeSpec, s conversion.Scope) error {
	return autoConvert_v1_CStorVolumeSpec_To_cstor_CStorVolumeSpec(in, out, s)
}

func autoConvert_cstor_CStorVolumeSpec_To_v1_CStorVolumeSpec(in *cstor.CStorVolumeSpec, out *v1.CStorVolumeSpec, s conversion.Scope) error {
	out.Capacity = in.Capacity
	out.TargetIP = in.TargetIP
	out.TargetPort = in.TargetPort
	out.Iqn = in.Iqn
	out.TargetPortal = in.TargetPortal
	out.ReplicationFactor = in.ReplicationFactor
	out.ConsistencyFactor = in.ConsistencyFactor
	out.DesiredReplicationFactor = in.DesiredReplicationFactor
	if err := Convert_cstor_CStorVolumeReplicaDetails_To_v1_CStorVolumeReplicaDetails(&in.ReplicaDetails, &out.ReplicaDetails, s); err != nil {
		return err
	}
	return nil
}

// Convert_cstor_CStorVolumeSpec_To_v1_CStorVolumeSpec is an autogenerated conversion function.
func Convert_cstor_CStorVolumeSpec_To_v1_CStorVolumeSpec(in *cstor.CStorVolumeSpec, out *v1.CStorVolumeSpec, s conversion.Scope) error {
	return autoConvert_cstor_CStorVolumeSpec_To_v1_CStorVolumeSpec(in, out, s)
}

func autoConvert_v1_CStorVolumeStatus_To_cstor_CStorVolumeStatus(in *v1.CStorVolumeStatus, out *cstor.CStorVolumeStatus, s conversion.Scope) error {
	out.Phase = cstor.CStorVolumePhase(in.Phase)
	out.ReplicaStatuses = *(*[]cstor.ReplicaStatus)(unsafe.Pointer(&in.ReplicaStatuses))
	out.Capacity = in.Capacity
	out.LastTransitionTime = in.LastTransitionTime
	out.LastUpdateTime = in.LastUpdateTime
	out.Message = in.Message
	out.Conditions = *(*[]cstor.CStorVolumeCondition)(unsafe.Pointer(&in.Conditions))
	if err := Convert_v1_CStorVolumeReplicaDetails_To_cstor_CStorVolumeReplicaDetails(&in.ReplicaDetails, &out.ReplicaDetails, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1_CStorVolumeStatus_To_cstor_CStorVolumeStatus is an autogenerated conversion function.
func Convert_v1_CStorVolumeStatus_To_cstor_CStorVolumeStatus(in *v1.CStorVolumeStatus, out *cstor.CStorVolumeStatus, s conversion.Scope) error {
	return autoConvert_v1_CStorVolumeStatus_To_cstor_CStorVolumeStatus(in, out, s)
}

func autoConvert_cstor_CStorVolumeStatus_To_v1_CStorVolumeStatus(in *cstor.CStorVolumeStatus, out *v1.CStorVolumeStatus, s conversion.Scope) error {
	out.Phase = v1.CStorVolumePhase(in.Phase)
	out.ReplicaStatuses = *(*[]v1.ReplicaStatus)(unsafe.Pointer(&in.ReplicaStatuses))
	out.Capacity = in.Capacity
	out.LastTransitionTime = in.LastTransitionTime
	out.LastUpdateTime = in.LastUpdateTime
	out.Message = in.Message
	out.Conditions = *(*[]v1.CStorVolumeCondition)(unsafe.Pointer(&in.Conditions))
	if err := Convert_cstor_CStorVolumeReplicaDetails_To_v1_CStorVolumeReplicaDetails(&in.ReplicaDetails, &out.ReplicaDetails, s); err != nil {
		return err
	}
	return nil
}

// Convert_cstor_CStorVolumeStatus_To_v1_CStorVolumeStatus is an autogenerated conversion function.
func Convert_cstor_CStorVolumeStatus_To_v1_CStorVolumeStatus(in *cstor.CStorVolumeStatus, out *v1.CStorVolumeStatus, s conversion.Scope) error {
	return autoConvert_cstor_CStorVolumeStatus_To_v1_CStorVolumeStatus(in, out, s)
}

func autoConvert_v1_CVStatus_To_cstor_CVStatus(in *v1.CVStatus, out *cstor.CVStatus, s conversion.Scope) error {
	out.Name = in.Name
	out.Status = in.Status
	out.ReplicaStatuses = *(*[]cstor.ReplicaStatus)(unsafe.Pointer(&in.ReplicaStatuses))
	return nil
}

// Convert_v1_CVStatus_To_cstor_CVStatus is an autogenerated conversion function.
func Convert_v1_CVStatus_To_cstor_CVStatus(in *v1.CVStatus, out *cstor.CVStatus, s conversion.Scope) error {
	return autoConvert_v1_CVStatus_To_cstor_CVStatus(in, out, s)
}

func autoConvert_cstor_CVStatus_To_v1_CVStatus(in *cstor.CVStatus, out *v1.CVStatus, s conversion.Scope) error {
	out.Name = in.Name
	out.Status = in.Status
	out.ReplicaStatuses = *(*[]v1.ReplicaStatus)(unsafe.Pointer(&in.ReplicaStatuses))
	return nil
}

// Convert_cstor_CVStatus_To_v1_CVStatus is an autogenerated conversion function.
func Convert_cstor_CVStatus_To_v1_CVStatus(in *cstor.CVStatus, out *v1.CVStatus, s conversion.Scope) error {
	return autoConvert_cstor_CVStatus_To_v1_CVStatus(in, out, s)
}

func autoConvert_v1_CVStatusResponse_To_cstor_CVStatusResponse(in *v1.CVStatusResponse, out *cstor.CVStatusResponse, s conversion.Scope) error {
	out.CVStatuses = *(*[]cstor.CVStatus)(unsafe.Pointer(&in.CVStatuses))
	return nil
}

// Convert_v1_CVStatusResponse_To_cstor_CVStatusResponse is an autogenerated conversion function.
func Convert_v1_CVStatusResponse_To_cstor_CVStatusResponse(in *v1.CVStatusResponse, out *cstor.CVStatusResponse, s conversion.Scope) error {
	return autoConvert_v1_CVStatusResponse_To_cstor_CVStatusResponse(in, out, s)
}

func autoConvert_cstor_CVStatusResponse_To_v1_CVStatusResponse(in *cstor.CVStatusResponse, out *v1.CVStatusResponse, s conversion.Scope) error {
	out.CVStatuses = *(*[]v1.CVStatus)(unsafe.Pointer(&in.CVStatuses))
	return nil
}

// Convert_cstor_CVStatusResponse_To_v1_CVStatusResponse is an autogenerated conversion function.
func Convert_cstor_CVStatusResponse_To_v1_CVStatusResponse(in *cstor.CVStatusResponse, out *v1.CVStatusResponse, s conversion.Scope) error {
	return autoConvert_cstor_CVStatusResponse_To_v1_CVStatusResponse(in, out, s)
}

func autoConvert_v1_ISCSIInfo_To_cstor_ISCSIInfo(in *v1.ISCSIInfo, out *cstor.ISCSIInfo, s conversion.Scope) error {
	out.Iqn = in.Iqn
	out.TargetPortal = in.TargetPortal
	out.IscsiInterface = in.IscsiInterface
	out.Lun = in.Lun
	return nil
}

// Convert_v1_ISCSIInfo_To_cstor_ISCSIInfo is an autogenerated conversion function.
func Convert_v1_ISCSIInfo_To_cstor_ISCSIInfo(in *v1.ISCSIInfo, out *cstor.ISCSIInfo, s conversion.Scope) error {
	return autoConvert_v1_ISCSIInfo_To_cstor_ISCSIInfo(in, out, s)
}

func autoConvert_cstor_ISCSIInfo_To_v1_ISCSIInfo(in *cstor.ISCSIInfo, out *v1.ISCSIInfo, s conversion.Scope) error {
	out.Iqn = in.Iqn
	out.TargetPortal = in.TargetPortal
	out.IscsiInterface = in.IscsiInterface
	out.Lun = in.Lun
	return nil
}

// Convert_cstor_ISCSIInfo_To_v1_ISCSIInfo is an autogenerated conversion function.
func Convert_cstor_ISCSIInfo_To_v1_ISCSIInfo(in *cstor.ISCSIInfo, out *v1.ISCSIInfo, s conversion.Scope) error {
	return autoConvert_cstor_ISCSIInfo_To_v1_ISCSIInfo(in, out, s)
}

func autoConvert_v1_PoolConfig_To_cstor_PoolConfig(in *v1.PoolConfig, out *cstor.PoolConfig, s conversion.Scope) error {
	out.DataRaidGroupType = in.DataRaidGroupType
	out.WriteCacheGroupType = in.WriteCacheGroupType
	out.ThickProvision = in.ThickProvision
	out.Compression = in.Compression
	out.Resources = (*corev1.ResourceRequirements)(unsafe.Pointer(in.Resources))
	out.AuxResources = (*corev1.ResourceRequirements)(unsafe.Pointer(in.AuxResources))
	out.Tolerations = *(*[]corev1.Toleration)(unsafe.Pointer(&in.Tolerations))
	out.PriorityClassName = (*string)(unsafe.Pointer(in.PriorityClassName))
	out.ROThresholdLimit = (*int)(unsafe.Pointer(in.ROThresholdLimit))
	return nil
}

// Convert_v1_PoolConfig_To_cstor_PoolConfig is an autogenerated conversion function.
func Convert_v1_PoolConfig_To_cstor_PoolConfig(in *v1.PoolConfig, out *cstor.PoolConfig, s conversion.Scope) error {
	return autoConvert_v1_PoolConfig_To_cstor_PoolConfig(in, out, s)
}

func autoConvert_cstor_PoolConfig_To_v1_PoolConfig(in *cstor.PoolConfig, out *v1.PoolConfig, s conversion.Scope) error {
	out.DataRaidGroupType = in.DataRaidGroupType
	out.WriteCacheGroupType = in.WriteCacheGroupType
	out.ThickProvision = in.ThickProvision
	out.Compression = in.Compression
	out.Resources = (*corev1.ResourceRequirements)(unsafe.Pointer(in.Resources))
	out.AuxResources = (*corev1.ResourceRequirements)(unsafe.Pointer(in.AuxResources))
	out.Tolerations = *(*[]corev1.Toleration)(unsafe.Pointer(&in.Tolerations))
	out.PriorityClassName = (*string)(unsafe.Pointer(in.PriorityClassName))
	out.ROThresholdLimit = (*int)(unsafe.Pointer(in.ROThresholdLimit))
	return nil
}

// Convert_cstor_PoolConfig_To_v1_PoolConfig is an autogenerated conversion function.
func Convert_cstor_PoolConfig_To_v1_PoolConfig(in *cstor.PoolConfig, out *v1.PoolConfig, s conversion.Scope) error {
	return autoConvert_cstor_PoolConfig_To_v1_PoolConfig(in, out, s)
}

func autoConvert_v1_PoolSpec_To_cstor_PoolSpec(in *v1.PoolSpec, out *cstor.PoolSpec, s conversion.Scope) error {
	out.NodeSelector = *(*map[string]string)(unsafe.Pointer(&in.NodeSelector))
	out.DataRaidGroups = *(*[]cstor.RaidGroup)(unsafe.Pointer(&in.DataRaidGroups))
	out.WriteCacheRaidGroups = *(*[]cstor.RaidGroup)(unsafe.Pointer(&in.WriteCacheRaidGroups))
	if err := Convert_v1_PoolConfig_To_cstor_PoolConfig(&in.PoolConfig, &out.PoolConfig, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1_PoolSpec_To_cstor_PoolSpec is an autogenerated conversion function.
func Convert_v1_PoolSpec_To_cstor_PoolSpec(in *v1.PoolSpec, out *cstor.PoolSpec, s conversion.Scope) error {
	return autoConvert_v1_PoolSpec_To_cstor_PoolSpec(in, out, s)
}

func autoConvert_cstor_PoolSpec_To_v1_PoolSpec(in *cstor.PoolSpec, out *v1.PoolSpec, s conversion.Scope) error {
	out.NodeSelector = *(*map[string]string)(unsafe.Pointer(&in.NodeSelector))
	out.DataRaidGroups = *(*[]v1.RaidGroup)(unsafe.Pointer(&in.DataRaidGroups))
	out.WriteCacheRaidGroups = *(*[]v1.RaidGroup)(unsafe.Pointer(&in.WriteCacheRaidGroups))
	if err := Convert_cstor_PoolConfig_To_v1_PoolConfig(&in.PoolConfig, &out.PoolConfig, s); err != nil {
		return err
	}
	return nil
}

// Convert_cstor_PoolSpec_To_v1_PoolSpec is an autogenerated conversion function.
func Convert_cstor_PoolSpec_To_v1_PoolSpec(in *cstor.PoolSpec, out *v1.PoolSpec, s conversion.Scope) error {
	return autoConvert_cstor_PoolSpec_To_v1_PoolSpec(in, out, s)
}

func autoConvert_v1_Provision_To_cstor_Provision(in *v1.Provision, out *cstor.Provision, s conversion.Scope) error {
	out.ReplicaAffinity = in.ReplicaAffinity
	out.BlockSize = in.BlockSize
	return nil
}

// Convert_v1_Provision_To_cstor_Provision is an autogenerated conversion function.
func Convert_v1_Provision_To_cstor_Provision(in *v1.Provision, out *cstor.Provision, s conversion.Scope) error {
	return autoConvert_v1_Provision_To_cstor_Provision(in, out, s)
}

func autoConvert_cstor_Provision_To_v1_Provision(in *cstor.Provision, out *v1.Provision, s conversion.Scope) error {
	out.ReplicaAffinity = in.ReplicaAffinity
	out.BlockSize = in.BlockSize
	return nil
}

// Convert_cstor_Provision_To_v1_Provision is an autogenerated conversion function.
func Convert_cstor_Provision_To_v1_Provision(in *cstor.Provision, out *v1.Provision, s conversion.Scope) error {
	return autoConvert_cstor_Provision_To_v1_Provision(in, out, s)
}

func autoConvert_v1_RaidGroup_To_cstor_RaidGroup(in *v1.RaidGroup, out *cstor.RaidGroup, s conversion.Scope) error {
	out.CStorPoolInstanceBlockDevices = *(*[]cstor.CStorPoolInstanceBlockDevice)(unsafe.Pointer(&in.CStorPoolInstanceBlockDevices))
	return nil
}

// Convert_v1_RaidGroup_To_cstor_RaidGroup is an autogenerated conversion function.
func Convert_v1_RaidGroup_To_cstor_RaidGroup(in *v1.RaidGroup, out *cstor.RaidGroup, s conversion.Scope) error {
	return autoConvert_v1_RaidGroup_To_cstor_RaidGroup(in, out, s)
}

func autoConvert_cstor_RaidGroup_To_v1_RaidGroup(in *cstor.RaidGroup, out *v1.RaidGroup, s conversion.Scope) error {
	out.CStorPoolInstanceBlockDevices = *(*[]v1.CStorPoolInstanceBlockDevice)(unsafe.Pointer(&in.CStorPoolInstanceBlockDevices))
	return nil
}

// Convert_cstor_RaidGroup_To_v1_RaidGroup is an autogenerated conversion function.
func Convert_cstor_RaidGroup_To_v1_RaidGroup(in *cstor.RaidGroup, out *v1.RaidGroup, s conversion.Scope) error {
	return autoConvert_cstor_RaidGroup_To_v1_RaidGroup(in, out, s)
}

func autoConvert_v1_ReplicaPoolInfo_To_cstor_ReplicaPoolInfo(in *v1.ReplicaPoolInfo, out *cstor.ReplicaPoolInfo, s conversion.Scope) error {
	out.PoolName = in.PoolName
	return nil
}

// Convert_v1_ReplicaPoolInfo_To_cstor_ReplicaPoolInfo is an autogenerated conversion function.
func Convert_v1_ReplicaPoolInfo_To_cstor_ReplicaPoolInfo(in *v1.ReplicaPoolInfo, out *cstor.ReplicaPoolInfo, s conversion.Scope) error {
	return autoConvert_v1_ReplicaPoolInfo_To_cstor_ReplicaPoolInfo(in, out, s)
}

func autoConvert_cstor_ReplicaPoolInfo_To_v1_ReplicaPoolInfo(in *cstor.ReplicaPoolInfo, out *v1.ReplicaPoolInfo, s conversion.Scope) error {
	out.PoolName = in.PoolName
	return nil
}

// Convert_cstor_ReplicaPoolInfo_To_v1_ReplicaPoolInfo is an autogenerated conversion function.
func Convert_cstor_ReplicaPoolInfo_To_v1_ReplicaPoolInfo(in *cstor.ReplicaPoolInfo, out *v1.ReplicaPoolInfo, s conversion.Scope) error {
	return autoConvert_cstor_ReplicaPoolInfo_To_v1_ReplicaPoolInfo(in, out, s)
}

func autoConvert_v1_ReplicaSpec_To_cstor_ReplicaSpec(in *v1.ReplicaSpec, out *cstor.ReplicaSpec, s conversion.Scope) error {
	out.IOWorkers = in.IOWorkers
	out.Compression = in.Compression
	return nil
}

// Convert_v1_ReplicaSpec_To_cstor_ReplicaSpec is an autogenerated conversion function.
func Convert_v1_ReplicaSpec_To_cstor_ReplicaSpec(in *v1.ReplicaSpec, out *cstor.ReplicaSpec, s conversion.Scope) error {
	return autoConvert_v1_ReplicaSpec_To_cstor_ReplicaSpec(in, out, s)
}

func autoConvert_cstor_ReplicaSpec_To_v1_ReplicaSpec(in *cstor.ReplicaSpec, out *v1.ReplicaSpec, s conversion.Scope) error {
	out.IOWorkers = in.IOWorkers
	out.Compression = in.Compression
	return nil
}

// Convert_cstor_ReplicaSpec_To_v1_ReplicaSpec is an autogenerated conversion function.
func Convert_cstor_ReplicaSpec_To_v1_ReplicaSpec(in *cstor.ReplicaSpec, out *v1.ReplicaSpec, s conversion.Scope) error {
	return autoConvert_cstor_ReplicaSpec_To_v1_ReplicaSpec(in, out, s)
}

func autoConvert_v1_ReplicaStatus_To_cstor_ReplicaStatus(in *v1.ReplicaStatus, out *cstor.ReplicaStatus, s conversion.Scope) error {
	out.ID = in.ID
	out.Mode = in.Mode
	out.CheckpointedIOSeq = in.CheckpointedIOSeq
	out.InflightRead = in.InflightRead
	out.InflightWrite = in.InflightWrite
	out.InflightSync = in.InflightSync
	out.UpTime = in.UpTime
	out.Quorum = in.Quorum
	return nil
}

// Convert_v1_ReplicaStatus_To_cstor_ReplicaStatus is an autogenerated conversion function.
func Convert_v1_ReplicaStatus_To_cstor_ReplicaStatus(in *v1.ReplicaStatus, out *cstor.ReplicaStatus, s conversion.Scope) error {
	return autoConvert_v1_ReplicaStatus_To_cstor_ReplicaStatus(in, out, s)
}

func autoConvert_cstor_ReplicaStatus_To_v1_ReplicaStatus(in *cstor.ReplicaStatus, out *v1.ReplicaStatus, s conversion.Scope) error {
	out.ID = in.ID
	out.Mode = in.Mode
	out.CheckpointedIOSeq = in.CheckpointedIOSeq
	out.InflightRead = in.InflightRead
	out.InflightWrite = in.InflightWrite
	out.InflightSync = in.InflightSync
	out.UpTime = in.UpTime
	out.Quorum = in.Quorum
	return nil
}

// Convert_cstor_ReplicaStatus_To_v1_ReplicaStatus is an autogenerated conversion function.
func Convert_cstor_ReplicaStatus_To_v1_ReplicaStatus(in *cstor.ReplicaStatus, out *v1.ReplicaStatus, s conversion.Scope) error {
	return autoConvert_cstor_ReplicaStatus_To_v1_ReplicaStatus(in, out, s)
}

func autoConvert_v1_TargetSpec_To_cstor_TargetSpec(in *v1.TargetSpec, out *cstor.TargetSpec, s conversion.Scope) error {
	out.QueueDepth = in.QueueDepth
	out.IOWorkers = in.IOWorkers
	out.Monitor = in.Monitor
	out.ReplicationFactor = in.ReplicationFactor
	out.Resources = (*corev1.ResourceRequirements)(unsafe.Pointer(in.Resources))
	out.AuxResources = (*corev1.ResourceRequirements)(unsafe.Pointer(in.AuxResources))
	out.Tolerations = *(*[]corev1.Toleration)(unsafe.Pointer(&in.Tolerations))
	out.PodAffinity = (*corev1.PodAffinity)(unsafe.Pointer(in.PodAffinity))
	out.NodeSelector = *(*map[string]string)(unsafe.Pointer(&in.NodeSelector))
	out.PriorityClassName = in.PriorityClassName
	return nil
}

// Convert_v1_TargetSpec_To_cstor_TargetSpec is an autogenerated conversion function.
func Convert_v1_TargetSpec_To_cstor_TargetSpec(in *v1.TargetSpec, out *cstor.TargetSpec, s conversion.Scope) error {
	return autoConvert_v1_TargetSpec_To_cstor_TargetSpec(in, out, s)
}

func autoConvert_cstor_TargetSpec_To_v1_TargetSpec(in *cstor.TargetSpec, out *v1.TargetSpec, s conversion.Scope) error {
	out.QueueDepth = in.QueueDepth
	out.IOWorkers = in.IOWorkers
	out.Monitor = in.Monitor
	out.ReplicationFactor = in.ReplicationFactor
	out.Resources = (*corev1.ResourceRequirements)(unsafe.Pointer(in.Resources))
	out.AuxResources = (*corev1.ResourceRequirements)(unsafe.Pointer(in.AuxResources))
	out.Tolerations = *(*[]corev1.Toleration)(unsafe.Pointer(&in.Tolerations))
	out.PodAffinity = (*corev1.PodAffinity)(unsafe.Pointer(in.PodAffinity))
	out.NodeSelector = *(*map[string]string)(unsafe.Pointer(&in.NodeSelector))
	out.PriorityClassName = in.PriorityClassName
	return nil
}

// Convert_cstor_TargetSpec_To_v1_TargetSpec is an autogenerated conversion function.
func Convert_cstor_TargetSpec_To_v1_TargetSpec(in *cstor.TargetSpec, out *v1.TargetSpec, s conversion.Scope) error {
	return autoConvert_cstor_TargetSpec_To_v1_TargetSpec(in, out, s)
}

func autoConvert_v1_VersionDetails_To_cstor_VersionDetails(in *v1.VersionDetails, out *cstor.VersionDetails, s conversion.Scope) error {
	out.AutoUpgrade = in.AutoUpgrade
	out.Desired = in.Desired
	if err := Convert_v1_VersionStatus_To_cstor_VersionStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	return nil
}

// Convert_v1_VersionDetails_To_cstor_VersionDetails is an autogenerated conversion function.
func Convert_v1_VersionDetails_To_cstor_VersionDetails(in *v1.VersionDetails, out *cstor.VersionDetails, s conversion.Scope) error {
	return autoConvert_v1_VersionDetails_To_cstor_VersionDetails(in, out, s)
}

func autoConvert_cstor_VersionDetails_To_v1_VersionDetails(in *cstor.VersionDetails, out *v1.VersionDetails, s conversion.Scope) error {
	out.AutoUpgrade = in.AutoUpgrade
	out.Desired = in.Desired
	if err := Convert_cstor_VersionStatus_To_v1_VersionStatus(&in.Status, &out.Status, s); err != nil {
		return err
	}
	return nil
}

// Convert_cstor_VersionDetails_To_v1_VersionDetails is an autogenerated conversion function.
func Convert_cstor_VersionDetails_To_v1_VersionDetails(in *cstor.VersionDetails, out *v1.VersionDetails, s conversion.Scope) error {
	return autoConvert_cstor_VersionDetails_To_v1_VersionDetails(in, out, s)
}

func autoConvert_v1_VersionStatus_To_cstor_VersionStatus(in *v1.VersionStatus, out *cstor.VersionStatus, s conversion.Scope) error {
	out.DependentsUpgraded = in.DependentsUpgraded
	out.Current = in.Current
	out.State = cstor.VersionState(in.State)
	out.Message = in.Message
	out.Reason = in.Reason
	out.LastUpdateTime = in.LastUpdateTime
	return nil
}

// Convert_v1_VersionStatus_To_cstor_VersionStatus is an autogenerated conversion function.
func Convert_v1_VersionStatus_To_cstor_VersionStatus(in *v1.VersionStatus, out *cstor.VersionStatus, s conversion.Scope) error {
	return autoConvert_v1_VersionStatus_To_cstor_VersionStatus(in, out, s)
}

func autoConvert_cstor_VersionStatus_To_v1_VersionStatus(in *cstor.VersionStatus, out *v1.VersionStatus, s conversion.Scope) error {
	out.DependentsUpgraded = in.DependentsUpgraded
	out.Current = in.Current
	out.State = v1.VersionState(in.State)
	out.Message = in.Message
	out.Reason = in.Reason
	out.LastUpdateTime = in.LastUpdateTime
	return nil
}

// Convert_cstor_VersionStatus_To_v1_VersionStatus is an autogenerated conversion function.
func Convert_cstor_VersionStatus_To_v1_VersionStatus(in *cstor.VersionStatus, out *v1.VersionStatus, s conversion.Scope) error {
	return autoConvert_cstor_VersionStatus_To_v1_VersionStatus(in, out, s)
}

func autoConvert_v1_VolumeInfo_To_cstor_VolumeInfo(in *v1.VolumeInfo, out *cstor.VolumeInfo, s conversion.Scope) error {
	out.Name = in.Name
	out.Capacity = in.Capacity
	out.OwnerNodeID = in.OwnerNodeID
	out.FSType = in.FSType
	out.AccessModes = *(*[]string)(unsafe.Pointer(&in.AccessModes))
	out.AccessType = in.AccessType
	out.StagingTargetPath = in.StagingTargetPath
	out.TargetPath = in.TargetPath
	out.ReadOnly = in.ReadOnly
	out.MountOptions = *(*[]string)(unsafe.Pointer(&in.MountOptions))
	out.DevicePath = in.DevicePath
	return nil
}

// Convert_v1_VolumeInfo_To_cstor_VolumeInfo is an autogenerated conversion function.
func Convert_v1_VolumeInfo_To_cstor_VolumeInfo(in *v1.VolumeInfo, out *cstor.VolumeInfo, s conversion.Scope) error {
	return autoConvert_v1_VolumeInfo_To_cstor_VolumeInfo(in, out, s)
}

func autoConvert_cstor_VolumeInfo_To_v1_VolumeInfo(in *cstor.VolumeInfo, out *v1.VolumeInfo, s conversion.Scope) error {
	out.Name = in.Name
	out.Capacity = in.Capacity
	out.OwnerNodeID = in.OwnerNodeID
	out.FSType = in.FSType
	out.AccessModes = *(*[]string)(unsafe.Pointer(&in.AccessModes))
	out.AccessType = in.AccessType
	out.StagingTargetPath = in.StagingTargetPath
	out.TargetPath = in.TargetPath
	out.ReadOnly = in.ReadOnly
	out.MountOptions = *(*[]string)(unsafe.Pointer(&in.MountOptions))
	out.DevicePath = in.DevicePath
	return nil
}

// Convert_cstor_VolumeInfo_To_v1_VolumeInfo is an autogenerated conversion function.
func Convert_cstor_VolumeInfo_To_v1_VolumeInfo(in *cstor.VolumeInfo, out *v1.VolumeInfo, s conversion.Scope) error {
	return autoConvert_cstor_VolumeInfo_To_v1_VolumeInfo(in, out, s)
}

func autoConvert_v1_VolumeProvision_To_cstor_VolumeProvision(in *v1.VolumeProvision, out *cstor.VolumeProvision, s conversion.Scope) error {
	out.Capacity = *(*corev1.ResourceList)(unsafe.Pointer(&in.Capacity))
	out.ReplicaCount = int32(in.ReplicaCount)
	return nil
}

// Convert_v1_VolumeProvision_To_cstor_VolumeProvision is an autogenerated conversion function.
func Convert_v1_VolumeProvision_To_cstor_VolumeProvision(in *v1.VolumeProvision, out *cstor.VolumeProvision, s conversion.Scope) error {
	return autoConvert_v1_VolumeProvision_To_cstor_VolumeProvision(in, out, s)
}

func autoConvert_cstor_VolumeProvision_To_v1_VolumeProvision(in *cstor.VolumeProvision, out *v1.VolumeProvision, s conversion.Scope) error {
	out.Capacity = *(*corev1.ResourceList)(unsafe.Pointer(&in.Capacity))
	out.ReplicaCount = int(in.ReplicaCount)
	return nil
}

// Convert_cstor_VolumeProvision_To_v1_VolumeProvision is an autogenerated conversion function.
func Convert_cstor_VolumeProvision_To_v1_VolumeProvision(in *cstor.VolumeProvision, out *v1.VolumeProvision, s conversion.Scope) error {
	return autoConvert_cstor_VolumeProvision_To_v1_VolumeProvision(in, out, s)
}

func autoConvert_v1_ZFSCapacityAttributes_To_cstor_ZFSCapacityAttributes(in *v1.ZFSCapacityAttributes, out *cstor.ZFSCapacityAttributes, s conversion.Scope) error {
	out.LogicalUsed = in.LogicalUsed
	return nil
}

// Convert_v1_ZFSCapacityAttributes_To_cstor_ZFSCapacityAttributes is an autogenerated conversion function.
func Convert_v1_ZFSCapacityAttributes_To_cstor_ZFSCapacityAttributes(in *v1.ZFSCapacityAttributes, out *cstor.ZFSCapacityAttributes, s conversion.Scope) error {
	return autoConvert_v1_ZFSCapacityAttributes_To_cstor_ZFSCapacityAttributes(in, out, s)
}

func autoConvert_cstor_ZFSCapacityAttributes_To_v1_ZFSCapacityAttributes(in *cstor.ZFSCapacityAttributes, out *v1.ZFSCapacityAttributes, s conversion.Scope) error {
	out.LogicalUsed = in.LogicalUsed
	return nil
}

// Convert_cstor_ZFSCapacityAttributes_To_v1_ZFSCapacityAttributes is an autogenerated conversion function.
func Convert_cstor_ZFSCapacityAttributes_To_v1_ZFSCapacityAttributes(in *cstor.ZFSCapacityAttributes, out *v1.ZFSCapacityAttributes, s conversion.Scope) error {
	return autoConvert_cstor_ZFSCapacityAttributes_To_v1_ZFSCapacityAttributes(in, out, s)
}