devicerepository.pb.setters.fm.go

// Code generated by protoc-gen-fieldmask. DO NOT EDIT.

package ttnpb

import fmt "fmt"

func (dst *EndDeviceBrand) SetFields(src *EndDeviceBrand, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "brand_id":
			if len(subs) > 0 {
				return fmt.Errorf("'brand_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.BrandId = src.BrandId
			} else {
				var zero string
				dst.BrandId = zero
			}
		case "name":
			if len(subs) > 0 {
				return fmt.Errorf("'name' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Name = src.Name
			} else {
				var zero string
				dst.Name = zero
			}
		case "private_enterprise_number":
			if len(subs) > 0 {
				return fmt.Errorf("'private_enterprise_number' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.PrivateEnterpriseNumber = src.PrivateEnterpriseNumber
			} else {
				var zero uint32
				dst.PrivateEnterpriseNumber = zero
			}
		case "organization_unique_identifiers":
			if len(subs) > 0 {
				return fmt.Errorf("'organization_unique_identifiers' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.OrganizationUniqueIdentifiers = src.OrganizationUniqueIdentifiers
			} else {
				dst.OrganizationUniqueIdentifiers = nil
			}
		case "lora_alliance_vendor_id":
			if len(subs) > 0 {
				return fmt.Errorf("'lora_alliance_vendor_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LoraAllianceVendorId = src.LoraAllianceVendorId
			} else {
				var zero uint32
				dst.LoraAllianceVendorId = zero
			}
		case "website":
			if len(subs) > 0 {
				return fmt.Errorf("'website' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Website = src.Website
			} else {
				var zero string
				dst.Website = zero
			}
		case "email":
			if len(subs) > 0 {
				return fmt.Errorf("'email' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Email = src.Email
			} else {
				var zero string
				dst.Email = zero
			}
		case "logo":
			if len(subs) > 0 {
				return fmt.Errorf("'logo' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Logo = src.Logo
			} else {
				var zero string
				dst.Logo = zero
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *EndDeviceModel) SetFields(src *EndDeviceModel, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "brand_id":
			if len(subs) > 0 {
				return fmt.Errorf("'brand_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.BrandId = src.BrandId
			} else {
				var zero string
				dst.BrandId = zero
			}
		case "model_id":
			if len(subs) > 0 {
				return fmt.Errorf("'model_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ModelId = src.ModelId
			} else {
				var zero string
				dst.ModelId = zero
			}
		case "name":
			if len(subs) > 0 {
				return fmt.Errorf("'name' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Name = src.Name
			} else {
				var zero string
				dst.Name = zero
			}
		case "description":
			if len(subs) > 0 {
				return fmt.Errorf("'description' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Description = src.Description
			} else {
				var zero string
				dst.Description = zero
			}
		case "hardware_versions":
			if len(subs) > 0 {
				return fmt.Errorf("'hardware_versions' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.HardwareVersions = src.HardwareVersions
			} else {
				dst.HardwareVersions = nil
			}
		case "firmware_versions":
			if len(subs) > 0 {
				return fmt.Errorf("'firmware_versions' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FirmwareVersions = src.FirmwareVersions
			} else {
				dst.FirmwareVersions = nil
			}
		case "sensors":
			if len(subs) > 0 {
				return fmt.Errorf("'sensors' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Sensors = src.Sensors
			} else {
				dst.Sensors = nil
			}
		case "dimensions":
			if len(subs) > 0 {
				var newDst, newSrc *EndDeviceModel_Dimensions
				if (src == nil || src.Dimensions == nil) && dst.Dimensions == nil {
					continue
				}
				if src != nil {
					newSrc = src.Dimensions
				}
				if dst.Dimensions != nil {
					newDst = dst.Dimensions
				} else {
					newDst = &EndDeviceModel_Dimensions{}
					dst.Dimensions = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Dimensions = src.Dimensions
				} else {
					dst.Dimensions = nil
				}
			}
		case "weight":
			if len(subs) > 0 {
				return fmt.Errorf("'weight' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Weight = src.Weight
			} else {
				dst.Weight = nil
			}
		case "battery":
			if len(subs) > 0 {
				var newDst, newSrc *EndDeviceModel_Battery
				if (src == nil || src.Battery == nil) && dst.Battery == nil {
					continue
				}
				if src != nil {
					newSrc = src.Battery
				}
				if dst.Battery != nil {
					newDst = dst.Battery
				} else {
					newDst = &EndDeviceModel_Battery{}
					dst.Battery = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Battery = src.Battery
				} else {
					dst.Battery = nil
				}
			}
		case "operating_conditions":
			if len(subs) > 0 {
				var newDst, newSrc *EndDeviceModel_OperatingConditions
				if (src == nil || src.OperatingConditions == nil) && dst.OperatingConditions == nil {
					continue
				}
				if src != nil {
					newSrc = src.OperatingConditions
				}
				if dst.OperatingConditions != nil {
					newDst = dst.OperatingConditions
				} else {
					newDst = &EndDeviceModel_OperatingConditions{}
					dst.OperatingConditions = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.OperatingConditions = src.OperatingConditions
				} else {
					dst.OperatingConditions = nil
				}
			}
		case "ip_code":
			if len(subs) > 0 {
				return fmt.Errorf("'ip_code' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.IpCode = src.IpCode
			} else {
				var zero string
				dst.IpCode = zero
			}
		case "key_provisioning":
			if len(subs) > 0 {
				return fmt.Errorf("'key_provisioning' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.KeyProvisioning = src.KeyProvisioning
			} else {
				dst.KeyProvisioning = nil
			}
		case "key_security":
			if len(subs) > 0 {
				return fmt.Errorf("'key_security' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.KeySecurity = src.KeySecurity
			} else {
				dst.KeySecurity = 0
			}
		case "photos":
			if len(subs) > 0 {
				var newDst, newSrc *EndDeviceModel_Photos
				if (src == nil || src.Photos == nil) && dst.Photos == nil {
					continue
				}
				if src != nil {
					newSrc = src.Photos
				}
				if dst.Photos != nil {
					newDst = dst.Photos
				} else {
					newDst = &EndDeviceModel_Photos{}
					dst.Photos = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Photos = src.Photos
				} else {
					dst.Photos = nil
				}
			}
		case "videos":
			if len(subs) > 0 {
				var newDst, newSrc *EndDeviceModel_Videos
				if (src == nil || src.Videos == nil) && dst.Videos == nil {
					continue
				}
				if src != nil {
					newSrc = src.Videos
				}
				if dst.Videos != nil {
					newDst = dst.Videos
				} else {
					newDst = &EndDeviceModel_Videos{}
					dst.Videos = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Videos = src.Videos
				} else {
					dst.Videos = nil
				}
			}
		case "product_url":
			if len(subs) > 0 {
				return fmt.Errorf("'product_url' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ProductUrl = src.ProductUrl
			} else {
				var zero string
				dst.ProductUrl = zero
			}
		case "datasheet_url":
			if len(subs) > 0 {
				return fmt.Errorf("'datasheet_url' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.DatasheetUrl = src.DatasheetUrl
			} else {
				var zero string
				dst.DatasheetUrl = zero
			}
		case "resellers":
			if len(subs) > 0 {
				return fmt.Errorf("'resellers' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Resellers = src.Resellers
			} else {
				dst.Resellers = nil
			}
		case "compliances":
			if len(subs) > 0 {
				var newDst, newSrc *EndDeviceModel_Compliances
				if (src == nil || src.Compliances == nil) && dst.Compliances == nil {
					continue
				}
				if src != nil {
					newSrc = src.Compliances
				}
				if dst.Compliances != nil {
					newDst = dst.Compliances
				} else {
					newDst = &EndDeviceModel_Compliances{}
					dst.Compliances = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Compliances = src.Compliances
				} else {
					dst.Compliances = nil
				}
			}
		case "additional_radios":
			if len(subs) > 0 {
				return fmt.Errorf("'additional_radios' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.AdditionalRadios = src.AdditionalRadios
			} else {
				dst.AdditionalRadios = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *GetEndDeviceBrandRequest) SetFields(src *GetEndDeviceBrandRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "application_ids":
			if len(subs) > 0 {
				var newDst, newSrc *ApplicationIdentifiers
				if (src == nil || src.ApplicationIds == nil) && dst.ApplicationIds == nil {
					continue
				}
				if src != nil {
					newSrc = src.ApplicationIds
				}
				if dst.ApplicationIds != nil {
					newDst = dst.ApplicationIds
				} else {
					newDst = &ApplicationIdentifiers{}
					dst.ApplicationIds = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.ApplicationIds = src.ApplicationIds
				} else {
					dst.ApplicationIds = nil
				}
			}
		case "brand_id":
			if len(subs) > 0 {
				return fmt.Errorf("'brand_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.BrandId = src.BrandId
			} else {
				var zero string
				dst.BrandId = zero
			}
		case "field_mask":
			if len(subs) > 0 {
				return fmt.Errorf("'field_mask' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FieldMask = src.FieldMask
			} else {
				dst.FieldMask = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *ListEndDeviceBrandsRequest) SetFields(src *ListEndDeviceBrandsRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "application_ids":
			if len(subs) > 0 {
				var newDst, newSrc *ApplicationIdentifiers
				if (src == nil || src.ApplicationIds == nil) && dst.ApplicationIds == nil {
					continue
				}
				if src != nil {
					newSrc = src.ApplicationIds
				}
				if dst.ApplicationIds != nil {
					newDst = dst.ApplicationIds
				} else {
					newDst = &ApplicationIdentifiers{}
					dst.ApplicationIds = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.ApplicationIds = src.ApplicationIds
				} else {
					dst.ApplicationIds = nil
				}
			}
		case "limit":
			if len(subs) > 0 {
				return fmt.Errorf("'limit' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Limit = src.Limit
			} else {
				var zero uint32
				dst.Limit = zero
			}
		case "page":
			if len(subs) > 0 {
				return fmt.Errorf("'page' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Page = src.Page
			} else {
				var zero uint32
				dst.Page = zero
			}
		case "order_by":
			if len(subs) > 0 {
				return fmt.Errorf("'order_by' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.OrderBy = src.OrderBy
			} else {
				var zero string
				dst.OrderBy = zero
			}
		case "search":
			if len(subs) > 0 {
				return fmt.Errorf("'search' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Search = src.Search
			} else {
				var zero string
				dst.Search = zero
			}
		case "field_mask":
			if len(subs) > 0 {
				return fmt.Errorf("'field_mask' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FieldMask = src.FieldMask
			} else {
				dst.FieldMask = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *GetEndDeviceModelRequest) SetFields(src *GetEndDeviceModelRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "application_ids":
			if len(subs) > 0 {
				var newDst, newSrc *ApplicationIdentifiers
				if (src == nil || src.ApplicationIds == nil) && dst.ApplicationIds == nil {
					continue
				}
				if src != nil {
					newSrc = src.ApplicationIds
				}
				if dst.ApplicationIds != nil {
					newDst = dst.ApplicationIds
				} else {
					newDst = &ApplicationIdentifiers{}
					dst.ApplicationIds = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.ApplicationIds = src.ApplicationIds
				} else {
					dst.ApplicationIds = nil
				}
			}
		case "brand_id":
			if len(subs) > 0 {
				return fmt.Errorf("'brand_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.BrandId = src.BrandId
			} else {
				var zero string
				dst.BrandId = zero
			}
		case "model_id":
			if len(subs) > 0 {
				return fmt.Errorf("'model_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ModelId = src.ModelId
			} else {
				var zero string
				dst.ModelId = zero
			}
		case "field_mask":
			if len(subs) > 0 {
				return fmt.Errorf("'field_mask' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FieldMask = src.FieldMask
			} else {
				dst.FieldMask = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *ListEndDeviceModelsRequest) SetFields(src *ListEndDeviceModelsRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "application_ids":
			if len(subs) > 0 {
				var newDst, newSrc *ApplicationIdentifiers
				if (src == nil || src.ApplicationIds == nil) && dst.ApplicationIds == nil {
					continue
				}
				if src != nil {
					newSrc = src.ApplicationIds
				}
				if dst.ApplicationIds != nil {
					newDst = dst.ApplicationIds
				} else {
					newDst = &ApplicationIdentifiers{}
					dst.ApplicationIds = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.ApplicationIds = src.ApplicationIds
				} else {
					dst.ApplicationIds = nil
				}
			}
		case "brand_id":
			if len(subs) > 0 {
				return fmt.Errorf("'brand_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.BrandId = src.BrandId
			} else {
				var zero string
				dst.BrandId = zero
			}
		case "limit":
			if len(subs) > 0 {
				return fmt.Errorf("'limit' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Limit = src.Limit
			} else {
				var zero uint32
				dst.Limit = zero
			}
		case "page":
			if len(subs) > 0 {
				return fmt.Errorf("'page' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Page = src.Page
			} else {
				var zero uint32
				dst.Page = zero
			}
		case "order_by":
			if len(subs) > 0 {
				return fmt.Errorf("'order_by' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.OrderBy = src.OrderBy
			} else {
				var zero string
				dst.OrderBy = zero
			}
		case "search":
			if len(subs) > 0 {
				return fmt.Errorf("'search' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Search = src.Search
			} else {
				var zero string
				dst.Search = zero
			}
		case "field_mask":
			if len(subs) > 0 {
				return fmt.Errorf("'field_mask' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FieldMask = src.FieldMask
			} else {
				dst.FieldMask = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *GetTemplateRequest) SetFields(src *GetTemplateRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "application_ids":
			if len(subs) > 0 {
				var newDst, newSrc *ApplicationIdentifiers
				if (src == nil || src.ApplicationIds == nil) && dst.ApplicationIds == nil {
					continue
				}
				if src != nil {
					newSrc = src.ApplicationIds
				}
				if dst.ApplicationIds != nil {
					newDst = dst.ApplicationIds
				} else {
					newDst = &ApplicationIdentifiers{}
					dst.ApplicationIds = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.ApplicationIds = src.ApplicationIds
				} else {
					dst.ApplicationIds = nil
				}
			}
		case "version_ids":
			if len(subs) > 0 {
				var newDst, newSrc *EndDeviceVersionIdentifiers
				if (src == nil || src.VersionIds == nil) && dst.VersionIds == nil {
					continue
				}
				if src != nil {
					newSrc = src.VersionIds
				}
				if dst.VersionIds != nil {
					newDst = dst.VersionIds
				} else {
					newDst = &EndDeviceVersionIdentifiers{}
					dst.VersionIds = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.VersionIds = src.VersionIds
				} else {
					dst.VersionIds = nil
				}
			}
		case "end_device_profile_ids":
			if len(subs) > 0 {
				var newDst, newSrc *GetTemplateRequest_EndDeviceProfileIdentifiers
				if (src == nil || src.EndDeviceProfileIds == nil) && dst.EndDeviceProfileIds == nil {
					continue
				}
				if src != nil {
					newSrc = src.EndDeviceProfileIds
				}
				if dst.EndDeviceProfileIds != nil {
					newDst = dst.EndDeviceProfileIds
				} else {
					newDst = &GetTemplateRequest_EndDeviceProfileIdentifiers{}
					dst.EndDeviceProfileIds = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.EndDeviceProfileIds = src.EndDeviceProfileIds
				} else {
					dst.EndDeviceProfileIds = nil
				}
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *GetPayloadFormatterRequest) SetFields(src *GetPayloadFormatterRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "application_ids":
			if len(subs) > 0 {
				var newDst, newSrc *ApplicationIdentifiers
				if (src == nil || src.ApplicationIds == nil) && dst.ApplicationIds == nil {
					continue
				}
				if src != nil {
					newSrc = src.ApplicationIds
				}
				if dst.ApplicationIds != nil {
					newDst = dst.ApplicationIds
				} else {
					newDst = &ApplicationIdentifiers{}
					dst.ApplicationIds = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.ApplicationIds = src.ApplicationIds
				} else {
					dst.ApplicationIds = nil
				}
			}
		case "version_ids":
			if len(subs) > 0 {
				var newDst, newSrc *EndDeviceVersionIdentifiers
				if (src == nil || src.VersionIds == nil) && dst.VersionIds == nil {
					continue
				}
				if src != nil {
					newSrc = src.VersionIds
				}
				if dst.VersionIds != nil {
					newDst = dst.VersionIds
				} else {
					newDst = &EndDeviceVersionIdentifiers{}
					dst.VersionIds = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.VersionIds = src.VersionIds
				} else {
					dst.VersionIds = nil
				}
			}
		case "field_mask":
			if len(subs) > 0 {
				return fmt.Errorf("'field_mask' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FieldMask = src.FieldMask
			} else {
				dst.FieldMask = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *ListEndDeviceBrandsResponse) SetFields(src *ListEndDeviceBrandsResponse, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "brands":
			if len(subs) > 0 {
				return fmt.Errorf("'brands' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Brands = src.Brands
			} else {
				dst.Brands = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *ListEndDeviceModelsResponse) SetFields(src *ListEndDeviceModelsResponse, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "models":
			if len(subs) > 0 {
				return fmt.Errorf("'models' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Models = src.Models
			} else {
				dst.Models = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *EncodedMessagePayload) SetFields(src *EncodedMessagePayload, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "f_port":
			if len(subs) > 0 {
				return fmt.Errorf("'f_port' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FPort = src.FPort
			} else {
				var zero uint32
				dst.FPort = zero
			}
		case "frm_payload":
			if len(subs) > 0 {
				return fmt.Errorf("'frm_payload' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FrmPayload = src.FrmPayload
			} else {
				dst.FrmPayload = nil
			}
		case "warnings":
			if len(subs) > 0 {
				return fmt.Errorf("'warnings' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Warnings = src.Warnings
			} else {
				dst.Warnings = nil
			}
		case "errors":
			if len(subs) > 0 {
				return fmt.Errorf("'errors' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Errors = src.Errors
			} else {
				dst.Errors = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *DecodedMessagePayload) SetFields(src *DecodedMessagePayload, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "data":
			if len(subs) > 0 {
				return fmt.Errorf("'data' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Data = src.Data
			} else {
				dst.Data = nil
			}
		case "warnings":
			if len(subs) > 0 {
				return fmt.Errorf("'warnings' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Warnings = src.Warnings
			} else {
				dst.Warnings = nil
			}
		case "errors":
			if len(subs) > 0 {
				return fmt.Errorf("'errors' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Errors = src.Errors
			} else {
				dst.Errors = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *MessagePayloadDecoder) SetFields(src *MessagePayloadDecoder, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "formatter":
			if len(subs) > 0 {
				return fmt.Errorf("'formatter' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Formatter = src.Formatter
			} else {
				dst.Formatter = 0
			}
		case "formatter_parameter":
			if len(subs) > 0 {
				return fmt.Errorf("'formatter_parameter' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FormatterParameter = src.FormatterParameter
			} else {
				var zero string
				dst.FormatterParameter = zero
			}
		case "codec_id":
			if len(subs) > 0 {
				return fmt.Errorf("'codec_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.CodecId = src.CodecId
			} else {
				var zero string
				dst.CodecId = zero
			}
		case "examples":
			if len(subs) > 0 {
				return fmt.Errorf("'examples' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Examples = src.Examples
			} else {
				dst.Examples = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *MessagePayloadEncoder) SetFields(src *MessagePayloadEncoder, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "formatter":
			if len(subs) > 0 {
				return fmt.Errorf("'formatter' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Formatter = src.Formatter
			} else {
				dst.Formatter = 0
			}
		case "formatter_parameter":
			if len(subs) > 0 {
				return fmt.Errorf("'formatter_parameter' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FormatterParameter = src.FormatterParameter
			} else {
				var zero string
				dst.FormatterParameter = zero
			}
		case "codec_id":
			if len(subs) > 0 {
				return fmt.Errorf("'codec_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.CodecId = src.CodecId
			} else {
				var zero string
				dst.CodecId = zero
			}
		case "examples":
			if len(subs) > 0 {
				return fmt.Errorf("'examples' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Examples = src.Examples
			} else {
				dst.Examples = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *EndDeviceModel_HardwareVersion) SetFields(src *EndDeviceModel_HardwareVersion, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "version":
			if len(subs) > 0 {
				return fmt.Errorf("'version' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Version = src.Version
			} else {
				var zero string
				dst.Version = zero
			}
		case "numeric":
			if len(subs) > 0 {
				return fmt.Errorf("'numeric' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Numeric = src.Numeric
			} else {
				var zero uint32
				dst.Numeric = zero
			}
		case "part_number":
			if len(subs) > 0 {
				return fmt.Errorf("'part_number' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.PartNumber = src.PartNumber
			} else {
				var zero string
				dst.PartNumber = zero
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *EndDeviceModel_FirmwareVersion) SetFields(src *EndDeviceModel_FirmwareVersion, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "version":
			if len(subs) > 0 {
				return fmt.Errorf("'version' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Version = src.Version
			} else {
				var zero string
				dst.Version = zero
			}
		case "numeric":
			if len(subs) > 0 {
				return fmt.Errorf("'numeric' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Numeric = src.Numeric
			} else {
				var zero uint32
				dst.Numeric = zero
			}
		case "supported_hardware_versions":
			if len(subs) > 0 {
				return fmt.Errorf("'supported_hardware_versions' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.SupportedHardwareVersions = src.SupportedHardwareVersions
			} else {
				dst.SupportedHardwareVersions = nil
			}
		case "profiles":
			if len(subs) > 0 {
				return fmt.Errorf("'profiles' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Profiles = src.Profiles
			} else {
				dst.Profiles = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *EndDeviceModel_Dimensions) SetFields(src *EndDeviceModel_Dimensions, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "width":
			if len(subs) > 0 {
				return fmt.Errorf("'width' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Width = src.Width
			} else {
				dst.Width = nil
			}
		case "height":
			if len(subs) > 0 {
				return fmt.Errorf("'height' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Height = src.Height
			} else {
				dst.Height = nil
			}
		case "diameter":
			if len(subs) > 0 {
				return fmt.Errorf("'diameter' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Diameter = src.Diameter
			} else {
				dst.Diameter = nil
			}
		case "length":
			if len(subs) > 0 {
				return fmt.Errorf("'length' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Length = src.Length
			} else {
				dst.Length = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *EndDeviceModel_Battery) SetFields(src *EndDeviceModel_Battery, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "replaceable":
			if len(subs) > 0 {
				return fmt.Errorf("'replaceable' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Replaceable = src.Replaceable
			} else {
				dst.Replaceable = nil
			}
		case "type":
			if len(subs) > 0 {
				return fmt.Errorf("'type' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Type = src.Type
			} else {
				var zero string
				dst.Type = zero
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *EndDeviceModel_OperatingConditions) SetFields(src *EndDeviceModel_OperatingConditions, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "temperature":
			if len(subs) > 0 {
				var newDst, newSrc *EndDeviceModel_OperatingConditions_Limits
				if (src == nil || src.Temperature == nil) && dst.Temperature == nil {
					continue
				}
				if src != nil {
					newSrc = src.Temperature
				}
				if dst.Temperature != nil {
					newDst = dst.Temperature
				} else {
					newDst = &EndDeviceModel_OperatingConditions_Limits{}
					dst.Temperature = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Temperature = src.Temperature
				} else {
					dst.Temperature = nil
				}
			}
		case "relative_humidity":
			if len(subs) > 0 {
				var newDst, newSrc *EndDeviceModel_OperatingConditions_Limits
				if (src == nil || src.RelativeHumidity == nil) && dst.RelativeHumidity == nil {
					continue
				}
				if src != nil {
					newSrc = src.RelativeHumidity
				}
				if dst.RelativeHumidity != nil {
					newDst = dst.RelativeHumidity
				} else {
					newDst = &EndDeviceModel_OperatingConditions_Limits{}
					dst.RelativeHumidity = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.RelativeHumidity = src.RelativeHumidity
				} else {
					dst.RelativeHumidity = nil
				}
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *EndDeviceModel_Photos) SetFields(src *EndDeviceModel_Photos, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "main":
			if len(subs) > 0 {
				return fmt.Errorf("'main' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Main = src.Main
			} else {
				var zero string
				dst.Main = zero
			}
		case "other":
			if len(subs) > 0 {
				return fmt.Errorf("'other' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Other = src.Other
			} else {
				dst.Other = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *EndDeviceModel_Videos) SetFields(src *EndDeviceModel_Videos, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "main":
			if len(subs) > 0 {
				return fmt.Errorf("'main' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Main = src.Main
			} else {
				var zero string
				dst.Main = zero
			}
		case "other":
			if len(subs) > 0 {
				return fmt.Errorf("'other' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Other = src.Other
			} else {
				dst.Other = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *EndDeviceModel_Reseller) SetFields(src *EndDeviceModel_Reseller, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "name":
			if len(subs) > 0 {
				return fmt.Errorf("'name' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Name = src.Name
			} else {
				var zero string
				dst.Name = zero
			}
		case "region":
			if len(subs) > 0 {
				return fmt.Errorf("'region' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Region = src.Region
			} else {
				dst.Region = nil
			}
		case "url":
			if len(subs) > 0 {
				return fmt.Errorf("'url' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Url = src.Url
			} else {
				var zero string
				dst.Url = zero
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *EndDeviceModel_Compliances) SetFields(src *EndDeviceModel_Compliances, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "safety":
			if len(subs) > 0 {
				return fmt.Errorf("'safety' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Safety = src.Safety
			} else {
				dst.Safety = nil
			}
		case "radio_equipment":
			if len(subs) > 0 {
				return fmt.Errorf("'radio_equipment' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.RadioEquipment = src.RadioEquipment
			} else {
				dst.RadioEquipment = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *EndDeviceModel_FirmwareVersion_Profile) SetFields(src *EndDeviceModel_FirmwareVersion_Profile, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "vendor_id":
			if len(subs) > 0 {
				return fmt.Errorf("'vendor_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.VendorId = src.VendorId
			} else {
				var zero string
				dst.VendorId = zero
			}
		case "profile_id":
			if len(subs) > 0 {
				return fmt.Errorf("'profile_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ProfileId = src.ProfileId
			} else {
				var zero string
				dst.ProfileId = zero
			}
		case "lorawan_certified":
			if len(subs) > 0 {
				return fmt.Errorf("'lorawan_certified' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LorawanCertified = src.LorawanCertified
			} else {
				var zero bool
				dst.LorawanCertified = zero
			}
		case "codec_id":
			if len(subs) > 0 {
				return fmt.Errorf("'codec_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.CodecId = src.CodecId
			} else {
				var zero string
				dst.CodecId = zero
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *EndDeviceModel_OperatingConditions_Limits) SetFields(src *EndDeviceModel_OperatingConditions_Limits, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "min":
			if len(subs) > 0 {
				return fmt.Errorf("'min' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Min = src.Min
			} else {
				dst.Min = nil
			}
		case "max":
			if len(subs) > 0 {
				return fmt.Errorf("'max' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Max = src.Max
			} else {
				dst.Max = nil
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *EndDeviceModel_Compliances_Compliance) SetFields(src *EndDeviceModel_Compliances_Compliance, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "body":
			if len(subs) > 0 {
				return fmt.Errorf("'body' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Body = src.Body
			} else {
				var zero string
				dst.Body = zero
			}
		case "norm":
			if len(subs) > 0 {
				return fmt.Errorf("'norm' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Norm = src.Norm
			} else {
				var zero string
				dst.Norm = zero
			}
		case "standard":
			if len(subs) > 0 {
				return fmt.Errorf("'standard' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Standard = src.Standard
			} else {
				var zero string
				dst.Standard = zero
			}
		case "version":
			if len(subs) > 0 {
				return fmt.Errorf("'version' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Version = src.Version
			} else {
				var zero string
				dst.Version = zero
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *GetTemplateRequest_EndDeviceProfileIdentifiers) SetFields(src *GetTemplateRequest_EndDeviceProfileIdentifiers, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "vendor_id":
			if len(subs) > 0 {
				return fmt.Errorf("'vendor_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.VendorId = src.VendorId
			} else {
				var zero uint32
				dst.VendorId = zero
			}
		case "vendor_profile_id":
			if len(subs) > 0 {
				return fmt.Errorf("'vendor_profile_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.VendorProfileId = src.VendorProfileId
			} else {
				var zero uint32
				dst.VendorProfileId = zero
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *MessagePayloadDecoder_Example) SetFields(src *MessagePayloadDecoder_Example, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "description":
			if len(subs) > 0 {
				return fmt.Errorf("'description' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Description = src.Description
			} else {
				var zero string
				dst.Description = zero
			}
		case "input":
			if len(subs) > 0 {
				var newDst, newSrc *EncodedMessagePayload
				if (src == nil || src.Input == nil) && dst.Input == nil {
					continue
				}
				if src != nil {
					newSrc = src.Input
				}
				if dst.Input != nil {
					newDst = dst.Input
				} else {
					newDst = &EncodedMessagePayload{}
					dst.Input = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Input = src.Input
				} else {
					dst.Input = nil
				}
			}
		case "output":
			if len(subs) > 0 {
				var newDst, newSrc *DecodedMessagePayload
				if (src == nil || src.Output == nil) && dst.Output == nil {
					continue
				}
				if src != nil {
					newSrc = src.Output
				}
				if dst.Output != nil {
					newDst = dst.Output
				} else {
					newDst = &DecodedMessagePayload{}
					dst.Output = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Output = src.Output
				} else {
					dst.Output = nil
				}
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}

func (dst *MessagePayloadEncoder_Example) SetFields(src *MessagePayloadEncoder_Example, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "description":
			if len(subs) > 0 {
				return fmt.Errorf("'description' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Description = src.Description
			} else {
				var zero string
				dst.Description = zero
			}
		case "input":
			if len(subs) > 0 {
				var newDst, newSrc *DecodedMessagePayload
				if (src == nil || src.Input == nil) && dst.Input == nil {
					continue
				}
				if src != nil {
					newSrc = src.Input
				}
				if dst.Input != nil {
					newDst = dst.Input
				} else {
					newDst = &DecodedMessagePayload{}
					dst.Input = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Input = src.Input
				} else {
					dst.Input = nil
				}
			}
		case "output":
			if len(subs) > 0 {
				var newDst, newSrc *EncodedMessagePayload
				if (src == nil || src.Output == nil) && dst.Output == nil {
					continue
				}
				if src != nil {
					newSrc = src.Output
				}
				if dst.Output != nil {
					newDst = dst.Output
				} else {
					newDst = &EncodedMessagePayload{}
					dst.Output = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Output = src.Output
				} else {
					dst.Output = nil
				}
			}

		default:
			return fmt.Errorf("invalid field: '%s'", name)
		}
	}
	return nil
}