end_device.pb.setters.fm.go

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

package ttnpb

import (
	fmt "fmt"
	go_thethings_network_lorawan_stack_v3_pkg_types "go.thethings.network/lorawan-stack/v3/pkg/types"
	time "time"
)

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 {
				var zero go_thethings_network_lorawan_stack_v3_pkg_types.DevAddr
				dst.DevAddr = zero
			}
		case "keys":
			if len(subs) > 0 {
				var newDst, newSrc *SessionKeys
				if src != nil {
					newSrc = &src.SessionKeys
				}
				newDst = &dst.SessionKeys
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.SessionKeys = src.SessionKeys
				} else {
					var zero SessionKeys
					dst.SessionKeys = zero
				}
			}
		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 {
				var zero time.Time
				dst.StartedAt = 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
			}

		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 {
				var zero DataRateIndex
				dst.AdrDataRateIndex = zero
			}
		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 {
				var zero RxDelay
				dst.Rx1Delay = zero
			}
		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 {
				var zero DataRateOffset
				dst.Rx1DataRateOffset = zero
			}
		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 {
				var zero DataRateIndex
				dst.Rx2DataRateIndex = zero
			}
		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 {
				var zero AggregatedDutyCycle
				dst.MaxDutyCycle = zero
			}
		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 {
				var zero RejoinTimeExponent
				dst.RejoinTimePeriodicity = zero
			}
		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 {
				var zero RejoinCountExponent
				dst.RejoinCountPeriodicity = zero
			}
		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 {
				var zero DataRateIndex
				dst.PingSlotDataRateIndex = zero
			}
		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 {
					newSrc = &src.EndDeviceVersionIdentifiers
				}
				newDst = &dst.EndDeviceVersionIdentifiers
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.EndDeviceVersionIdentifiers = src.EndDeviceVersionIdentifiers
				} else {
					var zero EndDeviceVersionIdentifiers
					dst.EndDeviceVersionIdentifiers = 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 {
				var zero MACVersion
				dst.LorawanVersion = zero
			}
		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 {
				var zero PHYVersion
				dst.LorawanPhyVersion = zero
			}
		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 {
					newSrc = &src.DefaultFormatters
				}
				newDst = &dst.DefaultFormatters
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.DefaultFormatters = src.DefaultFormatters
				} else {
					var zero MessagePayloadFormatters
					dst.DefaultFormatters = zero
				}
			}

		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 *FrequencyValue
				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 = &FrequencyValue{}
					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 *FrequencyValue
				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 = &FrequencyValue{}
					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 *FrequencyValue
				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 = &FrequencyValue{}
					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 *FrequencyValue
				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 = &FrequencyValue{}
					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
			}

		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 {
					newSrc = &src.CurrentParameters
				}
				newDst = &dst.CurrentParameters
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.CurrentParameters = src.CurrentParameters
				} else {
					var zero MACParameters
					dst.CurrentParameters = zero
				}
			}
		case "desired_parameters":
			if len(subs) > 0 {
				var newDst, newSrc *MACParameters
				if src != nil {
					newSrc = &src.DesiredParameters
				}
				newDst = &dst.DesiredParameters
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.DesiredParameters = src.DesiredParameters
				} else {
					var zero MACParameters
					dst.DesiredParameters = zero
				}
			}
		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 {
				var zero Class
				dst.DeviceClass = 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 {
				var zero MACVersion
				dst.LorawanVersion = zero
			}
		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
			}

		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 {
					newSrc = &src.EndDeviceIdentifiers
				}
				newDst = &dst.EndDeviceIdentifiers
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.EndDeviceIdentifiers = src.EndDeviceIdentifiers
				} else {
					var zero EndDeviceIdentifiers
					dst.EndDeviceIdentifiers = zero
				}
			}
		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 {
				var zero time.Time
				dst.CreatedAt = zero
			}
		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 {
				var zero time.Time
				dst.UpdatedAt = zero
			}
		case "name":
			if len(subs) > 0 {
				return fmt.Errorf("'name' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Name = src.Name
			} else {
				var zero string
				dst.Name = zero
			}
		case "description":
			if len(subs) > 0 {
				return fmt.Errorf("'description' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Description = src.Description
			} else {
				var zero string
				dst.Description = zero
			}
		case "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 {
				var zero MACVersion
				dst.LorawanVersion = zero
			}
		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 {
				var zero PHYVersion
				dst.LorawanPhyVersion = zero
			}
		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 {
				var zero PowerState
				dst.PowerState = zero
			}
		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
			}

		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 {
					newSrc = &src.EndDevice
				}
				newDst = &dst.EndDevice
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.EndDevice = src.EndDevice
				} else {
					var zero EndDevice
					dst.EndDevice = zero
				}
			}

		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 {
					newSrc = &src.EndDevice
				}
				newDst = &dst.EndDevice
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.EndDevice = src.EndDevice
				} else {
					var zero EndDevice
					dst.EndDevice = zero
				}
			}
		case "field_mask":
			if len(subs) > 0 {
				return fmt.Errorf("'field_mask' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FieldMask = src.FieldMask
			} else {
				dst.FieldMask = nil
			}

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

func (dst *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 {
					newSrc = &src.EndDeviceIdentifiers
				}
				newDst = &dst.EndDeviceIdentifiers
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.EndDeviceIdentifiers = src.EndDeviceIdentifiers
				} else {
					var zero EndDeviceIdentifiers
					dst.EndDeviceIdentifiers = zero
				}
			}
		case "field_mask":
			if len(subs) > 0 {
				return fmt.Errorf("'field_mask' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FieldMask = src.FieldMask
			} else {
				dst.FieldMask = nil
			}

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

func (dst *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 {
				var zero go_thethings_network_lorawan_stack_v3_pkg_types.EUI64
				dst.JoinEui = zero
			}
		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 {
				var zero go_thethings_network_lorawan_stack_v3_pkg_types.EUI64
				dst.DevEui = zero
			}

		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 {
					newSrc = &src.EndDevice
				}
				newDst = &dst.EndDevice
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.EndDevice = src.EndDevice
				} else {
					var zero EndDevice
					dst.EndDevice = zero
				}
			}
		case "field_mask":
			if len(subs) > 0 {
				return fmt.Errorf("'field_mask' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FieldMask = src.FieldMask
			} else {
				dst.FieldMask = nil
			}

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

func (dst *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 {
					newSrc = &src.EndDeviceIdentifiers
				}
				newDst = &dst.EndDeviceIdentifiers
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.EndDeviceIdentifiers = src.EndDeviceIdentifiers
				} else {
					var zero EndDeviceIdentifiers
					dst.EndDeviceIdentifiers = zero
				}
			}
		case "field_mask":
			if len(subs) > 0 {
				return fmt.Errorf("'field_mask' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FieldMask = src.FieldMask
			} else {
				dst.FieldMask = nil
			}

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

func (dst *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 {
					newSrc = &src.EndDevice
				}
				newDst = &dst.EndDevice
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.EndDevice = src.EndDevice
				} else {
					var zero EndDevice
					dst.EndDevice = zero
				}
			}
		case "field_mask":
			if len(subs) > 0 {
				return fmt.Errorf("'field_mask' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FieldMask = src.FieldMask
			} else {
				dst.FieldMask = nil
			}
		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
			}

		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 {
				var zero DataRateIndex
				dst.MinDataRateIndex = zero
			}
		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 {
				var zero DataRateIndex
				dst.MaxDataRateIndex = zero
			}
		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 *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 {
					newSrc = &src.DownlinkSettings
				}
				newDst = &dst.DownlinkSettings
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.DownlinkSettings = src.DownlinkSettings
				} else {
					var zero DLSettings
					dst.DownlinkSettings = zero
				}
			}
		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 {
				var zero RxDelay
				dst.RxDelay = zero
			}
		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 {
					newSrc = &src.Request
				}
				newDst = &dst.Request
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Request = src.Request
				} else {
					var zero MACState_JoinRequest
					dst.Request = zero
				}
			}
		case "keys":
			if len(subs) > 0 {
				var newDst, newSrc *SessionKeys
				if src != nil {
					newSrc = &src.Keys
				}
				newDst = &dst.Keys
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Keys = src.Keys
				} else {
					var zero SessionKeys
					dst.Keys = zero
				}
			}
		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 {
				var zero go_thethings_network_lorawan_stack_v3_pkg_types.DevAddr
				dst.DevAddr = zero
			}
		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 {
				var zero go_thethings_network_lorawan_stack_v3_pkg_types.NetID
				dst.NetId = zero
			}

		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 {
				var zero DataRateIndex
				dst.MinDataRateIndex = zero
			}
		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 {
				var zero DataRateIndex
				dst.MaxDataRateIndex = zero
			}

		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
}