end_device.pb.setters.fm.go

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

package ttnpb

import fmt "fmt"

func (dst *Session) SetFields(src *Session, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "dev_addr":
			if len(subs) > 0 {
				return fmt.Errorf("'dev_addr' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.DevAddr = src.DevAddr
			} else {
				dst.DevAddr = nil
			}
		case "keys":
			if len(subs) > 0 {
				var newDst, newSrc *SessionKeys
				if (src == nil || src.Keys == nil) && dst.Keys == nil {
					continue
				}
				if src != nil {
					newSrc = src.Keys
				}
				if dst.Keys != nil {
					newDst = dst.Keys
				} else {
					newDst = &SessionKeys{}
					dst.Keys = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Keys = src.Keys
				} else {
					dst.Keys = nil
				}
			}
		case "last_f_cnt_up":
			if len(subs) > 0 {
				return fmt.Errorf("'last_f_cnt_up' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LastFCntUp = src.LastFCntUp
			} else {
				var zero uint32
				dst.LastFCntUp = zero
			}
		case "last_n_f_cnt_down":
			if len(subs) > 0 {
				return fmt.Errorf("'last_n_f_cnt_down' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LastNFCntDown = src.LastNFCntDown
			} else {
				var zero uint32
				dst.LastNFCntDown = zero
			}
		case "last_a_f_cnt_down":
			if len(subs) > 0 {
				return fmt.Errorf("'last_a_f_cnt_down' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LastAFCntDown = src.LastAFCntDown
			} else {
				var zero uint32
				dst.LastAFCntDown = zero
			}
		case "last_conf_f_cnt_down":
			if len(subs) > 0 {
				return fmt.Errorf("'last_conf_f_cnt_down' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LastConfFCntDown = src.LastConfFCntDown
			} else {
				var zero uint32
				dst.LastConfFCntDown = zero
			}
		case "started_at":
			if len(subs) > 0 {
				return fmt.Errorf("'started_at' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.StartedAt = src.StartedAt
			} else {
				dst.StartedAt = nil
			}
		case "queued_application_downlinks":
			if len(subs) > 0 {
				return fmt.Errorf("'queued_application_downlinks' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.QueuedApplicationDownlinks = src.QueuedApplicationDownlinks
			} else {
				dst.QueuedApplicationDownlinks = nil
			}

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

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

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

func (dst *MACParameters) SetFields(src *MACParameters, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "max_eirp":
			if len(subs) > 0 {
				return fmt.Errorf("'max_eirp' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.MaxEirp = src.MaxEirp
			} else {
				var zero float32
				dst.MaxEirp = zero
			}
		case "adr_data_rate_index":
			if len(subs) > 0 {
				return fmt.Errorf("'adr_data_rate_index' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.AdrDataRateIndex = src.AdrDataRateIndex
			} else {
				dst.AdrDataRateIndex = 0
			}
		case "adr_tx_power_index":
			if len(subs) > 0 {
				return fmt.Errorf("'adr_tx_power_index' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.AdrTxPowerIndex = src.AdrTxPowerIndex
			} else {
				var zero uint32
				dst.AdrTxPowerIndex = zero
			}
		case "adr_nb_trans":
			if len(subs) > 0 {
				return fmt.Errorf("'adr_nb_trans' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.AdrNbTrans = src.AdrNbTrans
			} else {
				var zero uint32
				dst.AdrNbTrans = zero
			}
		case "adr_ack_limit":
			if len(subs) > 0 {
				return fmt.Errorf("'adr_ack_limit' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.AdrAckLimit = src.AdrAckLimit
			} else {
				var zero uint32
				dst.AdrAckLimit = zero
			}
		case "adr_ack_delay":
			if len(subs) > 0 {
				return fmt.Errorf("'adr_ack_delay' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.AdrAckDelay = src.AdrAckDelay
			} else {
				var zero uint32
				dst.AdrAckDelay = zero
			}
		case "rx1_delay":
			if len(subs) > 0 {
				return fmt.Errorf("'rx1_delay' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Rx1Delay = src.Rx1Delay
			} else {
				dst.Rx1Delay = 0
			}
		case "rx1_data_rate_offset":
			if len(subs) > 0 {
				return fmt.Errorf("'rx1_data_rate_offset' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Rx1DataRateOffset = src.Rx1DataRateOffset
			} else {
				dst.Rx1DataRateOffset = 0
			}
		case "rx2_data_rate_index":
			if len(subs) > 0 {
				return fmt.Errorf("'rx2_data_rate_index' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Rx2DataRateIndex = src.Rx2DataRateIndex
			} else {
				dst.Rx2DataRateIndex = 0
			}
		case "rx2_frequency":
			if len(subs) > 0 {
				return fmt.Errorf("'rx2_frequency' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Rx2Frequency = src.Rx2Frequency
			} else {
				var zero uint64
				dst.Rx2Frequency = zero
			}
		case "max_duty_cycle":
			if len(subs) > 0 {
				return fmt.Errorf("'max_duty_cycle' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.MaxDutyCycle = src.MaxDutyCycle
			} else {
				dst.MaxDutyCycle = 0
			}
		case "rejoin_time_periodicity":
			if len(subs) > 0 {
				return fmt.Errorf("'rejoin_time_periodicity' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.RejoinTimePeriodicity = src.RejoinTimePeriodicity
			} else {
				dst.RejoinTimePeriodicity = 0
			}
		case "rejoin_count_periodicity":
			if len(subs) > 0 {
				return fmt.Errorf("'rejoin_count_periodicity' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.RejoinCountPeriodicity = src.RejoinCountPeriodicity
			} else {
				dst.RejoinCountPeriodicity = 0
			}
		case "ping_slot_frequency":
			if len(subs) > 0 {
				return fmt.Errorf("'ping_slot_frequency' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.PingSlotFrequency = src.PingSlotFrequency
			} else {
				var zero uint64
				dst.PingSlotFrequency = zero
			}
		case "ping_slot_data_rate_index":
			if len(subs) > 0 {
				return fmt.Errorf("'ping_slot_data_rate_index' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.PingSlotDataRateIndex = src.PingSlotDataRateIndex
			} else {
				dst.PingSlotDataRateIndex = 0
			}
		case "beacon_frequency":
			if len(subs) > 0 {
				return fmt.Errorf("'beacon_frequency' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.BeaconFrequency = src.BeaconFrequency
			} else {
				var zero uint64
				dst.BeaconFrequency = zero
			}
		case "channels":
			if len(subs) > 0 {
				return fmt.Errorf("'channels' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Channels = src.Channels
			} else {
				dst.Channels = nil
			}
		case "uplink_dwell_time":
			if len(subs) > 0 {
				var newDst, newSrc *BoolValue
				if (src == nil || src.UplinkDwellTime == nil) && dst.UplinkDwellTime == nil {
					continue
				}
				if src != nil {
					newSrc = src.UplinkDwellTime
				}
				if dst.UplinkDwellTime != nil {
					newDst = dst.UplinkDwellTime
				} else {
					newDst = &BoolValue{}
					dst.UplinkDwellTime = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.UplinkDwellTime = src.UplinkDwellTime
				} else {
					dst.UplinkDwellTime = nil
				}
			}
		case "downlink_dwell_time":
			if len(subs) > 0 {
				var newDst, newSrc *BoolValue
				if (src == nil || src.DownlinkDwellTime == nil) && dst.DownlinkDwellTime == nil {
					continue
				}
				if src != nil {
					newSrc = src.DownlinkDwellTime
				}
				if dst.DownlinkDwellTime != nil {
					newDst = dst.DownlinkDwellTime
				} else {
					newDst = &BoolValue{}
					dst.DownlinkDwellTime = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.DownlinkDwellTime = src.DownlinkDwellTime
				} else {
					dst.DownlinkDwellTime = nil
				}
			}
		case "adr_ack_limit_exponent":
			if len(subs) > 0 {
				var newDst, newSrc *ADRAckLimitExponentValue
				if (src == nil || src.AdrAckLimitExponent == nil) && dst.AdrAckLimitExponent == nil {
					continue
				}
				if src != nil {
					newSrc = src.AdrAckLimitExponent
				}
				if dst.AdrAckLimitExponent != nil {
					newDst = dst.AdrAckLimitExponent
				} else {
					newDst = &ADRAckLimitExponentValue{}
					dst.AdrAckLimitExponent = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.AdrAckLimitExponent = src.AdrAckLimitExponent
				} else {
					dst.AdrAckLimitExponent = nil
				}
			}
		case "adr_ack_delay_exponent":
			if len(subs) > 0 {
				var newDst, newSrc *ADRAckDelayExponentValue
				if (src == nil || src.AdrAckDelayExponent == nil) && dst.AdrAckDelayExponent == nil {
					continue
				}
				if src != nil {
					newSrc = src.AdrAckDelayExponent
				}
				if dst.AdrAckDelayExponent != nil {
					newDst = dst.AdrAckDelayExponent
				} else {
					newDst = &ADRAckDelayExponentValue{}
					dst.AdrAckDelayExponent = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.AdrAckDelayExponent = src.AdrAckDelayExponent
				} else {
					dst.AdrAckDelayExponent = nil
				}
			}
		case "ping_slot_data_rate_index_value":
			if len(subs) > 0 {
				var newDst, newSrc *DataRateIndexValue
				if (src == nil || src.PingSlotDataRateIndexValue == nil) && dst.PingSlotDataRateIndexValue == nil {
					continue
				}
				if src != nil {
					newSrc = src.PingSlotDataRateIndexValue
				}
				if dst.PingSlotDataRateIndexValue != nil {
					newDst = dst.PingSlotDataRateIndexValue
				} else {
					newDst = &DataRateIndexValue{}
					dst.PingSlotDataRateIndexValue = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.PingSlotDataRateIndexValue = src.PingSlotDataRateIndexValue
				} else {
					dst.PingSlotDataRateIndexValue = nil
				}
			}

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

func (dst *EndDeviceVersion) SetFields(src *EndDeviceVersion, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "ids":
			if len(subs) > 0 {
				var newDst, newSrc *EndDeviceVersionIdentifiers
				if (src == nil || src.Ids == nil) && dst.Ids == nil {
					continue
				}
				if src != nil {
					newSrc = src.Ids
				}
				if dst.Ids != nil {
					newDst = dst.Ids
				} else {
					newDst = &EndDeviceVersionIdentifiers{}
					dst.Ids = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Ids = src.Ids
				} else {
					dst.Ids = nil
				}
			}
		case "lorawan_version":
			if len(subs) > 0 {
				return fmt.Errorf("'lorawan_version' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LorawanVersion = src.LorawanVersion
			} else {
				dst.LorawanVersion = 0
			}
		case "lorawan_phy_version":
			if len(subs) > 0 {
				return fmt.Errorf("'lorawan_phy_version' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LorawanPhyVersion = src.LorawanPhyVersion
			} else {
				dst.LorawanPhyVersion = 0
			}
		case "frequency_plan_id":
			if len(subs) > 0 {
				return fmt.Errorf("'frequency_plan_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FrequencyPlanId = src.FrequencyPlanId
			} else {
				var zero string
				dst.FrequencyPlanId = zero
			}
		case "photos":
			if len(subs) > 0 {
				return fmt.Errorf("'photos' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Photos = src.Photos
			} else {
				dst.Photos = nil
			}
		case "supports_class_b":
			if len(subs) > 0 {
				return fmt.Errorf("'supports_class_b' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.SupportsClassB = src.SupportsClassB
			} else {
				var zero bool
				dst.SupportsClassB = zero
			}
		case "supports_class_c":
			if len(subs) > 0 {
				return fmt.Errorf("'supports_class_c' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.SupportsClassC = src.SupportsClassC
			} else {
				var zero bool
				dst.SupportsClassC = zero
			}
		case "default_mac_settings":
			if len(subs) > 0 {
				var newDst, newSrc *MACSettings
				if (src == nil || src.DefaultMacSettings == nil) && dst.DefaultMacSettings == nil {
					continue
				}
				if src != nil {
					newSrc = src.DefaultMacSettings
				}
				if dst.DefaultMacSettings != nil {
					newDst = dst.DefaultMacSettings
				} else {
					newDst = &MACSettings{}
					dst.DefaultMacSettings = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.DefaultMacSettings = src.DefaultMacSettings
				} else {
					dst.DefaultMacSettings = nil
				}
			}
		case "min_frequency":
			if len(subs) > 0 {
				return fmt.Errorf("'min_frequency' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.MinFrequency = src.MinFrequency
			} else {
				var zero uint64
				dst.MinFrequency = zero
			}
		case "max_frequency":
			if len(subs) > 0 {
				return fmt.Errorf("'max_frequency' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.MaxFrequency = src.MaxFrequency
			} else {
				var zero uint64
				dst.MaxFrequency = zero
			}
		case "supports_join":
			if len(subs) > 0 {
				return fmt.Errorf("'supports_join' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.SupportsJoin = src.SupportsJoin
			} else {
				var zero bool
				dst.SupportsJoin = zero
			}
		case "resets_join_nonces":
			if len(subs) > 0 {
				return fmt.Errorf("'resets_join_nonces' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ResetsJoinNonces = src.ResetsJoinNonces
			} else {
				var zero bool
				dst.ResetsJoinNonces = zero
			}
		case "default_formatters":
			if len(subs) > 0 {
				var newDst, newSrc *MessagePayloadFormatters
				if (src == nil || src.DefaultFormatters == nil) && dst.DefaultFormatters == nil {
					continue
				}
				if src != nil {
					newSrc = src.DefaultFormatters
				}
				if dst.DefaultFormatters != nil {
					newDst = dst.DefaultFormatters
				} else {
					newDst = &MessagePayloadFormatters{}
					dst.DefaultFormatters = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.DefaultFormatters = src.DefaultFormatters
				} else {
					dst.DefaultFormatters = nil
				}
			}

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

func (dst *ADRSettings) SetFields(src *ADRSettings, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {

		case "mode":
			if len(subs) == 0 && src == nil {
				dst.Mode = nil
				continue
			} else if len(subs) == 0 {
				dst.Mode = src.Mode
				continue
			}

			subPathMap := _processPaths(subs)
			if len(subPathMap) > 1 {
				return fmt.Errorf("more than one field specified for oneof field '%s'", name)
			}
			for oneofName, oneofSubs := range subPathMap {
				switch oneofName {
				case "static":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Mode.(*ADRSettings_Static)
					}
					if srcValid := srcTypeOk || src == nil || src.Mode == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'static', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Mode.(*ADRSettings_Static)
					if dstValid := dstTypeOk || dst.Mode == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'static', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *ADRSettings_StaticMode
						if srcTypeOk {
							newSrc = src.Mode.(*ADRSettings_Static).Static
						}
						if dstTypeOk {
							newDst = dst.Mode.(*ADRSettings_Static).Static
						} else if srcTypeOk {
							newDst = &ADRSettings_StaticMode{}
							dst.Mode = &ADRSettings_Static{Static: newDst}
						} else {
							dst.Mode = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Mode = src.Mode
						} else {
							dst.Mode = nil
						}
					}
				case "dynamic":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Mode.(*ADRSettings_Dynamic)
					}
					if srcValid := srcTypeOk || src == nil || src.Mode == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'dynamic', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Mode.(*ADRSettings_Dynamic)
					if dstValid := dstTypeOk || dst.Mode == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'dynamic', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *ADRSettings_DynamicMode
						if srcTypeOk {
							newSrc = src.Mode.(*ADRSettings_Dynamic).Dynamic
						}
						if dstTypeOk {
							newDst = dst.Mode.(*ADRSettings_Dynamic).Dynamic
						} else if srcTypeOk {
							newDst = &ADRSettings_DynamicMode{}
							dst.Mode = &ADRSettings_Dynamic{Dynamic: newDst}
						} else {
							dst.Mode = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Mode = src.Mode
						} else {
							dst.Mode = nil
						}
					}
				case "disabled":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Mode.(*ADRSettings_Disabled)
					}
					if srcValid := srcTypeOk || src == nil || src.Mode == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'disabled', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Mode.(*ADRSettings_Disabled)
					if dstValid := dstTypeOk || dst.Mode == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'disabled', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *ADRSettings_DisabledMode
						if srcTypeOk {
							newSrc = src.Mode.(*ADRSettings_Disabled).Disabled
						}
						if dstTypeOk {
							newDst = dst.Mode.(*ADRSettings_Disabled).Disabled
						} else if srcTypeOk {
							newDst = &ADRSettings_DisabledMode{}
							dst.Mode = &ADRSettings_Disabled{Disabled: newDst}
						} else {
							dst.Mode = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Mode = src.Mode
						} else {
							dst.Mode = nil
						}
					}

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

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

func (dst *MACSettings) SetFields(src *MACSettings, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "class_b_timeout":
			if len(subs) > 0 {
				return fmt.Errorf("'class_b_timeout' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ClassBTimeout = src.ClassBTimeout
			} else {
				dst.ClassBTimeout = nil
			}
		case "ping_slot_periodicity":
			if len(subs) > 0 {
				var newDst, newSrc *PingSlotPeriodValue
				if (src == nil || src.PingSlotPeriodicity == nil) && dst.PingSlotPeriodicity == nil {
					continue
				}
				if src != nil {
					newSrc = src.PingSlotPeriodicity
				}
				if dst.PingSlotPeriodicity != nil {
					newDst = dst.PingSlotPeriodicity
				} else {
					newDst = &PingSlotPeriodValue{}
					dst.PingSlotPeriodicity = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.PingSlotPeriodicity = src.PingSlotPeriodicity
				} else {
					dst.PingSlotPeriodicity = nil
				}
			}
		case "ping_slot_data_rate_index":
			if len(subs) > 0 {
				var newDst, newSrc *DataRateIndexValue
				if (src == nil || src.PingSlotDataRateIndex == nil) && dst.PingSlotDataRateIndex == nil {
					continue
				}
				if src != nil {
					newSrc = src.PingSlotDataRateIndex
				}
				if dst.PingSlotDataRateIndex != nil {
					newDst = dst.PingSlotDataRateIndex
				} else {
					newDst = &DataRateIndexValue{}
					dst.PingSlotDataRateIndex = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.PingSlotDataRateIndex = src.PingSlotDataRateIndex
				} else {
					dst.PingSlotDataRateIndex = nil
				}
			}
		case "ping_slot_frequency":
			if len(subs) > 0 {
				var newDst, newSrc *ZeroableFrequencyValue
				if (src == nil || src.PingSlotFrequency == nil) && dst.PingSlotFrequency == nil {
					continue
				}
				if src != nil {
					newSrc = src.PingSlotFrequency
				}
				if dst.PingSlotFrequency != nil {
					newDst = dst.PingSlotFrequency
				} else {
					newDst = &ZeroableFrequencyValue{}
					dst.PingSlotFrequency = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.PingSlotFrequency = src.PingSlotFrequency
				} else {
					dst.PingSlotFrequency = nil
				}
			}
		case "beacon_frequency":
			if len(subs) > 0 {
				var newDst, newSrc *ZeroableFrequencyValue
				if (src == nil || src.BeaconFrequency == nil) && dst.BeaconFrequency == nil {
					continue
				}
				if src != nil {
					newSrc = src.BeaconFrequency
				}
				if dst.BeaconFrequency != nil {
					newDst = dst.BeaconFrequency
				} else {
					newDst = &ZeroableFrequencyValue{}
					dst.BeaconFrequency = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.BeaconFrequency = src.BeaconFrequency
				} else {
					dst.BeaconFrequency = nil
				}
			}
		case "class_c_timeout":
			if len(subs) > 0 {
				return fmt.Errorf("'class_c_timeout' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ClassCTimeout = src.ClassCTimeout
			} else {
				dst.ClassCTimeout = nil
			}
		case "rx1_delay":
			if len(subs) > 0 {
				var newDst, newSrc *RxDelayValue
				if (src == nil || src.Rx1Delay == nil) && dst.Rx1Delay == nil {
					continue
				}
				if src != nil {
					newSrc = src.Rx1Delay
				}
				if dst.Rx1Delay != nil {
					newDst = dst.Rx1Delay
				} else {
					newDst = &RxDelayValue{}
					dst.Rx1Delay = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Rx1Delay = src.Rx1Delay
				} else {
					dst.Rx1Delay = nil
				}
			}
		case "rx1_data_rate_offset":
			if len(subs) > 0 {
				var newDst, newSrc *DataRateOffsetValue
				if (src == nil || src.Rx1DataRateOffset == nil) && dst.Rx1DataRateOffset == nil {
					continue
				}
				if src != nil {
					newSrc = src.Rx1DataRateOffset
				}
				if dst.Rx1DataRateOffset != nil {
					newDst = dst.Rx1DataRateOffset
				} else {
					newDst = &DataRateOffsetValue{}
					dst.Rx1DataRateOffset = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Rx1DataRateOffset = src.Rx1DataRateOffset
				} else {
					dst.Rx1DataRateOffset = nil
				}
			}
		case "rx2_data_rate_index":
			if len(subs) > 0 {
				var newDst, newSrc *DataRateIndexValue
				if (src == nil || src.Rx2DataRateIndex == nil) && dst.Rx2DataRateIndex == nil {
					continue
				}
				if src != nil {
					newSrc = src.Rx2DataRateIndex
				}
				if dst.Rx2DataRateIndex != nil {
					newDst = dst.Rx2DataRateIndex
				} else {
					newDst = &DataRateIndexValue{}
					dst.Rx2DataRateIndex = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Rx2DataRateIndex = src.Rx2DataRateIndex
				} else {
					dst.Rx2DataRateIndex = nil
				}
			}
		case "rx2_frequency":
			if len(subs) > 0 {
				var newDst, newSrc *FrequencyValue
				if (src == nil || src.Rx2Frequency == nil) && dst.Rx2Frequency == nil {
					continue
				}
				if src != nil {
					newSrc = src.Rx2Frequency
				}
				if dst.Rx2Frequency != nil {
					newDst = dst.Rx2Frequency
				} else {
					newDst = &FrequencyValue{}
					dst.Rx2Frequency = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Rx2Frequency = src.Rx2Frequency
				} else {
					dst.Rx2Frequency = nil
				}
			}
		case "factory_preset_frequencies":
			if len(subs) > 0 {
				return fmt.Errorf("'factory_preset_frequencies' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FactoryPresetFrequencies = src.FactoryPresetFrequencies
			} else {
				dst.FactoryPresetFrequencies = nil
			}
		case "max_duty_cycle":
			if len(subs) > 0 {
				var newDst, newSrc *AggregatedDutyCycleValue
				if (src == nil || src.MaxDutyCycle == nil) && dst.MaxDutyCycle == nil {
					continue
				}
				if src != nil {
					newSrc = src.MaxDutyCycle
				}
				if dst.MaxDutyCycle != nil {
					newDst = dst.MaxDutyCycle
				} else {
					newDst = &AggregatedDutyCycleValue{}
					dst.MaxDutyCycle = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.MaxDutyCycle = src.MaxDutyCycle
				} else {
					dst.MaxDutyCycle = nil
				}
			}
		case "supports_32_bit_f_cnt":
			if len(subs) > 0 {
				var newDst, newSrc *BoolValue
				if (src == nil || src.Supports_32BitFCnt == nil) && dst.Supports_32BitFCnt == nil {
					continue
				}
				if src != nil {
					newSrc = src.Supports_32BitFCnt
				}
				if dst.Supports_32BitFCnt != nil {
					newDst = dst.Supports_32BitFCnt
				} else {
					newDst = &BoolValue{}
					dst.Supports_32BitFCnt = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Supports_32BitFCnt = src.Supports_32BitFCnt
				} else {
					dst.Supports_32BitFCnt = nil
				}
			}
		case "use_adr":
			if len(subs) > 0 {
				var newDst, newSrc *BoolValue
				if (src == nil || src.UseAdr == nil) && dst.UseAdr == nil {
					continue
				}
				if src != nil {
					newSrc = src.UseAdr
				}
				if dst.UseAdr != nil {
					newDst = dst.UseAdr
				} else {
					newDst = &BoolValue{}
					dst.UseAdr = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.UseAdr = src.UseAdr
				} else {
					dst.UseAdr = nil
				}
			}
		case "adr_margin":
			if len(subs) > 0 {
				return fmt.Errorf("'adr_margin' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.AdrMargin = src.AdrMargin
			} else {
				dst.AdrMargin = nil
			}
		case "resets_f_cnt":
			if len(subs) > 0 {
				var newDst, newSrc *BoolValue
				if (src == nil || src.ResetsFCnt == nil) && dst.ResetsFCnt == nil {
					continue
				}
				if src != nil {
					newSrc = src.ResetsFCnt
				}
				if dst.ResetsFCnt != nil {
					newDst = dst.ResetsFCnt
				} else {
					newDst = &BoolValue{}
					dst.ResetsFCnt = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.ResetsFCnt = src.ResetsFCnt
				} else {
					dst.ResetsFCnt = nil
				}
			}
		case "status_time_periodicity":
			if len(subs) > 0 {
				return fmt.Errorf("'status_time_periodicity' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.StatusTimePeriodicity = src.StatusTimePeriodicity
			} else {
				dst.StatusTimePeriodicity = nil
			}
		case "status_count_periodicity":
			if len(subs) > 0 {
				return fmt.Errorf("'status_count_periodicity' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.StatusCountPeriodicity = src.StatusCountPeriodicity
			} else {
				dst.StatusCountPeriodicity = nil
			}
		case "desired_rx1_delay":
			if len(subs) > 0 {
				var newDst, newSrc *RxDelayValue
				if (src == nil || src.DesiredRx1Delay == nil) && dst.DesiredRx1Delay == nil {
					continue
				}
				if src != nil {
					newSrc = src.DesiredRx1Delay
				}
				if dst.DesiredRx1Delay != nil {
					newDst = dst.DesiredRx1Delay
				} else {
					newDst = &RxDelayValue{}
					dst.DesiredRx1Delay = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.DesiredRx1Delay = src.DesiredRx1Delay
				} else {
					dst.DesiredRx1Delay = nil
				}
			}
		case "desired_rx1_data_rate_offset":
			if len(subs) > 0 {
				var newDst, newSrc *DataRateOffsetValue
				if (src == nil || src.DesiredRx1DataRateOffset == nil) && dst.DesiredRx1DataRateOffset == nil {
					continue
				}
				if src != nil {
					newSrc = src.DesiredRx1DataRateOffset
				}
				if dst.DesiredRx1DataRateOffset != nil {
					newDst = dst.DesiredRx1DataRateOffset
				} else {
					newDst = &DataRateOffsetValue{}
					dst.DesiredRx1DataRateOffset = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.DesiredRx1DataRateOffset = src.DesiredRx1DataRateOffset
				} else {
					dst.DesiredRx1DataRateOffset = nil
				}
			}
		case "desired_rx2_data_rate_index":
			if len(subs) > 0 {
				var newDst, newSrc *DataRateIndexValue
				if (src == nil || src.DesiredRx2DataRateIndex == nil) && dst.DesiredRx2DataRateIndex == nil {
					continue
				}
				if src != nil {
					newSrc = src.DesiredRx2DataRateIndex
				}
				if dst.DesiredRx2DataRateIndex != nil {
					newDst = dst.DesiredRx2DataRateIndex
				} else {
					newDst = &DataRateIndexValue{}
					dst.DesiredRx2DataRateIndex = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.DesiredRx2DataRateIndex = src.DesiredRx2DataRateIndex
				} else {
					dst.DesiredRx2DataRateIndex = nil
				}
			}
		case "desired_rx2_frequency":
			if len(subs) > 0 {
				var newDst, newSrc *FrequencyValue
				if (src == nil || src.DesiredRx2Frequency == nil) && dst.DesiredRx2Frequency == nil {
					continue
				}
				if src != nil {
					newSrc = src.DesiredRx2Frequency
				}
				if dst.DesiredRx2Frequency != nil {
					newDst = dst.DesiredRx2Frequency
				} else {
					newDst = &FrequencyValue{}
					dst.DesiredRx2Frequency = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.DesiredRx2Frequency = src.DesiredRx2Frequency
				} else {
					dst.DesiredRx2Frequency = nil
				}
			}
		case "desired_max_duty_cycle":
			if len(subs) > 0 {
				var newDst, newSrc *AggregatedDutyCycleValue
				if (src == nil || src.DesiredMaxDutyCycle == nil) && dst.DesiredMaxDutyCycle == nil {
					continue
				}
				if src != nil {
					newSrc = src.DesiredMaxDutyCycle
				}
				if dst.DesiredMaxDutyCycle != nil {
					newDst = dst.DesiredMaxDutyCycle
				} else {
					newDst = &AggregatedDutyCycleValue{}
					dst.DesiredMaxDutyCycle = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.DesiredMaxDutyCycle = src.DesiredMaxDutyCycle
				} else {
					dst.DesiredMaxDutyCycle = nil
				}
			}
		case "desired_adr_ack_limit_exponent":
			if len(subs) > 0 {
				var newDst, newSrc *ADRAckLimitExponentValue
				if (src == nil || src.DesiredAdrAckLimitExponent == nil) && dst.DesiredAdrAckLimitExponent == nil {
					continue
				}
				if src != nil {
					newSrc = src.DesiredAdrAckLimitExponent
				}
				if dst.DesiredAdrAckLimitExponent != nil {
					newDst = dst.DesiredAdrAckLimitExponent
				} else {
					newDst = &ADRAckLimitExponentValue{}
					dst.DesiredAdrAckLimitExponent = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.DesiredAdrAckLimitExponent = src.DesiredAdrAckLimitExponent
				} else {
					dst.DesiredAdrAckLimitExponent = nil
				}
			}
		case "desired_adr_ack_delay_exponent":
			if len(subs) > 0 {
				var newDst, newSrc *ADRAckDelayExponentValue
				if (src == nil || src.DesiredAdrAckDelayExponent == nil) && dst.DesiredAdrAckDelayExponent == nil {
					continue
				}
				if src != nil {
					newSrc = src.DesiredAdrAckDelayExponent
				}
				if dst.DesiredAdrAckDelayExponent != nil {
					newDst = dst.DesiredAdrAckDelayExponent
				} else {
					newDst = &ADRAckDelayExponentValue{}
					dst.DesiredAdrAckDelayExponent = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.DesiredAdrAckDelayExponent = src.DesiredAdrAckDelayExponent
				} else {
					dst.DesiredAdrAckDelayExponent = nil
				}
			}
		case "desired_ping_slot_data_rate_index":
			if len(subs) > 0 {
				var newDst, newSrc *DataRateIndexValue
				if (src == nil || src.DesiredPingSlotDataRateIndex == nil) && dst.DesiredPingSlotDataRateIndex == nil {
					continue
				}
				if src != nil {
					newSrc = src.DesiredPingSlotDataRateIndex
				}
				if dst.DesiredPingSlotDataRateIndex != nil {
					newDst = dst.DesiredPingSlotDataRateIndex
				} else {
					newDst = &DataRateIndexValue{}
					dst.DesiredPingSlotDataRateIndex = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.DesiredPingSlotDataRateIndex = src.DesiredPingSlotDataRateIndex
				} else {
					dst.DesiredPingSlotDataRateIndex = nil
				}
			}
		case "desired_ping_slot_frequency":
			if len(subs) > 0 {
				var newDst, newSrc *ZeroableFrequencyValue
				if (src == nil || src.DesiredPingSlotFrequency == nil) && dst.DesiredPingSlotFrequency == nil {
					continue
				}
				if src != nil {
					newSrc = src.DesiredPingSlotFrequency
				}
				if dst.DesiredPingSlotFrequency != nil {
					newDst = dst.DesiredPingSlotFrequency
				} else {
					newDst = &ZeroableFrequencyValue{}
					dst.DesiredPingSlotFrequency = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.DesiredPingSlotFrequency = src.DesiredPingSlotFrequency
				} else {
					dst.DesiredPingSlotFrequency = nil
				}
			}
		case "desired_beacon_frequency":
			if len(subs) > 0 {
				var newDst, newSrc *ZeroableFrequencyValue
				if (src == nil || src.DesiredBeaconFrequency == nil) && dst.DesiredBeaconFrequency == nil {
					continue
				}
				if src != nil {
					newSrc = src.DesiredBeaconFrequency
				}
				if dst.DesiredBeaconFrequency != nil {
					newDst = dst.DesiredBeaconFrequency
				} else {
					newDst = &ZeroableFrequencyValue{}
					dst.DesiredBeaconFrequency = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.DesiredBeaconFrequency = src.DesiredBeaconFrequency
				} else {
					dst.DesiredBeaconFrequency = nil
				}
			}
		case "desired_max_eirp":
			if len(subs) > 0 {
				var newDst, newSrc *DeviceEIRPValue
				if (src == nil || src.DesiredMaxEirp == nil) && dst.DesiredMaxEirp == nil {
					continue
				}
				if src != nil {
					newSrc = src.DesiredMaxEirp
				}
				if dst.DesiredMaxEirp != nil {
					newDst = dst.DesiredMaxEirp
				} else {
					newDst = &DeviceEIRPValue{}
					dst.DesiredMaxEirp = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.DesiredMaxEirp = src.DesiredMaxEirp
				} else {
					dst.DesiredMaxEirp = nil
				}
			}
		case "class_b_c_downlink_interval":
			if len(subs) > 0 {
				return fmt.Errorf("'class_b_c_downlink_interval' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ClassBCDownlinkInterval = src.ClassBCDownlinkInterval
			} else {
				dst.ClassBCDownlinkInterval = nil
			}
		case "uplink_dwell_time":
			if len(subs) > 0 {
				var newDst, newSrc *BoolValue
				if (src == nil || src.UplinkDwellTime == nil) && dst.UplinkDwellTime == nil {
					continue
				}
				if src != nil {
					newSrc = src.UplinkDwellTime
				}
				if dst.UplinkDwellTime != nil {
					newDst = dst.UplinkDwellTime
				} else {
					newDst = &BoolValue{}
					dst.UplinkDwellTime = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.UplinkDwellTime = src.UplinkDwellTime
				} else {
					dst.UplinkDwellTime = nil
				}
			}
		case "downlink_dwell_time":
			if len(subs) > 0 {
				var newDst, newSrc *BoolValue
				if (src == nil || src.DownlinkDwellTime == nil) && dst.DownlinkDwellTime == nil {
					continue
				}
				if src != nil {
					newSrc = src.DownlinkDwellTime
				}
				if dst.DownlinkDwellTime != nil {
					newDst = dst.DownlinkDwellTime
				} else {
					newDst = &BoolValue{}
					dst.DownlinkDwellTime = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.DownlinkDwellTime = src.DownlinkDwellTime
				} else {
					dst.DownlinkDwellTime = nil
				}
			}
		case "adr":
			if len(subs) > 0 {
				var newDst, newSrc *ADRSettings
				if (src == nil || src.Adr == nil) && dst.Adr == nil {
					continue
				}
				if src != nil {
					newSrc = src.Adr
				}
				if dst.Adr != nil {
					newDst = dst.Adr
				} else {
					newDst = &ADRSettings{}
					dst.Adr = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Adr = src.Adr
				} else {
					dst.Adr = nil
				}
			}
		case "schedule_downlinks":
			if len(subs) > 0 {
				var newDst, newSrc *BoolValue
				if (src == nil || src.ScheduleDownlinks == nil) && dst.ScheduleDownlinks == nil {
					continue
				}
				if src != nil {
					newSrc = src.ScheduleDownlinks
				}
				if dst.ScheduleDownlinks != nil {
					newDst = dst.ScheduleDownlinks
				} else {
					newDst = &BoolValue{}
					dst.ScheduleDownlinks = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.ScheduleDownlinks = src.ScheduleDownlinks
				} else {
					dst.ScheduleDownlinks = nil
				}
			}

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

func (dst *MACState) SetFields(src *MACState, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "current_parameters":
			if len(subs) > 0 {
				var newDst, newSrc *MACParameters
				if (src == nil || src.CurrentParameters == nil) && dst.CurrentParameters == nil {
					continue
				}
				if src != nil {
					newSrc = src.CurrentParameters
				}
				if dst.CurrentParameters != nil {
					newDst = dst.CurrentParameters
				} else {
					newDst = &MACParameters{}
					dst.CurrentParameters = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.CurrentParameters = src.CurrentParameters
				} else {
					dst.CurrentParameters = nil
				}
			}
		case "desired_parameters":
			if len(subs) > 0 {
				var newDst, newSrc *MACParameters
				if (src == nil || src.DesiredParameters == nil) && dst.DesiredParameters == nil {
					continue
				}
				if src != nil {
					newSrc = src.DesiredParameters
				}
				if dst.DesiredParameters != nil {
					newDst = dst.DesiredParameters
				} else {
					newDst = &MACParameters{}
					dst.DesiredParameters = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.DesiredParameters = src.DesiredParameters
				} else {
					dst.DesiredParameters = nil
				}
			}
		case "device_class":
			if len(subs) > 0 {
				return fmt.Errorf("'device_class' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.DeviceClass = src.DeviceClass
			} else {
				dst.DeviceClass = 0
			}
		case "lorawan_version":
			if len(subs) > 0 {
				return fmt.Errorf("'lorawan_version' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LorawanVersion = src.LorawanVersion
			} else {
				dst.LorawanVersion = 0
			}
		case "last_confirmed_downlink_at":
			if len(subs) > 0 {
				return fmt.Errorf("'last_confirmed_downlink_at' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LastConfirmedDownlinkAt = src.LastConfirmedDownlinkAt
			} else {
				dst.LastConfirmedDownlinkAt = nil
			}
		case "last_dev_status_f_cnt_up":
			if len(subs) > 0 {
				return fmt.Errorf("'last_dev_status_f_cnt_up' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LastDevStatusFCntUp = src.LastDevStatusFCntUp
			} else {
				var zero uint32
				dst.LastDevStatusFCntUp = zero
			}
		case "ping_slot_periodicity":
			if len(subs) > 0 {
				var newDst, newSrc *PingSlotPeriodValue
				if (src == nil || src.PingSlotPeriodicity == nil) && dst.PingSlotPeriodicity == nil {
					continue
				}
				if src != nil {
					newSrc = src.PingSlotPeriodicity
				}
				if dst.PingSlotPeriodicity != nil {
					newDst = dst.PingSlotPeriodicity
				} else {
					newDst = &PingSlotPeriodValue{}
					dst.PingSlotPeriodicity = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.PingSlotPeriodicity = src.PingSlotPeriodicity
				} else {
					dst.PingSlotPeriodicity = nil
				}
			}
		case "pending_application_downlink":
			if len(subs) > 0 {
				var newDst, newSrc *ApplicationDownlink
				if (src == nil || src.PendingApplicationDownlink == nil) && dst.PendingApplicationDownlink == nil {
					continue
				}
				if src != nil {
					newSrc = src.PendingApplicationDownlink
				}
				if dst.PendingApplicationDownlink != nil {
					newDst = dst.PendingApplicationDownlink
				} else {
					newDst = &ApplicationDownlink{}
					dst.PendingApplicationDownlink = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.PendingApplicationDownlink = src.PendingApplicationDownlink
				} else {
					dst.PendingApplicationDownlink = nil
				}
			}
		case "queued_responses":
			if len(subs) > 0 {
				return fmt.Errorf("'queued_responses' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.QueuedResponses = src.QueuedResponses
			} else {
				dst.QueuedResponses = nil
			}
		case "pending_requests":
			if len(subs) > 0 {
				return fmt.Errorf("'pending_requests' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.PendingRequests = src.PendingRequests
			} else {
				dst.PendingRequests = nil
			}
		case "queued_join_accept":
			if len(subs) > 0 {
				var newDst, newSrc *MACState_JoinAccept
				if (src == nil || src.QueuedJoinAccept == nil) && dst.QueuedJoinAccept == nil {
					continue
				}
				if src != nil {
					newSrc = src.QueuedJoinAccept
				}
				if dst.QueuedJoinAccept != nil {
					newDst = dst.QueuedJoinAccept
				} else {
					newDst = &MACState_JoinAccept{}
					dst.QueuedJoinAccept = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.QueuedJoinAccept = src.QueuedJoinAccept
				} else {
					dst.QueuedJoinAccept = nil
				}
			}
		case "pending_join_request":
			if len(subs) > 0 {
				var newDst, newSrc *MACState_JoinRequest
				if (src == nil || src.PendingJoinRequest == nil) && dst.PendingJoinRequest == nil {
					continue
				}
				if src != nil {
					newSrc = src.PendingJoinRequest
				}
				if dst.PendingJoinRequest != nil {
					newDst = dst.PendingJoinRequest
				} else {
					newDst = &MACState_JoinRequest{}
					dst.PendingJoinRequest = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.PendingJoinRequest = src.PendingJoinRequest
				} else {
					dst.PendingJoinRequest = nil
				}
			}
		case "rx_windows_available":
			if len(subs) > 0 {
				return fmt.Errorf("'rx_windows_available' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.RxWindowsAvailable = src.RxWindowsAvailable
			} else {
				var zero bool
				dst.RxWindowsAvailable = zero
			}
		case "recent_uplinks":
			if len(subs) > 0 {
				return fmt.Errorf("'recent_uplinks' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.RecentUplinks = src.RecentUplinks
			} else {
				dst.RecentUplinks = nil
			}
		case "recent_downlinks":
			if len(subs) > 0 {
				return fmt.Errorf("'recent_downlinks' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.RecentDownlinks = src.RecentDownlinks
			} else {
				dst.RecentDownlinks = nil
			}
		case "last_network_initiated_downlink_at":
			if len(subs) > 0 {
				return fmt.Errorf("'last_network_initiated_downlink_at' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LastNetworkInitiatedDownlinkAt = src.LastNetworkInitiatedDownlinkAt
			} else {
				dst.LastNetworkInitiatedDownlinkAt = nil
			}
		case "rejected_adr_data_rate_indexes":
			if len(subs) > 0 {
				return fmt.Errorf("'rejected_adr_data_rate_indexes' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.RejectedAdrDataRateIndexes = src.RejectedAdrDataRateIndexes
			} else {
				dst.RejectedAdrDataRateIndexes = nil
			}
		case "rejected_adr_tx_power_indexes":
			if len(subs) > 0 {
				return fmt.Errorf("'rejected_adr_tx_power_indexes' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.RejectedAdrTxPowerIndexes = src.RejectedAdrTxPowerIndexes
			} else {
				dst.RejectedAdrTxPowerIndexes = nil
			}
		case "rejected_frequencies":
			if len(subs) > 0 {
				return fmt.Errorf("'rejected_frequencies' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.RejectedFrequencies = src.RejectedFrequencies
			} else {
				dst.RejectedFrequencies = nil
			}
		case "last_downlink_at":
			if len(subs) > 0 {
				return fmt.Errorf("'last_downlink_at' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LastDownlinkAt = src.LastDownlinkAt
			} else {
				dst.LastDownlinkAt = nil
			}
		case "rejected_data_rate_ranges":
			if len(subs) > 0 {
				return fmt.Errorf("'rejected_data_rate_ranges' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.RejectedDataRateRanges = src.RejectedDataRateRanges
			} else {
				dst.RejectedDataRateRanges = nil
			}
		case "last_adr_change_f_cnt_up":
			if len(subs) > 0 {
				return fmt.Errorf("'last_adr_change_f_cnt_up' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LastAdrChangeFCntUp = src.LastAdrChangeFCntUp
			} else {
				var zero uint32
				dst.LastAdrChangeFCntUp = zero
			}
		case "recent_mac_command_identifiers":
			if len(subs) > 0 {
				return fmt.Errorf("'recent_mac_command_identifiers' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.RecentMacCommandIdentifiers = src.RecentMacCommandIdentifiers
			} else {
				dst.RecentMacCommandIdentifiers = nil
			}

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

func (dst *EndDeviceAuthenticationCode) SetFields(src *EndDeviceAuthenticationCode, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "value":
			if len(subs) > 0 {
				return fmt.Errorf("'value' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Value = src.Value
			} else {
				var zero string
				dst.Value = zero
			}
		case "valid_from":
			if len(subs) > 0 {
				return fmt.Errorf("'valid_from' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ValidFrom = src.ValidFrom
			} else {
				dst.ValidFrom = nil
			}
		case "valid_to":
			if len(subs) > 0 {
				return fmt.Errorf("'valid_to' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ValidTo = src.ValidTo
			} else {
				dst.ValidTo = nil
			}

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

func (dst *EndDevice) SetFields(src *EndDevice, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "ids":
			if len(subs) > 0 {
				var newDst, newSrc *EndDeviceIdentifiers
				if (src == nil || src.Ids == nil) && dst.Ids == nil {
					continue
				}
				if src != nil {
					newSrc = src.Ids
				}
				if dst.Ids != nil {
					newDst = dst.Ids
				} else {
					newDst = &EndDeviceIdentifiers{}
					dst.Ids = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Ids = src.Ids
				} else {
					dst.Ids = nil
				}
			}
		case "created_at":
			if len(subs) > 0 {
				return fmt.Errorf("'created_at' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.CreatedAt = src.CreatedAt
			} else {
				dst.CreatedAt = nil
			}
		case "updated_at":
			if len(subs) > 0 {
				return fmt.Errorf("'updated_at' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.UpdatedAt = src.UpdatedAt
			} else {
				dst.UpdatedAt = nil
			}
		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 "attributes":
			if len(subs) > 0 {
				return fmt.Errorf("'attributes' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Attributes = src.Attributes
			} else {
				dst.Attributes = 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 "service_profile_id":
			if len(subs) > 0 {
				return fmt.Errorf("'service_profile_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ServiceProfileId = src.ServiceProfileId
			} else {
				var zero string
				dst.ServiceProfileId = zero
			}
		case "network_server_address":
			if len(subs) > 0 {
				return fmt.Errorf("'network_server_address' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.NetworkServerAddress = src.NetworkServerAddress
			} else {
				var zero string
				dst.NetworkServerAddress = zero
			}
		case "network_server_kek_label":
			if len(subs) > 0 {
				return fmt.Errorf("'network_server_kek_label' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.NetworkServerKekLabel = src.NetworkServerKekLabel
			} else {
				var zero string
				dst.NetworkServerKekLabel = zero
			}
		case "application_server_address":
			if len(subs) > 0 {
				return fmt.Errorf("'application_server_address' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ApplicationServerAddress = src.ApplicationServerAddress
			} else {
				var zero string
				dst.ApplicationServerAddress = zero
			}
		case "application_server_kek_label":
			if len(subs) > 0 {
				return fmt.Errorf("'application_server_kek_label' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ApplicationServerKekLabel = src.ApplicationServerKekLabel
			} else {
				var zero string
				dst.ApplicationServerKekLabel = zero
			}
		case "application_server_id":
			if len(subs) > 0 {
				return fmt.Errorf("'application_server_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ApplicationServerId = src.ApplicationServerId
			} else {
				var zero string
				dst.ApplicationServerId = zero
			}
		case "join_server_address":
			if len(subs) > 0 {
				return fmt.Errorf("'join_server_address' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.JoinServerAddress = src.JoinServerAddress
			} else {
				var zero string
				dst.JoinServerAddress = zero
			}
		case "locations":
			if len(subs) > 0 {
				return fmt.Errorf("'locations' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Locations = src.Locations
			} else {
				dst.Locations = nil
			}
		case "picture":
			if len(subs) > 0 {
				var newDst, newSrc *Picture
				if (src == nil || src.Picture == nil) && dst.Picture == nil {
					continue
				}
				if src != nil {
					newSrc = src.Picture
				}
				if dst.Picture != nil {
					newDst = dst.Picture
				} else {
					newDst = &Picture{}
					dst.Picture = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Picture = src.Picture
				} else {
					dst.Picture = nil
				}
			}
		case "supports_class_b":
			if len(subs) > 0 {
				return fmt.Errorf("'supports_class_b' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.SupportsClassB = src.SupportsClassB
			} else {
				var zero bool
				dst.SupportsClassB = zero
			}
		case "supports_class_c":
			if len(subs) > 0 {
				return fmt.Errorf("'supports_class_c' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.SupportsClassC = src.SupportsClassC
			} else {
				var zero bool
				dst.SupportsClassC = zero
			}
		case "lorawan_version":
			if len(subs) > 0 {
				return fmt.Errorf("'lorawan_version' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LorawanVersion = src.LorawanVersion
			} else {
				dst.LorawanVersion = 0
			}
		case "lorawan_phy_version":
			if len(subs) > 0 {
				return fmt.Errorf("'lorawan_phy_version' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LorawanPhyVersion = src.LorawanPhyVersion
			} else {
				dst.LorawanPhyVersion = 0
			}
		case "frequency_plan_id":
			if len(subs) > 0 {
				return fmt.Errorf("'frequency_plan_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FrequencyPlanId = src.FrequencyPlanId
			} else {
				var zero string
				dst.FrequencyPlanId = zero
			}
		case "min_frequency":
			if len(subs) > 0 {
				return fmt.Errorf("'min_frequency' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.MinFrequency = src.MinFrequency
			} else {
				var zero uint64
				dst.MinFrequency = zero
			}
		case "max_frequency":
			if len(subs) > 0 {
				return fmt.Errorf("'max_frequency' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.MaxFrequency = src.MaxFrequency
			} else {
				var zero uint64
				dst.MaxFrequency = zero
			}
		case "supports_join":
			if len(subs) > 0 {
				return fmt.Errorf("'supports_join' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.SupportsJoin = src.SupportsJoin
			} else {
				var zero bool
				dst.SupportsJoin = zero
			}
		case "resets_join_nonces":
			if len(subs) > 0 {
				return fmt.Errorf("'resets_join_nonces' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ResetsJoinNonces = src.ResetsJoinNonces
			} else {
				var zero bool
				dst.ResetsJoinNonces = zero
			}
		case "root_keys":
			if len(subs) > 0 {
				var newDst, newSrc *RootKeys
				if (src == nil || src.RootKeys == nil) && dst.RootKeys == nil {
					continue
				}
				if src != nil {
					newSrc = src.RootKeys
				}
				if dst.RootKeys != nil {
					newDst = dst.RootKeys
				} else {
					newDst = &RootKeys{}
					dst.RootKeys = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.RootKeys = src.RootKeys
				} else {
					dst.RootKeys = nil
				}
			}
		case "net_id":
			if len(subs) > 0 {
				return fmt.Errorf("'net_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.NetId = src.NetId
			} else {
				dst.NetId = nil
			}
		case "mac_settings":
			if len(subs) > 0 {
				var newDst, newSrc *MACSettings
				if (src == nil || src.MacSettings == nil) && dst.MacSettings == nil {
					continue
				}
				if src != nil {
					newSrc = src.MacSettings
				}
				if dst.MacSettings != nil {
					newDst = dst.MacSettings
				} else {
					newDst = &MACSettings{}
					dst.MacSettings = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.MacSettings = src.MacSettings
				} else {
					dst.MacSettings = nil
				}
			}
		case "mac_state":
			if len(subs) > 0 {
				var newDst, newSrc *MACState
				if (src == nil || src.MacState == nil) && dst.MacState == nil {
					continue
				}
				if src != nil {
					newSrc = src.MacState
				}
				if dst.MacState != nil {
					newDst = dst.MacState
				} else {
					newDst = &MACState{}
					dst.MacState = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.MacState = src.MacState
				} else {
					dst.MacState = nil
				}
			}
		case "pending_mac_state":
			if len(subs) > 0 {
				var newDst, newSrc *MACState
				if (src == nil || src.PendingMacState == nil) && dst.PendingMacState == nil {
					continue
				}
				if src != nil {
					newSrc = src.PendingMacState
				}
				if dst.PendingMacState != nil {
					newDst = dst.PendingMacState
				} else {
					newDst = &MACState{}
					dst.PendingMacState = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.PendingMacState = src.PendingMacState
				} else {
					dst.PendingMacState = nil
				}
			}
		case "session":
			if len(subs) > 0 {
				var newDst, newSrc *Session
				if (src == nil || src.Session == nil) && dst.Session == nil {
					continue
				}
				if src != nil {
					newSrc = src.Session
				}
				if dst.Session != nil {
					newDst = dst.Session
				} else {
					newDst = &Session{}
					dst.Session = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Session = src.Session
				} else {
					dst.Session = nil
				}
			}
		case "pending_session":
			if len(subs) > 0 {
				var newDst, newSrc *Session
				if (src == nil || src.PendingSession == nil) && dst.PendingSession == nil {
					continue
				}
				if src != nil {
					newSrc = src.PendingSession
				}
				if dst.PendingSession != nil {
					newDst = dst.PendingSession
				} else {
					newDst = &Session{}
					dst.PendingSession = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.PendingSession = src.PendingSession
				} else {
					dst.PendingSession = nil
				}
			}
		case "last_dev_nonce":
			if len(subs) > 0 {
				return fmt.Errorf("'last_dev_nonce' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LastDevNonce = src.LastDevNonce
			} else {
				var zero uint32
				dst.LastDevNonce = zero
			}
		case "used_dev_nonces":
			if len(subs) > 0 {
				return fmt.Errorf("'used_dev_nonces' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.UsedDevNonces = src.UsedDevNonces
			} else {
				dst.UsedDevNonces = nil
			}
		case "last_join_nonce":
			if len(subs) > 0 {
				return fmt.Errorf("'last_join_nonce' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LastJoinNonce = src.LastJoinNonce
			} else {
				var zero uint32
				dst.LastJoinNonce = zero
			}
		case "last_rj_count_0":
			if len(subs) > 0 {
				return fmt.Errorf("'last_rj_count_0' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LastRjCount_0 = src.LastRjCount_0
			} else {
				var zero uint32
				dst.LastRjCount_0 = zero
			}
		case "last_rj_count_1":
			if len(subs) > 0 {
				return fmt.Errorf("'last_rj_count_1' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LastRjCount_1 = src.LastRjCount_1
			} else {
				var zero uint32
				dst.LastRjCount_1 = zero
			}
		case "last_dev_status_received_at":
			if len(subs) > 0 {
				return fmt.Errorf("'last_dev_status_received_at' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LastDevStatusReceivedAt = src.LastDevStatusReceivedAt
			} else {
				dst.LastDevStatusReceivedAt = nil
			}
		case "power_state":
			if len(subs) > 0 {
				return fmt.Errorf("'power_state' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.PowerState = src.PowerState
			} else {
				dst.PowerState = 0
			}
		case "battery_percentage":
			if len(subs) > 0 {
				return fmt.Errorf("'battery_percentage' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.BatteryPercentage = src.BatteryPercentage
			} else {
				dst.BatteryPercentage = nil
			}
		case "downlink_margin":
			if len(subs) > 0 {
				return fmt.Errorf("'downlink_margin' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.DownlinkMargin = src.DownlinkMargin
			} else {
				var zero int32
				dst.DownlinkMargin = zero
			}
		case "queued_application_downlinks":
			if len(subs) > 0 {
				return fmt.Errorf("'queued_application_downlinks' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.QueuedApplicationDownlinks = src.QueuedApplicationDownlinks
			} else {
				dst.QueuedApplicationDownlinks = nil
			}
		case "formatters":
			if len(subs) > 0 {
				var newDst, newSrc *MessagePayloadFormatters
				if (src == nil || src.Formatters == nil) && dst.Formatters == nil {
					continue
				}
				if src != nil {
					newSrc = src.Formatters
				}
				if dst.Formatters != nil {
					newDst = dst.Formatters
				} else {
					newDst = &MessagePayloadFormatters{}
					dst.Formatters = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Formatters = src.Formatters
				} else {
					dst.Formatters = nil
				}
			}
		case "provisioner_id":
			if len(subs) > 0 {
				return fmt.Errorf("'provisioner_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ProvisionerId = src.ProvisionerId
			} else {
				var zero string
				dst.ProvisionerId = zero
			}
		case "provisioning_data":
			if len(subs) > 0 {
				return fmt.Errorf("'provisioning_data' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ProvisioningData = src.ProvisioningData
			} else {
				dst.ProvisioningData = nil
			}
		case "multicast":
			if len(subs) > 0 {
				return fmt.Errorf("'multicast' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Multicast = src.Multicast
			} else {
				var zero bool
				dst.Multicast = zero
			}
		case "claim_authentication_code":
			if len(subs) > 0 {
				var newDst, newSrc *EndDeviceAuthenticationCode
				if (src == nil || src.ClaimAuthenticationCode == nil) && dst.ClaimAuthenticationCode == nil {
					continue
				}
				if src != nil {
					newSrc = src.ClaimAuthenticationCode
				}
				if dst.ClaimAuthenticationCode != nil {
					newDst = dst.ClaimAuthenticationCode
				} else {
					newDst = &EndDeviceAuthenticationCode{}
					dst.ClaimAuthenticationCode = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.ClaimAuthenticationCode = src.ClaimAuthenticationCode
				} else {
					dst.ClaimAuthenticationCode = nil
				}
			}
		case "skip_payload_crypto":
			if len(subs) > 0 {
				return fmt.Errorf("'skip_payload_crypto' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.SkipPayloadCrypto = src.SkipPayloadCrypto
			} else {
				var zero bool
				dst.SkipPayloadCrypto = zero
			}
		case "skip_payload_crypto_override":
			if len(subs) > 0 {
				return fmt.Errorf("'skip_payload_crypto_override' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.SkipPayloadCryptoOverride = src.SkipPayloadCryptoOverride
			} else {
				dst.SkipPayloadCryptoOverride = nil
			}
		case "activated_at":
			if len(subs) > 0 {
				return fmt.Errorf("'activated_at' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ActivatedAt = src.ActivatedAt
			} else {
				dst.ActivatedAt = nil
			}
		case "last_seen_at":
			if len(subs) > 0 {
				return fmt.Errorf("'last_seen_at' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LastSeenAt = src.LastSeenAt
			} else {
				dst.LastSeenAt = nil
			}
		case "serial_number":
			if len(subs) > 0 {
				return fmt.Errorf("'serial_number' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.SerialNumber = src.SerialNumber
			} else {
				var zero string
				dst.SerialNumber = zero
			}
		case "lora_alliance_profile_ids":
			if len(subs) > 0 {
				var newDst, newSrc *LoRaAllianceProfileIdentifiers
				if (src == nil || src.LoraAllianceProfileIds == nil) && dst.LoraAllianceProfileIds == nil {
					continue
				}
				if src != nil {
					newSrc = src.LoraAllianceProfileIds
				}
				if dst.LoraAllianceProfileIds != nil {
					newDst = dst.LoraAllianceProfileIds
				} else {
					newDst = &LoRaAllianceProfileIdentifiers{}
					dst.LoraAllianceProfileIds = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.LoraAllianceProfileIds = src.LoraAllianceProfileIds
				} else {
					dst.LoraAllianceProfileIds = nil
				}
			}

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

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

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

func (dst *DevAddrPrefix) SetFields(src *DevAddrPrefix, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "dev_addr":
			if len(subs) > 0 {
				return fmt.Errorf("'dev_addr' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.DevAddr = src.DevAddr
			} else {
				dst.DevAddr = 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 {
				var zero uint32
				dst.Length = zero
			}

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

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

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

func (dst *UpdateEndDeviceRequest) SetFields(src *UpdateEndDeviceRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "end_device":
			if len(subs) > 0 {
				var newDst, newSrc *EndDevice
				if (src == nil || src.EndDevice == nil) && dst.EndDevice == nil {
					continue
				}
				if src != nil {
					newSrc = src.EndDevice
				}
				if dst.EndDevice != nil {
					newDst = dst.EndDevice
				} else {
					newDst = &EndDevice{}
					dst.EndDevice = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.EndDevice = src.EndDevice
				} else {
					dst.EndDevice = 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 *BatchUpdateEndDeviceLastSeenRequest) SetFields(src *BatchUpdateEndDeviceLastSeenRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "updates":
			if len(subs) > 0 {
				return fmt.Errorf("'updates' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Updates = src.Updates
			} else {
				dst.Updates = nil
			}

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

func (dst *GetEndDeviceRequest) SetFields(src *GetEndDeviceRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "end_device_ids":
			if len(subs) > 0 {
				var newDst, newSrc *EndDeviceIdentifiers
				if (src == nil || src.EndDeviceIds == nil) && dst.EndDeviceIds == nil {
					continue
				}
				if src != nil {
					newSrc = src.EndDeviceIds
				}
				if dst.EndDeviceIds != nil {
					newDst = dst.EndDeviceIds
				} else {
					newDst = &EndDeviceIdentifiers{}
					dst.EndDeviceIds = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.EndDeviceIds = src.EndDeviceIds
				} else {
					dst.EndDeviceIds = 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 *GetEndDeviceIdentifiersForEUIsRequest) SetFields(src *GetEndDeviceIdentifiersForEUIsRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "join_eui":
			if len(subs) > 0 {
				return fmt.Errorf("'join_eui' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.JoinEui = src.JoinEui
			} else {
				dst.JoinEui = nil
			}
		case "dev_eui":
			if len(subs) > 0 {
				return fmt.Errorf("'dev_eui' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.DevEui = src.DevEui
			} else {
				dst.DevEui = nil
			}

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

func (dst *ListEndDevicesRequest) SetFields(src *ListEndDevicesRequest, 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 "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
			}
		case "order":
			if len(subs) > 0 {
				return fmt.Errorf("'order' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Order = src.Order
			} else {
				var zero string
				dst.Order = 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
			}

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

func (dst *SetEndDeviceRequest) SetFields(src *SetEndDeviceRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "end_device":
			if len(subs) > 0 {
				var newDst, newSrc *EndDevice
				if (src == nil || src.EndDevice == nil) && dst.EndDevice == nil {
					continue
				}
				if src != nil {
					newSrc = src.EndDevice
				}
				if dst.EndDevice != nil {
					newDst = dst.EndDevice
				} else {
					newDst = &EndDevice{}
					dst.EndDevice = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.EndDevice = src.EndDevice
				} else {
					dst.EndDevice = 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 *ResetAndGetEndDeviceRequest) SetFields(src *ResetAndGetEndDeviceRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "end_device_ids":
			if len(subs) > 0 {
				var newDst, newSrc *EndDeviceIdentifiers
				if (src == nil || src.EndDeviceIds == nil) && dst.EndDeviceIds == nil {
					continue
				}
				if src != nil {
					newSrc = src.EndDeviceIds
				}
				if dst.EndDeviceIds != nil {
					newDst = dst.EndDeviceIds
				} else {
					newDst = &EndDeviceIdentifiers{}
					dst.EndDeviceIds = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.EndDeviceIds = src.EndDeviceIds
				} else {
					dst.EndDeviceIds = 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 *EndDeviceTemplate) SetFields(src *EndDeviceTemplate, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "end_device":
			if len(subs) > 0 {
				var newDst, newSrc *EndDevice
				if (src == nil || src.EndDevice == nil) && dst.EndDevice == nil {
					continue
				}
				if src != nil {
					newSrc = src.EndDevice
				}
				if dst.EndDevice != nil {
					newDst = dst.EndDevice
				} else {
					newDst = &EndDevice{}
					dst.EndDevice = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.EndDevice = src.EndDevice
				} else {
					dst.EndDevice = 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
			}
		case "mapping_key":
			if len(subs) > 0 {
				return fmt.Errorf("'mapping_key' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.MappingKey = src.MappingKey
			} else {
				var zero string
				dst.MappingKey = zero
			}

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

func (dst *EndDeviceTemplateFormat) SetFields(src *EndDeviceTemplateFormat, 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 "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 "file_extensions":
			if len(subs) > 0 {
				return fmt.Errorf("'file_extensions' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FileExtensions = src.FileExtensions
			} else {
				dst.FileExtensions = nil
			}

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

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

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

func (dst *ConvertEndDeviceTemplateRequest) SetFields(src *ConvertEndDeviceTemplateRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "format_id":
			if len(subs) > 0 {
				return fmt.Errorf("'format_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FormatId = src.FormatId
			} else {
				var zero string
				dst.FormatId = zero
			}
		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 "end_device_version_ids":
			if len(subs) > 0 {
				var newDst, newSrc *EndDeviceVersionIdentifiers
				if (src == nil || src.EndDeviceVersionIds == nil) && dst.EndDeviceVersionIds == nil {
					continue
				}
				if src != nil {
					newSrc = src.EndDeviceVersionIds
				}
				if dst.EndDeviceVersionIds != nil {
					newDst = dst.EndDeviceVersionIds
				} else {
					newDst = &EndDeviceVersionIdentifiers{}
					dst.EndDeviceVersionIds = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.EndDeviceVersionIds = src.EndDeviceVersionIds
				} else {
					dst.EndDeviceVersionIds = nil
				}
			}

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

func (dst *MACParameters_Channel) SetFields(src *MACParameters_Channel, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "uplink_frequency":
			if len(subs) > 0 {
				return fmt.Errorf("'uplink_frequency' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.UplinkFrequency = src.UplinkFrequency
			} else {
				var zero uint64
				dst.UplinkFrequency = zero
			}
		case "downlink_frequency":
			if len(subs) > 0 {
				return fmt.Errorf("'downlink_frequency' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.DownlinkFrequency = src.DownlinkFrequency
			} else {
				var zero uint64
				dst.DownlinkFrequency = zero
			}
		case "min_data_rate_index":
			if len(subs) > 0 {
				return fmt.Errorf("'min_data_rate_index' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.MinDataRateIndex = src.MinDataRateIndex
			} else {
				dst.MinDataRateIndex = 0
			}
		case "max_data_rate_index":
			if len(subs) > 0 {
				return fmt.Errorf("'max_data_rate_index' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.MaxDataRateIndex = src.MaxDataRateIndex
			} else {
				dst.MaxDataRateIndex = 0
			}
		case "enable_uplink":
			if len(subs) > 0 {
				return fmt.Errorf("'enable_uplink' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.EnableUplink = src.EnableUplink
			} else {
				var zero bool
				dst.EnableUplink = zero
			}

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

func (dst *ADRSettings_StaticMode) SetFields(src *ADRSettings_StaticMode, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "data_rate_index":
			if len(subs) > 0 {
				return fmt.Errorf("'data_rate_index' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.DataRateIndex = src.DataRateIndex
			} else {
				dst.DataRateIndex = 0
			}
		case "tx_power_index":
			if len(subs) > 0 {
				return fmt.Errorf("'tx_power_index' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.TxPowerIndex = src.TxPowerIndex
			} else {
				var zero uint32
				dst.TxPowerIndex = zero
			}
		case "nb_trans":
			if len(subs) > 0 {
				return fmt.Errorf("'nb_trans' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.NbTrans = src.NbTrans
			} else {
				var zero uint32
				dst.NbTrans = zero
			}

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

func (dst *ADRSettings_DynamicMode) SetFields(src *ADRSettings_DynamicMode, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "margin":
			if len(subs) > 0 {
				return fmt.Errorf("'margin' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Margin = src.Margin
			} else {
				dst.Margin = nil
			}
		case "min_data_rate_index":
			if len(subs) > 0 {
				var newDst, newSrc *DataRateIndexValue
				if (src == nil || src.MinDataRateIndex == nil) && dst.MinDataRateIndex == nil {
					continue
				}
				if src != nil {
					newSrc = src.MinDataRateIndex
				}
				if dst.MinDataRateIndex != nil {
					newDst = dst.MinDataRateIndex
				} else {
					newDst = &DataRateIndexValue{}
					dst.MinDataRateIndex = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.MinDataRateIndex = src.MinDataRateIndex
				} else {
					dst.MinDataRateIndex = nil
				}
			}
		case "max_data_rate_index":
			if len(subs) > 0 {
				var newDst, newSrc *DataRateIndexValue
				if (src == nil || src.MaxDataRateIndex == nil) && dst.MaxDataRateIndex == nil {
					continue
				}
				if src != nil {
					newSrc = src.MaxDataRateIndex
				}
				if dst.MaxDataRateIndex != nil {
					newDst = dst.MaxDataRateIndex
				} else {
					newDst = &DataRateIndexValue{}
					dst.MaxDataRateIndex = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.MaxDataRateIndex = src.MaxDataRateIndex
				} else {
					dst.MaxDataRateIndex = nil
				}
			}
		case "min_tx_power_index":
			if len(subs) > 0 {
				return fmt.Errorf("'min_tx_power_index' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.MinTxPowerIndex = src.MinTxPowerIndex
			} else {
				dst.MinTxPowerIndex = nil
			}
		case "max_tx_power_index":
			if len(subs) > 0 {
				return fmt.Errorf("'max_tx_power_index' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.MaxTxPowerIndex = src.MaxTxPowerIndex
			} else {
				dst.MaxTxPowerIndex = nil
			}
		case "min_nb_trans":
			if len(subs) > 0 {
				return fmt.Errorf("'min_nb_trans' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.MinNbTrans = src.MinNbTrans
			} else {
				dst.MinNbTrans = nil
			}
		case "max_nb_trans":
			if len(subs) > 0 {
				return fmt.Errorf("'max_nb_trans' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.MaxNbTrans = src.MaxNbTrans
			} else {
				dst.MaxNbTrans = nil
			}
		case "channel_steering":
			if len(subs) > 0 {
				var newDst, newSrc *ADRSettings_DynamicMode_ChannelSteeringSettings
				if (src == nil || src.ChannelSteering == nil) && dst.ChannelSteering == nil {
					continue
				}
				if src != nil {
					newSrc = src.ChannelSteering
				}
				if dst.ChannelSteering != nil {
					newDst = dst.ChannelSteering
				} else {
					newDst = &ADRSettings_DynamicMode_ChannelSteeringSettings{}
					dst.ChannelSteering = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.ChannelSteering = src.ChannelSteering
				} else {
					dst.ChannelSteering = nil
				}
			}

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

func (dst *ADRSettings_DisabledMode) SetFields(src *ADRSettings_DisabledMode, paths ...string) error {
	if len(paths) != 0 {
		return fmt.Errorf("message ADRSettings_DisabledMode has no fields, but paths %s were specified", paths)
	}
	return nil
}

func (dst *ADRSettings_DynamicMode_ChannelSteeringSettings) SetFields(src *ADRSettings_DynamicMode_ChannelSteeringSettings, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {

		case "mode":
			if len(subs) == 0 && src == nil {
				dst.Mode = nil
				continue
			} else if len(subs) == 0 {
				dst.Mode = src.Mode
				continue
			}

			subPathMap := _processPaths(subs)
			if len(subPathMap) > 1 {
				return fmt.Errorf("more than one field specified for oneof field '%s'", name)
			}
			for oneofName, oneofSubs := range subPathMap {
				switch oneofName {
				case "lora_narrow":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Mode.(*ADRSettings_DynamicMode_ChannelSteeringSettings_LoraNarrow)
					}
					if srcValid := srcTypeOk || src == nil || src.Mode == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'lora_narrow', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Mode.(*ADRSettings_DynamicMode_ChannelSteeringSettings_LoraNarrow)
					if dstValid := dstTypeOk || dst.Mode == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'lora_narrow', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *ADRSettings_DynamicMode_ChannelSteeringSettings_LoRaNarrowMode
						if srcTypeOk {
							newSrc = src.Mode.(*ADRSettings_DynamicMode_ChannelSteeringSettings_LoraNarrow).LoraNarrow
						}
						if dstTypeOk {
							newDst = dst.Mode.(*ADRSettings_DynamicMode_ChannelSteeringSettings_LoraNarrow).LoraNarrow
						} else if srcTypeOk {
							newDst = &ADRSettings_DynamicMode_ChannelSteeringSettings_LoRaNarrowMode{}
							dst.Mode = &ADRSettings_DynamicMode_ChannelSteeringSettings_LoraNarrow{LoraNarrow: newDst}
						} else {
							dst.Mode = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Mode = src.Mode
						} else {
							dst.Mode = nil
						}
					}
				case "disabled":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Mode.(*ADRSettings_DynamicMode_ChannelSteeringSettings_Disabled)
					}
					if srcValid := srcTypeOk || src == nil || src.Mode == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'disabled', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Mode.(*ADRSettings_DynamicMode_ChannelSteeringSettings_Disabled)
					if dstValid := dstTypeOk || dst.Mode == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'disabled', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *ADRSettings_DynamicMode_ChannelSteeringSettings_DisabledMode
						if srcTypeOk {
							newSrc = src.Mode.(*ADRSettings_DynamicMode_ChannelSteeringSettings_Disabled).Disabled
						}
						if dstTypeOk {
							newDst = dst.Mode.(*ADRSettings_DynamicMode_ChannelSteeringSettings_Disabled).Disabled
						} else if srcTypeOk {
							newDst = &ADRSettings_DynamicMode_ChannelSteeringSettings_DisabledMode{}
							dst.Mode = &ADRSettings_DynamicMode_ChannelSteeringSettings_Disabled{Disabled: newDst}
						} else {
							dst.Mode = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Mode = src.Mode
						} else {
							dst.Mode = nil
						}
					}

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

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

func (dst *ADRSettings_DynamicMode_ChannelSteeringSettings_LoRaNarrowMode) SetFields(src *ADRSettings_DynamicMode_ChannelSteeringSettings_LoRaNarrowMode, paths ...string) error {
	if len(paths) != 0 {
		return fmt.Errorf("message ADRSettings_DynamicMode_ChannelSteeringSettings_LoRaNarrowMode has no fields, but paths %s were specified", paths)
	}
	return nil
}

func (dst *ADRSettings_DynamicMode_ChannelSteeringSettings_DisabledMode) SetFields(src *ADRSettings_DynamicMode_ChannelSteeringSettings_DisabledMode, paths ...string) error {
	if len(paths) != 0 {
		return fmt.Errorf("message ADRSettings_DynamicMode_ChannelSteeringSettings_DisabledMode has no fields, but paths %s were specified", paths)
	}
	return nil
}

func (dst *MACState_JoinRequest) SetFields(src *MACState_JoinRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "downlink_settings":
			if len(subs) > 0 {
				var newDst, newSrc *DLSettings
				if (src == nil || src.DownlinkSettings == nil) && dst.DownlinkSettings == nil {
					continue
				}
				if src != nil {
					newSrc = src.DownlinkSettings
				}
				if dst.DownlinkSettings != nil {
					newDst = dst.DownlinkSettings
				} else {
					newDst = &DLSettings{}
					dst.DownlinkSettings = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.DownlinkSettings = src.DownlinkSettings
				} else {
					dst.DownlinkSettings = nil
				}
			}
		case "rx_delay":
			if len(subs) > 0 {
				return fmt.Errorf("'rx_delay' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.RxDelay = src.RxDelay
			} else {
				dst.RxDelay = 0
			}
		case "cf_list":
			if len(subs) > 0 {
				var newDst, newSrc *CFList
				if (src == nil || src.CfList == nil) && dst.CfList == nil {
					continue
				}
				if src != nil {
					newSrc = src.CfList
				}
				if dst.CfList != nil {
					newDst = dst.CfList
				} else {
					newDst = &CFList{}
					dst.CfList = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.CfList = src.CfList
				} else {
					dst.CfList = nil
				}
			}

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

func (dst *MACState_JoinAccept) SetFields(src *MACState_JoinAccept, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "payload":
			if len(subs) > 0 {
				return fmt.Errorf("'payload' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Payload = src.Payload
			} else {
				dst.Payload = nil
			}
		case "request":
			if len(subs) > 0 {
				var newDst, newSrc *MACState_JoinRequest
				if (src == nil || src.Request == nil) && dst.Request == nil {
					continue
				}
				if src != nil {
					newSrc = src.Request
				}
				if dst.Request != nil {
					newDst = dst.Request
				} else {
					newDst = &MACState_JoinRequest{}
					dst.Request = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Request = src.Request
				} else {
					dst.Request = nil
				}
			}
		case "keys":
			if len(subs) > 0 {
				var newDst, newSrc *SessionKeys
				if (src == nil || src.Keys == nil) && dst.Keys == nil {
					continue
				}
				if src != nil {
					newSrc = src.Keys
				}
				if dst.Keys != nil {
					newDst = dst.Keys
				} else {
					newDst = &SessionKeys{}
					dst.Keys = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Keys = src.Keys
				} else {
					dst.Keys = nil
				}
			}
		case "correlation_ids":
			if len(subs) > 0 {
				return fmt.Errorf("'correlation_ids' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.CorrelationIds = src.CorrelationIds
			} else {
				dst.CorrelationIds = nil
			}
		case "dev_addr":
			if len(subs) > 0 {
				return fmt.Errorf("'dev_addr' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.DevAddr = src.DevAddr
			} else {
				dst.DevAddr = nil
			}
		case "net_id":
			if len(subs) > 0 {
				return fmt.Errorf("'net_id' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.NetId = src.NetId
			} else {
				dst.NetId = nil
			}

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

func (dst *MACState_UplinkMessage) SetFields(src *MACState_UplinkMessage, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "payload":
			if len(subs) > 0 {
				var newDst, newSrc *Message
				if (src == nil || src.Payload == nil) && dst.Payload == nil {
					continue
				}
				if src != nil {
					newSrc = src.Payload
				}
				if dst.Payload != nil {
					newDst = dst.Payload
				} else {
					newDst = &Message{}
					dst.Payload = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Payload = src.Payload
				} else {
					dst.Payload = nil
				}
			}
		case "settings":
			if len(subs) > 0 {
				var newDst, newSrc *MACState_UplinkMessage_TxSettings
				if (src == nil || src.Settings == nil) && dst.Settings == nil {
					continue
				}
				if src != nil {
					newSrc = src.Settings
				}
				if dst.Settings != nil {
					newDst = dst.Settings
				} else {
					newDst = &MACState_UplinkMessage_TxSettings{}
					dst.Settings = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Settings = src.Settings
				} else {
					dst.Settings = nil
				}
			}
		case "rx_metadata":
			if len(subs) > 0 {
				return fmt.Errorf("'rx_metadata' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.RxMetadata = src.RxMetadata
			} else {
				dst.RxMetadata = nil
			}
		case "received_at":
			if len(subs) > 0 {
				return fmt.Errorf("'received_at' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ReceivedAt = src.ReceivedAt
			} else {
				dst.ReceivedAt = nil
			}
		case "correlation_ids":
			if len(subs) > 0 {
				return fmt.Errorf("'correlation_ids' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.CorrelationIds = src.CorrelationIds
			} else {
				dst.CorrelationIds = nil
			}
		case "device_channel_index":
			if len(subs) > 0 {
				return fmt.Errorf("'device_channel_index' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.DeviceChannelIndex = src.DeviceChannelIndex
			} else {
				var zero uint32
				dst.DeviceChannelIndex = zero
			}

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

func (dst *MACState_DownlinkMessage) SetFields(src *MACState_DownlinkMessage, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "payload":
			if len(subs) > 0 {
				var newDst, newSrc *MACState_DownlinkMessage_Message
				if (src == nil || src.Payload == nil) && dst.Payload == nil {
					continue
				}
				if src != nil {
					newSrc = src.Payload
				}
				if dst.Payload != nil {
					newDst = dst.Payload
				} else {
					newDst = &MACState_DownlinkMessage_Message{}
					dst.Payload = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Payload = src.Payload
				} else {
					dst.Payload = nil
				}
			}
		case "correlation_ids":
			if len(subs) > 0 {
				return fmt.Errorf("'correlation_ids' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.CorrelationIds = src.CorrelationIds
			} else {
				dst.CorrelationIds = nil
			}

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

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

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

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

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

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

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

func (dst *MACState_UplinkMessage_RxMetadata) SetFields(src *MACState_UplinkMessage_RxMetadata, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "gateway_ids":
			if len(subs) > 0 {
				var newDst, newSrc *GatewayIdentifiers
				if (src == nil || src.GatewayIds == nil) && dst.GatewayIds == nil {
					continue
				}
				if src != nil {
					newSrc = src.GatewayIds
				}
				if dst.GatewayIds != nil {
					newDst = dst.GatewayIds
				} else {
					newDst = &GatewayIdentifiers{}
					dst.GatewayIds = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.GatewayIds = src.GatewayIds
				} else {
					dst.GatewayIds = nil
				}
			}
		case "channel_rssi":
			if len(subs) > 0 {
				return fmt.Errorf("'channel_rssi' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ChannelRssi = src.ChannelRssi
			} else {
				var zero float32
				dst.ChannelRssi = zero
			}
		case "snr":
			if len(subs) > 0 {
				return fmt.Errorf("'snr' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Snr = src.Snr
			} else {
				var zero float32
				dst.Snr = zero
			}
		case "downlink_path_constraint":
			if len(subs) > 0 {
				return fmt.Errorf("'downlink_path_constraint' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.DownlinkPathConstraint = src.DownlinkPathConstraint
			} else {
				dst.DownlinkPathConstraint = 0
			}
		case "uplink_token":
			if len(subs) > 0 {
				return fmt.Errorf("'uplink_token' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.UplinkToken = src.UplinkToken
			} else {
				dst.UplinkToken = nil
			}
		case "packet_broker":
			if len(subs) > 0 {
				var newDst, newSrc *MACState_UplinkMessage_RxMetadata_PacketBrokerMetadata
				if (src == nil || src.PacketBroker == nil) && dst.PacketBroker == nil {
					continue
				}
				if src != nil {
					newSrc = src.PacketBroker
				}
				if dst.PacketBroker != nil {
					newDst = dst.PacketBroker
				} else {
					newDst = &MACState_UplinkMessage_RxMetadata_PacketBrokerMetadata{}
					dst.PacketBroker = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.PacketBroker = src.PacketBroker
				} else {
					dst.PacketBroker = nil
				}
			}

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

func (dst *MACState_UplinkMessage_RxMetadata_PacketBrokerMetadata) SetFields(src *MACState_UplinkMessage_RxMetadata_PacketBrokerMetadata, paths ...string) error {
	if len(paths) != 0 {
		return fmt.Errorf("message MACState_UplinkMessage_RxMetadata_PacketBrokerMetadata has no fields, but paths %s were specified", paths)
	}
	return nil
}

func (dst *MACState_DownlinkMessage_Message) SetFields(src *MACState_DownlinkMessage_Message, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "m_hdr":
			if len(subs) > 0 {
				var newDst, newSrc *MACState_DownlinkMessage_Message_MHDR
				if (src == nil || src.MHdr == nil) && dst.MHdr == nil {
					continue
				}
				if src != nil {
					newSrc = src.MHdr
				}
				if dst.MHdr != nil {
					newDst = dst.MHdr
				} else {
					newDst = &MACState_DownlinkMessage_Message_MHDR{}
					dst.MHdr = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.MHdr = src.MHdr
				} else {
					dst.MHdr = nil
				}
			}
		case "mac_payload":
			if len(subs) > 0 {
				var newDst, newSrc *MACState_DownlinkMessage_Message_MACPayload
				if (src == nil || src.MacPayload == nil) && dst.MacPayload == nil {
					continue
				}
				if src != nil {
					newSrc = src.MacPayload
				}
				if dst.MacPayload != nil {
					newDst = dst.MacPayload
				} else {
					newDst = &MACState_DownlinkMessage_Message_MACPayload{}
					dst.MacPayload = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.MacPayload = src.MacPayload
				} else {
					dst.MacPayload = nil
				}
			}

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

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

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

func (dst *MACState_DownlinkMessage_Message_MACPayload) SetFields(src *MACState_DownlinkMessage_Message_MACPayload, 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 "full_f_cnt":
			if len(subs) > 0 {
				return fmt.Errorf("'full_f_cnt' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FullFCnt = src.FullFCnt
			} else {
				var zero uint32
				dst.FullFCnt = zero
			}

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

func (dst *BatchUpdateEndDeviceLastSeenRequest_EndDeviceLastSeenUpdate) SetFields(src *BatchUpdateEndDeviceLastSeenRequest_EndDeviceLastSeenUpdate, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "ids":
			if len(subs) > 0 {
				var newDst, newSrc *EndDeviceIdentifiers
				if (src == nil || src.Ids == nil) && dst.Ids == nil {
					continue
				}
				if src != nil {
					newSrc = src.Ids
				}
				if dst.Ids != nil {
					newDst = dst.Ids
				} else {
					newDst = &EndDeviceIdentifiers{}
					dst.Ids = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Ids = src.Ids
				} else {
					dst.Ids = nil
				}
			}
		case "last_seen_at":
			if len(subs) > 0 {
				return fmt.Errorf("'last_seen_at' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.LastSeenAt = src.LastSeenAt
			} else {
				dst.LastSeenAt = nil
			}

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