github.com/cloudwan/edgelq-sdk@v1.15.4/devices/resources/v1/device/device.pb.object_ext.go

// Code generated by protoc-gen-goten-object
// File: edgelq/devices/proto/v1/device.proto
// DO NOT EDIT!!!

package device

import (
	"fmt"
	"sort"

	"google.golang.org/protobuf/proto"
	googlefieldmaskpb "google.golang.org/protobuf/types/known/fieldmaskpb"

	gotenobject "github.com/cloudwan/goten-sdk/runtime/object"
)

// proto imports
import (
	api "github.com/cloudwan/edgelq-sdk/common/api"
	project "github.com/cloudwan/edgelq-sdk/devices/resources/v1/project"
	iam_attestation_domain "github.com/cloudwan/edgelq-sdk/iam/resources/v1/attestation_domain"
	iam_iam_common "github.com/cloudwan/edgelq-sdk/iam/resources/v1/common"
	iam_service_account "github.com/cloudwan/edgelq-sdk/iam/resources/v1/service_account"
	logging_bucket "github.com/cloudwan/edgelq-sdk/logging/resources/v1/bucket"
	monitoring_bucket "github.com/cloudwan/edgelq-sdk/monitoring/resources/v4/bucket"
	meta "github.com/cloudwan/goten-sdk/types/meta"
	latlng "google.golang.org/genproto/googleapis/type/latlng"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	fieldmaskpb "google.golang.org/protobuf/types/known/fieldmaskpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
)

// ensure the imports are used
var (
	_ = new(fmt.Stringer)
	_ = new(sort.Interface)

	_ = new(proto.Message)
	_ = googlefieldmaskpb.FieldMask{}

	_ = new(gotenobject.FieldPath)
)

// make sure we're using proto imports
var (
	_ = &api.HealthCheckSpec{}
	_ = &project.Project{}
	_ = &iam_attestation_domain.AttestationDomain{}
	_ = &iam_iam_common.PCR{}
	_ = &iam_service_account.ServiceAccount{}
	_ = &logging_bucket.Bucket{}
	_ = &monitoring_bucket.Bucket{}
	_ = &durationpb.Duration{}
	_ = &fieldmaskpb.FieldMask{}
	_ = &timestamppb.Timestamp{}
	_ = &latlng.LatLng{}
	_ = &meta.Meta{}
)

func (o *Device) GotenObjectExt() {}

func (o *Device) MakeFullFieldMask() *Device_FieldMask {
	return FullDevice_FieldMask()
}

func (o *Device) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_FieldMask()
}

func (o *Device) MakeDiffFieldMask(other *Device) *Device_FieldMask {
	if o == nil && other == nil {
		return &Device_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_FieldMask()
	}

	res := &Device_FieldMask{}
	if o.GetName().String() != other.GetName().String() {
		res.Paths = append(res.Paths, &Device_FieldTerminalPath{selector: Device_FieldPathSelectorName})
	}
	{
		subMask := o.GetMetadata().MakeDiffFieldMask(other.GetMetadata())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &Device_FieldTerminalPath{selector: Device_FieldPathSelectorMetadata})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &Device_FieldSubPath{selector: Device_FieldPathSelectorMetadata, subPath: subpath})
			}
		}
	}
	if o.GetDisplayName() != other.GetDisplayName() {
		res.Paths = append(res.Paths, &Device_FieldTerminalPath{selector: Device_FieldPathSelectorDisplayName})
	}
	if o.GetDescription() != other.GetDescription() {
		res.Paths = append(res.Paths, &Device_FieldTerminalPath{selector: Device_FieldPathSelectorDescription})
	}
	{
		subMask := o.GetSpec().MakeDiffFieldMask(other.GetSpec())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &Device_FieldTerminalPath{selector: Device_FieldPathSelectorSpec})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &Device_FieldSubPath{selector: Device_FieldPathSelectorSpec, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetStatus().MakeDiffFieldMask(other.GetStatus())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &Device_FieldTerminalPath{selector: Device_FieldPathSelectorStatus})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &Device_FieldSubPath{selector: Device_FieldPathSelectorStatus, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetPublicListingSpec().MakeDiffFieldMask(other.GetPublicListingSpec())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &Device_FieldTerminalPath{selector: Device_FieldPathSelectorPublicListingSpec})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &Device_FieldSubPath{selector: Device_FieldPathSelectorPublicListingSpec, subPath: subpath})
			}
		}
	}
	return res
}

func (o *Device) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device))
}

func (o *Device) Clone() *Device {
	if o == nil {
		return nil
	}
	result := &Device{}
	if o.Name == nil {
		result.Name = nil
	} else if data, err := o.Name.ProtoString(); err != nil {
		panic(err)
	} else {
		result.Name = &Name{}
		if err := result.Name.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.Metadata = o.Metadata.Clone()
	result.DisplayName = o.DisplayName
	result.Description = o.Description
	result.Spec = o.Spec.Clone()
	result.Status = o.Status.Clone()
	result.PublicListingSpec = o.PublicListingSpec.Clone()
	return result
}

func (o *Device) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device) Merge(source *Device) {
	if source.GetName() != nil {
		if data, err := source.GetName().ProtoString(); err != nil {
			panic(err)
		} else {
			o.Name = &Name{}
			if err := o.Name.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.Name = nil
	}
	if source.GetMetadata() != nil {
		if o.Metadata == nil {
			o.Metadata = new(meta.Meta)
		}
		o.Metadata.Merge(source.GetMetadata())
	}
	o.DisplayName = source.GetDisplayName()
	o.Description = source.GetDescription()
	if source.GetSpec() != nil {
		if o.Spec == nil {
			o.Spec = new(Device_Spec)
		}
		o.Spec.Merge(source.GetSpec())
	}
	if source.GetStatus() != nil {
		if o.Status == nil {
			o.Status = new(Device_Status)
		}
		o.Status.Merge(source.GetStatus())
	}
	if source.GetPublicListingSpec() != nil {
		if o.PublicListingSpec == nil {
			o.PublicListingSpec = new(Device_PublicListingSpec)
		}
		o.PublicListingSpec.Merge(source.GetPublicListingSpec())
	}
}

func (o *Device) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device))
}

func (o *Device_Spec) GotenObjectExt() {}

func (o *Device_Spec) MakeFullFieldMask() *Device_Spec_FieldMask {
	return FullDevice_Spec_FieldMask()
}

func (o *Device_Spec) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Spec_FieldMask()
}

func (o *Device_Spec) MakeDiffFieldMask(other *Device_Spec) *Device_Spec_FieldMask {
	if o == nil && other == nil {
		return &Device_Spec_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Spec_FieldMask()
	}

	res := &Device_Spec_FieldMask{}
	if o.GetServiceAccount().String() != other.GetServiceAccount().String() {
		res.Paths = append(res.Paths, &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorServiceAccount})
	}
	if o.GetLogBucket().String() != other.GetLogBucket().String() {
		res.Paths = append(res.Paths, &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorLogBucket})
	}
	if o.GetMetricsBucket().String() != other.GetMetricsBucket().String() {
		res.Paths = append(res.Paths, &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorMetricsBucket})
	}
	if o.GetOsVersion() != other.GetOsVersion() {
		res.Paths = append(res.Paths, &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorOsVersion})
	}
	if o.GetNetplanYamlConfig() != other.GetNetplanYamlConfig() {
		res.Paths = append(res.Paths, &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorNetplanYamlConfig})
	}
	if o.GetNetplanApiConfigMode() != other.GetNetplanApiConfigMode() {
		res.Paths = append(res.Paths, &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorNetplanApiConfigMode})
	}
	if o.GetOsImageUrl() != other.GetOsImageUrl() {
		res.Paths = append(res.Paths, &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorOsImageUrl})
	}
	{
		subMask := o.GetSshConfig().MakeDiffFieldMask(other.GetSshConfig())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorSshConfig})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceSpec_FieldSubPath{selector: DeviceSpec_FieldPathSelectorSshConfig, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetAttestationConfig().MakeDiffFieldMask(other.GetAttestationConfig())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorAttestationConfig})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceSpec_FieldSubPath{selector: DeviceSpec_FieldPathSelectorAttestationConfig, subPath: subpath})
			}
		}
	}
	if o.GetDisableDeviceDiscovery() != other.GetDisableDeviceDiscovery() {
		res.Paths = append(res.Paths, &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorDisableDeviceDiscovery})
	}
	{
		subMask := o.GetLoggingConfig().MakeDiffFieldMask(other.GetLoggingConfig())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorLoggingConfig})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceSpec_FieldSubPath{selector: DeviceSpec_FieldPathSelectorLoggingConfig, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetProxyConfig().MakeDiffFieldMask(other.GetProxyConfig())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorProxyConfig})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceSpec_FieldSubPath{selector: DeviceSpec_FieldPathSelectorProxyConfig, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetLocation().MakeDiffFieldMask(other.GetLocation())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorLocation})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceSpec_FieldSubPath{selector: DeviceSpec_FieldPathSelectorLocation, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetUsbGuard().MakeDiffFieldMask(other.GetUsbGuard())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorUsbGuard})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceSpec_FieldSubPath{selector: DeviceSpec_FieldPathSelectorUsbGuard, subPath: subpath})
			}
		}
	}

	if len(o.GetHealthChecks()) == len(other.GetHealthChecks()) {
		for i, lValue := range o.GetHealthChecks() {
			rValue := other.GetHealthChecks()[i]
			if !proto.Equal(lValue, rValue) {
				res.Paths = append(res.Paths, &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorHealthChecks})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorHealthChecks})
	}
	if o.GetDisableNetworkConfigFallback() != other.GetDisableNetworkConfigFallback() {
		res.Paths = append(res.Paths, &DeviceSpec_FieldTerminalPath{selector: DeviceSpec_FieldPathSelectorDisableNetworkConfigFallback})
	}
	return res
}

func (o *Device_Spec) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Spec))
}

func (o *Device_Spec) Clone() *Device_Spec {
	if o == nil {
		return nil
	}
	result := &Device_Spec{}
	if o.ServiceAccount == nil {
		result.ServiceAccount = nil
	} else if data, err := o.ServiceAccount.ProtoString(); err != nil {
		panic(err)
	} else {
		result.ServiceAccount = &iam_service_account.Reference{}
		if err := result.ServiceAccount.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	if o.LogBucket == nil {
		result.LogBucket = nil
	} else if data, err := o.LogBucket.ProtoString(); err != nil {
		panic(err)
	} else {
		result.LogBucket = &logging_bucket.Reference{}
		if err := result.LogBucket.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	if o.MetricsBucket == nil {
		result.MetricsBucket = nil
	} else if data, err := o.MetricsBucket.ProtoString(); err != nil {
		panic(err)
	} else {
		result.MetricsBucket = &monitoring_bucket.Reference{}
		if err := result.MetricsBucket.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	result.OsVersion = o.OsVersion
	result.NetplanYamlConfig = o.NetplanYamlConfig
	result.NetplanApiConfigMode = o.NetplanApiConfigMode
	result.OsImageUrl = o.OsImageUrl
	result.SshConfig = o.SshConfig.Clone()
	result.AttestationConfig = o.AttestationConfig.Clone()
	result.DisableDeviceDiscovery = o.DisableDeviceDiscovery
	result.LoggingConfig = o.LoggingConfig.Clone()
	result.ProxyConfig = o.ProxyConfig.Clone()
	result.Location = o.Location.Clone()
	result.UsbGuard = o.UsbGuard.Clone()
	result.HealthChecks = make([]*api.HealthCheckSpec, len(o.HealthChecks))
	for i, sourceValue := range o.HealthChecks {
		result.HealthChecks[i] = proto.Clone(sourceValue).(*api.HealthCheckSpec)
	}
	result.DisableNetworkConfigFallback = o.DisableNetworkConfigFallback
	return result
}

func (o *Device_Spec) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Spec) Merge(source *Device_Spec) {
	if source.GetServiceAccount() != nil {
		if data, err := source.GetServiceAccount().ProtoString(); err != nil {
			panic(err)
		} else {
			o.ServiceAccount = &iam_service_account.Reference{}
			if err := o.ServiceAccount.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.ServiceAccount = nil
	}
	if source.GetLogBucket() != nil {
		if data, err := source.GetLogBucket().ProtoString(); err != nil {
			panic(err)
		} else {
			o.LogBucket = &logging_bucket.Reference{}
			if err := o.LogBucket.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.LogBucket = nil
	}
	if source.GetMetricsBucket() != nil {
		if data, err := source.GetMetricsBucket().ProtoString(); err != nil {
			panic(err)
		} else {
			o.MetricsBucket = &monitoring_bucket.Reference{}
			if err := o.MetricsBucket.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.MetricsBucket = nil
	}
	o.OsVersion = source.GetOsVersion()
	o.NetplanYamlConfig = source.GetNetplanYamlConfig()
	o.NetplanApiConfigMode = source.GetNetplanApiConfigMode()
	o.OsImageUrl = source.GetOsImageUrl()
	if source.GetSshConfig() != nil {
		if o.SshConfig == nil {
			o.SshConfig = new(Device_Spec_SSHConfig)
		}
		o.SshConfig.Merge(source.GetSshConfig())
	}
	if source.GetAttestationConfig() != nil {
		if o.AttestationConfig == nil {
			o.AttestationConfig = new(Device_Spec_AttestationConfig)
		}
		o.AttestationConfig.Merge(source.GetAttestationConfig())
	}
	o.DisableDeviceDiscovery = source.GetDisableDeviceDiscovery()
	if source.GetLoggingConfig() != nil {
		if o.LoggingConfig == nil {
			o.LoggingConfig = new(Device_Spec_LoggingConfig)
		}
		o.LoggingConfig.Merge(source.GetLoggingConfig())
	}
	if source.GetProxyConfig() != nil {
		if o.ProxyConfig == nil {
			o.ProxyConfig = new(Device_Spec_ProxyConfig)
		}
		o.ProxyConfig.Merge(source.GetProxyConfig())
	}
	if source.GetLocation() != nil {
		if o.Location == nil {
			o.Location = new(Device_Spec_Location)
		}
		o.Location.Merge(source.GetLocation())
	}
	if source.GetUsbGuard() != nil {
		if o.UsbGuard == nil {
			o.UsbGuard = new(Device_Spec_USBGuard)
		}
		o.UsbGuard.Merge(source.GetUsbGuard())
	}
	for _, sourceValue := range source.GetHealthChecks() {
		exists := false
		for _, currentValue := range o.HealthChecks {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *api.HealthCheckSpec
			if sourceValue != nil {
				newDstElement = new(api.HealthCheckSpec)
				proto.Merge(newDstElement, sourceValue)
			}
			o.HealthChecks = append(o.HealthChecks, newDstElement)
		}
	}

	o.DisableNetworkConfigFallback = source.GetDisableNetworkConfigFallback()
}

func (o *Device_Spec) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Spec))
}

func (o *Device_Status) GotenObjectExt() {}

func (o *Device_Status) MakeFullFieldMask() *Device_Status_FieldMask {
	return FullDevice_Status_FieldMask()
}

func (o *Device_Status) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_FieldMask()
}

func (o *Device_Status) MakeDiffFieldMask(other *Device_Status) *Device_Status_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_FieldMask()
	}

	res := &Device_Status_FieldMask{}

	if len(o.GetAddresses()) == len(other.GetAddresses()) {
		for i, lValue := range o.GetAddresses() {
			rValue := other.GetAddresses()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &DeviceStatus_FieldTerminalPath{selector: DeviceStatus_FieldPathSelectorAddresses})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatus_FieldTerminalPath{selector: DeviceStatus_FieldPathSelectorAddresses})
	}

	if len(o.GetConditions()) == len(other.GetConditions()) {
		for i, lValue := range o.GetConditions() {
			rValue := other.GetConditions()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &DeviceStatus_FieldTerminalPath{selector: DeviceStatus_FieldPathSelectorConditions})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatus_FieldTerminalPath{selector: DeviceStatus_FieldPathSelectorConditions})
	}
	{
		subMask := o.GetNetworkConfigState().MakeDiffFieldMask(other.GetNetworkConfigState())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatus_FieldTerminalPath{selector: DeviceStatus_FieldPathSelectorNetworkConfigState})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatus_FieldSubPath{selector: DeviceStatus_FieldPathSelectorNetworkConfigState, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetProxyConfigStatus().MakeDiffFieldMask(other.GetProxyConfigStatus())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatus_FieldTerminalPath{selector: DeviceStatus_FieldPathSelectorProxyConfigStatus})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatus_FieldSubPath{selector: DeviceStatus_FieldPathSelectorProxyConfigStatus, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetDeviceInfo().MakeDiffFieldMask(other.GetDeviceInfo())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatus_FieldTerminalPath{selector: DeviceStatus_FieldPathSelectorDeviceInfo})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatus_FieldSubPath{selector: DeviceStatus_FieldPathSelectorDeviceInfo, subPath: subpath})
			}
		}
	}

	if len(o.GetAttestationStatus()) == len(other.GetAttestationStatus()) {
		for i, lValue := range o.GetAttestationStatus() {
			rValue := other.GetAttestationStatus()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &DeviceStatus_FieldTerminalPath{selector: DeviceStatus_FieldPathSelectorAttestationStatus})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatus_FieldTerminalPath{selector: DeviceStatus_FieldPathSelectorAttestationStatus})
	}
	{
		subMask := o.GetNormalizedAddress().MakeDiffFieldMask(other.GetNormalizedAddress())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatus_FieldTerminalPath{selector: DeviceStatus_FieldPathSelectorNormalizedAddress})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatus_FieldSubPath{selector: DeviceStatus_FieldPathSelectorNormalizedAddress, subPath: subpath})
			}
		}
	}
	if o.GetConnectionStatus() != other.GetConnectionStatus() {
		res.Paths = append(res.Paths, &DeviceStatus_FieldTerminalPath{selector: DeviceStatus_FieldPathSelectorConnectionStatus})
	}
	if !proto.Equal(o.GetConnectionStatusChangeTime(), other.GetConnectionStatusChangeTime()) {
		res.Paths = append(res.Paths, &DeviceStatus_FieldTerminalPath{selector: DeviceStatus_FieldPathSelectorConnectionStatusChangeTime})
	}
	return res
}

func (o *Device_Status) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status))
}

func (o *Device_Status) Clone() *Device_Status {
	if o == nil {
		return nil
	}
	result := &Device_Status{}
	result.Addresses = make([]*Device_Status_Address, len(o.Addresses))
	for i, sourceValue := range o.Addresses {
		result.Addresses[i] = sourceValue.Clone()
	}
	result.Conditions = make([]*Device_Status_Condition, len(o.Conditions))
	for i, sourceValue := range o.Conditions {
		result.Conditions[i] = sourceValue.Clone()
	}
	result.NetworkConfigState = o.NetworkConfigState.Clone()
	result.ProxyConfigStatus = o.ProxyConfigStatus.Clone()
	result.DeviceInfo = o.DeviceInfo.Clone()
	result.AttestationStatus = make([]*iam_iam_common.PCR, len(o.AttestationStatus))
	for i, sourceValue := range o.AttestationStatus {
		result.AttestationStatus[i] = sourceValue.Clone()
	}
	result.NormalizedAddress = o.NormalizedAddress.Clone()
	result.ConnectionStatus = o.ConnectionStatus
	result.ConnectionStatusChangeTime = proto.Clone(o.ConnectionStatusChangeTime).(*timestamppb.Timestamp)
	return result
}

func (o *Device_Status) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status) Merge(source *Device_Status) {
	for _, sourceValue := range source.GetAddresses() {
		exists := false
		for _, currentValue := range o.Addresses {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *Device_Status_Address
			if sourceValue != nil {
				newDstElement = new(Device_Status_Address)
				newDstElement.Merge(sourceValue)
			}
			o.Addresses = append(o.Addresses, newDstElement)
		}
	}

	for _, sourceValue := range source.GetConditions() {
		exists := false
		for _, currentValue := range o.Conditions {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *Device_Status_Condition
			if sourceValue != nil {
				newDstElement = new(Device_Status_Condition)
				newDstElement.Merge(sourceValue)
			}
			o.Conditions = append(o.Conditions, newDstElement)
		}
	}

	if source.GetNetworkConfigState() != nil {
		if o.NetworkConfigState == nil {
			o.NetworkConfigState = new(Device_Status_NetworkConfigState)
		}
		o.NetworkConfigState.Merge(source.GetNetworkConfigState())
	}
	if source.GetProxyConfigStatus() != nil {
		if o.ProxyConfigStatus == nil {
			o.ProxyConfigStatus = new(Device_Status_ProxyConfigStatus)
		}
		o.ProxyConfigStatus.Merge(source.GetProxyConfigStatus())
	}
	if source.GetDeviceInfo() != nil {
		if o.DeviceInfo == nil {
			o.DeviceInfo = new(Device_Status_DeviceInfo)
		}
		o.DeviceInfo.Merge(source.GetDeviceInfo())
	}
	for _, sourceValue := range source.GetAttestationStatus() {
		exists := false
		for _, currentValue := range o.AttestationStatus {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *iam_iam_common.PCR
			if sourceValue != nil {
				newDstElement = new(iam_iam_common.PCR)
				newDstElement.Merge(sourceValue)
			}
			o.AttestationStatus = append(o.AttestationStatus, newDstElement)
		}
	}

	if source.GetNormalizedAddress() != nil {
		if o.NormalizedAddress == nil {
			o.NormalizedAddress = new(Device_Status_NormalizedAddress)
		}
		o.NormalizedAddress.Merge(source.GetNormalizedAddress())
	}
	o.ConnectionStatus = source.GetConnectionStatus()
	if source.GetConnectionStatusChangeTime() != nil {
		if o.ConnectionStatusChangeTime == nil {
			o.ConnectionStatusChangeTime = new(timestamppb.Timestamp)
		}
		proto.Merge(o.ConnectionStatusChangeTime, source.GetConnectionStatusChangeTime())
	}
}

func (o *Device_Status) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status))
}

func (o *Device_PublicListingSpec) GotenObjectExt() {}

func (o *Device_PublicListingSpec) MakeFullFieldMask() *Device_PublicListingSpec_FieldMask {
	return FullDevice_PublicListingSpec_FieldMask()
}

func (o *Device_PublicListingSpec) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_PublicListingSpec_FieldMask()
}

func (o *Device_PublicListingSpec) MakeDiffFieldMask(other *Device_PublicListingSpec) *Device_PublicListingSpec_FieldMask {
	if o == nil && other == nil {
		return &Device_PublicListingSpec_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_PublicListingSpec_FieldMask()
	}

	res := &Device_PublicListingSpec_FieldMask{}
	if o.GetEnabled() != other.GetEnabled() {
		res.Paths = append(res.Paths, &DevicePublicListingSpec_FieldTerminalPath{selector: DevicePublicListingSpec_FieldPathSelectorEnabled})
	}
	if !proto.Equal(o.GetFieldMask(), other.GetFieldMask()) {
		res.Paths = append(res.Paths, &DevicePublicListingSpec_FieldTerminalPath{selector: DevicePublicListingSpec_FieldPathSelectorFieldMask})
	}
	return res
}

func (o *Device_PublicListingSpec) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_PublicListingSpec))
}

func (o *Device_PublicListingSpec) Clone() *Device_PublicListingSpec {
	if o == nil {
		return nil
	}
	result := &Device_PublicListingSpec{}
	result.Enabled = o.Enabled
	result.FieldMask = proto.Clone(o.FieldMask).(*Device_FieldMask)
	return result
}

func (o *Device_PublicListingSpec) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_PublicListingSpec) Merge(source *Device_PublicListingSpec) {
	o.Enabled = source.GetEnabled()
	if source.GetFieldMask() != nil {
		if o.FieldMask == nil {
			o.FieldMask = new(Device_FieldMask)
		}
		mergedMask := googlefieldmaskpb.Union(source.GetFieldMask().ToProtoFieldMask(), o.FieldMask.ToProtoFieldMask())
		if err := o.FieldMask.FromProtoFieldMask(mergedMask); err != nil {
			panic(err)
		}
	}
}

func (o *Device_PublicListingSpec) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_PublicListingSpec))
}

func (o *Device_Spec_SSHConfig) GotenObjectExt() {}

func (o *Device_Spec_SSHConfig) MakeFullFieldMask() *Device_Spec_SSHConfig_FieldMask {
	return FullDevice_Spec_SSHConfig_FieldMask()
}

func (o *Device_Spec_SSHConfig) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Spec_SSHConfig_FieldMask()
}

func (o *Device_Spec_SSHConfig) MakeDiffFieldMask(other *Device_Spec_SSHConfig) *Device_Spec_SSHConfig_FieldMask {
	if o == nil && other == nil {
		return &Device_Spec_SSHConfig_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Spec_SSHConfig_FieldMask()
	}

	res := &Device_Spec_SSHConfig_FieldMask{}
	if o.GetDisableSshServer() != other.GetDisableSshServer() {
		res.Paths = append(res.Paths, &DeviceSpecSSHConfig_FieldTerminalPath{selector: DeviceSpecSSHConfig_FieldPathSelectorDisableSshServer})
	}
	if o.GetDisableSshPassword() != other.GetDisableSshPassword() {
		res.Paths = append(res.Paths, &DeviceSpecSSHConfig_FieldTerminalPath{selector: DeviceSpecSSHConfig_FieldPathSelectorDisableSshPassword})
	}

	if len(o.GetSshAuthorized()) == len(other.GetSshAuthorized()) {
		for i, lValue := range o.GetSshAuthorized() {
			rValue := other.GetSshAuthorized()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &DeviceSpecSSHConfig_FieldTerminalPath{selector: DeviceSpecSSHConfig_FieldPathSelectorSshAuthorized})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceSpecSSHConfig_FieldTerminalPath{selector: DeviceSpecSSHConfig_FieldPathSelectorSshAuthorized})
	}

	if len(o.GetIpAllowList()) == len(other.GetIpAllowList()) {
		for i, lValue := range o.GetIpAllowList() {
			rValue := other.GetIpAllowList()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceSpecSSHConfig_FieldTerminalPath{selector: DeviceSpecSSHConfig_FieldPathSelectorIpAllowList})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceSpecSSHConfig_FieldTerminalPath{selector: DeviceSpecSSHConfig_FieldPathSelectorIpAllowList})
	}

	if len(o.GetIpDenyList()) == len(other.GetIpDenyList()) {
		for i, lValue := range o.GetIpDenyList() {
			rValue := other.GetIpDenyList()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceSpecSSHConfig_FieldTerminalPath{selector: DeviceSpecSSHConfig_FieldPathSelectorIpDenyList})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceSpecSSHConfig_FieldTerminalPath{selector: DeviceSpecSSHConfig_FieldPathSelectorIpDenyList})
	}
	if !proto.Equal(o.GetRejectPeriod(), other.GetRejectPeriod()) {
		res.Paths = append(res.Paths, &DeviceSpecSSHConfig_FieldTerminalPath{selector: DeviceSpecSSHConfig_FieldPathSelectorRejectPeriod})
	}
	if o.GetDisableSshAuthkey() != other.GetDisableSshAuthkey() {
		res.Paths = append(res.Paths, &DeviceSpecSSHConfig_FieldTerminalPath{selector: DeviceSpecSSHConfig_FieldPathSelectorDisableSshAuthkey})
	}
	return res
}

func (o *Device_Spec_SSHConfig) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Spec_SSHConfig))
}

func (o *Device_Spec_SSHConfig) Clone() *Device_Spec_SSHConfig {
	if o == nil {
		return nil
	}
	result := &Device_Spec_SSHConfig{}
	result.DisableSshServer = o.DisableSshServer
	result.DisableSshPassword = o.DisableSshPassword
	result.SshAuthorized = make([]*Device_Spec_SSHConfig_AuthKey, len(o.SshAuthorized))
	for i, sourceValue := range o.SshAuthorized {
		result.SshAuthorized[i] = sourceValue.Clone()
	}
	result.IpAllowList = make([]string, len(o.IpAllowList))
	for i, sourceValue := range o.IpAllowList {
		result.IpAllowList[i] = sourceValue
	}
	result.IpDenyList = make([]string, len(o.IpDenyList))
	for i, sourceValue := range o.IpDenyList {
		result.IpDenyList[i] = sourceValue
	}
	result.RejectPeriod = proto.Clone(o.RejectPeriod).(*durationpb.Duration)
	result.DisableSshAuthkey = o.DisableSshAuthkey
	return result
}

func (o *Device_Spec_SSHConfig) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Spec_SSHConfig) Merge(source *Device_Spec_SSHConfig) {
	o.DisableSshServer = source.GetDisableSshServer()
	o.DisableSshPassword = source.GetDisableSshPassword()
	for _, sourceValue := range source.GetSshAuthorized() {
		exists := false
		for _, currentValue := range o.SshAuthorized {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *Device_Spec_SSHConfig_AuthKey
			if sourceValue != nil {
				newDstElement = new(Device_Spec_SSHConfig_AuthKey)
				newDstElement.Merge(sourceValue)
			}
			o.SshAuthorized = append(o.SshAuthorized, newDstElement)
		}
	}

	for _, sourceValue := range source.GetIpAllowList() {
		exists := false
		for _, currentValue := range o.IpAllowList {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.IpAllowList = append(o.IpAllowList, newDstElement)
		}
	}

	for _, sourceValue := range source.GetIpDenyList() {
		exists := false
		for _, currentValue := range o.IpDenyList {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.IpDenyList = append(o.IpDenyList, newDstElement)
		}
	}

	if source.GetRejectPeriod() != nil {
		if o.RejectPeriod == nil {
			o.RejectPeriod = new(durationpb.Duration)
		}
		proto.Merge(o.RejectPeriod, source.GetRejectPeriod())
	}
	o.DisableSshAuthkey = source.GetDisableSshAuthkey()
}

func (o *Device_Spec_SSHConfig) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Spec_SSHConfig))
}

func (o *Device_Spec_AttestationConfig) GotenObjectExt() {}

func (o *Device_Spec_AttestationConfig) MakeFullFieldMask() *Device_Spec_AttestationConfig_FieldMask {
	return FullDevice_Spec_AttestationConfig_FieldMask()
}

func (o *Device_Spec_AttestationConfig) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Spec_AttestationConfig_FieldMask()
}

func (o *Device_Spec_AttestationConfig) MakeDiffFieldMask(other *Device_Spec_AttestationConfig) *Device_Spec_AttestationConfig_FieldMask {
	if o == nil && other == nil {
		return &Device_Spec_AttestationConfig_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Spec_AttestationConfig_FieldMask()
	}

	res := &Device_Spec_AttestationConfig_FieldMask{}
	if o.GetAttestationExpected() != other.GetAttestationExpected() {
		res.Paths = append(res.Paths, &DeviceSpecAttestationConfig_FieldTerminalPath{selector: DeviceSpecAttestationConfig_FieldPathSelectorAttestationExpected})
	}
	if o.GetAttestationDomain().String() != other.GetAttestationDomain().String() {
		res.Paths = append(res.Paths, &DeviceSpecAttestationConfig_FieldTerminalPath{selector: DeviceSpecAttestationConfig_FieldPathSelectorAttestationDomain})
	}
	return res
}

func (o *Device_Spec_AttestationConfig) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Spec_AttestationConfig))
}

func (o *Device_Spec_AttestationConfig) Clone() *Device_Spec_AttestationConfig {
	if o == nil {
		return nil
	}
	result := &Device_Spec_AttestationConfig{}
	result.AttestationExpected = o.AttestationExpected
	if o.AttestationDomain == nil {
		result.AttestationDomain = nil
	} else if data, err := o.AttestationDomain.ProtoString(); err != nil {
		panic(err)
	} else {
		result.AttestationDomain = &iam_attestation_domain.Reference{}
		if err := result.AttestationDomain.ParseProtoString(data); err != nil {
			panic(err)
		}
	}
	return result
}

func (o *Device_Spec_AttestationConfig) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Spec_AttestationConfig) Merge(source *Device_Spec_AttestationConfig) {
	o.AttestationExpected = source.GetAttestationExpected()
	if source.GetAttestationDomain() != nil {
		if data, err := source.GetAttestationDomain().ProtoString(); err != nil {
			panic(err)
		} else {
			o.AttestationDomain = &iam_attestation_domain.Reference{}
			if err := o.AttestationDomain.ParseProtoString(data); err != nil {
				panic(err)
			}
		}
	} else {
		o.AttestationDomain = nil
	}
}

func (o *Device_Spec_AttestationConfig) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Spec_AttestationConfig))
}

func (o *Device_Spec_LoggingConfig) GotenObjectExt() {}

func (o *Device_Spec_LoggingConfig) MakeFullFieldMask() *Device_Spec_LoggingConfig_FieldMask {
	return FullDevice_Spec_LoggingConfig_FieldMask()
}

func (o *Device_Spec_LoggingConfig) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Spec_LoggingConfig_FieldMask()
}

func (o *Device_Spec_LoggingConfig) MakeDiffFieldMask(other *Device_Spec_LoggingConfig) *Device_Spec_LoggingConfig_FieldMask {
	if o == nil && other == nil {
		return &Device_Spec_LoggingConfig_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Spec_LoggingConfig_FieldMask()
	}

	res := &Device_Spec_LoggingConfig_FieldMask{}
	if o.GetPriority() != other.GetPriority() {
		res.Paths = append(res.Paths, &DeviceSpecLoggingConfig_FieldTerminalPath{selector: DeviceSpecLoggingConfig_FieldPathSelectorPriority})
	}

	if len(o.GetUnits()) == len(other.GetUnits()) {
		for i, lValue := range o.GetUnits() {
			rValue := other.GetUnits()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceSpecLoggingConfig_FieldTerminalPath{selector: DeviceSpecLoggingConfig_FieldPathSelectorUnits})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceSpecLoggingConfig_FieldTerminalPath{selector: DeviceSpecLoggingConfig_FieldPathSelectorUnits})
	}
	if o.GetEnableJournalExport() != other.GetEnableJournalExport() {
		res.Paths = append(res.Paths, &DeviceSpecLoggingConfig_FieldTerminalPath{selector: DeviceSpecLoggingConfig_FieldPathSelectorEnableJournalExport})
	}
	{
		subMask := o.GetContainerLoggingConfig().MakeDiffFieldMask(other.GetContainerLoggingConfig())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceSpecLoggingConfig_FieldTerminalPath{selector: DeviceSpecLoggingConfig_FieldPathSelectorContainerLoggingConfig})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceSpecLoggingConfig_FieldSubPath{selector: DeviceSpecLoggingConfig_FieldPathSelectorContainerLoggingConfig, subPath: subpath})
			}
		}
	}
	return res
}

func (o *Device_Spec_LoggingConfig) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Spec_LoggingConfig))
}

func (o *Device_Spec_LoggingConfig) Clone() *Device_Spec_LoggingConfig {
	if o == nil {
		return nil
	}
	result := &Device_Spec_LoggingConfig{}
	result.Priority = o.Priority
	result.Units = make([]string, len(o.Units))
	for i, sourceValue := range o.Units {
		result.Units[i] = sourceValue
	}
	result.EnableJournalExport = o.EnableJournalExport
	result.ContainerLoggingConfig = o.ContainerLoggingConfig.Clone()
	return result
}

func (o *Device_Spec_LoggingConfig) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Spec_LoggingConfig) Merge(source *Device_Spec_LoggingConfig) {
	o.Priority = source.GetPriority()
	for _, sourceValue := range source.GetUnits() {
		exists := false
		for _, currentValue := range o.Units {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.Units = append(o.Units, newDstElement)
		}
	}

	o.EnableJournalExport = source.GetEnableJournalExport()
	if source.GetContainerLoggingConfig() != nil {
		if o.ContainerLoggingConfig == nil {
			o.ContainerLoggingConfig = new(Device_Spec_LoggingConfig_ContainerLoggingConfig)
		}
		o.ContainerLoggingConfig.Merge(source.GetContainerLoggingConfig())
	}
}

func (o *Device_Spec_LoggingConfig) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Spec_LoggingConfig))
}

func (o *Device_Spec_ProxyConfig) GotenObjectExt() {}

func (o *Device_Spec_ProxyConfig) MakeFullFieldMask() *Device_Spec_ProxyConfig_FieldMask {
	return FullDevice_Spec_ProxyConfig_FieldMask()
}

func (o *Device_Spec_ProxyConfig) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Spec_ProxyConfig_FieldMask()
}

func (o *Device_Spec_ProxyConfig) MakeDiffFieldMask(other *Device_Spec_ProxyConfig) *Device_Spec_ProxyConfig_FieldMask {
	if o == nil && other == nil {
		return &Device_Spec_ProxyConfig_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Spec_ProxyConfig_FieldMask()
	}

	res := &Device_Spec_ProxyConfig_FieldMask{}
	if o.GetHttpProxy() != other.GetHttpProxy() {
		res.Paths = append(res.Paths, &DeviceSpecProxyConfig_FieldTerminalPath{selector: DeviceSpecProxyConfig_FieldPathSelectorHttpProxy})
	}
	if o.GetHttpsProxy() != other.GetHttpsProxy() {
		res.Paths = append(res.Paths, &DeviceSpecProxyConfig_FieldTerminalPath{selector: DeviceSpecProxyConfig_FieldPathSelectorHttpsProxy})
	}
	if o.GetNoProxy() != other.GetNoProxy() {
		res.Paths = append(res.Paths, &DeviceSpecProxyConfig_FieldTerminalPath{selector: DeviceSpecProxyConfig_FieldPathSelectorNoProxy})
	}

	if len(o.GetProxyInterfaces()) == len(other.GetProxyInterfaces()) {
		for i, lValue := range o.GetProxyInterfaces() {
			rValue := other.GetProxyInterfaces()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceSpecProxyConfig_FieldTerminalPath{selector: DeviceSpecProxyConfig_FieldPathSelectorProxyInterfaces})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceSpecProxyConfig_FieldTerminalPath{selector: DeviceSpecProxyConfig_FieldPathSelectorProxyInterfaces})
	}
	return res
}

func (o *Device_Spec_ProxyConfig) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Spec_ProxyConfig))
}

func (o *Device_Spec_ProxyConfig) Clone() *Device_Spec_ProxyConfig {
	if o == nil {
		return nil
	}
	result := &Device_Spec_ProxyConfig{}
	result.HttpProxy = o.HttpProxy
	result.HttpsProxy = o.HttpsProxy
	result.NoProxy = o.NoProxy
	result.ProxyInterfaces = make([]string, len(o.ProxyInterfaces))
	for i, sourceValue := range o.ProxyInterfaces {
		result.ProxyInterfaces[i] = sourceValue
	}
	return result
}

func (o *Device_Spec_ProxyConfig) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Spec_ProxyConfig) Merge(source *Device_Spec_ProxyConfig) {
	o.HttpProxy = source.GetHttpProxy()
	o.HttpsProxy = source.GetHttpsProxy()
	o.NoProxy = source.GetNoProxy()
	for _, sourceValue := range source.GetProxyInterfaces() {
		exists := false
		for _, currentValue := range o.ProxyInterfaces {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.ProxyInterfaces = append(o.ProxyInterfaces, newDstElement)
		}
	}

}

func (o *Device_Spec_ProxyConfig) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Spec_ProxyConfig))
}

func (o *Device_Spec_Location) GotenObjectExt() {}

func (o *Device_Spec_Location) MakeFullFieldMask() *Device_Spec_Location_FieldMask {
	return FullDevice_Spec_Location_FieldMask()
}

func (o *Device_Spec_Location) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Spec_Location_FieldMask()
}

func (o *Device_Spec_Location) MakeDiffFieldMask(other *Device_Spec_Location) *Device_Spec_Location_FieldMask {
	if o == nil && other == nil {
		return &Device_Spec_Location_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Spec_Location_FieldMask()
	}

	res := &Device_Spec_Location_FieldMask{}
	if o.GetAddress() != other.GetAddress() {
		res.Paths = append(res.Paths, &DeviceSpecLocation_FieldTerminalPath{selector: DeviceSpecLocation_FieldPathSelectorAddress})
	}
	if o.GetPlacement() != other.GetPlacement() {
		res.Paths = append(res.Paths, &DeviceSpecLocation_FieldTerminalPath{selector: DeviceSpecLocation_FieldPathSelectorPlacement})
	}
	return res
}

func (o *Device_Spec_Location) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Spec_Location))
}

func (o *Device_Spec_Location) Clone() *Device_Spec_Location {
	if o == nil {
		return nil
	}
	result := &Device_Spec_Location{}
	result.Address = o.Address
	result.Placement = o.Placement
	return result
}

func (o *Device_Spec_Location) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Spec_Location) Merge(source *Device_Spec_Location) {
	o.Address = source.GetAddress()
	o.Placement = source.GetPlacement()
}

func (o *Device_Spec_Location) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Spec_Location))
}

func (o *Device_Spec_USBGuard) GotenObjectExt() {}

func (o *Device_Spec_USBGuard) MakeFullFieldMask() *Device_Spec_USBGuard_FieldMask {
	return FullDevice_Spec_USBGuard_FieldMask()
}

func (o *Device_Spec_USBGuard) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Spec_USBGuard_FieldMask()
}

func (o *Device_Spec_USBGuard) MakeDiffFieldMask(other *Device_Spec_USBGuard) *Device_Spec_USBGuard_FieldMask {
	if o == nil && other == nil {
		return &Device_Spec_USBGuard_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Spec_USBGuard_FieldMask()
	}

	res := &Device_Spec_USBGuard_FieldMask{}
	if o.GetEnable() != other.GetEnable() {
		res.Paths = append(res.Paths, &DeviceSpecUSBGuard_FieldTerminalPath{selector: DeviceSpecUSBGuard_FieldPathSelectorEnable})
	}

	if len(o.GetWhiteList()) == len(other.GetWhiteList()) {
		for i, lValue := range o.GetWhiteList() {
			rValue := other.GetWhiteList()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &DeviceSpecUSBGuard_FieldTerminalPath{selector: DeviceSpecUSBGuard_FieldPathSelectorWhiteList})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceSpecUSBGuard_FieldTerminalPath{selector: DeviceSpecUSBGuard_FieldPathSelectorWhiteList})
	}
	return res
}

func (o *Device_Spec_USBGuard) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Spec_USBGuard))
}

func (o *Device_Spec_USBGuard) Clone() *Device_Spec_USBGuard {
	if o == nil {
		return nil
	}
	result := &Device_Spec_USBGuard{}
	result.Enable = o.Enable
	result.WhiteList = make([]*Device_Spec_USBGuard_WhiteList, len(o.WhiteList))
	for i, sourceValue := range o.WhiteList {
		result.WhiteList[i] = sourceValue.Clone()
	}
	return result
}

func (o *Device_Spec_USBGuard) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Spec_USBGuard) Merge(source *Device_Spec_USBGuard) {
	o.Enable = source.GetEnable()
	for _, sourceValue := range source.GetWhiteList() {
		exists := false
		for _, currentValue := range o.WhiteList {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *Device_Spec_USBGuard_WhiteList
			if sourceValue != nil {
				newDstElement = new(Device_Spec_USBGuard_WhiteList)
				newDstElement.Merge(sourceValue)
			}
			o.WhiteList = append(o.WhiteList, newDstElement)
		}
	}

}

func (o *Device_Spec_USBGuard) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Spec_USBGuard))
}

func (o *Device_Spec_SSHConfig_AuthKey) GotenObjectExt() {}

func (o *Device_Spec_SSHConfig_AuthKey) MakeFullFieldMask() *Device_Spec_SSHConfig_AuthKey_FieldMask {
	return FullDevice_Spec_SSHConfig_AuthKey_FieldMask()
}

func (o *Device_Spec_SSHConfig_AuthKey) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Spec_SSHConfig_AuthKey_FieldMask()
}

func (o *Device_Spec_SSHConfig_AuthKey) MakeDiffFieldMask(other *Device_Spec_SSHConfig_AuthKey) *Device_Spec_SSHConfig_AuthKey_FieldMask {
	if o == nil && other == nil {
		return &Device_Spec_SSHConfig_AuthKey_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Spec_SSHConfig_AuthKey_FieldMask()
	}

	res := &Device_Spec_SSHConfig_AuthKey_FieldMask{}
	if o.GetSshaKey() != other.GetSshaKey() {
		res.Paths = append(res.Paths, &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorSshaKey})
	}
	if o.GetCertAuthority() != other.GetCertAuthority() {
		res.Paths = append(res.Paths, &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorCertAuthority})
	}
	if o.GetCommand() != other.GetCommand() {
		res.Paths = append(res.Paths, &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorCommand})
	}
	if o.GetEnvironment() != other.GetEnvironment() {
		res.Paths = append(res.Paths, &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorEnvironment})
	}
	if o.GetFrom() != other.GetFrom() {
		res.Paths = append(res.Paths, &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorFrom})
	}
	if o.GetNoAgentForwarding() != other.GetNoAgentForwarding() {
		res.Paths = append(res.Paths, &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoAgentForwarding})
	}
	if o.GetNoPortForwarding() != other.GetNoPortForwarding() {
		res.Paths = append(res.Paths, &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPortForwarding})
	}
	if o.GetNoPty() != other.GetNoPty() {
		res.Paths = append(res.Paths, &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoPty})
	}
	if o.GetNoUserRc() != other.GetNoUserRc() {
		res.Paths = append(res.Paths, &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoUserRc})
	}
	if o.GetNoX11Forwarding() != other.GetNoX11Forwarding() {
		res.Paths = append(res.Paths, &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorNoX11Forwarding})
	}
	if o.GetPermitopen() != other.GetPermitopen() {
		res.Paths = append(res.Paths, &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorPermitopen})
	}
	if o.GetPrincipals() != other.GetPrincipals() {
		res.Paths = append(res.Paths, &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorPrincipals})
	}
	if o.GetTunnel() != other.GetTunnel() {
		res.Paths = append(res.Paths, &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorTunnel})
	}
	if o.GetRestrict() != other.GetRestrict() {
		res.Paths = append(res.Paths, &DeviceSpecSSHConfigAuthKey_FieldTerminalPath{selector: DeviceSpecSSHConfigAuthKey_FieldPathSelectorRestrict})
	}
	return res
}

func (o *Device_Spec_SSHConfig_AuthKey) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Spec_SSHConfig_AuthKey))
}

func (o *Device_Spec_SSHConfig_AuthKey) Clone() *Device_Spec_SSHConfig_AuthKey {
	if o == nil {
		return nil
	}
	result := &Device_Spec_SSHConfig_AuthKey{}
	result.SshaKey = o.SshaKey
	result.CertAuthority = o.CertAuthority
	result.Command = o.Command
	result.Environment = o.Environment
	result.From = o.From
	result.NoAgentForwarding = o.NoAgentForwarding
	result.NoPortForwarding = o.NoPortForwarding
	result.NoPty = o.NoPty
	result.NoUserRc = o.NoUserRc
	result.NoX11Forwarding = o.NoX11Forwarding
	result.Permitopen = o.Permitopen
	result.Principals = o.Principals
	result.Tunnel = o.Tunnel
	result.Restrict = o.Restrict
	return result
}

func (o *Device_Spec_SSHConfig_AuthKey) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Spec_SSHConfig_AuthKey) Merge(source *Device_Spec_SSHConfig_AuthKey) {
	o.SshaKey = source.GetSshaKey()
	o.CertAuthority = source.GetCertAuthority()
	o.Command = source.GetCommand()
	o.Environment = source.GetEnvironment()
	o.From = source.GetFrom()
	o.NoAgentForwarding = source.GetNoAgentForwarding()
	o.NoPortForwarding = source.GetNoPortForwarding()
	o.NoPty = source.GetNoPty()
	o.NoUserRc = source.GetNoUserRc()
	o.NoX11Forwarding = source.GetNoX11Forwarding()
	o.Permitopen = source.GetPermitopen()
	o.Principals = source.GetPrincipals()
	o.Tunnel = source.GetTunnel()
	o.Restrict = source.GetRestrict()
}

func (o *Device_Spec_SSHConfig_AuthKey) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Spec_SSHConfig_AuthKey))
}

func (o *Device_Spec_LoggingConfig_ContainerLoggingConfig) GotenObjectExt() {}

func (o *Device_Spec_LoggingConfig_ContainerLoggingConfig) MakeFullFieldMask() *Device_Spec_LoggingConfig_ContainerLoggingConfig_FieldMask {
	return FullDevice_Spec_LoggingConfig_ContainerLoggingConfig_FieldMask()
}

func (o *Device_Spec_LoggingConfig_ContainerLoggingConfig) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Spec_LoggingConfig_ContainerLoggingConfig_FieldMask()
}

func (o *Device_Spec_LoggingConfig_ContainerLoggingConfig) MakeDiffFieldMask(other *Device_Spec_LoggingConfig_ContainerLoggingConfig) *Device_Spec_LoggingConfig_ContainerLoggingConfig_FieldMask {
	if o == nil && other == nil {
		return &Device_Spec_LoggingConfig_ContainerLoggingConfig_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Spec_LoggingConfig_ContainerLoggingConfig_FieldMask()
	}

	res := &Device_Spec_LoggingConfig_ContainerLoggingConfig_FieldMask{}
	if o.GetEnableContainerLogExport() != other.GetEnableContainerLogExport() {
		res.Paths = append(res.Paths, &DeviceSpecLoggingConfigContainerLoggingConfig_FieldTerminalPath{selector: DeviceSpecLoggingConfigContainerLoggingConfig_FieldPathSelectorEnableContainerLogExport})
	}
	return res
}

func (o *Device_Spec_LoggingConfig_ContainerLoggingConfig) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Spec_LoggingConfig_ContainerLoggingConfig))
}

func (o *Device_Spec_LoggingConfig_ContainerLoggingConfig) Clone() *Device_Spec_LoggingConfig_ContainerLoggingConfig {
	if o == nil {
		return nil
	}
	result := &Device_Spec_LoggingConfig_ContainerLoggingConfig{}
	result.EnableContainerLogExport = o.EnableContainerLogExport
	return result
}

func (o *Device_Spec_LoggingConfig_ContainerLoggingConfig) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Spec_LoggingConfig_ContainerLoggingConfig) Merge(source *Device_Spec_LoggingConfig_ContainerLoggingConfig) {
	o.EnableContainerLogExport = source.GetEnableContainerLogExport()
}

func (o *Device_Spec_LoggingConfig_ContainerLoggingConfig) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Spec_LoggingConfig_ContainerLoggingConfig))
}

func (o *Device_Spec_USBGuard_Port) GotenObjectExt() {}

func (o *Device_Spec_USBGuard_Port) MakeFullFieldMask() *Device_Spec_USBGuard_Port_FieldMask {
	return FullDevice_Spec_USBGuard_Port_FieldMask()
}

func (o *Device_Spec_USBGuard_Port) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Spec_USBGuard_Port_FieldMask()
}

func (o *Device_Spec_USBGuard_Port) MakeDiffFieldMask(other *Device_Spec_USBGuard_Port) *Device_Spec_USBGuard_Port_FieldMask {
	if o == nil && other == nil {
		return &Device_Spec_USBGuard_Port_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Spec_USBGuard_Port_FieldMask()
	}

	res := &Device_Spec_USBGuard_Port_FieldMask{}

	if len(o.GetEquals()) == len(other.GetEquals()) {
		for i, lValue := range o.GetEquals() {
			rValue := other.GetEquals()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceSpecUSBGuardPort_FieldTerminalPath{selector: DeviceSpecUSBGuardPort_FieldPathSelectorEquals})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceSpecUSBGuardPort_FieldTerminalPath{selector: DeviceSpecUSBGuardPort_FieldPathSelectorEquals})
	}

	if len(o.GetOneOf()) == len(other.GetOneOf()) {
		for i, lValue := range o.GetOneOf() {
			rValue := other.GetOneOf()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceSpecUSBGuardPort_FieldTerminalPath{selector: DeviceSpecUSBGuardPort_FieldPathSelectorOneOf})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceSpecUSBGuardPort_FieldTerminalPath{selector: DeviceSpecUSBGuardPort_FieldPathSelectorOneOf})
	}
	return res
}

func (o *Device_Spec_USBGuard_Port) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Spec_USBGuard_Port))
}

func (o *Device_Spec_USBGuard_Port) Clone() *Device_Spec_USBGuard_Port {
	if o == nil {
		return nil
	}
	result := &Device_Spec_USBGuard_Port{}
	result.Equals = make([]string, len(o.Equals))
	for i, sourceValue := range o.Equals {
		result.Equals[i] = sourceValue
	}
	result.OneOf = make([]string, len(o.OneOf))
	for i, sourceValue := range o.OneOf {
		result.OneOf[i] = sourceValue
	}
	return result
}

func (o *Device_Spec_USBGuard_Port) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Spec_USBGuard_Port) Merge(source *Device_Spec_USBGuard_Port) {
	for _, sourceValue := range source.GetEquals() {
		exists := false
		for _, currentValue := range o.Equals {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.Equals = append(o.Equals, newDstElement)
		}
	}

	for _, sourceValue := range source.GetOneOf() {
		exists := false
		for _, currentValue := range o.OneOf {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.OneOf = append(o.OneOf, newDstElement)
		}
	}

}

func (o *Device_Spec_USBGuard_Port) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Spec_USBGuard_Port))
}

func (o *Device_Spec_USBGuard_Interface) GotenObjectExt() {}

func (o *Device_Spec_USBGuard_Interface) MakeFullFieldMask() *Device_Spec_USBGuard_Interface_FieldMask {
	return FullDevice_Spec_USBGuard_Interface_FieldMask()
}

func (o *Device_Spec_USBGuard_Interface) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Spec_USBGuard_Interface_FieldMask()
}

func (o *Device_Spec_USBGuard_Interface) MakeDiffFieldMask(other *Device_Spec_USBGuard_Interface) *Device_Spec_USBGuard_Interface_FieldMask {
	if o == nil && other == nil {
		return &Device_Spec_USBGuard_Interface_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Spec_USBGuard_Interface_FieldMask()
	}

	res := &Device_Spec_USBGuard_Interface_FieldMask{}

	if len(o.GetEquals()) == len(other.GetEquals()) {
		for i, lValue := range o.GetEquals() {
			rValue := other.GetEquals()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceSpecUSBGuardInterface_FieldTerminalPath{selector: DeviceSpecUSBGuardInterface_FieldPathSelectorEquals})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceSpecUSBGuardInterface_FieldTerminalPath{selector: DeviceSpecUSBGuardInterface_FieldPathSelectorEquals})
	}

	if len(o.GetOneOf()) == len(other.GetOneOf()) {
		for i, lValue := range o.GetOneOf() {
			rValue := other.GetOneOf()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceSpecUSBGuardInterface_FieldTerminalPath{selector: DeviceSpecUSBGuardInterface_FieldPathSelectorOneOf})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceSpecUSBGuardInterface_FieldTerminalPath{selector: DeviceSpecUSBGuardInterface_FieldPathSelectorOneOf})
	}
	return res
}

func (o *Device_Spec_USBGuard_Interface) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Spec_USBGuard_Interface))
}

func (o *Device_Spec_USBGuard_Interface) Clone() *Device_Spec_USBGuard_Interface {
	if o == nil {
		return nil
	}
	result := &Device_Spec_USBGuard_Interface{}
	result.Equals = make([]string, len(o.Equals))
	for i, sourceValue := range o.Equals {
		result.Equals[i] = sourceValue
	}
	result.OneOf = make([]string, len(o.OneOf))
	for i, sourceValue := range o.OneOf {
		result.OneOf[i] = sourceValue
	}
	return result
}

func (o *Device_Spec_USBGuard_Interface) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Spec_USBGuard_Interface) Merge(source *Device_Spec_USBGuard_Interface) {
	for _, sourceValue := range source.GetEquals() {
		exists := false
		for _, currentValue := range o.Equals {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.Equals = append(o.Equals, newDstElement)
		}
	}

	for _, sourceValue := range source.GetOneOf() {
		exists := false
		for _, currentValue := range o.OneOf {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.OneOf = append(o.OneOf, newDstElement)
		}
	}

}

func (o *Device_Spec_USBGuard_Interface) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Spec_USBGuard_Interface))
}

func (o *Device_Spec_USBGuard_WhiteList) GotenObjectExt() {}

func (o *Device_Spec_USBGuard_WhiteList) MakeFullFieldMask() *Device_Spec_USBGuard_WhiteList_FieldMask {
	return FullDevice_Spec_USBGuard_WhiteList_FieldMask()
}

func (o *Device_Spec_USBGuard_WhiteList) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Spec_USBGuard_WhiteList_FieldMask()
}

func (o *Device_Spec_USBGuard_WhiteList) MakeDiffFieldMask(other *Device_Spec_USBGuard_WhiteList) *Device_Spec_USBGuard_WhiteList_FieldMask {
	if o == nil && other == nil {
		return &Device_Spec_USBGuard_WhiteList_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Spec_USBGuard_WhiteList_FieldMask()
	}

	res := &Device_Spec_USBGuard_WhiteList_FieldMask{}
	if o.GetDeviceName() != other.GetDeviceName() {
		res.Paths = append(res.Paths, &DeviceSpecUSBGuardWhiteList_FieldTerminalPath{selector: DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceName})
	}
	if o.GetDeviceId() != other.GetDeviceId() {
		res.Paths = append(res.Paths, &DeviceSpecUSBGuardWhiteList_FieldTerminalPath{selector: DeviceSpecUSBGuardWhiteList_FieldPathSelectorDeviceId})
	}
	{
		subMask := o.GetViaPort().MakeDiffFieldMask(other.GetViaPort())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceSpecUSBGuardWhiteList_FieldTerminalPath{selector: DeviceSpecUSBGuardWhiteList_FieldPathSelectorViaPort})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceSpecUSBGuardWhiteList_FieldSubPath{selector: DeviceSpecUSBGuardWhiteList_FieldPathSelectorViaPort, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetWithInterface().MakeDiffFieldMask(other.GetWithInterface())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceSpecUSBGuardWhiteList_FieldTerminalPath{selector: DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithInterface})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceSpecUSBGuardWhiteList_FieldSubPath{selector: DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithInterface, subPath: subpath})
			}
		}
	}
	if o.GetWithConnectType() != other.GetWithConnectType() {
		res.Paths = append(res.Paths, &DeviceSpecUSBGuardWhiteList_FieldTerminalPath{selector: DeviceSpecUSBGuardWhiteList_FieldPathSelectorWithConnectType})
	}
	return res
}

func (o *Device_Spec_USBGuard_WhiteList) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Spec_USBGuard_WhiteList))
}

func (o *Device_Spec_USBGuard_WhiteList) Clone() *Device_Spec_USBGuard_WhiteList {
	if o == nil {
		return nil
	}
	result := &Device_Spec_USBGuard_WhiteList{}
	result.DeviceName = o.DeviceName
	result.DeviceId = o.DeviceId
	result.ViaPort = o.ViaPort.Clone()
	result.WithInterface = o.WithInterface.Clone()
	result.WithConnectType = o.WithConnectType
	return result
}

func (o *Device_Spec_USBGuard_WhiteList) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Spec_USBGuard_WhiteList) Merge(source *Device_Spec_USBGuard_WhiteList) {
	o.DeviceName = source.GetDeviceName()
	o.DeviceId = source.GetDeviceId()
	if source.GetViaPort() != nil {
		if o.ViaPort == nil {
			o.ViaPort = new(Device_Spec_USBGuard_Port)
		}
		o.ViaPort.Merge(source.GetViaPort())
	}
	if source.GetWithInterface() != nil {
		if o.WithInterface == nil {
			o.WithInterface = new(Device_Spec_USBGuard_Interface)
		}
		o.WithInterface.Merge(source.GetWithInterface())
	}
	o.WithConnectType = source.GetWithConnectType()
}

func (o *Device_Spec_USBGuard_WhiteList) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Spec_USBGuard_WhiteList))
}

func (o *Device_Status_Address) GotenObjectExt() {}

func (o *Device_Status_Address) MakeFullFieldMask() *Device_Status_Address_FieldMask {
	return FullDevice_Status_Address_FieldMask()
}

func (o *Device_Status_Address) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_Address_FieldMask()
}

func (o *Device_Status_Address) MakeDiffFieldMask(other *Device_Status_Address) *Device_Status_Address_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_Address_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_Address_FieldMask()
	}

	res := &Device_Status_Address_FieldMask{}
	if o.GetAddress() != other.GetAddress() {
		res.Paths = append(res.Paths, &DeviceStatusAddress_FieldTerminalPath{selector: DeviceStatusAddress_FieldPathSelectorAddress})
	}
	if o.GetType() != other.GetType() {
		res.Paths = append(res.Paths, &DeviceStatusAddress_FieldTerminalPath{selector: DeviceStatusAddress_FieldPathSelectorType})
	}
	return res
}

func (o *Device_Status_Address) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_Address))
}

func (o *Device_Status_Address) Clone() *Device_Status_Address {
	if o == nil {
		return nil
	}
	result := &Device_Status_Address{}
	result.Address = o.Address
	result.Type = o.Type
	return result
}

func (o *Device_Status_Address) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_Address) Merge(source *Device_Status_Address) {
	o.Address = source.GetAddress()
	o.Type = source.GetType()
}

func (o *Device_Status_Address) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_Address))
}

func (o *Device_Status_Condition) GotenObjectExt() {}

func (o *Device_Status_Condition) MakeFullFieldMask() *Device_Status_Condition_FieldMask {
	return FullDevice_Status_Condition_FieldMask()
}

func (o *Device_Status_Condition) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_Condition_FieldMask()
}

func (o *Device_Status_Condition) MakeDiffFieldMask(other *Device_Status_Condition) *Device_Status_Condition_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_Condition_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_Condition_FieldMask()
	}

	res := &Device_Status_Condition_FieldMask{}
	if o.GetMessage() != other.GetMessage() {
		res.Paths = append(res.Paths, &DeviceStatusCondition_FieldTerminalPath{selector: DeviceStatusCondition_FieldPathSelectorMessage})
	}
	if o.GetReason() != other.GetReason() {
		res.Paths = append(res.Paths, &DeviceStatusCondition_FieldTerminalPath{selector: DeviceStatusCondition_FieldPathSelectorReason})
	}
	if o.GetStatus() != other.GetStatus() {
		res.Paths = append(res.Paths, &DeviceStatusCondition_FieldTerminalPath{selector: DeviceStatusCondition_FieldPathSelectorStatus})
	}
	if o.GetType() != other.GetType() {
		res.Paths = append(res.Paths, &DeviceStatusCondition_FieldTerminalPath{selector: DeviceStatusCondition_FieldPathSelectorType})
	}
	if !proto.Equal(o.GetLastHeartBeatTime(), other.GetLastHeartBeatTime()) {
		res.Paths = append(res.Paths, &DeviceStatusCondition_FieldTerminalPath{selector: DeviceStatusCondition_FieldPathSelectorLastHeartBeatTime})
	}
	if !proto.Equal(o.GetLastTransitionTime(), other.GetLastTransitionTime()) {
		res.Paths = append(res.Paths, &DeviceStatusCondition_FieldTerminalPath{selector: DeviceStatusCondition_FieldPathSelectorLastTransitionTime})
	}
	return res
}

func (o *Device_Status_Condition) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_Condition))
}

func (o *Device_Status_Condition) Clone() *Device_Status_Condition {
	if o == nil {
		return nil
	}
	result := &Device_Status_Condition{}
	result.Message = o.Message
	result.Reason = o.Reason
	result.Status = o.Status
	result.Type = o.Type
	result.LastHeartBeatTime = proto.Clone(o.LastHeartBeatTime).(*timestamppb.Timestamp)
	result.LastTransitionTime = proto.Clone(o.LastTransitionTime).(*timestamppb.Timestamp)
	return result
}

func (o *Device_Status_Condition) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_Condition) Merge(source *Device_Status_Condition) {
	o.Message = source.GetMessage()
	o.Reason = source.GetReason()
	o.Status = source.GetStatus()
	o.Type = source.GetType()
	if source.GetLastHeartBeatTime() != nil {
		if o.LastHeartBeatTime == nil {
			o.LastHeartBeatTime = new(timestamppb.Timestamp)
		}
		proto.Merge(o.LastHeartBeatTime, source.GetLastHeartBeatTime())
	}
	if source.GetLastTransitionTime() != nil {
		if o.LastTransitionTime == nil {
			o.LastTransitionTime = new(timestamppb.Timestamp)
		}
		proto.Merge(o.LastTransitionTime, source.GetLastTransitionTime())
	}
}

func (o *Device_Status_Condition) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_Condition))
}

func (o *Device_Status_NetworkConfigState) GotenObjectExt() {}

func (o *Device_Status_NetworkConfigState) MakeFullFieldMask() *Device_Status_NetworkConfigState_FieldMask {
	return FullDevice_Status_NetworkConfigState_FieldMask()
}

func (o *Device_Status_NetworkConfigState) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_NetworkConfigState_FieldMask()
}

func (o *Device_Status_NetworkConfigState) MakeDiffFieldMask(other *Device_Status_NetworkConfigState) *Device_Status_NetworkConfigState_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_NetworkConfigState_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_NetworkConfigState_FieldMask()
	}

	res := &Device_Status_NetworkConfigState_FieldMask{}
	if o.GetActiveNetworkConfigSource() != other.GetActiveNetworkConfigSource() {
		res.Paths = append(res.Paths, &DeviceStatusNetworkConfigState_FieldTerminalPath{selector: DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetworkConfigSource})
	}
	if o.GetDesiredNetworkConfigSource() != other.GetDesiredNetworkConfigSource() {
		res.Paths = append(res.Paths, &DeviceStatusNetworkConfigState_FieldTerminalPath{selector: DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigSource})
	}
	if o.GetDesiredNetworkConfigError() != other.GetDesiredNetworkConfigError() {
		res.Paths = append(res.Paths, &DeviceStatusNetworkConfigState_FieldTerminalPath{selector: DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetworkConfigError})
	}
	if o.GetDefaultNetplanConfig() != other.GetDefaultNetplanConfig() {
		res.Paths = append(res.Paths, &DeviceStatusNetworkConfigState_FieldTerminalPath{selector: DeviceStatusNetworkConfigState_FieldPathSelectorDefaultNetplanConfig})
	}
	if o.GetActiveNetplanConfig() != other.GetActiveNetplanConfig() {
		res.Paths = append(res.Paths, &DeviceStatusNetworkConfigState_FieldTerminalPath{selector: DeviceStatusNetworkConfigState_FieldPathSelectorActiveNetplanConfig})
	}
	if o.GetDesiredNetplanConfig() != other.GetDesiredNetplanConfig() {
		res.Paths = append(res.Paths, &DeviceStatusNetworkConfigState_FieldTerminalPath{selector: DeviceStatusNetworkConfigState_FieldPathSelectorDesiredNetplanConfig})
	}
	return res
}

func (o *Device_Status_NetworkConfigState) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_NetworkConfigState))
}

func (o *Device_Status_NetworkConfigState) Clone() *Device_Status_NetworkConfigState {
	if o == nil {
		return nil
	}
	result := &Device_Status_NetworkConfigState{}
	result.ActiveNetworkConfigSource = o.ActiveNetworkConfigSource
	result.DesiredNetworkConfigSource = o.DesiredNetworkConfigSource
	result.DesiredNetworkConfigError = o.DesiredNetworkConfigError
	result.DefaultNetplanConfig = o.DefaultNetplanConfig
	result.ActiveNetplanConfig = o.ActiveNetplanConfig
	result.DesiredNetplanConfig = o.DesiredNetplanConfig
	return result
}

func (o *Device_Status_NetworkConfigState) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_NetworkConfigState) Merge(source *Device_Status_NetworkConfigState) {
	o.ActiveNetworkConfigSource = source.GetActiveNetworkConfigSource()
	o.DesiredNetworkConfigSource = source.GetDesiredNetworkConfigSource()
	o.DesiredNetworkConfigError = source.GetDesiredNetworkConfigError()
	o.DefaultNetplanConfig = source.GetDefaultNetplanConfig()
	o.ActiveNetplanConfig = source.GetActiveNetplanConfig()
	o.DesiredNetplanConfig = source.GetDesiredNetplanConfig()
}

func (o *Device_Status_NetworkConfigState) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_NetworkConfigState))
}

func (o *Device_Status_ProxyConfigStatus) GotenObjectExt() {}

func (o *Device_Status_ProxyConfigStatus) MakeFullFieldMask() *Device_Status_ProxyConfigStatus_FieldMask {
	return FullDevice_Status_ProxyConfigStatus_FieldMask()
}

func (o *Device_Status_ProxyConfigStatus) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_ProxyConfigStatus_FieldMask()
}

func (o *Device_Status_ProxyConfigStatus) MakeDiffFieldMask(other *Device_Status_ProxyConfigStatus) *Device_Status_ProxyConfigStatus_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_ProxyConfigStatus_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_ProxyConfigStatus_FieldMask()
	}

	res := &Device_Status_ProxyConfigStatus_FieldMask{}
	if o.GetActiveConfigSource() != other.GetActiveConfigSource() {
		res.Paths = append(res.Paths, &DeviceStatusProxyConfigStatus_FieldTerminalPath{selector: DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfigSource})
	}
	if o.GetDesiredConfigSource() != other.GetDesiredConfigSource() {
		res.Paths = append(res.Paths, &DeviceStatusProxyConfigStatus_FieldTerminalPath{selector: DeviceStatusProxyConfigStatus_FieldPathSelectorDesiredConfigSource})
	}
	if o.GetProxyConfigError() != other.GetProxyConfigError() {
		res.Paths = append(res.Paths, &DeviceStatusProxyConfigStatus_FieldTerminalPath{selector: DeviceStatusProxyConfigStatus_FieldPathSelectorProxyConfigError})
	}
	{
		subMask := o.GetDefaultConfig().MakeDiffFieldMask(other.GetDefaultConfig())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusProxyConfigStatus_FieldTerminalPath{selector: DeviceStatusProxyConfigStatus_FieldPathSelectorDefaultConfig})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusProxyConfigStatus_FieldSubPath{selector: DeviceStatusProxyConfigStatus_FieldPathSelectorDefaultConfig, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetActiveConfig().MakeDiffFieldMask(other.GetActiveConfig())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusProxyConfigStatus_FieldTerminalPath{selector: DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfig})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusProxyConfigStatus_FieldSubPath{selector: DeviceStatusProxyConfigStatus_FieldPathSelectorActiveConfig, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetApiConfig().MakeDiffFieldMask(other.GetApiConfig())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusProxyConfigStatus_FieldTerminalPath{selector: DeviceStatusProxyConfigStatus_FieldPathSelectorApiConfig})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusProxyConfigStatus_FieldSubPath{selector: DeviceStatusProxyConfigStatus_FieldPathSelectorApiConfig, subPath: subpath})
			}
		}
	}
	return res
}

func (o *Device_Status_ProxyConfigStatus) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_ProxyConfigStatus))
}

func (o *Device_Status_ProxyConfigStatus) Clone() *Device_Status_ProxyConfigStatus {
	if o == nil {
		return nil
	}
	result := &Device_Status_ProxyConfigStatus{}
	result.ActiveConfigSource = o.ActiveConfigSource
	result.DesiredConfigSource = o.DesiredConfigSource
	result.ProxyConfigError = o.ProxyConfigError
	result.DefaultConfig = o.DefaultConfig.Clone()
	result.ActiveConfig = o.ActiveConfig.Clone()
	result.ApiConfig = o.ApiConfig.Clone()
	return result
}

func (o *Device_Status_ProxyConfigStatus) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_ProxyConfigStatus) Merge(source *Device_Status_ProxyConfigStatus) {
	o.ActiveConfigSource = source.GetActiveConfigSource()
	o.DesiredConfigSource = source.GetDesiredConfigSource()
	o.ProxyConfigError = source.GetProxyConfigError()
	if source.GetDefaultConfig() != nil {
		if o.DefaultConfig == nil {
			o.DefaultConfig = new(Device_Spec_ProxyConfig)
		}
		o.DefaultConfig.Merge(source.GetDefaultConfig())
	}
	if source.GetActiveConfig() != nil {
		if o.ActiveConfig == nil {
			o.ActiveConfig = new(Device_Spec_ProxyConfig)
		}
		o.ActiveConfig.Merge(source.GetActiveConfig())
	}
	if source.GetApiConfig() != nil {
		if o.ApiConfig == nil {
			o.ApiConfig = new(Device_Spec_ProxyConfig)
		}
		o.ApiConfig.Merge(source.GetApiConfig())
	}
}

func (o *Device_Status_ProxyConfigStatus) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_ProxyConfigStatus))
}

func (o *Device_Status_DeviceInfo) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo) MakeFullFieldMask() *Device_Status_DeviceInfo_FieldMask {
	return FullDevice_Status_DeviceInfo_FieldMask()
}

func (o *Device_Status_DeviceInfo) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_FieldMask()
}

func (o *Device_Status_DeviceInfo) MakeDiffFieldMask(other *Device_Status_DeviceInfo) *Device_Status_DeviceInfo_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_FieldMask()
	}

	res := &Device_Status_DeviceInfo_FieldMask{}
	if o.GetArchitecture() != other.GetArchitecture() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorArchitecture})
	}
	if o.GetHardware() != other.GetHardware() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorHardware})
	}
	if o.GetOperatingSystem() != other.GetOperatingSystem() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorOperatingSystem})
	}
	if o.GetKernelVersion() != other.GetKernelVersion() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorKernelVersion})
	}
	if o.GetOsImage() != other.GetOsImage() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorOsImage})
	}
	if o.GetContainerRuntimeVersion() != other.GetContainerRuntimeVersion() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorContainerRuntimeVersion})
	}
	if o.GetOsVersion() != other.GetOsVersion() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorOsVersion})
	}
	if o.GetDriver() != other.GetDriver() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorDriver})
	}
	{
		subMask := o.GetHardwareInformation().MakeDiffFieldMask(other.GetHardwareInformation())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorHardwareInformation})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfo_FieldSubPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorHardwareInformation, subPath: subpath})
			}
		}
	}

	if len(o.GetNetworkInterfaces()) == len(other.GetNetworkInterfaces()) {
		for i, lValue := range o.GetNetworkInterfaces() {
			rValue := other.GetNetworkInterfaces()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorNetworkInterfaces})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorNetworkInterfaces})
	}
	{
		subMask := o.GetControlPlaneInterfaceInfo().MakeDiffFieldMask(other.GetControlPlaneInterfaceInfo())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorControlPlaneInterfaceInfo})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfo_FieldSubPath{selector: DeviceStatusDeviceInfo_FieldPathSelectorControlPlaneInterfaceInfo, subPath: subpath})
			}
		}
	}
	return res
}

func (o *Device_Status_DeviceInfo) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo))
}

func (o *Device_Status_DeviceInfo) Clone() *Device_Status_DeviceInfo {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo{}
	result.Architecture = o.Architecture
	result.Hardware = o.Hardware
	result.OperatingSystem = o.OperatingSystem
	result.KernelVersion = o.KernelVersion
	result.OsImage = o.OsImage
	result.ContainerRuntimeVersion = o.ContainerRuntimeVersion
	result.OsVersion = o.OsVersion
	result.Driver = o.Driver
	result.HardwareInformation = o.HardwareInformation.Clone()
	result.NetworkInterfaces = map[string]*Device_Status_DeviceInfo_NetworkInterface{}
	for key, sourceValue := range o.NetworkInterfaces {
		result.NetworkInterfaces[key] = sourceValue.Clone()
	}
	result.ControlPlaneInterfaceInfo = o.ControlPlaneInterfaceInfo.Clone()
	return result
}

func (o *Device_Status_DeviceInfo) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo) Merge(source *Device_Status_DeviceInfo) {
	o.Architecture = source.GetArchitecture()
	o.Hardware = source.GetHardware()
	o.OperatingSystem = source.GetOperatingSystem()
	o.KernelVersion = source.GetKernelVersion()
	o.OsImage = source.GetOsImage()
	o.ContainerRuntimeVersion = source.GetContainerRuntimeVersion()
	o.OsVersion = source.GetOsVersion()
	o.Driver = source.GetDriver()
	if source.GetHardwareInformation() != nil {
		if o.HardwareInformation == nil {
			o.HardwareInformation = new(Device_Status_DeviceInfo_HardwareInformation)
		}
		o.HardwareInformation.Merge(source.GetHardwareInformation())
	}
	if source.GetNetworkInterfaces() != nil {
		if o.NetworkInterfaces == nil {
			o.NetworkInterfaces = make(map[string]*Device_Status_DeviceInfo_NetworkInterface, len(source.GetNetworkInterfaces()))
		}
		for key, sourceValue := range source.GetNetworkInterfaces() {
			if sourceValue != nil {
				if o.NetworkInterfaces[key] == nil {
					o.NetworkInterfaces[key] = new(Device_Status_DeviceInfo_NetworkInterface)
				}
				o.NetworkInterfaces[key].Merge(sourceValue)
			}
		}
	}
	if source.GetControlPlaneInterfaceInfo() != nil {
		if o.ControlPlaneInterfaceInfo == nil {
			o.ControlPlaneInterfaceInfo = new(Device_Status_DeviceInfo_ControlPlaneInterfaceInfo)
		}
		o.ControlPlaneInterfaceInfo.Merge(source.GetControlPlaneInterfaceInfo())
	}
}

func (o *Device_Status_DeviceInfo) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo))
}

func (o *Device_Status_NormalizedAddress) GotenObjectExt() {}

func (o *Device_Status_NormalizedAddress) MakeFullFieldMask() *Device_Status_NormalizedAddress_FieldMask {
	return FullDevice_Status_NormalizedAddress_FieldMask()
}

func (o *Device_Status_NormalizedAddress) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_NormalizedAddress_FieldMask()
}

func (o *Device_Status_NormalizedAddress) MakeDiffFieldMask(other *Device_Status_NormalizedAddress) *Device_Status_NormalizedAddress_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_NormalizedAddress_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_NormalizedAddress_FieldMask()
	}

	res := &Device_Status_NormalizedAddress_FieldMask{}
	if o.GetPostalCode() != other.GetPostalCode() {
		res.Paths = append(res.Paths, &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorPostalCode})
	}
	if o.GetCountryCode() != other.GetCountryCode() {
		res.Paths = append(res.Paths, &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorCountryCode})
	}
	if o.GetContinent() != other.GetContinent() {
		res.Paths = append(res.Paths, &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorContinent})
	}
	if o.GetContinentId() != other.GetContinentId() {
		res.Paths = append(res.Paths, &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorContinentId})
	}
	if o.GetCountry() != other.GetCountry() {
		res.Paths = append(res.Paths, &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorCountry})
	}
	if o.GetCountryId() != other.GetCountryId() {
		res.Paths = append(res.Paths, &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorCountryId})
	}
	if o.GetAdminArea1() != other.GetAdminArea1() {
		res.Paths = append(res.Paths, &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1})
	}
	if o.GetAdminArea1Id() != other.GetAdminArea1Id() {
		res.Paths = append(res.Paths, &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea1Id})
	}
	if o.GetAdminArea2() != other.GetAdminArea2() {
		res.Paths = append(res.Paths, &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2})
	}
	if o.GetAdminArea2Id() != other.GetAdminArea2Id() {
		res.Paths = append(res.Paths, &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea2Id})
	}
	if o.GetAdminArea3() != other.GetAdminArea3() {
		res.Paths = append(res.Paths, &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3})
	}
	if o.GetAdminArea3Id() != other.GetAdminArea3Id() {
		res.Paths = append(res.Paths, &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea3Id})
	}
	if o.GetAdminArea4() != other.GetAdminArea4() {
		res.Paths = append(res.Paths, &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4})
	}
	if o.GetAdminArea4Id() != other.GetAdminArea4Id() {
		res.Paths = append(res.Paths, &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorAdminArea4Id})
	}
	if o.GetAddress() != other.GetAddress() {
		res.Paths = append(res.Paths, &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorAddress})
	}
	if !proto.Equal(o.GetCoordinates(), other.GetCoordinates()) {
		res.Paths = append(res.Paths, &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorCoordinates})
	}
	if o.GetAccuracy() != other.GetAccuracy() {
		res.Paths = append(res.Paths, &DeviceStatusNormalizedAddress_FieldTerminalPath{selector: DeviceStatusNormalizedAddress_FieldPathSelectorAccuracy})
	}
	return res
}

func (o *Device_Status_NormalizedAddress) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_NormalizedAddress))
}

func (o *Device_Status_NormalizedAddress) Clone() *Device_Status_NormalizedAddress {
	if o == nil {
		return nil
	}
	result := &Device_Status_NormalizedAddress{}
	result.PostalCode = o.PostalCode
	result.CountryCode = o.CountryCode
	result.Continent = o.Continent
	result.ContinentId = o.ContinentId
	result.Country = o.Country
	result.CountryId = o.CountryId
	result.AdminArea1 = o.AdminArea1
	result.AdminArea1Id = o.AdminArea1Id
	result.AdminArea2 = o.AdminArea2
	result.AdminArea2Id = o.AdminArea2Id
	result.AdminArea3 = o.AdminArea3
	result.AdminArea3Id = o.AdminArea3Id
	result.AdminArea4 = o.AdminArea4
	result.AdminArea4Id = o.AdminArea4Id
	result.Address = o.Address
	result.Coordinates = proto.Clone(o.Coordinates).(*latlng.LatLng)
	result.Accuracy = o.Accuracy
	return result
}

func (o *Device_Status_NormalizedAddress) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_NormalizedAddress) Merge(source *Device_Status_NormalizedAddress) {
	o.PostalCode = source.GetPostalCode()
	o.CountryCode = source.GetCountryCode()
	o.Continent = source.GetContinent()
	o.ContinentId = source.GetContinentId()
	o.Country = source.GetCountry()
	o.CountryId = source.GetCountryId()
	o.AdminArea1 = source.GetAdminArea1()
	o.AdminArea1Id = source.GetAdminArea1Id()
	o.AdminArea2 = source.GetAdminArea2()
	o.AdminArea2Id = source.GetAdminArea2Id()
	o.AdminArea3 = source.GetAdminArea3()
	o.AdminArea3Id = source.GetAdminArea3Id()
	o.AdminArea4 = source.GetAdminArea4()
	o.AdminArea4Id = source.GetAdminArea4Id()
	o.Address = source.GetAddress()
	if source.GetCoordinates() != nil {
		if o.Coordinates == nil {
			o.Coordinates = new(latlng.LatLng)
		}
		proto.Merge(o.Coordinates, source.GetCoordinates())
	}
	o.Accuracy = source.GetAccuracy()
}

func (o *Device_Status_NormalizedAddress) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_NormalizedAddress))
}

func (o *Device_Status_DeviceInfo_HardwareInformation) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation) *Device_Status_DeviceInfo_HardwareInformation_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_FieldMask{}
	{
		subMask := o.GetOs().MakeDiffFieldMask(other.GetOs())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorOs})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformation_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorOs, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetBios().MakeDiffFieldMask(other.GetBios())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBios})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformation_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBios, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetSystem().MakeDiffFieldMask(other.GetSystem())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorSystem})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformation_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorSystem, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetCpu().MakeDiffFieldMask(other.GetCpu())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorCpu})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformation_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorCpu, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetBlock().MakeDiffFieldMask(other.GetBlock())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBlock})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformation_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorBlock, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetNetwork().MakeDiffFieldMask(other.GetNetwork())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNetwork})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformation_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNetwork, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetGpu().MakeDiffFieldMask(other.GetGpu())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorGpu})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformation_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorGpu, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetMemoryInfo().MakeDiffFieldMask(other.GetMemoryInfo())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorMemoryInfo})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformation_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorMemoryInfo, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetHailoInfo().MakeDiffFieldMask(other.GetHailoInfo())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorHailoInfo})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformation_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorHailoInfo, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetNvidiaInfo().MakeDiffFieldMask(other.GetNvidiaInfo())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNvidiaInfo})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformation_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorNvidiaInfo, subPath: subpath})
			}
		}
	}

	if len(o.GetModemStatus()) == len(other.GetModemStatus()) {
		for i, lValue := range o.GetModemStatus() {
			rValue := other.GetModemStatus()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorModemStatus})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformation_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformation_FieldPathSelectorModemStatus})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation))
}

func (o *Device_Status_DeviceInfo_HardwareInformation) Clone() *Device_Status_DeviceInfo_HardwareInformation {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation{}
	result.Os = o.Os.Clone()
	result.Bios = o.Bios.Clone()
	result.System = o.System.Clone()
	result.Cpu = o.Cpu.Clone()
	result.Block = o.Block.Clone()
	result.Network = o.Network.Clone()
	result.Gpu = o.Gpu.Clone()
	result.MemoryInfo = o.MemoryInfo.Clone()
	result.HailoInfo = o.HailoInfo.Clone()
	result.NvidiaInfo = o.NvidiaInfo.Clone()
	result.ModemStatus = make([]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus, len(o.ModemStatus))
	for i, sourceValue := range o.ModemStatus {
		result.ModemStatus[i] = sourceValue.Clone()
	}
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation) Merge(source *Device_Status_DeviceInfo_HardwareInformation) {
	if source.GetOs() != nil {
		if o.Os == nil {
			o.Os = new(Device_Status_DeviceInfo_HardwareInformation_OS)
		}
		o.Os.Merge(source.GetOs())
	}
	if source.GetBios() != nil {
		if o.Bios == nil {
			o.Bios = new(Device_Status_DeviceInfo_HardwareInformation_BIOS)
		}
		o.Bios.Merge(source.GetBios())
	}
	if source.GetSystem() != nil {
		if o.System == nil {
			o.System = new(Device_Status_DeviceInfo_HardwareInformation_System)
		}
		o.System.Merge(source.GetSystem())
	}
	if source.GetCpu() != nil {
		if o.Cpu == nil {
			o.Cpu = new(Device_Status_DeviceInfo_HardwareInformation_CPU)
		}
		o.Cpu.Merge(source.GetCpu())
	}
	if source.GetBlock() != nil {
		if o.Block == nil {
			o.Block = new(Device_Status_DeviceInfo_HardwareInformation_Block)
		}
		o.Block.Merge(source.GetBlock())
	}
	if source.GetNetwork() != nil {
		if o.Network == nil {
			o.Network = new(Device_Status_DeviceInfo_HardwareInformation_Network)
		}
		o.Network.Merge(source.GetNetwork())
	}
	if source.GetGpu() != nil {
		if o.Gpu == nil {
			o.Gpu = new(Device_Status_DeviceInfo_HardwareInformation_GPU)
		}
		o.Gpu.Merge(source.GetGpu())
	}
	if source.GetMemoryInfo() != nil {
		if o.MemoryInfo == nil {
			o.MemoryInfo = new(Device_Status_DeviceInfo_HardwareInformation_MemoryInfo)
		}
		o.MemoryInfo.Merge(source.GetMemoryInfo())
	}
	if source.GetHailoInfo() != nil {
		if o.HailoInfo == nil {
			o.HailoInfo = new(Device_Status_DeviceInfo_HardwareInformation_HailoInfo)
		}
		o.HailoInfo.Merge(source.GetHailoInfo())
	}
	if source.GetNvidiaInfo() != nil {
		if o.NvidiaInfo == nil {
			o.NvidiaInfo = new(Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo)
		}
		o.NvidiaInfo.Merge(source.GetNvidiaInfo())
	}
	for _, sourceValue := range source.GetModemStatus() {
		exists := false
		for _, currentValue := range o.ModemStatus {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *Device_Status_DeviceInfo_HardwareInformation_ModemStatus
			if sourceValue != nil {
				newDstElement = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus)
				newDstElement.Merge(sourceValue)
			}
			o.ModemStatus = append(o.ModemStatus, newDstElement)
		}
	}

}

func (o *Device_Status_DeviceInfo_HardwareInformation) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation))
}

func (o *Device_Status_DeviceInfo_NetworkInterface) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_NetworkInterface) MakeFullFieldMask() *Device_Status_DeviceInfo_NetworkInterface_FieldMask {
	return FullDevice_Status_DeviceInfo_NetworkInterface_FieldMask()
}

func (o *Device_Status_DeviceInfo_NetworkInterface) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_NetworkInterface_FieldMask()
}

func (o *Device_Status_DeviceInfo_NetworkInterface) MakeDiffFieldMask(other *Device_Status_DeviceInfo_NetworkInterface) *Device_Status_DeviceInfo_NetworkInterface_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_NetworkInterface_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_NetworkInterface_FieldMask()
	}

	res := &Device_Status_DeviceInfo_NetworkInterface_FieldMask{}
	if o.GetInterfaceName() != other.GetInterfaceName() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorInterfaceName})
	}

	if len(o.GetIpAddressV4()) == len(other.GetIpAddressV4()) {
		for i, lValue := range o.GetIpAddressV4() {
			rValue := other.GetIpAddressV4()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV4})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV4})
	}

	if len(o.GetExternalIpAddressV4()) == len(other.GetExternalIpAddressV4()) {
		for i, lValue := range o.GetExternalIpAddressV4() {
			rValue := other.GetExternalIpAddressV4()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV4})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV4})
	}

	if len(o.GetIpAddressV6()) == len(other.GetIpAddressV6()) {
		for i, lValue := range o.GetIpAddressV6() {
			rValue := other.GetIpAddressV6()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV6})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorIpAddressV6})
	}

	if len(o.GetExternalIpAddressV6()) == len(other.GetExternalIpAddressV6()) {
		for i, lValue := range o.GetExternalIpAddressV6() {
			rValue := other.GetExternalIpAddressV6()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV6})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorExternalIpAddressV6})
	}
	{
		subMask := o.GetAsInfo().MakeDiffFieldMask(other.GetAsInfo())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorAsInfo})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoNetworkInterface_FieldSubPath{selector: DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorAsInfo, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetCarrier().MakeDiffFieldMask(other.GetCarrier())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfoNetworkInterface_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorCarrier})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoNetworkInterface_FieldSubPath{selector: DeviceStatusDeviceInfoNetworkInterface_FieldPathSelectorCarrier, subPath: subpath})
			}
		}
	}
	return res
}

func (o *Device_Status_DeviceInfo_NetworkInterface) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_NetworkInterface))
}

func (o *Device_Status_DeviceInfo_NetworkInterface) Clone() *Device_Status_DeviceInfo_NetworkInterface {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_NetworkInterface{}
	result.InterfaceName = o.InterfaceName
	result.IpAddressV4 = make([]string, len(o.IpAddressV4))
	for i, sourceValue := range o.IpAddressV4 {
		result.IpAddressV4[i] = sourceValue
	}
	result.ExternalIpAddressV4 = make([]string, len(o.ExternalIpAddressV4))
	for i, sourceValue := range o.ExternalIpAddressV4 {
		result.ExternalIpAddressV4[i] = sourceValue
	}
	result.IpAddressV6 = make([]string, len(o.IpAddressV6))
	for i, sourceValue := range o.IpAddressV6 {
		result.IpAddressV6[i] = sourceValue
	}
	result.ExternalIpAddressV6 = make([]string, len(o.ExternalIpAddressV6))
	for i, sourceValue := range o.ExternalIpAddressV6 {
		result.ExternalIpAddressV6[i] = sourceValue
	}
	result.AsInfo = o.AsInfo.Clone()
	result.Carrier = o.Carrier.Clone()
	return result
}

func (o *Device_Status_DeviceInfo_NetworkInterface) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_NetworkInterface) Merge(source *Device_Status_DeviceInfo_NetworkInterface) {
	o.InterfaceName = source.GetInterfaceName()
	for _, sourceValue := range source.GetIpAddressV4() {
		exists := false
		for _, currentValue := range o.IpAddressV4 {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.IpAddressV4 = append(o.IpAddressV4, newDstElement)
		}
	}

	for _, sourceValue := range source.GetExternalIpAddressV4() {
		exists := false
		for _, currentValue := range o.ExternalIpAddressV4 {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.ExternalIpAddressV4 = append(o.ExternalIpAddressV4, newDstElement)
		}
	}

	for _, sourceValue := range source.GetIpAddressV6() {
		exists := false
		for _, currentValue := range o.IpAddressV6 {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.IpAddressV6 = append(o.IpAddressV6, newDstElement)
		}
	}

	for _, sourceValue := range source.GetExternalIpAddressV6() {
		exists := false
		for _, currentValue := range o.ExternalIpAddressV6 {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.ExternalIpAddressV6 = append(o.ExternalIpAddressV6, newDstElement)
		}
	}

	if source.GetAsInfo() != nil {
		if o.AsInfo == nil {
			o.AsInfo = new(Device_Status_DeviceInfo_NetworkInterface_ASInfo)
		}
		o.AsInfo.Merge(source.GetAsInfo())
	}
	if source.GetCarrier() != nil {
		if o.Carrier == nil {
			o.Carrier = new(Device_Status_DeviceInfo_NetworkInterface_Carrier)
		}
		o.Carrier.Merge(source.GetCarrier())
	}
}

func (o *Device_Status_DeviceInfo_NetworkInterface) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_NetworkInterface))
}

func (o *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) MakeFullFieldMask() *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo_FieldMask {
	return FullDevice_Status_DeviceInfo_ControlPlaneInterfaceInfo_FieldMask()
}

func (o *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_ControlPlaneInterfaceInfo_FieldMask()
}

func (o *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) MakeDiffFieldMask(other *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_ControlPlaneInterfaceInfo_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_ControlPlaneInterfaceInfo_FieldMask()
	}

	res := &Device_Status_DeviceInfo_ControlPlaneInterfaceInfo_FieldMask{}
	if o.GetActiveControlPlaneInterface() != other.GetActiveControlPlaneInterface() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorActiveControlPlaneInterface})
	}
	if o.GetUsesProxy() != other.GetUsesProxy() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorUsesProxy})
	}
	if o.GetIsFallback() != other.GetIsFallback() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoControlPlaneInterfaceInfo_FieldPathSelectorIsFallback})
	}
	return res
}

func (o *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_ControlPlaneInterfaceInfo))
}

func (o *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) Clone() *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_ControlPlaneInterfaceInfo{}
	result.ActiveControlPlaneInterface = o.ActiveControlPlaneInterface
	result.UsesProxy = o.UsesProxy
	result.IsFallback = o.IsFallback
	return result
}

func (o *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) Merge(source *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) {
	o.ActiveControlPlaneInterface = source.GetActiveControlPlaneInterface()
	o.UsesProxy = source.GetUsesProxy()
	o.IsFallback = source.GetIsFallback()
}

func (o *Device_Status_DeviceInfo_ControlPlaneInterfaceInfo) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_ControlPlaneInterfaceInfo))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Capability) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_Capability) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_Capability_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_Capability_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Capability) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_Capability_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Capability) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_Capability) *Device_Status_DeviceInfo_HardwareInformation_Capability_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_Capability_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_Capability_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_Capability_FieldMask{}
	if o.GetName() != other.GetName() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelectorName})
	}
	if o.GetDescription() != other.GetDescription() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationCapability_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCapability_FieldPathSelectorDescription})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Capability) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_Capability))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Capability) Clone() *Device_Status_DeviceInfo_HardwareInformation_Capability {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_Capability{}
	result.Name = o.Name
	result.Description = o.Description
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Capability) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Capability) Merge(source *Device_Status_DeviceInfo_HardwareInformation_Capability) {
	o.Name = source.GetName()
	o.Description = source.GetDescription()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Capability) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_Capability))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_OS) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_OS) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_OS_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_OS_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_OS) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_OS_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_OS) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_OS) *Device_Status_DeviceInfo_HardwareInformation_OS_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_OS_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_OS_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_OS_FieldMask{}
	if o.GetOperatingSystem() != other.GetOperatingSystem() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOperatingSystem})
	}
	if o.GetKernelVersion() != other.GetKernelVersion() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorKernelVersion})
	}
	if o.GetOsImage() != other.GetOsImage() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorOsImage})
	}
	if o.GetContainerRuntimeVersion() != other.GetContainerRuntimeVersion() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationOS_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationOS_FieldPathSelectorContainerRuntimeVersion})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_OS) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_OS))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_OS) Clone() *Device_Status_DeviceInfo_HardwareInformation_OS {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_OS{}
	result.OperatingSystem = o.OperatingSystem
	result.KernelVersion = o.KernelVersion
	result.OsImage = o.OsImage
	result.ContainerRuntimeVersion = o.ContainerRuntimeVersion
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_OS) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_OS) Merge(source *Device_Status_DeviceInfo_HardwareInformation_OS) {
	o.OperatingSystem = source.GetOperatingSystem()
	o.KernelVersion = source.GetKernelVersion()
	o.OsImage = source.GetOsImage()
	o.ContainerRuntimeVersion = source.GetContainerRuntimeVersion()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_OS) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_OS))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_BIOS) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_BIOS) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_BIOS_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_BIOS_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_BIOS) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_BIOS_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_BIOS) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_BIOS) *Device_Status_DeviceInfo_HardwareInformation_BIOS_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_BIOS_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_BIOS_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_BIOS_FieldMask{}
	if o.GetVendor() != other.GetVendor() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorVendor})
	}
	if o.GetBiosVersion() != other.GetBiosVersion() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorBiosVersion})
	}
	if o.GetReleaseDate() != other.GetReleaseDate() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationBIOS_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBIOS_FieldPathSelectorReleaseDate})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_BIOS) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_BIOS))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_BIOS) Clone() *Device_Status_DeviceInfo_HardwareInformation_BIOS {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_BIOS{}
	result.Vendor = o.Vendor
	result.BiosVersion = o.BiosVersion
	result.ReleaseDate = o.ReleaseDate
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_BIOS) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_BIOS) Merge(source *Device_Status_DeviceInfo_HardwareInformation_BIOS) {
	o.Vendor = source.GetVendor()
	o.BiosVersion = source.GetBiosVersion()
	o.ReleaseDate = source.GetReleaseDate()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_BIOS) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_BIOS))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_System) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_System) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_System_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_System_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_System) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_System_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_System) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_System) *Device_Status_DeviceInfo_HardwareInformation_System_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_System_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_System_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_System_FieldMask{}
	if o.GetManufacturer() != other.GetManufacturer() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorManufacturer})
	}
	if o.GetProductName() != other.GetProductName() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorProductName})
	}
	if o.GetVersion() != other.GetVersion() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorVersion})
	}
	if o.GetSerialNumber() != other.GetSerialNumber() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorSerialNumber})
	}
	{
		subMask := o.GetConfiguration().MakeDiffFieldMask(other.GetConfiguration())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationSystem_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorConfiguration})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationSystem_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationSystem_FieldPathSelectorConfiguration, subPath: subpath})
			}
		}
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_System) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_System))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_System) Clone() *Device_Status_DeviceInfo_HardwareInformation_System {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_System{}
	result.Manufacturer = o.Manufacturer
	result.ProductName = o.ProductName
	result.Version = o.Version
	result.SerialNumber = o.SerialNumber
	result.Configuration = o.Configuration.Clone()
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_System) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_System) Merge(source *Device_Status_DeviceInfo_HardwareInformation_System) {
	o.Manufacturer = source.GetManufacturer()
	o.ProductName = source.GetProductName()
	o.Version = source.GetVersion()
	o.SerialNumber = source.GetSerialNumber()
	if source.GetConfiguration() != nil {
		if o.Configuration == nil {
			o.Configuration = new(Device_Status_DeviceInfo_HardwareInformation_System_Configuration)
		}
		o.Configuration.Merge(source.GetConfiguration())
	}
}

func (o *Device_Status_DeviceInfo_HardwareInformation_System) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_System))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_CPU_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_CPU_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_CPU_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_CPU) *Device_Status_DeviceInfo_HardwareInformation_CPU_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_CPU_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_CPU_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_CPU_FieldMask{}

	if len(o.GetProcessors()) == len(other.GetProcessors()) {
		for i, lValue := range o.GetProcessors() {
			rValue := other.GetProcessors()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathSelectorProcessors})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationCPU_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPU_FieldPathSelectorProcessors})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_CPU))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU) Clone() *Device_Status_DeviceInfo_HardwareInformation_CPU {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_CPU{}
	result.Processors = make([]*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor, len(o.Processors))
	for i, sourceValue := range o.Processors {
		result.Processors[i] = sourceValue.Clone()
	}
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU) Merge(source *Device_Status_DeviceInfo_HardwareInformation_CPU) {
	for _, sourceValue := range source.GetProcessors() {
		exists := false
		for _, currentValue := range o.Processors {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor
			if sourceValue != nil {
				newDstElement = new(Device_Status_DeviceInfo_HardwareInformation_CPU_Processor)
				newDstElement.Merge(sourceValue)
			}
			o.Processors = append(o.Processors, newDstElement)
		}
	}

}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_CPU))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_Block_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_Block_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_Block_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_Block) *Device_Status_DeviceInfo_HardwareInformation_Block_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_Block_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_Block_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_Block_FieldMask{}

	if len(o.GetDisks()) == len(other.GetDisks()) {
		for i, lValue := range o.GetDisks() {
			rValue := other.GetDisks()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelectorDisks})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationBlock_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlock_FieldPathSelectorDisks})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_Block))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block) Clone() *Device_Status_DeviceInfo_HardwareInformation_Block {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_Block{}
	result.Disks = make([]*Device_Status_DeviceInfo_HardwareInformation_Block_Disk, len(o.Disks))
	for i, sourceValue := range o.Disks {
		result.Disks[i] = sourceValue.Clone()
	}
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block) Merge(source *Device_Status_DeviceInfo_HardwareInformation_Block) {
	for _, sourceValue := range source.GetDisks() {
		exists := false
		for _, currentValue := range o.Disks {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *Device_Status_DeviceInfo_HardwareInformation_Block_Disk
			if sourceValue != nil {
				newDstElement = new(Device_Status_DeviceInfo_HardwareInformation_Block_Disk)
				newDstElement.Merge(sourceValue)
			}
			o.Disks = append(o.Disks, newDstElement)
		}
	}

}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_Block))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Network) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_Network) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_Network_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_Network_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Network) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_Network_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Network) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_Network) *Device_Status_DeviceInfo_HardwareInformation_Network_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_Network_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_Network_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_Network_FieldMask{}

	if len(o.GetNics()) == len(other.GetNics()) {
		for i, lValue := range o.GetNics() {
			rValue := other.GetNics()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelectorNics})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationNetwork_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNetwork_FieldPathSelectorNics})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Network) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_Network))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Network) Clone() *Device_Status_DeviceInfo_HardwareInformation_Network {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_Network{}
	result.Nics = make([]*Device_Status_DeviceInfo_HardwareInformation_Network_NIC, len(o.Nics))
	for i, sourceValue := range o.Nics {
		result.Nics[i] = sourceValue.Clone()
	}
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Network) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Network) Merge(source *Device_Status_DeviceInfo_HardwareInformation_Network) {
	for _, sourceValue := range source.GetNics() {
		exists := false
		for _, currentValue := range o.Nics {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *Device_Status_DeviceInfo_HardwareInformation_Network_NIC
			if sourceValue != nil {
				newDstElement = new(Device_Status_DeviceInfo_HardwareInformation_Network_NIC)
				newDstElement.Merge(sourceValue)
			}
			o.Nics = append(o.Nics, newDstElement)
		}
	}

}

func (o *Device_Status_DeviceInfo_HardwareInformation_Network) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_Network))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_GPU) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_GPU) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_GPU_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_GPU_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_GPU) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_GPU_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_GPU) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_GPU) *Device_Status_DeviceInfo_HardwareInformation_GPU_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_GPU_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_GPU_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_GPU_FieldMask{}

	if len(o.GetGraphicCards()) == len(other.GetGraphicCards()) {
		for i, lValue := range o.GetGraphicCards() {
			rValue := other.GetGraphicCards()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelectorGraphicCards})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationGPU_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationGPU_FieldPathSelectorGraphicCards})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_GPU) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_GPU))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_GPU) Clone() *Device_Status_DeviceInfo_HardwareInformation_GPU {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_GPU{}
	result.GraphicCards = make([]*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard, len(o.GraphicCards))
	for i, sourceValue := range o.GraphicCards {
		result.GraphicCards[i] = sourceValue.Clone()
	}
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_GPU) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_GPU) Merge(source *Device_Status_DeviceInfo_HardwareInformation_GPU) {
	for _, sourceValue := range source.GetGraphicCards() {
		exists := false
		for _, currentValue := range o.GraphicCards {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard
			if sourceValue != nil {
				newDstElement = new(Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard)
				newDstElement.Merge(sourceValue)
			}
			o.GraphicCards = append(o.GraphicCards, newDstElement)
		}
	}

}

func (o *Device_Status_DeviceInfo_HardwareInformation_GPU) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_GPU))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_PCIDevice_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_PCIDevice_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_PCIDevice_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) *Device_Status_DeviceInfo_HardwareInformation_PCIDevice_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_PCIDevice_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_PCIDevice_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_PCIDevice_FieldMask{}
	if o.GetAddress() != other.GetAddress() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorAddress})
	}
	if o.GetVendor() != other.GetVendor() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorVendor})
	}
	if o.GetProduct() != other.GetProduct() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorProduct})
	}
	if o.GetName() != other.GetName() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorName})
	}
	if o.GetSubvendor() != other.GetSubvendor() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationPCIDevice_FieldPathSelectorSubvendor})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_PCIDevice))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) Clone() *Device_Status_DeviceInfo_HardwareInformation_PCIDevice {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_PCIDevice{}
	result.Address = o.Address
	result.Vendor = o.Vendor
	result.Product = o.Product
	result.Name = o.Name
	result.Subvendor = o.Subvendor
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) Merge(source *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) {
	o.Address = source.GetAddress()
	o.Vendor = source.GetVendor()
	o.Product = source.GetProduct()
	o.Name = source.GetName()
	o.Subvendor = source.GetSubvendor()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_PCIDevice) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_PCIDevice))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_MemoryInfo_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_MemoryInfo_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_MemoryInfo_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_FieldMask{}
	if o.GetDescription() != other.GetDescription() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorDescription})
	}
	if o.GetSizeBytes() != other.GetSizeBytes() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorSizeBytes})
	}

	if len(o.GetMemoryBanks()) == len(other.GetMemoryBanks()) {
		for i, lValue := range o.GetMemoryBanks() {
			rValue := other.GetMemoryBanks()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorMemoryBanks})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationMemoryInfo_FieldPathSelectorMemoryBanks})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) Clone() *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_MemoryInfo{}
	result.Description = o.Description
	result.SizeBytes = o.SizeBytes
	result.MemoryBanks = make([]*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank, len(o.MemoryBanks))
	for i, sourceValue := range o.MemoryBanks {
		result.MemoryBanks[i] = sourceValue.Clone()
	}
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) Merge(source *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) {
	o.Description = source.GetDescription()
	o.SizeBytes = source.GetSizeBytes()
	for _, sourceValue := range source.GetMemoryBanks() {
		exists := false
		for _, currentValue := range o.MemoryBanks {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank
			if sourceValue != nil {
				newDstElement = new(Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank)
				newDstElement.Merge(sourceValue)
			}
			o.MemoryBanks = append(o.MemoryBanks, newDstElement)
		}
	}

}

func (o *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_HailoInfo_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_HailoInfo_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_HailoInfo_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_HailoInfo_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_HailoInfo_FieldMask{}
	if o.GetStatus() != other.GetStatus() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorStatus})
	}
	if o.GetCliVersion() != other.GetCliVersion() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorCliVersion})
	}

	if len(o.GetModules()) == len(other.GetModules()) {
		for i, lValue := range o.GetModules() {
			rValue := other.GetModules()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorModules})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfo_FieldPathSelectorModules})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) Clone() *Device_Status_DeviceInfo_HardwareInformation_HailoInfo {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_HailoInfo{}
	result.Status = o.Status
	result.CliVersion = o.CliVersion
	result.Modules = make([]*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo, len(o.Modules))
	for i, sourceValue := range o.Modules {
		result.Modules[i] = sourceValue.Clone()
	}
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) Merge(source *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) {
	o.Status = source.GetStatus()
	o.CliVersion = source.GetCliVersion()
	for _, sourceValue := range source.GetModules() {
		exists := false
		for _, currentValue := range o.Modules {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo
			if sourceValue != nil {
				newDstElement = new(Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo)
				newDstElement.Merge(sourceValue)
			}
			o.Modules = append(o.Modules, newDstElement)
		}
	}

}

func (o *Device_Status_DeviceInfo_HardwareInformation_HailoInfo) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_NvidiaInfo_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_NvidiaInfo_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_NvidiaInfo_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_FieldMask{}
	if o.GetStatus() != other.GetStatus() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorStatus})
	}
	if o.GetDriverVersion() != other.GetDriverVersion() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorDriverVersion})
	}
	if o.GetCudaVersion() != other.GetCudaVersion() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorCudaVersion})
	}

	if len(o.GetGpus()) == len(other.GetGpus()) {
		for i, lValue := range o.GetGpus() {
			rValue := other.GetGpus()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorGpus})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNvidiaInfo_FieldPathSelectorGpus})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) Clone() *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo{}
	result.Status = o.Status
	result.DriverVersion = o.DriverVersion
	result.CudaVersion = o.CudaVersion
	result.Gpus = make([]*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo, len(o.Gpus))
	for i, sourceValue := range o.Gpus {
		result.Gpus[i] = sourceValue.Clone()
	}
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) Merge(source *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) {
	o.Status = source.GetStatus()
	o.DriverVersion = source.GetDriverVersion()
	o.CudaVersion = source.GetCudaVersion()
	for _, sourceValue := range source.GetGpus() {
		exists := false
		for _, currentValue := range o.Gpus {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo
			if sourceValue != nil {
				newDstElement = new(Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo)
				newDstElement.Merge(sourceValue)
			}
			o.Gpus = append(o.Gpus, newDstElement)
		}
	}

}

func (o *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_ModemStatus) *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FieldMask{}
	{
		subMask := o.GetModem().MakeDiffFieldMask(other.GetModem())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelectorModem})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatus_FieldPathSelectorModem, subPath: subpath})
			}
		}
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus) Clone() *Device_Status_DeviceInfo_HardwareInformation_ModemStatus {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_ModemStatus{}
	result.Modem = o.Modem.Clone()
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus) Merge(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus) {
	if source.GetModem() != nil {
		if o.Modem == nil {
			o.Modem = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem)
		}
		o.Modem.Merge(source.GetModem())
	}
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_System_Configuration_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_System_Configuration_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_System_Configuration_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) *Device_Status_DeviceInfo_HardwareInformation_System_Configuration_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_System_Configuration_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_System_Configuration_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_System_Configuration_FieldMask{}
	if o.GetChassis() != other.GetChassis() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorChassis})
	}
	if o.GetUuid() != other.GetUuid() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorUuid})
	}
	if o.GetSkuNumber() != other.GetSkuNumber() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorSkuNumber})
	}
	if o.GetFamily() != other.GetFamily() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationSystemConfiguration_FieldPathSelectorFamily})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_System_Configuration))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) Clone() *Device_Status_DeviceInfo_HardwareInformation_System_Configuration {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_System_Configuration{}
	result.Chassis = o.Chassis
	result.Uuid = o.Uuid
	result.SkuNumber = o.SkuNumber
	result.Family = o.Family
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) Merge(source *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) {
	o.Chassis = source.GetChassis()
	o.Uuid = source.GetUuid()
	o.SkuNumber = source.GetSkuNumber()
	o.Family = source.GetFamily()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_System_Configuration) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_System_Configuration))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_CPU_Processor_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_CPU_Processor_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_CPU_Processor_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_FieldMask{}
	if o.GetVendor() != other.GetVendor() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorVendor})
	}
	if o.GetModel() != other.GetModel() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorModel})
	}

	if len(o.GetCapabilities()) == len(other.GetCapabilities()) {
		for i, lValue := range o.GetCapabilities() {
			rValue := other.GetCapabilities()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCapabilities})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCapabilities})
	}
	if o.GetNumThreads() != other.GetNumThreads() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumThreads})
	}
	if o.GetNumCores() != other.GetNumCores() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumCores})
	}
	if o.GetNumEnabledCores() != other.GetNumEnabledCores() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorNumEnabledCores})
	}
	if o.GetName() != other.GetName() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorName})
	}
	if o.GetSerial() != other.GetSerial() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorSerial})
	}
	if o.GetFrequencyMhz() != other.GetFrequencyMhz() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorFrequencyMhz})
	}
	if o.GetMaxFrequencyMhz() != other.GetMaxFrequencyMhz() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorMaxFrequencyMhz})
	}

	if len(o.GetCacheInfo()) == len(other.GetCacheInfo()) {
		for i, lValue := range o.GetCacheInfo() {
			rValue := other.GetCacheInfo()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCacheInfo})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorCacheInfo})
	}
	if o.GetDriver() != other.GetDriver() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorDriver})
	}
	if o.GetLatency() != other.GetLatency() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorLatency})
	}
	if o.GetClock() != other.GetClock() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessor_FieldPathSelectorClock})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) Clone() *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_CPU_Processor{}
	result.Vendor = o.Vendor
	result.Model = o.Model
	result.Capabilities = make([]*Device_Status_DeviceInfo_HardwareInformation_Capability, len(o.Capabilities))
	for i, sourceValue := range o.Capabilities {
		result.Capabilities[i] = sourceValue.Clone()
	}
	result.NumThreads = o.NumThreads
	result.NumCores = o.NumCores
	result.NumEnabledCores = o.NumEnabledCores
	result.Name = o.Name
	result.Serial = o.Serial
	result.FrequencyMhz = o.FrequencyMhz
	result.MaxFrequencyMhz = o.MaxFrequencyMhz
	result.CacheInfo = make([]*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache, len(o.CacheInfo))
	for i, sourceValue := range o.CacheInfo {
		result.CacheInfo[i] = sourceValue.Clone()
	}
	result.Driver = o.Driver
	result.Latency = o.Latency
	result.Clock = o.Clock
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) Merge(source *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) {
	o.Vendor = source.GetVendor()
	o.Model = source.GetModel()
	for _, sourceValue := range source.GetCapabilities() {
		exists := false
		for _, currentValue := range o.Capabilities {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *Device_Status_DeviceInfo_HardwareInformation_Capability
			if sourceValue != nil {
				newDstElement = new(Device_Status_DeviceInfo_HardwareInformation_Capability)
				newDstElement.Merge(sourceValue)
			}
			o.Capabilities = append(o.Capabilities, newDstElement)
		}
	}

	o.NumThreads = source.GetNumThreads()
	o.NumCores = source.GetNumCores()
	o.NumEnabledCores = source.GetNumEnabledCores()
	o.Name = source.GetName()
	o.Serial = source.GetSerial()
	o.FrequencyMhz = source.GetFrequencyMhz()
	o.MaxFrequencyMhz = source.GetMaxFrequencyMhz()
	for _, sourceValue := range source.GetCacheInfo() {
		exists := false
		for _, currentValue := range o.CacheInfo {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache
			if sourceValue != nil {
				newDstElement = new(Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache)
				newDstElement.Merge(sourceValue)
			}
			o.CacheInfo = append(o.CacheInfo, newDstElement)
		}
	}

	o.Driver = source.GetDriver()
	o.Latency = source.GetLatency()
	o.Clock = source.GetClock()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache_FieldMask{}
	if o.GetType() != other.GetType() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorType})
	}
	if o.GetSizeBytes() != other.GetSizeBytes() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationCPUProcessorCache_FieldPathSelectorSizeBytes})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) Clone() *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache{}
	result.Type = o.Type
	result.SizeBytes = o.SizeBytes
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) Merge(source *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) {
	o.Type = source.GetType()
	o.SizeBytes = source.GetSizeBytes()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_CPU_Processor_Cache))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block_Disk) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block_Disk) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_Block_Disk_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block_Disk) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_Block_Disk_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block_Disk) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_Block_Disk) *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_Block_Disk_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_Block_Disk_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_Block_Disk_FieldMask{}
	if o.GetName() != other.GetName() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorName})
	}
	if o.GetSizeBytes() != other.GetSizeBytes() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSizeBytes})
	}
	if o.GetDriveType() != other.GetDriveType() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorDriveType})
	}
	if o.GetVendor() != other.GetVendor() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorVendor})
	}
	if o.GetModel() != other.GetModel() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorModel})
	}
	if o.GetSerialNumber() != other.GetSerialNumber() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorSerialNumber})
	}
	if o.GetWwn() != other.GetWwn() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorWwn})
	}

	if len(o.GetPartitions()) == len(other.GetPartitions()) {
		for i, lValue := range o.GetPartitions() {
			rValue := other.GetPartitions()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorPartitions})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDisk_FieldPathSelectorPartitions})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block_Disk) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block_Disk) Clone() *Device_Status_DeviceInfo_HardwareInformation_Block_Disk {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_Block_Disk{}
	result.Name = o.Name
	result.SizeBytes = o.SizeBytes
	result.DriveType = o.DriveType
	result.Vendor = o.Vendor
	result.Model = o.Model
	result.SerialNumber = o.SerialNumber
	result.Wwn = o.Wwn
	result.Partitions = make([]*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition, len(o.Partitions))
	for i, sourceValue := range o.Partitions {
		result.Partitions[i] = sourceValue.Clone()
	}
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block_Disk) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block_Disk) Merge(source *Device_Status_DeviceInfo_HardwareInformation_Block_Disk) {
	o.Name = source.GetName()
	o.SizeBytes = source.GetSizeBytes()
	o.DriveType = source.GetDriveType()
	o.Vendor = source.GetVendor()
	o.Model = source.GetModel()
	o.SerialNumber = source.GetSerialNumber()
	o.Wwn = source.GetWwn()
	for _, sourceValue := range source.GetPartitions() {
		exists := false
		for _, currentValue := range o.Partitions {
			if proto.Equal(sourceValue, currentValue) {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition
			if sourceValue != nil {
				newDstElement = new(Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition)
				newDstElement.Merge(sourceValue)
			}
			o.Partitions = append(o.Partitions, newDstElement)
		}
	}

}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block_Disk) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition_FieldMask{}
	if o.GetName() != other.GetName() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorName})
	}
	if o.GetSizeBytes() != other.GetSizeBytes() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorSizeBytes})
	}
	if o.GetMountPoint() != other.GetMountPoint() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorMountPoint})
	}
	if o.GetType() != other.GetType() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationBlockDiskPartition_FieldPathSelectorType})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) Clone() *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition{}
	result.Name = o.Name
	result.SizeBytes = o.SizeBytes
	result.MountPoint = o.MountPoint
	result.Type = o.Type
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) Merge(source *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) {
	o.Name = source.GetName()
	o.SizeBytes = source.GetSizeBytes()
	o.MountPoint = source.GetMountPoint()
	o.Type = source.GetType()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_Block_Disk_Partition))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Network_NIC) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_Network_NIC) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_Network_NIC_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_Network_NIC_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Network_NIC) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_Network_NIC_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Network_NIC) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_Network_NIC) *Device_Status_DeviceInfo_HardwareInformation_Network_NIC_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_Network_NIC_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_Network_NIC_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_Network_NIC_FieldMask{}
	if o.GetName() != other.GetName() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorName})
	}
	if o.GetMacAddress() != other.GetMacAddress() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorMacAddress})
	}
	if o.GetVirtual() != other.GetVirtual() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVirtual})
	}
	if o.GetDescription() != other.GetDescription() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorDescription})
	}
	if o.GetProductName() != other.GetProductName() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorProductName})
	}
	if o.GetVendor() != other.GetVendor() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorVendor})
	}
	if o.GetSubvendor() != other.GetSubvendor() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSubvendor})
	}

	if len(o.GetSetting()) == len(other.GetSetting()) {
		for i, lValue := range o.GetSetting() {
			rValue := other.GetSetting()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNetworkNIC_FieldPathSelectorSetting})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Network_NIC) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_Network_NIC))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Network_NIC) Clone() *Device_Status_DeviceInfo_HardwareInformation_Network_NIC {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_Network_NIC{}
	result.Name = o.Name
	result.MacAddress = o.MacAddress
	result.Virtual = o.Virtual
	result.Description = o.Description
	result.ProductName = o.ProductName
	result.Vendor = o.Vendor
	result.Subvendor = o.Subvendor
	result.Setting = map[string]string{}
	for key, sourceValue := range o.Setting {
		result.Setting[key] = sourceValue
	}
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Network_NIC) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Network_NIC) Merge(source *Device_Status_DeviceInfo_HardwareInformation_Network_NIC) {
	o.Name = source.GetName()
	o.MacAddress = source.GetMacAddress()
	o.Virtual = source.GetVirtual()
	o.Description = source.GetDescription()
	o.ProductName = source.GetProductName()
	o.Vendor = source.GetVendor()
	o.Subvendor = source.GetSubvendor()
	if source.GetSetting() != nil {
		if o.Setting == nil {
			o.Setting = make(map[string]string, len(source.GetSetting()))
		}
		for key, sourceValue := range source.GetSetting() {
			o.Setting[key] = sourceValue
		}
	}
}

func (o *Device_Status_DeviceInfo_HardwareInformation_Network_NIC) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_Network_NIC))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard_FieldMask{}
	if o.GetIndex() != other.GetIndex() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorIndex})
	}
	{
		subMask := o.GetDevice().MakeDiffFieldMask(other.GetDevice())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorDevice})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationGPUGraphicCard_FieldPathSelectorDevice, subPath: subpath})
			}
		}
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) Clone() *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard{}
	result.Index = o.Index
	result.Device = o.Device.Clone()
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) Merge(source *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) {
	o.Index = source.GetIndex()
	if source.GetDevice() != nil {
		if o.Device == nil {
			o.Device = new(Device_Status_DeviceInfo_HardwareInformation_PCIDevice)
		}
		o.Device.Merge(source.GetDevice())
	}
}

func (o *Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_GPU_GraphicCard))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank_FieldMask{}
	if o.GetDescription() != other.GetDescription() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorDescription})
	}
	if o.GetProduct() != other.GetProduct() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorProduct})
	}
	if o.GetVendor() != other.GetVendor() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorVendor})
	}
	if o.GetSerial() != other.GetSerial() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSerial})
	}
	if o.GetSlot() != other.GetSlot() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSlot})
	}
	if o.GetSizeBytes() != other.GetSizeBytes() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorSizeBytes})
	}
	if o.GetFrequencyHz() != other.GetFrequencyHz() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorFrequencyHz})
	}
	if o.GetWidthBits() != other.GetWidthBits() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationMemoryInfoMemoryBank_FieldPathSelectorWidthBits})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) Clone() *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank{}
	result.Description = o.Description
	result.Product = o.Product
	result.Vendor = o.Vendor
	result.Serial = o.Serial
	result.Slot = o.Slot
	result.SizeBytes = o.SizeBytes
	result.FrequencyHz = o.FrequencyHz
	result.WidthBits = o.WidthBits
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) Merge(source *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) {
	o.Description = source.GetDescription()
	o.Product = source.GetProduct()
	o.Vendor = source.GetVendor()
	o.Serial = source.GetSerial()
	o.Slot = source.GetSlot()
	o.SizeBytes = source.GetSizeBytes()
	o.FrequencyHz = source.GetFrequencyHz()
	o.WidthBits = source.GetWidthBits()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_MemoryInfo_MemoryBank))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo_FieldMask{}
	if o.GetDevId() != other.GetDevId() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorDevId})
	}
	if o.GetControlProtoVersion() != other.GetControlProtoVersion() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorControlProtoVersion})
	}
	if o.GetFirmwareVersion() != other.GetFirmwareVersion() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorFirmwareVersion})
	}
	if o.GetLoggerVersion() != other.GetLoggerVersion() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorLoggerVersion})
	}
	if o.GetBoardName() != other.GetBoardName() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorBoardName})
	}
	if o.GetSerialNumber() != other.GetSerialNumber() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorSerialNumber})
	}
	if o.GetPartNumber() != other.GetPartNumber() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorPartNumber})
	}
	if o.GetProductName() != other.GetProductName() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorProductName})
	}
	if o.GetNeuralNetworkCoreClockRate() != other.GetNeuralNetworkCoreClockRate() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationHailoInfoHailoModuleInfo_FieldPathSelectorNeuralNetworkCoreClockRate})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) Clone() *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo{}
	result.DevId = o.DevId
	result.ControlProtoVersion = o.ControlProtoVersion
	result.FirmwareVersion = o.FirmwareVersion
	result.LoggerVersion = o.LoggerVersion
	result.BoardName = o.BoardName
	result.SerialNumber = o.SerialNumber
	result.PartNumber = o.PartNumber
	result.ProductName = o.ProductName
	result.NeuralNetworkCoreClockRate = o.NeuralNetworkCoreClockRate
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) Merge(source *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) {
	o.DevId = source.GetDevId()
	o.ControlProtoVersion = source.GetControlProtoVersion()
	o.FirmwareVersion = source.GetFirmwareVersion()
	o.LoggerVersion = source.GetLoggerVersion()
	o.BoardName = source.GetBoardName()
	o.SerialNumber = source.GetSerialNumber()
	o.PartNumber = source.GetPartNumber()
	o.ProductName = source.GetProductName()
	o.NeuralNetworkCoreClockRate = source.GetNeuralNetworkCoreClockRate()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_HailoInfo_HailoModuleInfo))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo_FieldMask{}
	if o.GetId() != other.GetId() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorId})
	}
	if o.GetProductName() != other.GetProductName() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationNvidiaInfoGpuInfo_FieldPathSelectorProductName})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) Clone() *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo{}
	result.Id = o.Id
	result.ProductName = o.ProductName
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) Merge(source *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) {
	o.Id = source.GetId()
	o.ProductName = source.GetProductName()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_NvidiaInfo_GpuInfo))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) GotenObjectExt() {
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings_FieldMask{}
	if o.GetDrxCycle() != other.GetDrxCycle() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorDrxCycle})
	}
	if o.GetMicoMode() != other.GetMicoMode() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusRegistrationSettings_FieldPathSelectorMicoMode})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) Clone() *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings{}
	result.DrxCycle = o.DrxCycle
	result.MicoMode = o.MicoMode
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) Merge(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) {
	o.DrxCycle = source.GetDrxCycle()
	o.MicoMode = source.GetMicoMode()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr_FieldMask{}
	{
		subMask := o.GetRegistrationSettings().MakeDiffFieldMask(other.GetRegistrationSettings())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelectorRegistrationSettings})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusFiveGNr_FieldPathSelectorRegistrationSettings, subPath: subpath})
			}
		}
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) Clone() *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr{}
	result.RegistrationSettings = o.RegistrationSettings.Clone()
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) Merge(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) {
	if source.GetRegistrationSettings() != nil {
		if o.RegistrationSettings == nil {
			o.RegistrationSettings = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_RegistrationSettings)
		}
		o.RegistrationSettings.Merge(source.GetRegistrationSettings())
	}
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings_FieldMask{}
	if o.GetApn() != other.GetApn() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorApn})
	}
	if o.GetIpType() != other.GetIpType() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorIpType})
	}
	if o.GetPassword() != other.GetPassword() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorPassword})
	}
	if o.GetUser() != other.GetUser() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSettings_FieldPathSelectorUser})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) Clone() *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings{}
	result.Apn = o.Apn
	result.IpType = o.IpType
	result.Password = o.Password
	result.User = o.User
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) Merge(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) {
	o.Apn = source.GetApn()
	o.IpType = source.GetIpType()
	o.Password = source.GetPassword()
	o.User = source.GetUser()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer_FieldMask{}
	if o.GetDbusPath() != other.GetDbusPath() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorDbusPath})
	}
	{
		subMask := o.GetSettings().MakeDiffFieldMask(other.GetSettings())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorSettings})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusInitialBearer_FieldPathSelectorSettings, subPath: subpath})
			}
		}
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) Clone() *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer{}
	result.DbusPath = o.DbusPath
	result.Settings = o.Settings.Clone()
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) Merge(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) {
	o.DbusPath = source.GetDbusPath()
	if source.GetSettings() != nil {
		if o.Settings == nil {
			o.Settings = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Settings)
		}
		o.Settings.Merge(source.GetSettings())
	}
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps_FieldMask{}
	{
		subMask := o.GetInitialBearer().MakeDiffFieldMask(other.GetInitialBearer())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorInitialBearer})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorInitialBearer, subPath: subpath})
			}
		}
	}
	if o.GetUeModeOperation() != other.GetUeModeOperation() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusEps_FieldPathSelectorUeModeOperation})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) Clone() *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps{}
	result.InitialBearer = o.InitialBearer.Clone()
	result.UeModeOperation = o.UeModeOperation
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) Merge(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) {
	if source.GetInitialBearer() != nil {
		if o.InitialBearer == nil {
			o.InitialBearer = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_InitialBearer)
		}
		o.InitialBearer.Merge(source.GetInitialBearer())
	}
	o.UeModeOperation = source.GetUeModeOperation()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp_FieldMask{}
	{
		subMask := o.GetFivegNr().MakeDiffFieldMask(other.GetFivegNr())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorFivegNr})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorFivegNr, subPath: subpath})
			}
		}
	}

	if len(o.GetEnabledLocks()) == len(other.GetEnabledLocks()) {
		for i, lValue := range o.GetEnabledLocks() {
			rValue := other.GetEnabledLocks()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEnabledLocks})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEnabledLocks})
	}
	{
		subMask := o.GetEps().MakeDiffFieldMask(other.GetEps())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEps})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorEps, subPath: subpath})
			}
		}
	}
	if o.GetImei() != other.GetImei() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorImei})
	}
	if o.GetOperatorCode() != other.GetOperatorCode() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorCode})
	}
	if o.GetOperatorName() != other.GetOperatorName() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorOperatorName})
	}
	if o.GetPacketServiceState() != other.GetPacketServiceState() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPacketServiceState})
	}
	if o.GetPco() != other.GetPco() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorPco})
	}
	if o.GetRegistrationState() != other.GetRegistrationState() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusThreeGpp_FieldPathSelectorRegistrationState})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) Clone() *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp{}
	result.FivegNr = o.FivegNr.Clone()
	result.EnabledLocks = make([]string, len(o.EnabledLocks))
	for i, sourceValue := range o.EnabledLocks {
		result.EnabledLocks[i] = sourceValue
	}
	result.Eps = o.Eps.Clone()
	result.Imei = o.Imei
	result.OperatorCode = o.OperatorCode
	result.OperatorName = o.OperatorName
	result.PacketServiceState = o.PacketServiceState
	result.Pco = o.Pco
	result.RegistrationState = o.RegistrationState
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) Merge(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) {
	if source.GetFivegNr() != nil {
		if o.FivegNr == nil {
			o.FivegNr = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_FiveGNr)
		}
		o.FivegNr.Merge(source.GetFivegNr())
	}
	for _, sourceValue := range source.GetEnabledLocks() {
		exists := false
		for _, currentValue := range o.EnabledLocks {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.EnabledLocks = append(o.EnabledLocks, newDstElement)
		}
	}

	if source.GetEps() != nil {
		if o.Eps == nil {
			o.Eps = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Eps)
		}
		o.Eps.Merge(source.GetEps())
	}
	o.Imei = source.GetImei()
	o.OperatorCode = source.GetOperatorCode()
	o.OperatorName = source.GetOperatorName()
	o.PacketServiceState = source.GetPacketServiceState()
	o.Pco = source.GetPco()
	o.RegistrationState = source.GetRegistrationState()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma_FieldMask{}
	if o.GetActivationState() != other.GetActivationState() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorActivationState})
	}
	if o.GetCdma1XRegistrationState() != other.GetCdma1XRegistrationState() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorCdma1xRegistrationState})
	}
	if o.GetEsn() != other.GetEsn() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEsn})
	}
	if o.GetEvdoRegistrationState() != other.GetEvdoRegistrationState() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorEvdoRegistrationState})
	}
	if o.GetMeid() != other.GetMeid() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorMeid})
	}
	if o.GetNid() != other.GetNid() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorNid})
	}
	if o.GetSid() != other.GetSid() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusCdma_FieldPathSelectorSid})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) Clone() *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma{}
	result.ActivationState = o.ActivationState
	result.Cdma1XRegistrationState = o.Cdma1XRegistrationState
	result.Esn = o.Esn
	result.EvdoRegistrationState = o.EvdoRegistrationState
	result.Meid = o.Meid
	result.Nid = o.Nid
	result.Sid = o.Sid
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) Merge(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) {
	o.ActivationState = source.GetActivationState()
	o.Cdma1XRegistrationState = source.GetCdma1XRegistrationState()
	o.Esn = source.GetEsn()
	o.EvdoRegistrationState = source.GetEvdoRegistrationState()
	o.Meid = source.GetMeid()
	o.Nid = source.GetNid()
	o.Sid = source.GetSid()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality_FieldMask{}
	if o.GetRecent() != other.GetRecent() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorRecent})
	}
	if o.GetValue() != other.GetValue() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSignalQuality_FieldPathSelectorValue})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) Clone() *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality{}
	result.Recent = o.Recent
	result.Value = o.Value
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) Merge(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) {
	o.Recent = source.GetRecent()
	o.Value = source.GetValue()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic_FieldMask{}

	if len(o.GetAccessTechnologies()) == len(other.GetAccessTechnologies()) {
		for i, lValue := range o.GetAccessTechnologies() {
			rValue := other.GetAccessTechnologies()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorAccessTechnologies})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorAccessTechnologies})
	}

	if len(o.GetBearers()) == len(other.GetBearers()) {
		for i, lValue := range o.GetBearers() {
			rValue := other.GetBearers()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorBearers})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorBearers})
	}
	if o.GetCarrierConfiguration() != other.GetCarrierConfiguration() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfiguration})
	}
	if o.GetCarrierConfigurationRevision() != other.GetCarrierConfigurationRevision() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCarrierConfigurationRevision})
	}

	if len(o.GetCurrentBands()) == len(other.GetCurrentBands()) {
		for i, lValue := range o.GetCurrentBands() {
			rValue := other.GetCurrentBands()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentBands})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentBands})
	}

	if len(o.GetCurrentCapabilities()) == len(other.GetCurrentCapabilities()) {
		for i, lValue := range o.GetCurrentCapabilities() {
			rValue := other.GetCurrentCapabilities()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentCapabilities})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentCapabilities})
	}
	if o.GetCurrentModes() != other.GetCurrentModes() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorCurrentModes})
	}
	if o.GetDevice() != other.GetDevice() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDevice})
	}
	if o.GetDeviceIdentifier() != other.GetDeviceIdentifier() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDeviceIdentifier})
	}

	if len(o.GetDrivers()) == len(other.GetDrivers()) {
		for i, lValue := range o.GetDrivers() {
			rValue := other.GetDrivers()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDrivers})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorDrivers})
	}
	if o.GetEquipmentIdentifier() != other.GetEquipmentIdentifier() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorEquipmentIdentifier})
	}
	if o.GetHardwareRevision() != other.GetHardwareRevision() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorHardwareRevision})
	}
	if o.GetManufacturer() != other.GetManufacturer() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorManufacturer})
	}
	if o.GetModel() != other.GetModel() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorModel})
	}

	if len(o.GetOwnNumbers()) == len(other.GetOwnNumbers()) {
		for i, lValue := range o.GetOwnNumbers() {
			rValue := other.GetOwnNumbers()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorOwnNumbers})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorOwnNumbers})
	}
	if o.GetPlugin() != other.GetPlugin() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPlugin})
	}

	if len(o.GetPorts()) == len(other.GetPorts()) {
		for i, lValue := range o.GetPorts() {
			rValue := other.GetPorts()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPorts})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPorts})
	}
	if o.GetPowerState() != other.GetPowerState() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPowerState})
	}
	if o.GetPrimaryPort() != other.GetPrimaryPort() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimaryPort})
	}
	if o.GetPrimarySimSlot() != other.GetPrimarySimSlot() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorPrimarySimSlot})
	}
	if o.GetRevision() != other.GetRevision() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorRevision})
	}
	{
		subMask := o.GetSignalQuality().MakeDiffFieldMask(other.GetSignalQuality())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSignalQuality})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSignalQuality, subPath: subpath})
			}
		}
	}
	if o.GetSim() != other.GetSim() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSim})
	}

	if len(o.GetSimSlots()) == len(other.GetSimSlots()) {
		for i, lValue := range o.GetSimSlots() {
			rValue := other.GetSimSlots()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSimSlots})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSimSlots})
	}
	if o.GetState() != other.GetState() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorState})
	}
	if o.GetStateFailedReason() != other.GetStateFailedReason() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorStateFailedReason})
	}

	if len(o.GetSupportedBands()) == len(other.GetSupportedBands()) {
		for i, lValue := range o.GetSupportedBands() {
			rValue := other.GetSupportedBands()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedBands})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedBands})
	}

	if len(o.GetSupportedCapabilities()) == len(other.GetSupportedCapabilities()) {
		for i, lValue := range o.GetSupportedCapabilities() {
			rValue := other.GetSupportedCapabilities()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedCapabilities})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedCapabilities})
	}

	if len(o.GetSupportedIpFamilies()) == len(other.GetSupportedIpFamilies()) {
		for i, lValue := range o.GetSupportedIpFamilies() {
			rValue := other.GetSupportedIpFamilies()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedIpFamilies})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedIpFamilies})
	}

	if len(o.GetSupportedModes()) == len(other.GetSupportedModes()) {
		for i, lValue := range o.GetSupportedModes() {
			rValue := other.GetSupportedModes()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedModes})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorSupportedModes})
	}
	if o.GetUnlockRequired() != other.GetUnlockRequired() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRequired})
	}

	if len(o.GetUnlockRetries()) == len(other.GetUnlockRetries()) {
		for i, lValue := range o.GetUnlockRetries() {
			rValue := other.GetUnlockRetries()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRetries})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusGeneric_FieldPathSelectorUnlockRetries})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) Clone() *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic{}
	result.AccessTechnologies = make([]string, len(o.AccessTechnologies))
	for i, sourceValue := range o.AccessTechnologies {
		result.AccessTechnologies[i] = sourceValue
	}
	result.Bearers = make([]string, len(o.Bearers))
	for i, sourceValue := range o.Bearers {
		result.Bearers[i] = sourceValue
	}
	result.CarrierConfiguration = o.CarrierConfiguration
	result.CarrierConfigurationRevision = o.CarrierConfigurationRevision
	result.CurrentBands = make([]string, len(o.CurrentBands))
	for i, sourceValue := range o.CurrentBands {
		result.CurrentBands[i] = sourceValue
	}
	result.CurrentCapabilities = make([]string, len(o.CurrentCapabilities))
	for i, sourceValue := range o.CurrentCapabilities {
		result.CurrentCapabilities[i] = sourceValue
	}
	result.CurrentModes = o.CurrentModes
	result.Device = o.Device
	result.DeviceIdentifier = o.DeviceIdentifier
	result.Drivers = make([]string, len(o.Drivers))
	for i, sourceValue := range o.Drivers {
		result.Drivers[i] = sourceValue
	}
	result.EquipmentIdentifier = o.EquipmentIdentifier
	result.HardwareRevision = o.HardwareRevision
	result.Manufacturer = o.Manufacturer
	result.Model = o.Model
	result.OwnNumbers = make([]string, len(o.OwnNumbers))
	for i, sourceValue := range o.OwnNumbers {
		result.OwnNumbers[i] = sourceValue
	}
	result.Plugin = o.Plugin
	result.Ports = make([]string, len(o.Ports))
	for i, sourceValue := range o.Ports {
		result.Ports[i] = sourceValue
	}
	result.PowerState = o.PowerState
	result.PrimaryPort = o.PrimaryPort
	result.PrimarySimSlot = o.PrimarySimSlot
	result.Revision = o.Revision
	result.SignalQuality = o.SignalQuality.Clone()
	result.Sim = o.Sim
	result.SimSlots = make([]string, len(o.SimSlots))
	for i, sourceValue := range o.SimSlots {
		result.SimSlots[i] = sourceValue
	}
	result.State = o.State
	result.StateFailedReason = o.StateFailedReason
	result.SupportedBands = make([]string, len(o.SupportedBands))
	for i, sourceValue := range o.SupportedBands {
		result.SupportedBands[i] = sourceValue
	}
	result.SupportedCapabilities = make([]string, len(o.SupportedCapabilities))
	for i, sourceValue := range o.SupportedCapabilities {
		result.SupportedCapabilities[i] = sourceValue
	}
	result.SupportedIpFamilies = make([]string, len(o.SupportedIpFamilies))
	for i, sourceValue := range o.SupportedIpFamilies {
		result.SupportedIpFamilies[i] = sourceValue
	}
	result.SupportedModes = make([]string, len(o.SupportedModes))
	for i, sourceValue := range o.SupportedModes {
		result.SupportedModes[i] = sourceValue
	}
	result.UnlockRequired = o.UnlockRequired
	result.UnlockRetries = make([]string, len(o.UnlockRetries))
	for i, sourceValue := range o.UnlockRetries {
		result.UnlockRetries[i] = sourceValue
	}
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) Merge(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) {
	for _, sourceValue := range source.GetAccessTechnologies() {
		exists := false
		for _, currentValue := range o.AccessTechnologies {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.AccessTechnologies = append(o.AccessTechnologies, newDstElement)
		}
	}

	for _, sourceValue := range source.GetBearers() {
		exists := false
		for _, currentValue := range o.Bearers {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.Bearers = append(o.Bearers, newDstElement)
		}
	}

	o.CarrierConfiguration = source.GetCarrierConfiguration()
	o.CarrierConfigurationRevision = source.GetCarrierConfigurationRevision()
	for _, sourceValue := range source.GetCurrentBands() {
		exists := false
		for _, currentValue := range o.CurrentBands {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.CurrentBands = append(o.CurrentBands, newDstElement)
		}
	}

	for _, sourceValue := range source.GetCurrentCapabilities() {
		exists := false
		for _, currentValue := range o.CurrentCapabilities {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.CurrentCapabilities = append(o.CurrentCapabilities, newDstElement)
		}
	}

	o.CurrentModes = source.GetCurrentModes()
	o.Device = source.GetDevice()
	o.DeviceIdentifier = source.GetDeviceIdentifier()
	for _, sourceValue := range source.GetDrivers() {
		exists := false
		for _, currentValue := range o.Drivers {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.Drivers = append(o.Drivers, newDstElement)
		}
	}

	o.EquipmentIdentifier = source.GetEquipmentIdentifier()
	o.HardwareRevision = source.GetHardwareRevision()
	o.Manufacturer = source.GetManufacturer()
	o.Model = source.GetModel()
	for _, sourceValue := range source.GetOwnNumbers() {
		exists := false
		for _, currentValue := range o.OwnNumbers {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.OwnNumbers = append(o.OwnNumbers, newDstElement)
		}
	}

	o.Plugin = source.GetPlugin()
	for _, sourceValue := range source.GetPorts() {
		exists := false
		for _, currentValue := range o.Ports {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.Ports = append(o.Ports, newDstElement)
		}
	}

	o.PowerState = source.GetPowerState()
	o.PrimaryPort = source.GetPrimaryPort()
	o.PrimarySimSlot = source.GetPrimarySimSlot()
	o.Revision = source.GetRevision()
	if source.GetSignalQuality() != nil {
		if o.SignalQuality == nil {
			o.SignalQuality = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SignalQuality)
		}
		o.SignalQuality.Merge(source.GetSignalQuality())
	}
	o.Sim = source.GetSim()
	for _, sourceValue := range source.GetSimSlots() {
		exists := false
		for _, currentValue := range o.SimSlots {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.SimSlots = append(o.SimSlots, newDstElement)
		}
	}

	o.State = source.GetState()
	o.StateFailedReason = source.GetStateFailedReason()
	for _, sourceValue := range source.GetSupportedBands() {
		exists := false
		for _, currentValue := range o.SupportedBands {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.SupportedBands = append(o.SupportedBands, newDstElement)
		}
	}

	for _, sourceValue := range source.GetSupportedCapabilities() {
		exists := false
		for _, currentValue := range o.SupportedCapabilities {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.SupportedCapabilities = append(o.SupportedCapabilities, newDstElement)
		}
	}

	for _, sourceValue := range source.GetSupportedIpFamilies() {
		exists := false
		for _, currentValue := range o.SupportedIpFamilies {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.SupportedIpFamilies = append(o.SupportedIpFamilies, newDstElement)
		}
	}

	for _, sourceValue := range source.GetSupportedModes() {
		exists := false
		for _, currentValue := range o.SupportedModes {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.SupportedModes = append(o.SupportedModes, newDstElement)
		}
	}

	o.UnlockRequired = source.GetUnlockRequired()
	for _, sourceValue := range source.GetUnlockRetries() {
		exists := false
		for _, currentValue := range o.UnlockRetries {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.UnlockRetries = append(o.UnlockRetries, newDstElement)
		}
	}

}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus_FieldMask{}
	if o.GetDbusPath() != other.GetDbusPath() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorDbusPath})
	}
	if o.GetActive() != other.GetActive() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorActive})
	}
	if o.GetEid() != other.GetEid() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEid})
	}

	if len(o.GetEmergencyNumbers()) == len(other.GetEmergencyNumbers()) {
		for i, lValue := range o.GetEmergencyNumbers() {
			rValue := other.GetEmergencyNumbers()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEmergencyNumbers})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEmergencyNumbers})
	}
	if o.GetEsimStatus() != other.GetEsimStatus() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorEsimStatus})
	}
	if o.GetGid1() != other.GetGid1() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid1})
	}
	if o.GetGid2() != other.GetGid2() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorGid2})
	}
	if o.GetIccid() != other.GetIccid() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorIccid})
	}
	if o.GetImsi() != other.GetImsi() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorImsi})
	}
	if o.GetOperatorCode() != other.GetOperatorCode() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorCode})
	}
	if o.GetOperatorName() != other.GetOperatorName() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorOperatorName})
	}
	if o.GetRemovability() != other.GetRemovability() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorRemovability})
	}
	if o.GetSimType() != other.GetSimType() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusSimStatus_FieldPathSelectorSimType})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) Clone() *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus{}
	result.DbusPath = o.DbusPath
	result.Active = o.Active
	result.Eid = o.Eid
	result.EmergencyNumbers = make([]string, len(o.EmergencyNumbers))
	for i, sourceValue := range o.EmergencyNumbers {
		result.EmergencyNumbers[i] = sourceValue
	}
	result.EsimStatus = o.EsimStatus
	result.Gid1 = o.Gid1
	result.Gid2 = o.Gid2
	result.Iccid = o.Iccid
	result.Imsi = o.Imsi
	result.OperatorCode = o.OperatorCode
	result.OperatorName = o.OperatorName
	result.Removability = o.Removability
	result.SimType = o.SimType
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) Merge(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) {
	o.DbusPath = source.GetDbusPath()
	o.Active = source.GetActive()
	o.Eid = source.GetEid()
	for _, sourceValue := range source.GetEmergencyNumbers() {
		exists := false
		for _, currentValue := range o.EmergencyNumbers {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.EmergencyNumbers = append(o.EmergencyNumbers, newDstElement)
		}
	}

	o.EsimStatus = source.GetEsimStatus()
	o.Gid1 = source.GetGid1()
	o.Gid2 = source.GetGid2()
	o.Iccid = source.GetIccid()
	o.Imsi = source.GetImsi()
	o.OperatorCode = source.GetOperatorCode()
	o.OperatorName = source.GetOperatorName()
	o.Removability = source.GetRemovability()
	o.SimType = source.GetSimType()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) MakeFullFieldMask() *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem_FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem_FieldMask()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) MakeDiffFieldMask(other *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem_FieldMask()
	}

	res := &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem_FieldMask{}
	{
		subMask := o.GetThreeGPp().MakeDiffFieldMask(other.GetThreeGPp())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorThreeGPp})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorThreeGPp, subPath: subpath})
			}
		}
	}
	{
		subMask := o.GetCdma().MakeDiffFieldMask(other.GetCdma())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorCdma})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorCdma, subPath: subpath})
			}
		}
	}
	if o.GetDbusPath() != other.GetDbusPath() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorDbusPath})
	}
	{
		subMask := o.GetGeneric().MakeDiffFieldMask(other.GetGeneric())
		if subMask.IsFull() {
			res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorGeneric})
		} else {
			for _, subpath := range subMask.Paths {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldSubPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorGeneric, subPath: subpath})
			}
		}
	}

	if len(o.GetSimStatus()) == len(other.GetSimStatus()) {
		for i, lValue := range o.GetSimStatus() {
			rValue := other.GetSimStatus()[i]
			if len(lValue.MakeDiffFieldMask(rValue).Paths) > 0 {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorSimStatus})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldTerminalPath{selector: DeviceStatusDeviceInfoHardwareInformationModemStatusModem_FieldPathSelectorSimStatus})
	}
	return res
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem))
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) Clone() *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem{}
	result.ThreeGPp = o.ThreeGPp.Clone()
	result.Cdma = o.Cdma.Clone()
	result.DbusPath = o.DbusPath
	result.Generic = o.Generic.Clone()
	result.SimStatus = map[string]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus{}
	for key, sourceValue := range o.SimStatus {
		result.SimStatus[key] = sourceValue.Clone()
	}
	return result
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) Merge(source *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) {
	if source.GetThreeGPp() != nil {
		if o.ThreeGPp == nil {
			o.ThreeGPp = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_ThreeGpp)
		}
		o.ThreeGPp.Merge(source.GetThreeGPp())
	}
	if source.GetCdma() != nil {
		if o.Cdma == nil {
			o.Cdma = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Cdma)
		}
		o.Cdma.Merge(source.GetCdma())
	}
	o.DbusPath = source.GetDbusPath()
	if source.GetGeneric() != nil {
		if o.Generic == nil {
			o.Generic = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Generic)
		}
		o.Generic.Merge(source.GetGeneric())
	}
	if source.GetSimStatus() != nil {
		if o.SimStatus == nil {
			o.SimStatus = make(map[string]*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus, len(source.GetSimStatus()))
		}
		for key, sourceValue := range source.GetSimStatus() {
			if sourceValue != nil {
				if o.SimStatus[key] == nil {
					o.SimStatus[key] = new(Device_Status_DeviceInfo_HardwareInformation_ModemStatus_SimStatus)
				}
				o.SimStatus[key].Merge(sourceValue)
			}
		}
	}
}

func (o *Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_HardwareInformation_ModemStatus_Modem))
}

func (o *Device_Status_DeviceInfo_NetworkInterface_ASInfo) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_NetworkInterface_ASInfo) MakeFullFieldMask() *Device_Status_DeviceInfo_NetworkInterface_ASInfo_FieldMask {
	return FullDevice_Status_DeviceInfo_NetworkInterface_ASInfo_FieldMask()
}

func (o *Device_Status_DeviceInfo_NetworkInterface_ASInfo) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_NetworkInterface_ASInfo_FieldMask()
}

func (o *Device_Status_DeviceInfo_NetworkInterface_ASInfo) MakeDiffFieldMask(other *Device_Status_DeviceInfo_NetworkInterface_ASInfo) *Device_Status_DeviceInfo_NetworkInterface_ASInfo_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_NetworkInterface_ASInfo_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_NetworkInterface_ASInfo_FieldMask()
	}

	res := &Device_Status_DeviceInfo_NetworkInterface_ASInfo_FieldMask{}
	if o.GetAsn() != other.GetAsn() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsn})
	}
	if o.GetName() != other.GetName() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorName})
	}
	if o.GetDomain() != other.GetDomain() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorDomain})
	}

	if len(o.GetRoutes()) == len(other.GetRoutes()) {
		for i, lValue := range o.GetRoutes() {
			rValue := other.GetRoutes()[i]
			if lValue != rValue {
				res.Paths = append(res.Paths, &DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorRoutes})
				break
			}
		}
	} else {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorRoutes})
	}
	if o.GetAsnType() != other.GetAsnType() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterfaceASInfo_FieldPathSelectorAsnType})
	}
	return res
}

func (o *Device_Status_DeviceInfo_NetworkInterface_ASInfo) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_NetworkInterface_ASInfo))
}

func (o *Device_Status_DeviceInfo_NetworkInterface_ASInfo) Clone() *Device_Status_DeviceInfo_NetworkInterface_ASInfo {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_NetworkInterface_ASInfo{}
	result.Asn = o.Asn
	result.Name = o.Name
	result.Domain = o.Domain
	result.Routes = make([]string, len(o.Routes))
	for i, sourceValue := range o.Routes {
		result.Routes[i] = sourceValue
	}
	result.AsnType = o.AsnType
	return result
}

func (o *Device_Status_DeviceInfo_NetworkInterface_ASInfo) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_NetworkInterface_ASInfo) Merge(source *Device_Status_DeviceInfo_NetworkInterface_ASInfo) {
	o.Asn = source.GetAsn()
	o.Name = source.GetName()
	o.Domain = source.GetDomain()
	for _, sourceValue := range source.GetRoutes() {
		exists := false
		for _, currentValue := range o.Routes {
			if currentValue == sourceValue {
				exists = true
				break
			}
		}
		if !exists {
			var newDstElement string
			newDstElement = sourceValue
			o.Routes = append(o.Routes, newDstElement)
		}
	}

	o.AsnType = source.GetAsnType()
}

func (o *Device_Status_DeviceInfo_NetworkInterface_ASInfo) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_NetworkInterface_ASInfo))
}

func (o *Device_Status_DeviceInfo_NetworkInterface_Carrier) GotenObjectExt() {}

func (o *Device_Status_DeviceInfo_NetworkInterface_Carrier) MakeFullFieldMask() *Device_Status_DeviceInfo_NetworkInterface_Carrier_FieldMask {
	return FullDevice_Status_DeviceInfo_NetworkInterface_Carrier_FieldMask()
}

func (o *Device_Status_DeviceInfo_NetworkInterface_Carrier) MakeRawFullFieldMask() gotenobject.FieldMask {
	return FullDevice_Status_DeviceInfo_NetworkInterface_Carrier_FieldMask()
}

func (o *Device_Status_DeviceInfo_NetworkInterface_Carrier) MakeDiffFieldMask(other *Device_Status_DeviceInfo_NetworkInterface_Carrier) *Device_Status_DeviceInfo_NetworkInterface_Carrier_FieldMask {
	if o == nil && other == nil {
		return &Device_Status_DeviceInfo_NetworkInterface_Carrier_FieldMask{}
	}
	if o == nil || other == nil {
		return FullDevice_Status_DeviceInfo_NetworkInterface_Carrier_FieldMask()
	}

	res := &Device_Status_DeviceInfo_NetworkInterface_Carrier_FieldMask{}
	if o.GetName() != other.GetName() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorName})
	}
	if o.GetMobileCountryCode() != other.GetMobileCountryCode() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileCountryCode})
	}
	if o.GetMobileNetworkCode() != other.GetMobileNetworkCode() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorMobileNetworkCode})
	}
	if o.GetLocationAreaCode() != other.GetLocationAreaCode() {
		res.Paths = append(res.Paths, &DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldTerminalPath{selector: DeviceStatusDeviceInfoNetworkInterfaceCarrier_FieldPathSelectorLocationAreaCode})
	}
	return res
}

func (o *Device_Status_DeviceInfo_NetworkInterface_Carrier) MakeRawDiffFieldMask(other gotenobject.GotenObjectExt) gotenobject.FieldMask {
	return o.MakeDiffFieldMask(other.(*Device_Status_DeviceInfo_NetworkInterface_Carrier))
}

func (o *Device_Status_DeviceInfo_NetworkInterface_Carrier) Clone() *Device_Status_DeviceInfo_NetworkInterface_Carrier {
	if o == nil {
		return nil
	}
	result := &Device_Status_DeviceInfo_NetworkInterface_Carrier{}
	result.Name = o.Name
	result.MobileCountryCode = o.MobileCountryCode
	result.MobileNetworkCode = o.MobileNetworkCode
	result.LocationAreaCode = o.LocationAreaCode
	return result
}

func (o *Device_Status_DeviceInfo_NetworkInterface_Carrier) CloneRaw() gotenobject.GotenObjectExt {
	return o.Clone()
}

func (o *Device_Status_DeviceInfo_NetworkInterface_Carrier) Merge(source *Device_Status_DeviceInfo_NetworkInterface_Carrier) {
	o.Name = source.GetName()
	o.MobileCountryCode = source.GetMobileCountryCode()
	o.MobileNetworkCode = source.GetMobileNetworkCode()
	o.LocationAreaCode = source.GetLocationAreaCode()
}

func (o *Device_Status_DeviceInfo_NetworkInterface_Carrier) MergeRaw(source gotenobject.GotenObjectExt) {
	o.Merge(source.(*Device_Status_DeviceInfo_NetworkInterface_Carrier))
}