lorawan.pb.setters.fm.go

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

package ttnpb

import fmt "fmt"

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

		case "Payload":
			if len(subs) == 0 && src == nil {
				dst.Payload = nil
				continue
			} else if len(subs) == 0 {
				dst.Payload = src.Payload
				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 "mac_payload":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*Message_MacPayload)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'mac_payload', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*Message_MacPayload)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'mac_payload', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACPayload
						if srcTypeOk {
							newSrc = src.Payload.(*Message_MacPayload).MacPayload
						}
						if dstTypeOk {
							newDst = dst.Payload.(*Message_MacPayload).MacPayload
						} else if srcTypeOk {
							newDst = &MACPayload{}
							dst.Payload = &Message_MacPayload{MacPayload: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "join_request_payload":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*Message_JoinRequestPayload)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'join_request_payload', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*Message_JoinRequestPayload)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'join_request_payload', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *JoinRequestPayload
						if srcTypeOk {
							newSrc = src.Payload.(*Message_JoinRequestPayload).JoinRequestPayload
						}
						if dstTypeOk {
							newDst = dst.Payload.(*Message_JoinRequestPayload).JoinRequestPayload
						} else if srcTypeOk {
							newDst = &JoinRequestPayload{}
							dst.Payload = &Message_JoinRequestPayload{JoinRequestPayload: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "join_accept_payload":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*Message_JoinAcceptPayload)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'join_accept_payload', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*Message_JoinAcceptPayload)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'join_accept_payload', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *JoinAcceptPayload
						if srcTypeOk {
							newSrc = src.Payload.(*Message_JoinAcceptPayload).JoinAcceptPayload
						}
						if dstTypeOk {
							newDst = dst.Payload.(*Message_JoinAcceptPayload).JoinAcceptPayload
						} else if srcTypeOk {
							newDst = &JoinAcceptPayload{}
							dst.Payload = &Message_JoinAcceptPayload{JoinAcceptPayload: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "rejoin_request_payload":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*Message_RejoinRequestPayload)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'rejoin_request_payload', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*Message_RejoinRequestPayload)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'rejoin_request_payload', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *RejoinRequestPayload
						if srcTypeOk {
							newSrc = src.Payload.(*Message_RejoinRequestPayload).RejoinRequestPayload
						}
						if dstTypeOk {
							newDst = dst.Payload.(*Message_RejoinRequestPayload).RejoinRequestPayload
						} else if srcTypeOk {
							newDst = &RejoinRequestPayload{}
							dst.Payload = &Message_RejoinRequestPayload{RejoinRequestPayload: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}

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

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

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

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

func (dst *MACPayload) SetFields(src *MACPayload, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "f_hdr":
			if len(subs) > 0 {
				var newDst, newSrc *FHDR
				if (src == nil || src.FHdr == nil) && dst.FHdr == nil {
					continue
				}
				if src != nil {
					newSrc = src.FHdr
				}
				if dst.FHdr != nil {
					newDst = dst.FHdr
				} else {
					newDst = &FHDR{}
					dst.FHdr = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.FHdr = src.FHdr
				} else {
					dst.FHdr = nil
				}
			}
		case "f_port":
			if len(subs) > 0 {
				return fmt.Errorf("'f_port' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FPort = src.FPort
			} else {
				var zero uint32
				dst.FPort = zero
			}
		case "frm_payload":
			if len(subs) > 0 {
				return fmt.Errorf("'frm_payload' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FrmPayload = src.FrmPayload
			} else {
				dst.FrmPayload = nil
			}
		case "decoded_payload":
			if len(subs) > 0 {
				return fmt.Errorf("'decoded_payload' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.DecodedPayload = src.DecodedPayload
			} else {
				dst.DecodedPayload = nil
			}
		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 *FHDR) SetFields(src *FHDR, 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 "f_ctrl":
			if len(subs) > 0 {
				var newDst, newSrc *FCtrl
				if (src == nil || src.FCtrl == nil) && dst.FCtrl == nil {
					continue
				}
				if src != nil {
					newSrc = src.FCtrl
				}
				if dst.FCtrl != nil {
					newDst = dst.FCtrl
				} else {
					newDst = &FCtrl{}
					dst.FCtrl = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.FCtrl = src.FCtrl
				} else {
					dst.FCtrl = nil
				}
			}
		case "f_cnt":
			if len(subs) > 0 {
				return fmt.Errorf("'f_cnt' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FCnt = src.FCnt
			} else {
				var zero uint32
				dst.FCnt = zero
			}
		case "f_opts":
			if len(subs) > 0 {
				return fmt.Errorf("'f_opts' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FOpts = src.FOpts
			} else {
				dst.FOpts = nil
			}

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

func (dst *FCtrl) SetFields(src *FCtrl, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "adr":
			if len(subs) > 0 {
				return fmt.Errorf("'adr' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Adr = src.Adr
			} else {
				var zero bool
				dst.Adr = zero
			}
		case "adr_ack_req":
			if len(subs) > 0 {
				return fmt.Errorf("'adr_ack_req' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.AdrAckReq = src.AdrAckReq
			} else {
				var zero bool
				dst.AdrAckReq = zero
			}
		case "ack":
			if len(subs) > 0 {
				return fmt.Errorf("'ack' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Ack = src.Ack
			} else {
				var zero bool
				dst.Ack = zero
			}
		case "f_pending":
			if len(subs) > 0 {
				return fmt.Errorf("'f_pending' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.FPending = src.FPending
			} else {
				var zero bool
				dst.FPending = zero
			}
		case "class_b":
			if len(subs) > 0 {
				return fmt.Errorf("'class_b' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ClassB = src.ClassB
			} else {
				var zero bool
				dst.ClassB = zero
			}

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

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

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

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

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

func (dst *JoinAcceptPayload) SetFields(src *JoinAcceptPayload, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "encrypted":
			if len(subs) > 0 {
				return fmt.Errorf("'encrypted' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Encrypted = src.Encrypted
			} else {
				dst.Encrypted = nil
			}
		case "join_nonce":
			if len(subs) > 0 {
				return fmt.Errorf("'join_nonce' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.JoinNonce = src.JoinNonce
			} else {
				dst.JoinNonce = 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 "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 "dl_settings":
			if len(subs) > 0 {
				var newDst, newSrc *DLSettings
				if (src == nil || src.DlSettings == nil) && dst.DlSettings == nil {
					continue
				}
				if src != nil {
					newSrc = src.DlSettings
				}
				if dst.DlSettings != nil {
					newDst = dst.DlSettings
				} else {
					newDst = &DLSettings{}
					dst.DlSettings = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.DlSettings = src.DlSettings
				} else {
					dst.DlSettings = 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 *DLSettings) SetFields(src *DLSettings, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "rx1_dr_offset":
			if len(subs) > 0 {
				return fmt.Errorf("'rx1_dr_offset' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Rx1DrOffset = src.Rx1DrOffset
			} else {
				dst.Rx1DrOffset = 0
			}
		case "rx2_dr":
			if len(subs) > 0 {
				return fmt.Errorf("'rx2_dr' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Rx2Dr = src.Rx2Dr
			} else {
				dst.Rx2Dr = 0
			}
		case "opt_neg":
			if len(subs) > 0 {
				return fmt.Errorf("'opt_neg' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.OptNeg = src.OptNeg
			} else {
				var zero bool
				dst.OptNeg = zero
			}

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

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

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

func (dst *LoRaDataRate) SetFields(src *LoRaDataRate, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "bandwidth":
			if len(subs) > 0 {
				return fmt.Errorf("'bandwidth' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Bandwidth = src.Bandwidth
			} else {
				var zero uint32
				dst.Bandwidth = zero
			}
		case "spreading_factor":
			if len(subs) > 0 {
				return fmt.Errorf("'spreading_factor' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.SpreadingFactor = src.SpreadingFactor
			} else {
				var zero uint32
				dst.SpreadingFactor = zero
			}
		case "coding_rate":
			if len(subs) > 0 {
				return fmt.Errorf("'coding_rate' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.CodingRate = src.CodingRate
			} else {
				var zero string
				dst.CodingRate = zero
			}

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

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

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

func (dst *LRFHSSDataRate) SetFields(src *LRFHSSDataRate, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "modulation_type":
			if len(subs) > 0 {
				return fmt.Errorf("'modulation_type' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ModulationType = src.ModulationType
			} else {
				var zero uint32
				dst.ModulationType = zero
			}
		case "operating_channel_width":
			if len(subs) > 0 {
				return fmt.Errorf("'operating_channel_width' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.OperatingChannelWidth = src.OperatingChannelWidth
			} else {
				var zero uint32
				dst.OperatingChannelWidth = zero
			}
		case "coding_rate":
			if len(subs) > 0 {
				return fmt.Errorf("'coding_rate' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.CodingRate = src.CodingRate
			} else {
				var zero string
				dst.CodingRate = zero
			}

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

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

		case "modulation":
			if len(subs) == 0 && src == nil {
				dst.Modulation = nil
				continue
			} else if len(subs) == 0 {
				dst.Modulation = src.Modulation
				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":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Modulation.(*DataRate_Lora)
					}
					if srcValid := srcTypeOk || src == nil || src.Modulation == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'lora', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Modulation.(*DataRate_Lora)
					if dstValid := dstTypeOk || dst.Modulation == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'lora', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *LoRaDataRate
						if srcTypeOk {
							newSrc = src.Modulation.(*DataRate_Lora).Lora
						}
						if dstTypeOk {
							newDst = dst.Modulation.(*DataRate_Lora).Lora
						} else if srcTypeOk {
							newDst = &LoRaDataRate{}
							dst.Modulation = &DataRate_Lora{Lora: newDst}
						} else {
							dst.Modulation = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Modulation = src.Modulation
						} else {
							dst.Modulation = nil
						}
					}
				case "fsk":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Modulation.(*DataRate_Fsk)
					}
					if srcValid := srcTypeOk || src == nil || src.Modulation == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'fsk', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Modulation.(*DataRate_Fsk)
					if dstValid := dstTypeOk || dst.Modulation == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'fsk', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *FSKDataRate
						if srcTypeOk {
							newSrc = src.Modulation.(*DataRate_Fsk).Fsk
						}
						if dstTypeOk {
							newDst = dst.Modulation.(*DataRate_Fsk).Fsk
						} else if srcTypeOk {
							newDst = &FSKDataRate{}
							dst.Modulation = &DataRate_Fsk{Fsk: newDst}
						} else {
							dst.Modulation = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Modulation = src.Modulation
						} else {
							dst.Modulation = nil
						}
					}
				case "lrfhss":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Modulation.(*DataRate_Lrfhss)
					}
					if srcValid := srcTypeOk || src == nil || src.Modulation == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'lrfhss', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Modulation.(*DataRate_Lrfhss)
					if dstValid := dstTypeOk || dst.Modulation == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'lrfhss', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *LRFHSSDataRate
						if srcTypeOk {
							newSrc = src.Modulation.(*DataRate_Lrfhss).Lrfhss
						}
						if dstTypeOk {
							newDst = dst.Modulation.(*DataRate_Lrfhss).Lrfhss
						} else if srcTypeOk {
							newDst = &LRFHSSDataRate{}
							dst.Modulation = &DataRate_Lrfhss{Lrfhss: newDst}
						} else {
							dst.Modulation = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Modulation = src.Modulation
						} else {
							dst.Modulation = nil
						}
					}

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

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

func (dst *TxSettings) SetFields(src *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
				}
			}
		case "frequency":
			if len(subs) > 0 {
				return fmt.Errorf("'frequency' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Frequency = src.Frequency
			} else {
				var zero uint64
				dst.Frequency = zero
			}
		case "enable_crc":
			if len(subs) > 0 {
				return fmt.Errorf("'enable_crc' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.EnableCrc = src.EnableCrc
			} else {
				var zero bool
				dst.EnableCrc = zero
			}
		case "timestamp":
			if len(subs) > 0 {
				return fmt.Errorf("'timestamp' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Timestamp = src.Timestamp
			} else {
				var zero uint32
				dst.Timestamp = zero
			}
		case "time":
			if len(subs) > 0 {
				return fmt.Errorf("'time' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Time = src.Time
			} else {
				dst.Time = nil
			}
		case "downlink":
			if len(subs) > 0 {
				var newDst, newSrc *TxSettings_Downlink
				if (src == nil || src.Downlink == nil) && dst.Downlink == nil {
					continue
				}
				if src != nil {
					newSrc = src.Downlink
				}
				if dst.Downlink != nil {
					newDst = dst.Downlink
				} else {
					newDst = &TxSettings_Downlink{}
					dst.Downlink = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Downlink = src.Downlink
				} else {
					dst.Downlink = nil
				}
			}
		case "concentrator_timestamp":
			if len(subs) > 0 {
				return fmt.Errorf("'concentrator_timestamp' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ConcentratorTimestamp = src.ConcentratorTimestamp
			} else {
				var zero int64
				dst.ConcentratorTimestamp = zero
			}

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

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

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

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

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

func (dst *UplinkToken) SetFields(src *UplinkToken, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "ids":
			if len(subs) > 0 {
				var newDst, newSrc *GatewayAntennaIdentifiers
				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 = &GatewayAntennaIdentifiers{}
					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 "timestamp":
			if len(subs) > 0 {
				return fmt.Errorf("'timestamp' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Timestamp = src.Timestamp
			} else {
				var zero uint32
				dst.Timestamp = zero
			}
		case "server_time":
			if len(subs) > 0 {
				return fmt.Errorf("'server_time' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ServerTime = src.ServerTime
			} else {
				dst.ServerTime = nil
			}
		case "concentrator_time":
			if len(subs) > 0 {
				return fmt.Errorf("'concentrator_time' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ConcentratorTime = src.ConcentratorTime
			} else {
				var zero int64
				dst.ConcentratorTime = zero
			}
		case "gateway_time":
			if len(subs) > 0 {
				return fmt.Errorf("'gateway_time' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.GatewayTime = src.GatewayTime
			} else {
				dst.GatewayTime = nil
			}

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

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

		case "path":
			if len(subs) == 0 && src == nil {
				dst.Path = nil
				continue
			} else if len(subs) == 0 {
				dst.Path = src.Path
				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 "uplink_token":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Path.(*DownlinkPath_UplinkToken)
					}
					if srcValid := srcTypeOk || src == nil || src.Path == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'uplink_token', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Path.(*DownlinkPath_UplinkToken)
					if dstValid := dstTypeOk || dst.Path == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'uplink_token', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						return fmt.Errorf("'uplink_token' has no subfields, but %s were specified", oneofSubs)
					}
					if srcTypeOk {
						dst.Path = src.Path
					} else {
						dst.Path = nil
					}
				case "fixed":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Path.(*DownlinkPath_Fixed)
					}
					if srcValid := srcTypeOk || src == nil || src.Path == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'fixed', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Path.(*DownlinkPath_Fixed)
					if dstValid := dstTypeOk || dst.Path == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'fixed', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *GatewayAntennaIdentifiers
						if srcTypeOk {
							newSrc = src.Path.(*DownlinkPath_Fixed).Fixed
						}
						if dstTypeOk {
							newDst = dst.Path.(*DownlinkPath_Fixed).Fixed
						} else if srcTypeOk {
							newDst = &GatewayAntennaIdentifiers{}
							dst.Path = &DownlinkPath_Fixed{Fixed: newDst}
						} else {
							dst.Path = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Path = src.Path
						} else {
							dst.Path = nil
						}
					}

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

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

func (dst *TxRequest) SetFields(src *TxRequest, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "class":
			if len(subs) > 0 {
				return fmt.Errorf("'class' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Class = src.Class
			} else {
				dst.Class = 0
			}
		case "downlink_paths":
			if len(subs) > 0 {
				return fmt.Errorf("'downlink_paths' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.DownlinkPaths = src.DownlinkPaths
			} else {
				dst.DownlinkPaths = nil
			}
		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":
			if len(subs) > 0 {
				var newDst, newSrc *DataRate
				if (src == nil || src.Rx1DataRate == nil) && dst.Rx1DataRate == nil {
					continue
				}
				if src != nil {
					newSrc = src.Rx1DataRate
				}
				if dst.Rx1DataRate != nil {
					newDst = dst.Rx1DataRate
				} else {
					newDst = &DataRate{}
					dst.Rx1DataRate = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Rx1DataRate = src.Rx1DataRate
				} else {
					dst.Rx1DataRate = nil
				}
			}
		case "rx1_frequency":
			if len(subs) > 0 {
				return fmt.Errorf("'rx1_frequency' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Rx1Frequency = src.Rx1Frequency
			} else {
				var zero uint64
				dst.Rx1Frequency = zero
			}
		case "rx2_data_rate":
			if len(subs) > 0 {
				var newDst, newSrc *DataRate
				if (src == nil || src.Rx2DataRate == nil) && dst.Rx2DataRate == nil {
					continue
				}
				if src != nil {
					newSrc = src.Rx2DataRate
				}
				if dst.Rx2DataRate != nil {
					newDst = dst.Rx2DataRate
				} else {
					newDst = &DataRate{}
					dst.Rx2DataRate = newDst
				}
				if err := newDst.SetFields(newSrc, subs...); err != nil {
					return err
				}
			} else {
				if src != nil {
					dst.Rx2DataRate = src.Rx2DataRate
				} else {
					dst.Rx2DataRate = nil
				}
			}
		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 "priority":
			if len(subs) > 0 {
				return fmt.Errorf("'priority' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Priority = src.Priority
			} else {
				dst.Priority = 0
			}
		case "absolute_time":
			if len(subs) > 0 {
				return fmt.Errorf("'absolute_time' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.AbsoluteTime = src.AbsoluteTime
			} else {
				dst.AbsoluteTime = nil
			}
		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 "advanced":
			if len(subs) > 0 {
				return fmt.Errorf("'advanced' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.Advanced = src.Advanced
			} else {
				dst.Advanced = nil
			}

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

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

		case "payload":
			if len(subs) == 0 && src == nil {
				dst.Payload = nil
				continue
			} else if len(subs) == 0 {
				dst.Payload = src.Payload
				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 "raw_payload":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_RawPayload)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'raw_payload', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_RawPayload)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'raw_payload', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						return fmt.Errorf("'raw_payload' has no subfields, but %s were specified", oneofSubs)
					}
					if srcTypeOk {
						dst.Payload = src.Payload
					} else {
						dst.Payload = nil
					}
				case "reset_ind":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_ResetInd_)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'reset_ind', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_ResetInd_)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'reset_ind', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_ResetInd
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_ResetInd_).ResetInd
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_ResetInd_).ResetInd
						} else if srcTypeOk {
							newDst = &MACCommand_ResetInd{}
							dst.Payload = &MACCommand_ResetInd_{ResetInd: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "reset_conf":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_ResetConf_)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'reset_conf', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_ResetConf_)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'reset_conf', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_ResetConf
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_ResetConf_).ResetConf
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_ResetConf_).ResetConf
						} else if srcTypeOk {
							newDst = &MACCommand_ResetConf{}
							dst.Payload = &MACCommand_ResetConf_{ResetConf: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "link_check_ans":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_LinkCheckAns_)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'link_check_ans', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_LinkCheckAns_)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'link_check_ans', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_LinkCheckAns
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_LinkCheckAns_).LinkCheckAns
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_LinkCheckAns_).LinkCheckAns
						} else if srcTypeOk {
							newDst = &MACCommand_LinkCheckAns{}
							dst.Payload = &MACCommand_LinkCheckAns_{LinkCheckAns: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "link_adr_req":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_LinkAdrReq)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'link_adr_req', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_LinkAdrReq)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'link_adr_req', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_LinkADRReq
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_LinkAdrReq).LinkAdrReq
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_LinkAdrReq).LinkAdrReq
						} else if srcTypeOk {
							newDst = &MACCommand_LinkADRReq{}
							dst.Payload = &MACCommand_LinkAdrReq{LinkAdrReq: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "link_adr_ans":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_LinkAdrAns)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'link_adr_ans', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_LinkAdrAns)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'link_adr_ans', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_LinkADRAns
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_LinkAdrAns).LinkAdrAns
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_LinkAdrAns).LinkAdrAns
						} else if srcTypeOk {
							newDst = &MACCommand_LinkADRAns{}
							dst.Payload = &MACCommand_LinkAdrAns{LinkAdrAns: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "duty_cycle_req":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_DutyCycleReq_)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'duty_cycle_req', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_DutyCycleReq_)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'duty_cycle_req', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_DutyCycleReq
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_DutyCycleReq_).DutyCycleReq
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_DutyCycleReq_).DutyCycleReq
						} else if srcTypeOk {
							newDst = &MACCommand_DutyCycleReq{}
							dst.Payload = &MACCommand_DutyCycleReq_{DutyCycleReq: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "rx_param_setup_req":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_RxParamSetupReq_)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'rx_param_setup_req', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_RxParamSetupReq_)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'rx_param_setup_req', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_RxParamSetupReq
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_RxParamSetupReq_).RxParamSetupReq
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_RxParamSetupReq_).RxParamSetupReq
						} else if srcTypeOk {
							newDst = &MACCommand_RxParamSetupReq{}
							dst.Payload = &MACCommand_RxParamSetupReq_{RxParamSetupReq: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "rx_param_setup_ans":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_RxParamSetupAns_)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'rx_param_setup_ans', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_RxParamSetupAns_)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'rx_param_setup_ans', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_RxParamSetupAns
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_RxParamSetupAns_).RxParamSetupAns
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_RxParamSetupAns_).RxParamSetupAns
						} else if srcTypeOk {
							newDst = &MACCommand_RxParamSetupAns{}
							dst.Payload = &MACCommand_RxParamSetupAns_{RxParamSetupAns: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "dev_status_ans":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_DevStatusAns_)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'dev_status_ans', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_DevStatusAns_)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'dev_status_ans', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_DevStatusAns
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_DevStatusAns_).DevStatusAns
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_DevStatusAns_).DevStatusAns
						} else if srcTypeOk {
							newDst = &MACCommand_DevStatusAns{}
							dst.Payload = &MACCommand_DevStatusAns_{DevStatusAns: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "new_channel_req":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_NewChannelReq_)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'new_channel_req', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_NewChannelReq_)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'new_channel_req', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_NewChannelReq
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_NewChannelReq_).NewChannelReq
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_NewChannelReq_).NewChannelReq
						} else if srcTypeOk {
							newDst = &MACCommand_NewChannelReq{}
							dst.Payload = &MACCommand_NewChannelReq_{NewChannelReq: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "new_channel_ans":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_NewChannelAns_)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'new_channel_ans', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_NewChannelAns_)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'new_channel_ans', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_NewChannelAns
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_NewChannelAns_).NewChannelAns
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_NewChannelAns_).NewChannelAns
						} else if srcTypeOk {
							newDst = &MACCommand_NewChannelAns{}
							dst.Payload = &MACCommand_NewChannelAns_{NewChannelAns: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "dl_channel_req":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_DlChannelReq)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'dl_channel_req', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_DlChannelReq)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'dl_channel_req', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_DLChannelReq
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_DlChannelReq).DlChannelReq
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_DlChannelReq).DlChannelReq
						} else if srcTypeOk {
							newDst = &MACCommand_DLChannelReq{}
							dst.Payload = &MACCommand_DlChannelReq{DlChannelReq: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "dl_channel_ans":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_DlChannelAns)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'dl_channel_ans', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_DlChannelAns)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'dl_channel_ans', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_DLChannelAns
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_DlChannelAns).DlChannelAns
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_DlChannelAns).DlChannelAns
						} else if srcTypeOk {
							newDst = &MACCommand_DLChannelAns{}
							dst.Payload = &MACCommand_DlChannelAns{DlChannelAns: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "rx_timing_setup_req":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_RxTimingSetupReq_)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'rx_timing_setup_req', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_RxTimingSetupReq_)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'rx_timing_setup_req', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_RxTimingSetupReq
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_RxTimingSetupReq_).RxTimingSetupReq
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_RxTimingSetupReq_).RxTimingSetupReq
						} else if srcTypeOk {
							newDst = &MACCommand_RxTimingSetupReq{}
							dst.Payload = &MACCommand_RxTimingSetupReq_{RxTimingSetupReq: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "tx_param_setup_req":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_TxParamSetupReq_)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'tx_param_setup_req', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_TxParamSetupReq_)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'tx_param_setup_req', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_TxParamSetupReq
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_TxParamSetupReq_).TxParamSetupReq
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_TxParamSetupReq_).TxParamSetupReq
						} else if srcTypeOk {
							newDst = &MACCommand_TxParamSetupReq{}
							dst.Payload = &MACCommand_TxParamSetupReq_{TxParamSetupReq: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "rekey_ind":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_RekeyInd_)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'rekey_ind', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_RekeyInd_)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'rekey_ind', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_RekeyInd
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_RekeyInd_).RekeyInd
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_RekeyInd_).RekeyInd
						} else if srcTypeOk {
							newDst = &MACCommand_RekeyInd{}
							dst.Payload = &MACCommand_RekeyInd_{RekeyInd: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "rekey_conf":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_RekeyConf_)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'rekey_conf', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_RekeyConf_)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'rekey_conf', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_RekeyConf
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_RekeyConf_).RekeyConf
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_RekeyConf_).RekeyConf
						} else if srcTypeOk {
							newDst = &MACCommand_RekeyConf{}
							dst.Payload = &MACCommand_RekeyConf_{RekeyConf: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "adr_param_setup_req":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_AdrParamSetupReq)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'adr_param_setup_req', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_AdrParamSetupReq)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'adr_param_setup_req', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_ADRParamSetupReq
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_AdrParamSetupReq).AdrParamSetupReq
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_AdrParamSetupReq).AdrParamSetupReq
						} else if srcTypeOk {
							newDst = &MACCommand_ADRParamSetupReq{}
							dst.Payload = &MACCommand_AdrParamSetupReq{AdrParamSetupReq: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "device_time_ans":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_DeviceTimeAns_)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'device_time_ans', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_DeviceTimeAns_)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'device_time_ans', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_DeviceTimeAns
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_DeviceTimeAns_).DeviceTimeAns
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_DeviceTimeAns_).DeviceTimeAns
						} else if srcTypeOk {
							newDst = &MACCommand_DeviceTimeAns{}
							dst.Payload = &MACCommand_DeviceTimeAns_{DeviceTimeAns: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "force_rejoin_req":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_ForceRejoinReq_)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'force_rejoin_req', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_ForceRejoinReq_)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'force_rejoin_req', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_ForceRejoinReq
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_ForceRejoinReq_).ForceRejoinReq
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_ForceRejoinReq_).ForceRejoinReq
						} else if srcTypeOk {
							newDst = &MACCommand_ForceRejoinReq{}
							dst.Payload = &MACCommand_ForceRejoinReq_{ForceRejoinReq: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "rejoin_param_setup_req":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_RejoinParamSetupReq_)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'rejoin_param_setup_req', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_RejoinParamSetupReq_)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'rejoin_param_setup_req', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_RejoinParamSetupReq
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_RejoinParamSetupReq_).RejoinParamSetupReq
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_RejoinParamSetupReq_).RejoinParamSetupReq
						} else if srcTypeOk {
							newDst = &MACCommand_RejoinParamSetupReq{}
							dst.Payload = &MACCommand_RejoinParamSetupReq_{RejoinParamSetupReq: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "rejoin_param_setup_ans":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_RejoinParamSetupAns_)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'rejoin_param_setup_ans', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_RejoinParamSetupAns_)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'rejoin_param_setup_ans', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_RejoinParamSetupAns
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_RejoinParamSetupAns_).RejoinParamSetupAns
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_RejoinParamSetupAns_).RejoinParamSetupAns
						} else if srcTypeOk {
							newDst = &MACCommand_RejoinParamSetupAns{}
							dst.Payload = &MACCommand_RejoinParamSetupAns_{RejoinParamSetupAns: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "ping_slot_info_req":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_PingSlotInfoReq_)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'ping_slot_info_req', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_PingSlotInfoReq_)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'ping_slot_info_req', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_PingSlotInfoReq
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_PingSlotInfoReq_).PingSlotInfoReq
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_PingSlotInfoReq_).PingSlotInfoReq
						} else if srcTypeOk {
							newDst = &MACCommand_PingSlotInfoReq{}
							dst.Payload = &MACCommand_PingSlotInfoReq_{PingSlotInfoReq: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "ping_slot_channel_req":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_PingSlotChannelReq_)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'ping_slot_channel_req', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_PingSlotChannelReq_)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'ping_slot_channel_req', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_PingSlotChannelReq
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_PingSlotChannelReq_).PingSlotChannelReq
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_PingSlotChannelReq_).PingSlotChannelReq
						} else if srcTypeOk {
							newDst = &MACCommand_PingSlotChannelReq{}
							dst.Payload = &MACCommand_PingSlotChannelReq_{PingSlotChannelReq: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "ping_slot_channel_ans":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_PingSlotChannelAns_)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'ping_slot_channel_ans', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_PingSlotChannelAns_)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'ping_slot_channel_ans', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_PingSlotChannelAns
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_PingSlotChannelAns_).PingSlotChannelAns
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_PingSlotChannelAns_).PingSlotChannelAns
						} else if srcTypeOk {
							newDst = &MACCommand_PingSlotChannelAns{}
							dst.Payload = &MACCommand_PingSlotChannelAns_{PingSlotChannelAns: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "beacon_timing_ans":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_BeaconTimingAns_)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'beacon_timing_ans', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_BeaconTimingAns_)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'beacon_timing_ans', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_BeaconTimingAns
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_BeaconTimingAns_).BeaconTimingAns
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_BeaconTimingAns_).BeaconTimingAns
						} else if srcTypeOk {
							newDst = &MACCommand_BeaconTimingAns{}
							dst.Payload = &MACCommand_BeaconTimingAns_{BeaconTimingAns: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "beacon_freq_req":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_BeaconFreqReq_)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'beacon_freq_req', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_BeaconFreqReq_)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'beacon_freq_req', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_BeaconFreqReq
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_BeaconFreqReq_).BeaconFreqReq
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_BeaconFreqReq_).BeaconFreqReq
						} else if srcTypeOk {
							newDst = &MACCommand_BeaconFreqReq{}
							dst.Payload = &MACCommand_BeaconFreqReq_{BeaconFreqReq: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "beacon_freq_ans":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_BeaconFreqAns_)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'beacon_freq_ans', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_BeaconFreqAns_)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'beacon_freq_ans', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_BeaconFreqAns
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_BeaconFreqAns_).BeaconFreqAns
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_BeaconFreqAns_).BeaconFreqAns
						} else if srcTypeOk {
							newDst = &MACCommand_BeaconFreqAns{}
							dst.Payload = &MACCommand_BeaconFreqAns_{BeaconFreqAns: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "device_mode_ind":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_DeviceModeInd_)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'device_mode_ind', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_DeviceModeInd_)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'device_mode_ind', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_DeviceModeInd
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_DeviceModeInd_).DeviceModeInd
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_DeviceModeInd_).DeviceModeInd
						} else if srcTypeOk {
							newDst = &MACCommand_DeviceModeInd{}
							dst.Payload = &MACCommand_DeviceModeInd_{DeviceModeInd: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}
				case "device_mode_conf":
					var srcTypeOk bool
					if src != nil {
						_, srcTypeOk = src.Payload.(*MACCommand_DeviceModeConf_)
					}
					if srcValid := srcTypeOk || src == nil || src.Payload == nil || len(oneofSubs) == 0; !srcValid {
						return fmt.Errorf("attempt to set oneof 'device_mode_conf', while different oneof is set in source")
					}
					_, dstTypeOk := dst.Payload.(*MACCommand_DeviceModeConf_)
					if dstValid := dstTypeOk || dst.Payload == nil || len(oneofSubs) == 0; !dstValid {
						return fmt.Errorf("attempt to set oneof 'device_mode_conf', while different oneof is set in destination")
					}
					if len(oneofSubs) > 0 {
						var newDst, newSrc *MACCommand_DeviceModeConf
						if srcTypeOk {
							newSrc = src.Payload.(*MACCommand_DeviceModeConf_).DeviceModeConf
						}
						if dstTypeOk {
							newDst = dst.Payload.(*MACCommand_DeviceModeConf_).DeviceModeConf
						} else if srcTypeOk {
							newDst = &MACCommand_DeviceModeConf{}
							dst.Payload = &MACCommand_DeviceModeConf_{DeviceModeConf: newDst}
						} else {
							dst.Payload = nil
							continue
						}
						if err := newDst.SetFields(newSrc, oneofSubs...); err != nil {
							return err
						}
					} else {
						if srcTypeOk {
							dst.Payload = src.Payload
						} else {
							dst.Payload = nil
						}
					}

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

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

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

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

func (dst *FrequencyValue) SetFields(src *FrequencyValue, 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 uint64
				dst.Value = zero
			}

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

func (dst *ZeroableFrequencyValue) SetFields(src *ZeroableFrequencyValue, 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 uint64
				dst.Value = zero
			}

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

func (dst *DataRateOffsetValue) SetFields(src *DataRateOffsetValue, 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 {
				dst.Value = 0
			}

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

func (dst *DataRateIndexValue) SetFields(src *DataRateIndexValue, 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 {
				dst.Value = 0
			}

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

func (dst *PingSlotPeriodValue) SetFields(src *PingSlotPeriodValue, 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 {
				dst.Value = 0
			}

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

func (dst *AggregatedDutyCycleValue) SetFields(src *AggregatedDutyCycleValue, 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 {
				dst.Value = 0
			}

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

func (dst *RxDelayValue) SetFields(src *RxDelayValue, 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 {
				dst.Value = 0
			}

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

func (dst *ADRAckLimitExponentValue) SetFields(src *ADRAckLimitExponentValue, 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 {
				dst.Value = 0
			}

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

func (dst *ADRAckDelayExponentValue) SetFields(src *ADRAckDelayExponentValue, 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 {
				dst.Value = 0
			}

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

func (dst *DeviceEIRPValue) SetFields(src *DeviceEIRPValue, 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 {
				dst.Value = 0
			}

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

func (dst *TxSettings_Downlink) SetFields(src *TxSettings_Downlink, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "antenna_index":
			if len(subs) > 0 {
				return fmt.Errorf("'antenna_index' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.AntennaIndex = src.AntennaIndex
			} else {
				var zero uint32
				dst.AntennaIndex = zero
			}
		case "tx_power":
			if len(subs) > 0 {
				return fmt.Errorf("'tx_power' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.TxPower = src.TxPower
			} else {
				var zero float32
				dst.TxPower = zero
			}
		case "invert_polarization":
			if len(subs) > 0 {
				return fmt.Errorf("'invert_polarization' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.InvertPolarization = src.InvertPolarization
			} else {
				var zero bool
				dst.InvertPolarization = zero
			}

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

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

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

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

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

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

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

func (dst *MACCommand_LinkADRReq) SetFields(src *MACCommand_LinkADRReq, 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 "channel_mask":
			if len(subs) > 0 {
				return fmt.Errorf("'channel_mask' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ChannelMask = src.ChannelMask
			} else {
				dst.ChannelMask = nil
			}
		case "channel_mask_control":
			if len(subs) > 0 {
				return fmt.Errorf("'channel_mask_control' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ChannelMaskControl = src.ChannelMaskControl
			} else {
				var zero uint32
				dst.ChannelMaskControl = 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 *MACCommand_LinkADRAns) SetFields(src *MACCommand_LinkADRAns, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		case "channel_mask_ack":
			if len(subs) > 0 {
				return fmt.Errorf("'channel_mask_ack' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.ChannelMaskAck = src.ChannelMaskAck
			} else {
				var zero bool
				dst.ChannelMaskAck = zero
			}
		case "data_rate_index_ack":
			if len(subs) > 0 {
				return fmt.Errorf("'data_rate_index_ack' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.DataRateIndexAck = src.DataRateIndexAck
			} else {
				var zero bool
				dst.DataRateIndexAck = zero
			}
		case "tx_power_index_ack":
			if len(subs) > 0 {
				return fmt.Errorf("'tx_power_index_ack' has no subfields, but %s were specified", subs)
			}
			if src != nil {
				dst.TxPowerIndexAck = src.TxPowerIndexAck
			} else {
				var zero bool
				dst.TxPowerIndexAck = zero
			}

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

func (dst *MACCommand_DutyCycleReq) SetFields(src *MACCommand_DutyCycleReq, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		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
			}

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

func (dst *MACCommand_RxParamSetupReq) SetFields(src *MACCommand_RxParamSetupReq, paths ...string) error {
	for name, subs := range _processPaths(paths) {
		switch name {
		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 "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_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
			}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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