lorawan_json.pb.go

// Code generated by protoc-gen-go-json. DO NOT EDIT.
// versions:
// - protoc-gen-go-json v1.5.1
// - protoc             v4.22.2
// source: lorawan-stack/api/lorawan.proto

package ttnpb

import (
	golang "github.com/TheThingsIndustries/protoc-gen-go-json/golang"
	jsonplugin "github.com/TheThingsIndustries/protoc-gen-go-json/jsonplugin"
	types "go.thethings.network/lorawan-stack/v3/pkg/types"
	strconv "strconv"
)

// MarshalProtoJSON marshals the MType to JSON.
func (x MType) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	s.WriteEnumString(int32(x), MType_name)
}

// MarshalText marshals the MType to text.
func (x MType) MarshalText() ([]byte, error) {
	return []byte(jsonplugin.GetEnumString(int32(x), MType_name)), nil
}

// MarshalJSON marshals the MType to JSON.
func (x MType) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the MType from JSON.
func (x *MType) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	v := s.ReadEnum(MType_value)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read MType enum: %v", err)
		return
	}
	*x = MType(v)
}

// UnmarshalText unmarshals the MType from text.
func (x *MType) UnmarshalText(b []byte) error {
	i, err := jsonplugin.ParseEnumString(string(b), MType_value)
	if err != nil {
		return err
	}
	*x = MType(i)
	return nil
}

// UnmarshalJSON unmarshals the MType from JSON.
func (x *MType) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the Major to JSON.
func (x Major) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	s.WriteEnumString(int32(x), Major_name)
}

// MarshalText marshals the Major to text.
func (x Major) MarshalText() ([]byte, error) {
	return []byte(jsonplugin.GetEnumString(int32(x), Major_name)), nil
}

// MarshalJSON marshals the Major to JSON.
func (x Major) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// Major_customvalue contains custom string values that extend Major_value.
var Major_customvalue = map[string]int32{
	"R1": 0,
}

// UnmarshalProtoJSON unmarshals the Major from JSON.
func (x *Major) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	v := s.ReadEnum(Major_value, Major_customvalue)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read Major enum: %v", err)
		return
	}
	*x = Major(v)
}

// UnmarshalText unmarshals the Major from text.
func (x *Major) UnmarshalText(b []byte) error {
	i, err := jsonplugin.ParseEnumString(string(b), Major_customvalue, Major_value)
	if err != nil {
		return err
	}
	*x = Major(i)
	return nil
}

// UnmarshalJSON unmarshals the Major from JSON.
func (x *Major) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the MACVersion to JSON.
func (x MACVersion) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	s.WriteEnumString(int32(x), MACVersion_name)
}

// MarshalText marshals the MACVersion to text.
func (x MACVersion) MarshalText() ([]byte, error) {
	return []byte(jsonplugin.GetEnumString(int32(x), MACVersion_name)), nil
}

// MarshalJSON marshals the MACVersion to JSON.
func (x MACVersion) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// MACVersion_customvalue contains custom string values that extend MACVersion_value.
var MACVersion_customvalue = map[string]int32{
	"UNKNOWN": 0,
	"unknown": 0,
	"V1_0":    1,
	"1.0":     1,
	"1.0.0":   1,
	"V1_0_1":  2,
	"1.0.1":   2,
	"V1_0_2":  3,
	"1.0.2":   3,
	"V1_1":    4,
	"1.1":     4,
	"1.1.0":   4,
	"V1_0_3":  5,
	"1.0.3":   5,
	"V1_0_4":  6,
	"1.0.4":   6,
}

// UnmarshalProtoJSON unmarshals the MACVersion from JSON.
func (x *MACVersion) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	v := s.ReadEnum(MACVersion_value, MACVersion_customvalue)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read MACVersion enum: %v", err)
		return
	}
	*x = MACVersion(v)
}

// UnmarshalText unmarshals the MACVersion from text.
func (x *MACVersion) UnmarshalText(b []byte) error {
	i, err := jsonplugin.ParseEnumString(string(b), MACVersion_customvalue, MACVersion_value)
	if err != nil {
		return err
	}
	*x = MACVersion(i)
	return nil
}

// UnmarshalJSON unmarshals the MACVersion from JSON.
func (x *MACVersion) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the PHYVersion to JSON.
func (x PHYVersion) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	s.WriteEnumString(int32(x), PHYVersion_name)
}

// MarshalText marshals the PHYVersion to text.
func (x PHYVersion) MarshalText() ([]byte, error) {
	return []byte(jsonplugin.GetEnumString(int32(x), PHYVersion_name)), nil
}

// MarshalJSON marshals the PHYVersion to JSON.
func (x PHYVersion) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// PHYVersion_customvalue contains custom string values that extend PHYVersion_value.
var PHYVersion_customvalue = map[string]int32{
	"unknown":      0,
	"1.0":          1,
	"1.0.0":        1,
	"V1_0":         1,
	"1.0.1":        2,
	"V1_0_1":       2,
	"1.0.2":        3,
	"1.0.2-a":      3,
	"V1_0_2":       3,
	"V1_0_2_REV_A": 3,
	"1.0.2-b":      4,
	"V1_0_2_REV_B": 4,
	"1.1-a":        5,
	"1.1.0-a":      5,
	"V1_1_REV_A":   5,
	"1.1-b":        6,
	"1.1.0-b":      6,
	"V1_1_REV_B":   6,
	"1.0.3-a":      7,
	"V1_0_3_REV_A": 7,
}

// UnmarshalProtoJSON unmarshals the PHYVersion from JSON.
func (x *PHYVersion) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	v := s.ReadEnum(PHYVersion_value, PHYVersion_customvalue)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read PHYVersion enum: %v", err)
		return
	}
	*x = PHYVersion(v)
}

// UnmarshalText unmarshals the PHYVersion from text.
func (x *PHYVersion) UnmarshalText(b []byte) error {
	i, err := jsonplugin.ParseEnumString(string(b), PHYVersion_customvalue, PHYVersion_value)
	if err != nil {
		return err
	}
	*x = PHYVersion(i)
	return nil
}

// UnmarshalJSON unmarshals the PHYVersion from JSON.
func (x *PHYVersion) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the DataRateIndex to JSON.
func (x DataRateIndex) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	s.WriteEnumNumber(int32(x))
}

// MarshalText marshals the DataRateIndex to text.
func (x DataRateIndex) MarshalText() ([]byte, error) {
	return []byte(strconv.FormatInt(int64(x), 10)), nil
}

// MarshalJSON marshals the DataRateIndex to JSON.
func (x DataRateIndex) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// DataRateIndex_customvalue contains custom string values that extend DataRateIndex_value.
var DataRateIndex_customvalue = map[string]int32{
	"0":  0,
	"1":  1,
	"2":  2,
	"3":  3,
	"4":  4,
	"5":  5,
	"6":  6,
	"7":  7,
	"8":  8,
	"9":  9,
	"10": 10,
	"11": 11,
	"12": 12,
	"13": 13,
	"14": 14,
	"15": 15,
}

// UnmarshalProtoJSON unmarshals the DataRateIndex from JSON.
func (x *DataRateIndex) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	v := s.ReadEnum(DataRateIndex_value, DataRateIndex_customvalue)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read DataRateIndex enum: %v", err)
		return
	}
	*x = DataRateIndex(v)
}

// UnmarshalText unmarshals the DataRateIndex from text.
func (x *DataRateIndex) UnmarshalText(b []byte) error {
	i, err := jsonplugin.ParseEnumString(string(b), DataRateIndex_customvalue, DataRateIndex_value)
	if err != nil {
		return err
	}
	*x = DataRateIndex(i)
	return nil
}

// UnmarshalJSON unmarshals the DataRateIndex from JSON.
func (x *DataRateIndex) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the DataRateOffset to JSON.
func (x DataRateOffset) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	s.WriteEnumNumber(int32(x))
}

// MarshalText marshals the DataRateOffset to text.
func (x DataRateOffset) MarshalText() ([]byte, error) {
	return []byte(strconv.FormatInt(int64(x), 10)), nil
}

// MarshalJSON marshals the DataRateOffset to JSON.
func (x DataRateOffset) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// DataRateOffset_customvalue contains custom string values that extend DataRateOffset_value.
var DataRateOffset_customvalue = map[string]int32{
	"0": 0,
	"1": 1,
	"2": 2,
	"3": 3,
	"4": 4,
	"5": 5,
	"6": 6,
	"7": 7,
}

// UnmarshalProtoJSON unmarshals the DataRateOffset from JSON.
func (x *DataRateOffset) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	v := s.ReadEnum(DataRateOffset_value, DataRateOffset_customvalue)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read DataRateOffset enum: %v", err)
		return
	}
	*x = DataRateOffset(v)
}

// UnmarshalText unmarshals the DataRateOffset from text.
func (x *DataRateOffset) UnmarshalText(b []byte) error {
	i, err := jsonplugin.ParseEnumString(string(b), DataRateOffset_customvalue, DataRateOffset_value)
	if err != nil {
		return err
	}
	*x = DataRateOffset(i)
	return nil
}

// UnmarshalJSON unmarshals the DataRateOffset from JSON.
func (x *DataRateOffset) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the JoinRequestType to JSON.
func (x JoinRequestType) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	s.WriteEnumString(int32(x), JoinRequestType_name)
}

// MarshalText marshals the JoinRequestType to text.
func (x JoinRequestType) MarshalText() ([]byte, error) {
	return []byte(jsonplugin.GetEnumString(int32(x), JoinRequestType_name)), nil
}

// MarshalJSON marshals the JoinRequestType to JSON.
func (x JoinRequestType) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the JoinRequestType from JSON.
func (x *JoinRequestType) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	v := s.ReadEnum(JoinRequestType_value)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read JoinRequestType enum: %v", err)
		return
	}
	*x = JoinRequestType(v)
}

// UnmarshalText unmarshals the JoinRequestType from text.
func (x *JoinRequestType) UnmarshalText(b []byte) error {
	i, err := jsonplugin.ParseEnumString(string(b), JoinRequestType_value)
	if err != nil {
		return err
	}
	*x = JoinRequestType(i)
	return nil
}

// UnmarshalJSON unmarshals the JoinRequestType from JSON.
func (x *JoinRequestType) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the RejoinRequestType to JSON.
func (x RejoinRequestType) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	s.WriteEnumString(int32(x), RejoinRequestType_name)
}

// MarshalText marshals the RejoinRequestType to text.
func (x RejoinRequestType) MarshalText() ([]byte, error) {
	return []byte(jsonplugin.GetEnumString(int32(x), RejoinRequestType_name)), nil
}

// MarshalJSON marshals the RejoinRequestType to JSON.
func (x RejoinRequestType) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the RejoinRequestType from JSON.
func (x *RejoinRequestType) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	v := s.ReadEnum(RejoinRequestType_value)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read RejoinRequestType enum: %v", err)
		return
	}
	*x = RejoinRequestType(v)
}

// UnmarshalText unmarshals the RejoinRequestType from text.
func (x *RejoinRequestType) UnmarshalText(b []byte) error {
	i, err := jsonplugin.ParseEnumString(string(b), RejoinRequestType_value)
	if err != nil {
		return err
	}
	*x = RejoinRequestType(i)
	return nil
}

// UnmarshalJSON unmarshals the RejoinRequestType from JSON.
func (x *RejoinRequestType) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the CFListType to JSON.
func (x CFListType) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	s.WriteEnumString(int32(x), CFListType_name)
}

// MarshalText marshals the CFListType to text.
func (x CFListType) MarshalText() ([]byte, error) {
	return []byte(jsonplugin.GetEnumString(int32(x), CFListType_name)), nil
}

// MarshalJSON marshals the CFListType to JSON.
func (x CFListType) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the CFListType from JSON.
func (x *CFListType) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	v := s.ReadEnum(CFListType_value)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read CFListType enum: %v", err)
		return
	}
	*x = CFListType(v)
}

// UnmarshalText unmarshals the CFListType from text.
func (x *CFListType) UnmarshalText(b []byte) error {
	i, err := jsonplugin.ParseEnumString(string(b), CFListType_value)
	if err != nil {
		return err
	}
	*x = CFListType(i)
	return nil
}

// UnmarshalJSON unmarshals the CFListType from JSON.
func (x *CFListType) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the Class to JSON.
func (x Class) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	s.WriteEnumString(int32(x), Class_name)
}

// MarshalText marshals the Class to text.
func (x Class) MarshalText() ([]byte, error) {
	return []byte(jsonplugin.GetEnumString(int32(x), Class_name)), nil
}

// MarshalJSON marshals the Class to JSON.
func (x Class) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// Class_customvalue contains custom string values that extend Class_value.
var Class_customvalue = map[string]int32{
	"A": 0,
	"B": 1,
	"C": 2,
}

// UnmarshalProtoJSON unmarshals the Class from JSON.
func (x *Class) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	v := s.ReadEnum(Class_value, Class_customvalue)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read Class enum: %v", err)
		return
	}
	*x = Class(v)
}

// UnmarshalText unmarshals the Class from text.
func (x *Class) UnmarshalText(b []byte) error {
	i, err := jsonplugin.ParseEnumString(string(b), Class_customvalue, Class_value)
	if err != nil {
		return err
	}
	*x = Class(i)
	return nil
}

// UnmarshalJSON unmarshals the Class from JSON.
func (x *Class) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the TxSchedulePriority to JSON.
func (x TxSchedulePriority) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	s.WriteEnumString(int32(x), TxSchedulePriority_name)
}

// MarshalText marshals the TxSchedulePriority to text.
func (x TxSchedulePriority) MarshalText() ([]byte, error) {
	return []byte(jsonplugin.GetEnumString(int32(x), TxSchedulePriority_name)), nil
}

// MarshalJSON marshals the TxSchedulePriority to JSON.
func (x TxSchedulePriority) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the TxSchedulePriority from JSON.
func (x *TxSchedulePriority) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	v := s.ReadEnum(TxSchedulePriority_value)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read TxSchedulePriority enum: %v", err)
		return
	}
	*x = TxSchedulePriority(v)
}

// UnmarshalText unmarshals the TxSchedulePriority from text.
func (x *TxSchedulePriority) UnmarshalText(b []byte) error {
	i, err := jsonplugin.ParseEnumString(string(b), TxSchedulePriority_value)
	if err != nil {
		return err
	}
	*x = TxSchedulePriority(i)
	return nil
}

// UnmarshalJSON unmarshals the TxSchedulePriority from JSON.
func (x *TxSchedulePriority) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the MACCommandIdentifier to JSON.
func (x MACCommandIdentifier) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	s.WriteEnumString(int32(x), MACCommandIdentifier_name)
}

// MarshalText marshals the MACCommandIdentifier to text.
func (x MACCommandIdentifier) MarshalText() ([]byte, error) {
	return []byte(jsonplugin.GetEnumString(int32(x), MACCommandIdentifier_name)), nil
}

// MarshalJSON marshals the MACCommandIdentifier to JSON.
func (x MACCommandIdentifier) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// MACCommandIdentifier_customvalue contains custom string values that extend MACCommandIdentifier_value.
var MACCommandIdentifier_customvalue = map[string]int32{
	"RFU_0":              0,
	"RESET":              1,
	"LINK_CHECK":         2,
	"LINK_ADR":           3,
	"DUTY_CYCLE":         4,
	"RX_PARAM_SETUP":     5,
	"DEV_STATUS":         6,
	"NEW_CHANNEL":        7,
	"RX_TIMING_SETUP":    8,
	"TX_PARAM_SETUP":     9,
	"DL_CHANNEL":         10,
	"REKEY":              11,
	"ADR_PARAM_SETUP":    12,
	"DEVICE_TIME":        13,
	"FORCE_REJOIN":       14,
	"REJOIN_PARAM_SETUP": 15,
	"PING_SLOT_INFO":     16,
	"PING_SLOT_CHANNEL":  17,
	"BEACON_TIMING":      18,
	"BEACON_FREQ":        19,
	"DEVICE_MODE":        32,
}

// UnmarshalProtoJSON unmarshals the MACCommandIdentifier from JSON.
func (x *MACCommandIdentifier) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	v := s.ReadEnum(MACCommandIdentifier_value, MACCommandIdentifier_customvalue)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read MACCommandIdentifier enum: %v", err)
		return
	}
	*x = MACCommandIdentifier(v)
}

// UnmarshalText unmarshals the MACCommandIdentifier from text.
func (x *MACCommandIdentifier) UnmarshalText(b []byte) error {
	i, err := jsonplugin.ParseEnumString(string(b), MACCommandIdentifier_customvalue, MACCommandIdentifier_value)
	if err != nil {
		return err
	}
	*x = MACCommandIdentifier(i)
	return nil
}

// UnmarshalJSON unmarshals the MACCommandIdentifier from JSON.
func (x *MACCommandIdentifier) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the AggregatedDutyCycle to JSON.
func (x AggregatedDutyCycle) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	s.WriteEnumString(int32(x), AggregatedDutyCycle_name)
}

// MarshalText marshals the AggregatedDutyCycle to text.
func (x AggregatedDutyCycle) MarshalText() ([]byte, error) {
	return []byte(jsonplugin.GetEnumString(int32(x), AggregatedDutyCycle_name)), nil
}

// MarshalJSON marshals the AggregatedDutyCycle to JSON.
func (x AggregatedDutyCycle) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// AggregatedDutyCycle_customvalue contains custom string values that extend AggregatedDutyCycle_value.
var AggregatedDutyCycle_customvalue = map[string]int32{
	"1":     0,
	"2":     1,
	"4":     2,
	"8":     3,
	"16":    4,
	"32":    5,
	"64":    6,
	"128":   7,
	"256":   8,
	"512":   9,
	"1024":  10,
	"2048":  11,
	"4096":  12,
	"8192":  13,
	"16384": 14,
	"32768": 15,
}

// UnmarshalProtoJSON unmarshals the AggregatedDutyCycle from JSON.
func (x *AggregatedDutyCycle) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	v := s.ReadEnum(AggregatedDutyCycle_value, AggregatedDutyCycle_customvalue)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read AggregatedDutyCycle enum: %v", err)
		return
	}
	*x = AggregatedDutyCycle(v)
}

// UnmarshalText unmarshals the AggregatedDutyCycle from text.
func (x *AggregatedDutyCycle) UnmarshalText(b []byte) error {
	i, err := jsonplugin.ParseEnumString(string(b), AggregatedDutyCycle_customvalue, AggregatedDutyCycle_value)
	if err != nil {
		return err
	}
	*x = AggregatedDutyCycle(i)
	return nil
}

// UnmarshalJSON unmarshals the AggregatedDutyCycle from JSON.
func (x *AggregatedDutyCycle) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the PingSlotPeriod to JSON.
func (x PingSlotPeriod) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	s.WriteEnumString(int32(x), PingSlotPeriod_name)
}

// MarshalText marshals the PingSlotPeriod to text.
func (x PingSlotPeriod) MarshalText() ([]byte, error) {
	return []byte(jsonplugin.GetEnumString(int32(x), PingSlotPeriod_name)), nil
}

// MarshalJSON marshals the PingSlotPeriod to JSON.
func (x PingSlotPeriod) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// PingSlotPeriod_customvalue contains custom string values that extend PingSlotPeriod_value.
var PingSlotPeriod_customvalue = map[string]int32{
	"1S":   0,
	"2S":   1,
	"4S":   2,
	"8S":   3,
	"16S":  4,
	"32S":  5,
	"64S":  6,
	"128S": 7,
}

// UnmarshalProtoJSON unmarshals the PingSlotPeriod from JSON.
func (x *PingSlotPeriod) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	v := s.ReadEnum(PingSlotPeriod_value, PingSlotPeriod_customvalue)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read PingSlotPeriod enum: %v", err)
		return
	}
	*x = PingSlotPeriod(v)
}

// UnmarshalText unmarshals the PingSlotPeriod from text.
func (x *PingSlotPeriod) UnmarshalText(b []byte) error {
	i, err := jsonplugin.ParseEnumString(string(b), PingSlotPeriod_customvalue, PingSlotPeriod_value)
	if err != nil {
		return err
	}
	*x = PingSlotPeriod(i)
	return nil
}

// UnmarshalJSON unmarshals the PingSlotPeriod from JSON.
func (x *PingSlotPeriod) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the RejoinCountExponent to JSON.
func (x RejoinCountExponent) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	s.WriteEnumString(int32(x), RejoinCountExponent_name)
}

// MarshalText marshals the RejoinCountExponent to text.
func (x RejoinCountExponent) MarshalText() ([]byte, error) {
	return []byte(jsonplugin.GetEnumString(int32(x), RejoinCountExponent_name)), nil
}

// MarshalJSON marshals the RejoinCountExponent to JSON.
func (x RejoinCountExponent) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// RejoinCountExponent_customvalue contains custom string values that extend RejoinCountExponent_value.
var RejoinCountExponent_customvalue = map[string]int32{
	"16":     0,
	"32":     1,
	"64":     2,
	"128":    3,
	"256":    4,
	"512":    5,
	"1024":   6,
	"2048":   7,
	"4096":   8,
	"8192":   9,
	"16384":  10,
	"32768":  11,
	"65536":  12,
	"131072": 13,
	"262144": 14,
	"524288": 15,
}

// UnmarshalProtoJSON unmarshals the RejoinCountExponent from JSON.
func (x *RejoinCountExponent) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	v := s.ReadEnum(RejoinCountExponent_value, RejoinCountExponent_customvalue)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read RejoinCountExponent enum: %v", err)
		return
	}
	*x = RejoinCountExponent(v)
}

// UnmarshalText unmarshals the RejoinCountExponent from text.
func (x *RejoinCountExponent) UnmarshalText(b []byte) error {
	i, err := jsonplugin.ParseEnumString(string(b), RejoinCountExponent_customvalue, RejoinCountExponent_value)
	if err != nil {
		return err
	}
	*x = RejoinCountExponent(i)
	return nil
}

// UnmarshalJSON unmarshals the RejoinCountExponent from JSON.
func (x *RejoinCountExponent) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the RejoinTimeExponent to JSON.
func (x RejoinTimeExponent) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	s.WriteEnumString(int32(x), RejoinTimeExponent_name)
}

// MarshalText marshals the RejoinTimeExponent to text.
func (x RejoinTimeExponent) MarshalText() ([]byte, error) {
	return []byte(jsonplugin.GetEnumString(int32(x), RejoinTimeExponent_name)), nil
}

// MarshalJSON marshals the RejoinTimeExponent to JSON.
func (x RejoinTimeExponent) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// RejoinTimeExponent_customvalue contains custom string values that extend RejoinTimeExponent_value.
var RejoinTimeExponent_customvalue = map[string]int32{
	"0":  0,
	"1":  1,
	"2":  2,
	"3":  3,
	"4":  4,
	"5":  5,
	"6":  6,
	"7":  7,
	"8":  8,
	"9":  9,
	"10": 10,
	"11": 11,
	"12": 12,
	"13": 13,
	"14": 14,
	"15": 15,
}

// UnmarshalProtoJSON unmarshals the RejoinTimeExponent from JSON.
func (x *RejoinTimeExponent) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	v := s.ReadEnum(RejoinTimeExponent_value, RejoinTimeExponent_customvalue)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read RejoinTimeExponent enum: %v", err)
		return
	}
	*x = RejoinTimeExponent(v)
}

// UnmarshalText unmarshals the RejoinTimeExponent from text.
func (x *RejoinTimeExponent) UnmarshalText(b []byte) error {
	i, err := jsonplugin.ParseEnumString(string(b), RejoinTimeExponent_customvalue, RejoinTimeExponent_value)
	if err != nil {
		return err
	}
	*x = RejoinTimeExponent(i)
	return nil
}

// UnmarshalJSON unmarshals the RejoinTimeExponent from JSON.
func (x *RejoinTimeExponent) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the RejoinPeriodExponent to JSON.
func (x RejoinPeriodExponent) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	s.WriteEnumString(int32(x), RejoinPeriodExponent_name)
}

// MarshalText marshals the RejoinPeriodExponent to text.
func (x RejoinPeriodExponent) MarshalText() ([]byte, error) {
	return []byte(jsonplugin.GetEnumString(int32(x), RejoinPeriodExponent_name)), nil
}

// MarshalJSON marshals the RejoinPeriodExponent to JSON.
func (x RejoinPeriodExponent) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// RejoinPeriodExponent_customvalue contains custom string values that extend RejoinPeriodExponent_value.
var RejoinPeriodExponent_customvalue = map[string]int32{
	"0": 0,
	"1": 1,
	"2": 2,
	"3": 3,
	"4": 4,
	"5": 5,
	"6": 6,
	"7": 7,
}

// UnmarshalProtoJSON unmarshals the RejoinPeriodExponent from JSON.
func (x *RejoinPeriodExponent) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	v := s.ReadEnum(RejoinPeriodExponent_value, RejoinPeriodExponent_customvalue)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read RejoinPeriodExponent enum: %v", err)
		return
	}
	*x = RejoinPeriodExponent(v)
}

// UnmarshalText unmarshals the RejoinPeriodExponent from text.
func (x *RejoinPeriodExponent) UnmarshalText(b []byte) error {
	i, err := jsonplugin.ParseEnumString(string(b), RejoinPeriodExponent_customvalue, RejoinPeriodExponent_value)
	if err != nil {
		return err
	}
	*x = RejoinPeriodExponent(i)
	return nil
}

// UnmarshalJSON unmarshals the RejoinPeriodExponent from JSON.
func (x *RejoinPeriodExponent) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the DeviceEIRP to JSON.
func (x DeviceEIRP) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	s.WriteEnumString(int32(x), DeviceEIRP_name)
}

// MarshalText marshals the DeviceEIRP to text.
func (x DeviceEIRP) MarshalText() ([]byte, error) {
	return []byte(jsonplugin.GetEnumString(int32(x), DeviceEIRP_name)), nil
}

// MarshalJSON marshals the DeviceEIRP to JSON.
func (x DeviceEIRP) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// DeviceEIRP_customvalue contains custom string values that extend DeviceEIRP_value.
var DeviceEIRP_customvalue = map[string]int32{
	"8":  0,
	"10": 1,
	"12": 2,
	"13": 3,
	"14": 4,
	"16": 5,
	"18": 6,
	"20": 7,
	"21": 8,
	"24": 9,
	"26": 10,
	"27": 11,
	"29": 12,
	"30": 13,
	"33": 14,
	"36": 15,
}

// UnmarshalProtoJSON unmarshals the DeviceEIRP from JSON.
func (x *DeviceEIRP) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	v := s.ReadEnum(DeviceEIRP_value, DeviceEIRP_customvalue)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read DeviceEIRP enum: %v", err)
		return
	}
	*x = DeviceEIRP(v)
}

// UnmarshalText unmarshals the DeviceEIRP from text.
func (x *DeviceEIRP) UnmarshalText(b []byte) error {
	i, err := jsonplugin.ParseEnumString(string(b), DeviceEIRP_customvalue, DeviceEIRP_value)
	if err != nil {
		return err
	}
	*x = DeviceEIRP(i)
	return nil
}

// UnmarshalJSON unmarshals the DeviceEIRP from JSON.
func (x *DeviceEIRP) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ADRAckLimitExponent to JSON.
func (x ADRAckLimitExponent) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	s.WriteEnumString(int32(x), ADRAckLimitExponent_name)
}

// MarshalText marshals the ADRAckLimitExponent to text.
func (x ADRAckLimitExponent) MarshalText() ([]byte, error) {
	return []byte(jsonplugin.GetEnumString(int32(x), ADRAckLimitExponent_name)), nil
}

// MarshalJSON marshals the ADRAckLimitExponent to JSON.
func (x ADRAckLimitExponent) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// ADRAckLimitExponent_customvalue contains custom string values that extend ADRAckLimitExponent_value.
var ADRAckLimitExponent_customvalue = map[string]int32{
	"1":     0,
	"2":     1,
	"4":     2,
	"8":     3,
	"16":    4,
	"32":    5,
	"64":    6,
	"128":   7,
	"256":   8,
	"512":   9,
	"1024":  10,
	"2048":  11,
	"4096":  12,
	"8192":  13,
	"16384": 14,
	"32768": 15,
}

// UnmarshalProtoJSON unmarshals the ADRAckLimitExponent from JSON.
func (x *ADRAckLimitExponent) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	v := s.ReadEnum(ADRAckLimitExponent_value, ADRAckLimitExponent_customvalue)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read ADRAckLimitExponent enum: %v", err)
		return
	}
	*x = ADRAckLimitExponent(v)
}

// UnmarshalText unmarshals the ADRAckLimitExponent from text.
func (x *ADRAckLimitExponent) UnmarshalText(b []byte) error {
	i, err := jsonplugin.ParseEnumString(string(b), ADRAckLimitExponent_customvalue, ADRAckLimitExponent_value)
	if err != nil {
		return err
	}
	*x = ADRAckLimitExponent(i)
	return nil
}

// UnmarshalJSON unmarshals the ADRAckLimitExponent from JSON.
func (x *ADRAckLimitExponent) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ADRAckDelayExponent to JSON.
func (x ADRAckDelayExponent) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	s.WriteEnumString(int32(x), ADRAckDelayExponent_name)
}

// MarshalText marshals the ADRAckDelayExponent to text.
func (x ADRAckDelayExponent) MarshalText() ([]byte, error) {
	return []byte(jsonplugin.GetEnumString(int32(x), ADRAckDelayExponent_name)), nil
}

// MarshalJSON marshals the ADRAckDelayExponent to JSON.
func (x ADRAckDelayExponent) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// ADRAckDelayExponent_customvalue contains custom string values that extend ADRAckDelayExponent_value.
var ADRAckDelayExponent_customvalue = map[string]int32{
	"1":     0,
	"2":     1,
	"4":     2,
	"8":     3,
	"16":    4,
	"32":    5,
	"64":    6,
	"128":   7,
	"256":   8,
	"512":   9,
	"1024":  10,
	"2048":  11,
	"4096":  12,
	"8192":  13,
	"16384": 14,
	"32768": 15,
}

// UnmarshalProtoJSON unmarshals the ADRAckDelayExponent from JSON.
func (x *ADRAckDelayExponent) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	v := s.ReadEnum(ADRAckDelayExponent_value, ADRAckDelayExponent_customvalue)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read ADRAckDelayExponent enum: %v", err)
		return
	}
	*x = ADRAckDelayExponent(v)
}

// UnmarshalText unmarshals the ADRAckDelayExponent from text.
func (x *ADRAckDelayExponent) UnmarshalText(b []byte) error {
	i, err := jsonplugin.ParseEnumString(string(b), ADRAckDelayExponent_customvalue, ADRAckDelayExponent_value)
	if err != nil {
		return err
	}
	*x = ADRAckDelayExponent(i)
	return nil
}

// UnmarshalJSON unmarshals the ADRAckDelayExponent from JSON.
func (x *ADRAckDelayExponent) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the RxDelay to JSON.
func (x RxDelay) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	s.WriteEnumNumber(int32(x))
}

// MarshalText marshals the RxDelay to text.
func (x RxDelay) MarshalText() ([]byte, error) {
	return []byte(strconv.FormatInt(int64(x), 10)), nil
}

// MarshalJSON marshals the RxDelay to JSON.
func (x RxDelay) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// RxDelay_customvalue contains custom string values that extend RxDelay_value.
var RxDelay_customvalue = map[string]int32{
	"0":  0,
	"1":  1,
	"2":  2,
	"3":  3,
	"4":  4,
	"5":  5,
	"6":  6,
	"7":  7,
	"8":  8,
	"9":  9,
	"10": 10,
	"11": 11,
	"12": 12,
	"13": 13,
	"14": 14,
	"15": 15,
}

// UnmarshalProtoJSON unmarshals the RxDelay from JSON.
func (x *RxDelay) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	v := s.ReadEnum(RxDelay_value, RxDelay_customvalue)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read RxDelay enum: %v", err)
		return
	}
	*x = RxDelay(v)
}

// UnmarshalText unmarshals the RxDelay from text.
func (x *RxDelay) UnmarshalText(b []byte) error {
	i, err := jsonplugin.ParseEnumString(string(b), RxDelay_customvalue, RxDelay_value)
	if err != nil {
		return err
	}
	*x = RxDelay(i)
	return nil
}

// UnmarshalJSON unmarshals the RxDelay from JSON.
func (x *RxDelay) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the Minor to JSON.
func (x Minor) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	s.WriteEnumString(int32(x), Minor_name)
}

// MarshalText marshals the Minor to text.
func (x Minor) MarshalText() ([]byte, error) {
	return []byte(jsonplugin.GetEnumString(int32(x), Minor_name)), nil
}

// MarshalJSON marshals the Minor to JSON.
func (x Minor) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// Minor_customvalue contains custom string values that extend Minor_value.
var Minor_customvalue = map[string]int32{
	"RFU_0":  0,
	"1":      1,
	"RFU_2":  2,
	"RFU_3":  3,
	"RFU_4":  4,
	"RFU_5":  5,
	"RFU_6":  6,
	"RFU_7":  7,
	"RFU_8":  8,
	"RFU_9":  9,
	"RFU_10": 10,
	"RFU_11": 11,
	"RFU_12": 12,
	"RFU_13": 13,
	"RFU_14": 14,
	"RFU_15": 15,
}

// UnmarshalProtoJSON unmarshals the Minor from JSON.
func (x *Minor) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	v := s.ReadEnum(Minor_value, Minor_customvalue)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read Minor enum: %v", err)
		return
	}
	*x = Minor(v)
}

// UnmarshalText unmarshals the Minor from text.
func (x *Minor) UnmarshalText(b []byte) error {
	i, err := jsonplugin.ParseEnumString(string(b), Minor_customvalue, Minor_value)
	if err != nil {
		return err
	}
	*x = Minor(i)
	return nil
}

// UnmarshalJSON unmarshals the Minor from JSON.
func (x *Minor) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the Message message to JSON.
func (x *Message) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.MHdr != nil || s.HasField("m_hdr") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("m_hdr")
		x.MHdr.MarshalProtoJSON(s.WithField("m_hdr"))
	}
	if len(x.Mic) > 0 || s.HasField("mic") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("mic")
		s.WriteBytes(x.Mic)
	}
	if x.Payload != nil {
		switch ov := x.Payload.(type) {
		case *Message_MacPayload:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("mac_payload")
			ov.MacPayload.MarshalProtoJSON(s.WithField("mac_payload"))
		case *Message_JoinRequestPayload:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("join_request_payload")
			ov.JoinRequestPayload.MarshalProtoJSON(s.WithField("join_request_payload"))
		case *Message_JoinAcceptPayload:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("join_accept_payload")
			ov.JoinAcceptPayload.MarshalProtoJSON(s.WithField("join_accept_payload"))
		case *Message_RejoinRequestPayload:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("rejoin_request_payload")
			ov.RejoinRequestPayload.MarshalProtoJSON(s.WithField("rejoin_request_payload"))
		}
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the Message to JSON.
func (x *Message) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the Message message from JSON.
func (x *Message) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "m_hdr", "mHdr":
			if s.ReadNil() {
				x.MHdr = nil
				return
			}
			x.MHdr = &MHDR{}
			x.MHdr.UnmarshalProtoJSON(s.WithField("m_hdr", true))
		case "mic":
			s.AddField("mic")
			x.Mic = s.ReadBytes()
		case "mac_payload", "macPayload":
			ov := &Message_MacPayload{}
			x.Payload = ov
			if s.ReadNil() {
				ov.MacPayload = nil
				return
			}
			ov.MacPayload = &MACPayload{}
			ov.MacPayload.UnmarshalProtoJSON(s.WithField("mac_payload", true))
		case "join_request_payload", "joinRequestPayload":
			ov := &Message_JoinRequestPayload{}
			x.Payload = ov
			if s.ReadNil() {
				ov.JoinRequestPayload = nil
				return
			}
			ov.JoinRequestPayload = &JoinRequestPayload{}
			ov.JoinRequestPayload.UnmarshalProtoJSON(s.WithField("join_request_payload", true))
		case "join_accept_payload", "joinAcceptPayload":
			ov := &Message_JoinAcceptPayload{}
			x.Payload = ov
			if s.ReadNil() {
				ov.JoinAcceptPayload = nil
				return
			}
			ov.JoinAcceptPayload = &JoinAcceptPayload{}
			ov.JoinAcceptPayload.UnmarshalProtoJSON(s.WithField("join_accept_payload", true))
		case "rejoin_request_payload", "rejoinRequestPayload":
			ov := &Message_RejoinRequestPayload{}
			x.Payload = ov
			if s.ReadNil() {
				ov.RejoinRequestPayload = nil
				return
			}
			ov.RejoinRequestPayload = &RejoinRequestPayload{}
			ov.RejoinRequestPayload.UnmarshalProtoJSON(s.WithField("rejoin_request_payload", true))
		}
	})
}

// UnmarshalJSON unmarshals the Message from JSON.
func (x *Message) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the MHDR message to JSON.
func (x *MHDR) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.MType != 0 || s.HasField("m_type") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("m_type")
		x.MType.MarshalProtoJSON(s)
	}
	if x.Major != 0 || s.HasField("major") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("major")
		x.Major.MarshalProtoJSON(s)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the MHDR to JSON.
func (x *MHDR) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the MHDR message from JSON.
func (x *MHDR) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "m_type", "mType":
			s.AddField("m_type")
			x.MType.UnmarshalProtoJSON(s)
		case "major":
			s.AddField("major")
			x.Major.UnmarshalProtoJSON(s)
		}
	})
}

// UnmarshalJSON unmarshals the MHDR from JSON.
func (x *MHDR) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the MACPayload message to JSON.
func (x *MACPayload) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.FHdr != nil || s.HasField("f_hdr") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("f_hdr")
		x.FHdr.MarshalProtoJSON(s.WithField("f_hdr"))
	}
	if x.FPort != 0 || s.HasField("f_port") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("f_port")
		s.WriteUint32(x.FPort)
	}
	if len(x.FrmPayload) > 0 || s.HasField("frm_payload") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("frm_payload")
		s.WriteBytes(x.FrmPayload)
	}
	if x.DecodedPayload != nil || s.HasField("decoded_payload") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("decoded_payload")
		if x.DecodedPayload == nil {
			s.WriteNil()
		} else {
			golang.MarshalStruct(s, x.DecodedPayload)
		}
	}
	if x.FullFCnt != 0 || s.HasField("full_f_cnt") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("full_f_cnt")
		s.WriteUint32(x.FullFCnt)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the MACPayload to JSON.
func (x *MACPayload) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the MACPayload message from JSON.
func (x *MACPayload) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "f_hdr", "fHdr":
			if s.ReadNil() {
				x.FHdr = nil
				return
			}
			x.FHdr = &FHDR{}
			x.FHdr.UnmarshalProtoJSON(s.WithField("f_hdr", true))
		case "f_port", "fPort":
			s.AddField("f_port")
			x.FPort = s.ReadUint32()
		case "frm_payload", "frmPayload":
			s.AddField("frm_payload")
			x.FrmPayload = s.ReadBytes()
		case "decoded_payload", "decodedPayload":
			s.AddField("decoded_payload")
			if s.ReadNil() {
				x.DecodedPayload = nil
				return
			}
			v := golang.UnmarshalStruct(s)
			if s.Err() != nil {
				return
			}
			x.DecodedPayload = v
		case "full_f_cnt", "fullFCnt":
			s.AddField("full_f_cnt")
			x.FullFCnt = s.ReadUint32()
		}
	})
}

// UnmarshalJSON unmarshals the MACPayload from JSON.
func (x *MACPayload) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the FHDR message to JSON.
func (x *FHDR) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if len(x.DevAddr) > 0 || s.HasField("dev_addr") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("dev_addr")
		types.MarshalHEXBytes(s.WithField("dev_addr"), x.DevAddr)
	}
	if x.FCtrl != nil || s.HasField("f_ctrl") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("f_ctrl")
		// NOTE: FCtrl does not seem to implement MarshalProtoJSON.
		golang.MarshalMessage(s, x.FCtrl)
	}
	if x.FCnt != 0 || s.HasField("f_cnt") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("f_cnt")
		s.WriteUint32(x.FCnt)
	}
	if len(x.FOpts) > 0 || s.HasField("f_opts") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("f_opts")
		s.WriteBytes(x.FOpts)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the FHDR to JSON.
func (x *FHDR) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the FHDR message from JSON.
func (x *FHDR) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "dev_addr", "devAddr":
			s.AddField("dev_addr")
			x.DevAddr = types.Unmarshal4Bytes(s.WithField("dev_addr", false))
		case "f_ctrl", "fCtrl":
			s.AddField("f_ctrl")
			if s.ReadNil() {
				x.FCtrl = nil
				return
			}
			// NOTE: FCtrl does not seem to implement UnmarshalProtoJSON.
			var v FCtrl
			golang.UnmarshalMessage(s, &v)
			x.FCtrl = &v
		case "f_cnt", "fCnt":
			s.AddField("f_cnt")
			x.FCnt = s.ReadUint32()
		case "f_opts", "fOpts":
			s.AddField("f_opts")
			x.FOpts = s.ReadBytes()
		}
	})
}

// UnmarshalJSON unmarshals the FHDR from JSON.
func (x *FHDR) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the JoinRequestPayload message to JSON.
func (x *JoinRequestPayload) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if len(x.JoinEui) > 0 || s.HasField("join_eui") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("join_eui")
		types.MarshalHEXBytes(s.WithField("join_eui"), x.JoinEui)
	}
	if len(x.DevEui) > 0 || s.HasField("dev_eui") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("dev_eui")
		types.MarshalHEXBytes(s.WithField("dev_eui"), x.DevEui)
	}
	if len(x.DevNonce) > 0 || s.HasField("dev_nonce") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("dev_nonce")
		types.MarshalHEXBytes(s.WithField("dev_nonce"), x.DevNonce)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the JoinRequestPayload to JSON.
func (x *JoinRequestPayload) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the JoinRequestPayload message from JSON.
func (x *JoinRequestPayload) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "join_eui", "joinEui":
			s.AddField("join_eui")
			x.JoinEui = types.Unmarshal8Bytes(s.WithField("join_eui", false))
		case "dev_eui", "devEui":
			s.AddField("dev_eui")
			x.DevEui = types.Unmarshal8Bytes(s.WithField("dev_eui", false))
		case "dev_nonce", "devNonce":
			s.AddField("dev_nonce")
			x.DevNonce = types.Unmarshal2Bytes(s.WithField("dev_nonce", false))
		}
	})
}

// UnmarshalJSON unmarshals the JoinRequestPayload from JSON.
func (x *JoinRequestPayload) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the RejoinRequestPayload message to JSON.
func (x *RejoinRequestPayload) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.RejoinType != 0 || s.HasField("rejoin_type") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("rejoin_type")
		x.RejoinType.MarshalProtoJSON(s)
	}
	if len(x.NetId) > 0 || s.HasField("net_id") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("net_id")
		types.MarshalHEXBytes(s.WithField("net_id"), x.NetId)
	}
	if len(x.JoinEui) > 0 || s.HasField("join_eui") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("join_eui")
		types.MarshalHEXBytes(s.WithField("join_eui"), x.JoinEui)
	}
	if len(x.DevEui) > 0 || s.HasField("dev_eui") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("dev_eui")
		types.MarshalHEXBytes(s.WithField("dev_eui"), x.DevEui)
	}
	if x.RejoinCnt != 0 || s.HasField("rejoin_cnt") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("rejoin_cnt")
		s.WriteUint32(x.RejoinCnt)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the RejoinRequestPayload to JSON.
func (x *RejoinRequestPayload) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the RejoinRequestPayload message from JSON.
func (x *RejoinRequestPayload) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "rejoin_type", "rejoinType":
			s.AddField("rejoin_type")
			x.RejoinType.UnmarshalProtoJSON(s)
		case "net_id", "netId":
			s.AddField("net_id")
			x.NetId = types.Unmarshal3Bytes(s.WithField("net_id", false))
		case "join_eui", "joinEui":
			s.AddField("join_eui")
			x.JoinEui = types.Unmarshal8Bytes(s.WithField("join_eui", false))
		case "dev_eui", "devEui":
			s.AddField("dev_eui")
			x.DevEui = types.Unmarshal8Bytes(s.WithField("dev_eui", false))
		case "rejoin_cnt", "rejoinCnt":
			s.AddField("rejoin_cnt")
			x.RejoinCnt = s.ReadUint32()
		}
	})
}

// UnmarshalJSON unmarshals the RejoinRequestPayload from JSON.
func (x *RejoinRequestPayload) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the JoinAcceptPayload message to JSON.
func (x *JoinAcceptPayload) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if len(x.Encrypted) > 0 || s.HasField("encrypted") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("encrypted")
		s.WriteBytes(x.Encrypted)
	}
	if len(x.JoinNonce) > 0 || s.HasField("join_nonce") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("join_nonce")
		types.MarshalHEXBytes(s.WithField("join_nonce"), x.JoinNonce)
	}
	if len(x.NetId) > 0 || s.HasField("net_id") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("net_id")
		types.MarshalHEXBytes(s.WithField("net_id"), x.NetId)
	}
	if len(x.DevAddr) > 0 || s.HasField("dev_addr") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("dev_addr")
		types.MarshalHEXBytes(s.WithField("dev_addr"), x.DevAddr)
	}
	if x.DlSettings != nil || s.HasField("dl_settings") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("dl_settings")
		x.DlSettings.MarshalProtoJSON(s.WithField("dl_settings"))
	}
	if x.RxDelay != 0 || s.HasField("rx_delay") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("rx_delay")
		x.RxDelay.MarshalProtoJSON(s)
	}
	if x.CfList != nil || s.HasField("cf_list") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("cf_list")
		x.CfList.MarshalProtoJSON(s.WithField("cf_list"))
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the JoinAcceptPayload to JSON.
func (x *JoinAcceptPayload) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the JoinAcceptPayload message from JSON.
func (x *JoinAcceptPayload) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "encrypted":
			s.AddField("encrypted")
			x.Encrypted = s.ReadBytes()
		case "join_nonce", "joinNonce":
			s.AddField("join_nonce")
			x.JoinNonce = types.Unmarshal3Bytes(s.WithField("join_nonce", false))
		case "net_id", "netId":
			s.AddField("net_id")
			x.NetId = types.Unmarshal3Bytes(s.WithField("net_id", false))
		case "dev_addr", "devAddr":
			s.AddField("dev_addr")
			x.DevAddr = types.Unmarshal4Bytes(s.WithField("dev_addr", false))
		case "dl_settings", "dlSettings":
			if s.ReadNil() {
				x.DlSettings = nil
				return
			}
			x.DlSettings = &DLSettings{}
			x.DlSettings.UnmarshalProtoJSON(s.WithField("dl_settings", true))
		case "rx_delay", "rxDelay":
			s.AddField("rx_delay")
			x.RxDelay.UnmarshalProtoJSON(s)
		case "cf_list", "cfList":
			if s.ReadNil() {
				x.CfList = nil
				return
			}
			x.CfList = &CFList{}
			x.CfList.UnmarshalProtoJSON(s.WithField("cf_list", true))
		}
	})
}

// UnmarshalJSON unmarshals the JoinAcceptPayload from JSON.
func (x *JoinAcceptPayload) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the DLSettings message to JSON.
func (x *DLSettings) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Rx1DrOffset != 0 || s.HasField("rx1_dr_offset") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("rx1_dr_offset")
		x.Rx1DrOffset.MarshalProtoJSON(s)
	}
	if x.Rx2Dr != 0 || s.HasField("rx2_dr") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("rx2_dr")
		x.Rx2Dr.MarshalProtoJSON(s)
	}
	if x.OptNeg || s.HasField("opt_neg") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("opt_neg")
		s.WriteBool(x.OptNeg)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the DLSettings to JSON.
func (x *DLSettings) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the DLSettings message from JSON.
func (x *DLSettings) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "rx1_dr_offset", "rx1DrOffset":
			s.AddField("rx1_dr_offset")
			x.Rx1DrOffset.UnmarshalProtoJSON(s)
		case "rx2_dr", "rx2Dr":
			s.AddField("rx2_dr")
			x.Rx2Dr.UnmarshalProtoJSON(s)
		case "opt_neg", "optNeg":
			s.AddField("opt_neg")
			x.OptNeg = s.ReadBool()
		}
	})
}

// UnmarshalJSON unmarshals the DLSettings from JSON.
func (x *DLSettings) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the CFList message to JSON.
func (x *CFList) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Type != 0 || s.HasField("type") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("type")
		x.Type.MarshalProtoJSON(s)
	}
	if len(x.Freq) > 0 || s.HasField("freq") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("freq")
		s.WriteUint32Array(x.Freq)
	}
	if len(x.ChMasks) > 0 || s.HasField("ch_masks") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("ch_masks")
		s.WriteBoolArray(x.ChMasks)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the CFList to JSON.
func (x *CFList) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the CFList message from JSON.
func (x *CFList) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "type":
			s.AddField("type")
			x.Type.UnmarshalProtoJSON(s)
		case "freq":
			s.AddField("freq")
			if s.ReadNil() {
				x.Freq = nil
				return
			}
			x.Freq = s.ReadUint32Array()
		case "ch_masks", "chMasks":
			s.AddField("ch_masks")
			if s.ReadNil() {
				x.ChMasks = nil
				return
			}
			x.ChMasks = s.ReadBoolArray()
		}
	})
}

// UnmarshalJSON unmarshals the CFList from JSON.
func (x *CFList) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the GatewayAntennaIdentifiers message to JSON.
func (x *GatewayAntennaIdentifiers) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.GatewayIds != nil || s.HasField("gateway_ids") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("gateway_ids")
		x.GatewayIds.MarshalProtoJSON(s.WithField("gateway_ids"))
	}
	if x.AntennaIndex != 0 || s.HasField("antenna_index") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("antenna_index")
		s.WriteUint32(x.AntennaIndex)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the GatewayAntennaIdentifiers to JSON.
func (x *GatewayAntennaIdentifiers) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the GatewayAntennaIdentifiers message from JSON.
func (x *GatewayAntennaIdentifiers) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "gateway_ids", "gatewayIds":
			if s.ReadNil() {
				x.GatewayIds = nil
				return
			}
			x.GatewayIds = &GatewayIdentifiers{}
			x.GatewayIds.UnmarshalProtoJSON(s.WithField("gateway_ids", true))
		case "antenna_index", "antennaIndex":
			s.AddField("antenna_index")
			x.AntennaIndex = s.ReadUint32()
		}
	})
}

// UnmarshalJSON unmarshals the GatewayAntennaIdentifiers from JSON.
func (x *GatewayAntennaIdentifiers) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ClassBCGatewayIdentifiers message to JSON.
func (x *ClassBCGatewayIdentifiers) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.GatewayIds != nil || s.HasField("gateway_ids") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("gateway_ids")
		x.GatewayIds.MarshalProtoJSON(s.WithField("gateway_ids"))
	}
	if x.AntennaIndex != 0 || s.HasField("antenna_index") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("antenna_index")
		s.WriteUint32(x.AntennaIndex)
	}
	if x.GroupIndex != 0 || s.HasField("group_index") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("group_index")
		s.WriteUint32(x.GroupIndex)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the ClassBCGatewayIdentifiers to JSON.
func (x *ClassBCGatewayIdentifiers) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ClassBCGatewayIdentifiers message from JSON.
func (x *ClassBCGatewayIdentifiers) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "gateway_ids", "gatewayIds":
			if s.ReadNil() {
				x.GatewayIds = nil
				return
			}
			x.GatewayIds = &GatewayIdentifiers{}
			x.GatewayIds.UnmarshalProtoJSON(s.WithField("gateway_ids", true))
		case "antenna_index", "antennaIndex":
			s.AddField("antenna_index")
			x.AntennaIndex = s.ReadUint32()
		case "group_index", "groupIndex":
			s.AddField("group_index")
			x.GroupIndex = s.ReadUint32()
		}
	})
}

// UnmarshalJSON unmarshals the ClassBCGatewayIdentifiers from JSON.
func (x *ClassBCGatewayIdentifiers) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the UplinkToken message to JSON.
func (x *UplinkToken) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Ids != nil || s.HasField("ids") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("ids")
		x.Ids.MarshalProtoJSON(s.WithField("ids"))
	}
	if x.Timestamp != 0 || s.HasField("timestamp") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("timestamp")
		s.WriteUint32(x.Timestamp)
	}
	if x.ServerTime != nil || s.HasField("server_time") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("server_time")
		if x.ServerTime == nil {
			s.WriteNil()
		} else {
			golang.MarshalTimestamp(s, x.ServerTime)
		}
	}
	if x.ConcentratorTime != 0 || s.HasField("concentrator_time") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("concentrator_time")
		s.WriteInt64(x.ConcentratorTime)
	}
	if x.GatewayTime != nil || s.HasField("gateway_time") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("gateway_time")
		if x.GatewayTime == nil {
			s.WriteNil()
		} else {
			golang.MarshalTimestamp(s, x.GatewayTime)
		}
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the UplinkToken to JSON.
func (x *UplinkToken) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the UplinkToken message from JSON.
func (x *UplinkToken) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "ids":
			if s.ReadNil() {
				x.Ids = nil
				return
			}
			x.Ids = &GatewayAntennaIdentifiers{}
			x.Ids.UnmarshalProtoJSON(s.WithField("ids", true))
		case "timestamp":
			s.AddField("timestamp")
			x.Timestamp = s.ReadUint32()
		case "server_time", "serverTime":
			s.AddField("server_time")
			if s.ReadNil() {
				x.ServerTime = nil
				return
			}
			v := golang.UnmarshalTimestamp(s)
			if s.Err() != nil {
				return
			}
			x.ServerTime = v
		case "concentrator_time", "concentratorTime":
			s.AddField("concentrator_time")
			x.ConcentratorTime = s.ReadInt64()
		case "gateway_time", "gatewayTime":
			s.AddField("gateway_time")
			if s.ReadNil() {
				x.GatewayTime = nil
				return
			}
			v := golang.UnmarshalTimestamp(s)
			if s.Err() != nil {
				return
			}
			x.GatewayTime = v
		}
	})
}

// UnmarshalJSON unmarshals the UplinkToken from JSON.
func (x *UplinkToken) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the DownlinkPath message to JSON.
func (x *DownlinkPath) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Path != nil {
		switch ov := x.Path.(type) {
		case *DownlinkPath_UplinkToken:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("uplink_token")
			s.WriteBytes(ov.UplinkToken)
		case *DownlinkPath_Fixed:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("fixed")
			ov.Fixed.MarshalProtoJSON(s.WithField("fixed"))
		}
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the DownlinkPath to JSON.
func (x *DownlinkPath) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the DownlinkPath message from JSON.
func (x *DownlinkPath) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "uplink_token", "uplinkToken":
			s.AddField("uplink_token")
			ov := &DownlinkPath_UplinkToken{}
			x.Path = ov
			ov.UplinkToken = s.ReadBytes()
		case "fixed":
			ov := &DownlinkPath_Fixed{}
			x.Path = ov
			if s.ReadNil() {
				ov.Fixed = nil
				return
			}
			ov.Fixed = &GatewayAntennaIdentifiers{}
			ov.Fixed.UnmarshalProtoJSON(s.WithField("fixed", true))
		}
	})
}

// UnmarshalJSON unmarshals the DownlinkPath from JSON.
func (x *DownlinkPath) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the TxRequest message to JSON.
func (x *TxRequest) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Class != 0 || s.HasField("class") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("class")
		x.Class.MarshalProtoJSON(s)
	}
	if len(x.DownlinkPaths) > 0 || s.HasField("downlink_paths") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("downlink_paths")
		s.WriteArrayStart()
		var wroteElement bool
		for _, element := range x.DownlinkPaths {
			s.WriteMoreIf(&wroteElement)
			element.MarshalProtoJSON(s.WithField("downlink_paths"))
		}
		s.WriteArrayEnd()
	}
	if x.Rx1Delay != 0 || s.HasField("rx1_delay") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("rx1_delay")
		x.Rx1Delay.MarshalProtoJSON(s)
	}
	if x.Rx1DataRate != nil || s.HasField("rx1_data_rate") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("rx1_data_rate")
		// NOTE: DataRate does not seem to implement MarshalProtoJSON.
		golang.MarshalMessage(s, x.Rx1DataRate)
	}
	if x.Rx1Frequency != 0 || s.HasField("rx1_frequency") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("rx1_frequency")
		s.WriteUint64(x.Rx1Frequency)
	}
	if x.Rx2DataRate != nil || s.HasField("rx2_data_rate") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("rx2_data_rate")
		// NOTE: DataRate does not seem to implement MarshalProtoJSON.
		golang.MarshalMessage(s, x.Rx2DataRate)
	}
	if x.Rx2Frequency != 0 || s.HasField("rx2_frequency") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("rx2_frequency")
		s.WriteUint64(x.Rx2Frequency)
	}
	if x.Priority != 0 || s.HasField("priority") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("priority")
		x.Priority.MarshalProtoJSON(s)
	}
	if x.AbsoluteTime != nil || s.HasField("absolute_time") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("absolute_time")
		if x.AbsoluteTime == nil {
			s.WriteNil()
		} else {
			golang.MarshalTimestamp(s, x.AbsoluteTime)
		}
	}
	if x.FrequencyPlanId != "" || s.HasField("frequency_plan_id") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("frequency_plan_id")
		s.WriteString(x.FrequencyPlanId)
	}
	if x.Advanced != nil || s.HasField("advanced") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("advanced")
		if x.Advanced == nil {
			s.WriteNil()
		} else {
			golang.MarshalStruct(s, x.Advanced)
		}
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the TxRequest to JSON.
func (x *TxRequest) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the TxRequest message from JSON.
func (x *TxRequest) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "class":
			s.AddField("class")
			x.Class.UnmarshalProtoJSON(s)
		case "downlink_paths", "downlinkPaths":
			s.AddField("downlink_paths")
			if s.ReadNil() {
				x.DownlinkPaths = nil
				return
			}
			s.ReadArray(func() {
				if s.ReadNil() {
					x.DownlinkPaths = append(x.DownlinkPaths, nil)
					return
				}
				v := &DownlinkPath{}
				v.UnmarshalProtoJSON(s.WithField("downlink_paths", false))
				if s.Err() != nil {
					return
				}
				x.DownlinkPaths = append(x.DownlinkPaths, v)
			})
		case "rx1_delay", "rx1Delay":
			s.AddField("rx1_delay")
			x.Rx1Delay.UnmarshalProtoJSON(s)
		case "rx1_data_rate", "rx1DataRate":
			s.AddField("rx1_data_rate")
			if s.ReadNil() {
				x.Rx1DataRate = nil
				return
			}
			// NOTE: DataRate does not seem to implement UnmarshalProtoJSON.
			var v DataRate
			golang.UnmarshalMessage(s, &v)
			x.Rx1DataRate = &v
		case "rx1_frequency", "rx1Frequency":
			s.AddField("rx1_frequency")
			x.Rx1Frequency = s.ReadUint64()
		case "rx2_data_rate", "rx2DataRate":
			s.AddField("rx2_data_rate")
			if s.ReadNil() {
				x.Rx2DataRate = nil
				return
			}
			// NOTE: DataRate does not seem to implement UnmarshalProtoJSON.
			var v DataRate
			golang.UnmarshalMessage(s, &v)
			x.Rx2DataRate = &v
		case "rx2_frequency", "rx2Frequency":
			s.AddField("rx2_frequency")
			x.Rx2Frequency = s.ReadUint64()
		case "priority":
			s.AddField("priority")
			x.Priority.UnmarshalProtoJSON(s)
		case "absolute_time", "absoluteTime":
			s.AddField("absolute_time")
			if s.ReadNil() {
				x.AbsoluteTime = nil
				return
			}
			v := golang.UnmarshalTimestamp(s)
			if s.Err() != nil {
				return
			}
			x.AbsoluteTime = v
		case "frequency_plan_id", "frequencyPlanId":
			s.AddField("frequency_plan_id")
			x.FrequencyPlanId = s.ReadString()
		case "advanced":
			s.AddField("advanced")
			if s.ReadNil() {
				x.Advanced = nil
				return
			}
			v := golang.UnmarshalStruct(s)
			if s.Err() != nil {
				return
			}
			x.Advanced = v
		}
	})
}

// UnmarshalJSON unmarshals the TxRequest from JSON.
func (x *TxRequest) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the MACCommand_ResetInd message to JSON.
func (x *MACCommand_ResetInd) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.MinorVersion != 0 || s.HasField("minor_version") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("minor_version")
		x.MinorVersion.MarshalProtoJSON(s)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the MACCommand_ResetInd to JSON.
func (x *MACCommand_ResetInd) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the MACCommand_ResetInd message from JSON.
func (x *MACCommand_ResetInd) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "minor_version", "minorVersion":
			s.AddField("minor_version")
			x.MinorVersion.UnmarshalProtoJSON(s)
		}
	})
}

// UnmarshalJSON unmarshals the MACCommand_ResetInd from JSON.
func (x *MACCommand_ResetInd) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the MACCommand_ResetConf message to JSON.
func (x *MACCommand_ResetConf) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.MinorVersion != 0 || s.HasField("minor_version") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("minor_version")
		x.MinorVersion.MarshalProtoJSON(s)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the MACCommand_ResetConf to JSON.
func (x *MACCommand_ResetConf) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the MACCommand_ResetConf message from JSON.
func (x *MACCommand_ResetConf) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "minor_version", "minorVersion":
			s.AddField("minor_version")
			x.MinorVersion.UnmarshalProtoJSON(s)
		}
	})
}

// UnmarshalJSON unmarshals the MACCommand_ResetConf from JSON.
func (x *MACCommand_ResetConf) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the MACCommand_LinkADRReq message to JSON.
func (x *MACCommand_LinkADRReq) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.DataRateIndex != 0 || s.HasField("data_rate_index") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("data_rate_index")
		x.DataRateIndex.MarshalProtoJSON(s)
	}
	if x.TxPowerIndex != 0 || s.HasField("tx_power_index") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("tx_power_index")
		s.WriteUint32(x.TxPowerIndex)
	}
	if len(x.ChannelMask) > 0 || s.HasField("channel_mask") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("channel_mask")
		s.WriteBoolArray(x.ChannelMask)
	}
	if x.ChannelMaskControl != 0 || s.HasField("channel_mask_control") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("channel_mask_control")
		s.WriteUint32(x.ChannelMaskControl)
	}
	if x.NbTrans != 0 || s.HasField("nb_trans") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("nb_trans")
		s.WriteUint32(x.NbTrans)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the MACCommand_LinkADRReq to JSON.
func (x *MACCommand_LinkADRReq) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the MACCommand_LinkADRReq message from JSON.
func (x *MACCommand_LinkADRReq) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "data_rate_index", "dataRateIndex":
			s.AddField("data_rate_index")
			x.DataRateIndex.UnmarshalProtoJSON(s)
		case "tx_power_index", "txPowerIndex":
			s.AddField("tx_power_index")
			x.TxPowerIndex = s.ReadUint32()
		case "channel_mask", "channelMask":
			s.AddField("channel_mask")
			if s.ReadNil() {
				x.ChannelMask = nil
				return
			}
			x.ChannelMask = s.ReadBoolArray()
		case "channel_mask_control", "channelMaskControl":
			s.AddField("channel_mask_control")
			x.ChannelMaskControl = s.ReadUint32()
		case "nb_trans", "nbTrans":
			s.AddField("nb_trans")
			x.NbTrans = s.ReadUint32()
		}
	})
}

// UnmarshalJSON unmarshals the MACCommand_LinkADRReq from JSON.
func (x *MACCommand_LinkADRReq) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the MACCommand_DutyCycleReq message to JSON.
func (x *MACCommand_DutyCycleReq) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.MaxDutyCycle != 0 || s.HasField("max_duty_cycle") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("max_duty_cycle")
		x.MaxDutyCycle.MarshalProtoJSON(s)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the MACCommand_DutyCycleReq to JSON.
func (x *MACCommand_DutyCycleReq) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the MACCommand_DutyCycleReq message from JSON.
func (x *MACCommand_DutyCycleReq) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "max_duty_cycle", "maxDutyCycle":
			s.AddField("max_duty_cycle")
			x.MaxDutyCycle.UnmarshalProtoJSON(s)
		}
	})
}

// UnmarshalJSON unmarshals the MACCommand_DutyCycleReq from JSON.
func (x *MACCommand_DutyCycleReq) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the MACCommand_RxParamSetupReq message to JSON.
func (x *MACCommand_RxParamSetupReq) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Rx2DataRateIndex != 0 || s.HasField("rx2_data_rate_index") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("rx2_data_rate_index")
		x.Rx2DataRateIndex.MarshalProtoJSON(s)
	}
	if x.Rx1DataRateOffset != 0 || s.HasField("rx1_data_rate_offset") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("rx1_data_rate_offset")
		x.Rx1DataRateOffset.MarshalProtoJSON(s)
	}
	if x.Rx2Frequency != 0 || s.HasField("rx2_frequency") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("rx2_frequency")
		s.WriteUint64(x.Rx2Frequency)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the MACCommand_RxParamSetupReq to JSON.
func (x *MACCommand_RxParamSetupReq) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the MACCommand_RxParamSetupReq message from JSON.
func (x *MACCommand_RxParamSetupReq) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "rx2_data_rate_index", "rx2DataRateIndex":
			s.AddField("rx2_data_rate_index")
			x.Rx2DataRateIndex.UnmarshalProtoJSON(s)
		case "rx1_data_rate_offset", "rx1DataRateOffset":
			s.AddField("rx1_data_rate_offset")
			x.Rx1DataRateOffset.UnmarshalProtoJSON(s)
		case "rx2_frequency", "rx2Frequency":
			s.AddField("rx2_frequency")
			x.Rx2Frequency = s.ReadUint64()
		}
	})
}

// UnmarshalJSON unmarshals the MACCommand_RxParamSetupReq from JSON.
func (x *MACCommand_RxParamSetupReq) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the MACCommand_NewChannelReq message to JSON.
func (x *MACCommand_NewChannelReq) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.ChannelIndex != 0 || s.HasField("channel_index") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("channel_index")
		s.WriteUint32(x.ChannelIndex)
	}
	if x.Frequency != 0 || s.HasField("frequency") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("frequency")
		s.WriteUint64(x.Frequency)
	}
	if x.MinDataRateIndex != 0 || s.HasField("min_data_rate_index") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("min_data_rate_index")
		x.MinDataRateIndex.MarshalProtoJSON(s)
	}
	if x.MaxDataRateIndex != 0 || s.HasField("max_data_rate_index") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("max_data_rate_index")
		x.MaxDataRateIndex.MarshalProtoJSON(s)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the MACCommand_NewChannelReq to JSON.
func (x *MACCommand_NewChannelReq) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the MACCommand_NewChannelReq message from JSON.
func (x *MACCommand_NewChannelReq) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "channel_index", "channelIndex":
			s.AddField("channel_index")
			x.ChannelIndex = s.ReadUint32()
		case "frequency":
			s.AddField("frequency")
			x.Frequency = s.ReadUint64()
		case "min_data_rate_index", "minDataRateIndex":
			s.AddField("min_data_rate_index")
			x.MinDataRateIndex.UnmarshalProtoJSON(s)
		case "max_data_rate_index", "maxDataRateIndex":
			s.AddField("max_data_rate_index")
			x.MaxDataRateIndex.UnmarshalProtoJSON(s)
		}
	})
}

// UnmarshalJSON unmarshals the MACCommand_NewChannelReq from JSON.
func (x *MACCommand_NewChannelReq) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the MACCommand_RxTimingSetupReq message to JSON.
func (x *MACCommand_RxTimingSetupReq) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Delay != 0 || s.HasField("delay") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("delay")
		x.Delay.MarshalProtoJSON(s)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the MACCommand_RxTimingSetupReq to JSON.
func (x *MACCommand_RxTimingSetupReq) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the MACCommand_RxTimingSetupReq message from JSON.
func (x *MACCommand_RxTimingSetupReq) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "delay":
			s.AddField("delay")
			x.Delay.UnmarshalProtoJSON(s)
		}
	})
}

// UnmarshalJSON unmarshals the MACCommand_RxTimingSetupReq from JSON.
func (x *MACCommand_RxTimingSetupReq) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the MACCommand_TxParamSetupReq message to JSON.
func (x *MACCommand_TxParamSetupReq) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.MaxEirpIndex != 0 || s.HasField("max_eirp_index") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("max_eirp_index")
		x.MaxEirpIndex.MarshalProtoJSON(s)
	}
	if x.UplinkDwellTime || s.HasField("uplink_dwell_time") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("uplink_dwell_time")
		s.WriteBool(x.UplinkDwellTime)
	}
	if x.DownlinkDwellTime || s.HasField("downlink_dwell_time") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("downlink_dwell_time")
		s.WriteBool(x.DownlinkDwellTime)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the MACCommand_TxParamSetupReq to JSON.
func (x *MACCommand_TxParamSetupReq) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the MACCommand_TxParamSetupReq message from JSON.
func (x *MACCommand_TxParamSetupReq) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "max_eirp_index", "maxEirpIndex":
			s.AddField("max_eirp_index")
			x.MaxEirpIndex.UnmarshalProtoJSON(s)
		case "uplink_dwell_time", "uplinkDwellTime":
			s.AddField("uplink_dwell_time")
			x.UplinkDwellTime = s.ReadBool()
		case "downlink_dwell_time", "downlinkDwellTime":
			s.AddField("downlink_dwell_time")
			x.DownlinkDwellTime = s.ReadBool()
		}
	})
}

// UnmarshalJSON unmarshals the MACCommand_TxParamSetupReq from JSON.
func (x *MACCommand_TxParamSetupReq) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the MACCommand_RekeyInd message to JSON.
func (x *MACCommand_RekeyInd) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.MinorVersion != 0 || s.HasField("minor_version") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("minor_version")
		x.MinorVersion.MarshalProtoJSON(s)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the MACCommand_RekeyInd to JSON.
func (x *MACCommand_RekeyInd) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the MACCommand_RekeyInd message from JSON.
func (x *MACCommand_RekeyInd) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "minor_version", "minorVersion":
			s.AddField("minor_version")
			x.MinorVersion.UnmarshalProtoJSON(s)
		}
	})
}

// UnmarshalJSON unmarshals the MACCommand_RekeyInd from JSON.
func (x *MACCommand_RekeyInd) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the MACCommand_RekeyConf message to JSON.
func (x *MACCommand_RekeyConf) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.MinorVersion != 0 || s.HasField("minor_version") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("minor_version")
		x.MinorVersion.MarshalProtoJSON(s)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the MACCommand_RekeyConf to JSON.
func (x *MACCommand_RekeyConf) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the MACCommand_RekeyConf message from JSON.
func (x *MACCommand_RekeyConf) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "minor_version", "minorVersion":
			s.AddField("minor_version")
			x.MinorVersion.UnmarshalProtoJSON(s)
		}
	})
}

// UnmarshalJSON unmarshals the MACCommand_RekeyConf from JSON.
func (x *MACCommand_RekeyConf) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the MACCommand_ADRParamSetupReq message to JSON.
func (x *MACCommand_ADRParamSetupReq) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.AdrAckLimitExponent != 0 || s.HasField("adr_ack_limit_exponent") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("adr_ack_limit_exponent")
		x.AdrAckLimitExponent.MarshalProtoJSON(s)
	}
	if x.AdrAckDelayExponent != 0 || s.HasField("adr_ack_delay_exponent") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("adr_ack_delay_exponent")
		x.AdrAckDelayExponent.MarshalProtoJSON(s)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the MACCommand_ADRParamSetupReq to JSON.
func (x *MACCommand_ADRParamSetupReq) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the MACCommand_ADRParamSetupReq message from JSON.
func (x *MACCommand_ADRParamSetupReq) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "adr_ack_limit_exponent", "adrAckLimitExponent":
			s.AddField("adr_ack_limit_exponent")
			x.AdrAckLimitExponent.UnmarshalProtoJSON(s)
		case "adr_ack_delay_exponent", "adrAckDelayExponent":
			s.AddField("adr_ack_delay_exponent")
			x.AdrAckDelayExponent.UnmarshalProtoJSON(s)
		}
	})
}

// UnmarshalJSON unmarshals the MACCommand_ADRParamSetupReq from JSON.
func (x *MACCommand_ADRParamSetupReq) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the MACCommand_ForceRejoinReq message to JSON.
func (x *MACCommand_ForceRejoinReq) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.RejoinType != 0 || s.HasField("rejoin_type") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("rejoin_type")
		x.RejoinType.MarshalProtoJSON(s)
	}
	if x.DataRateIndex != 0 || s.HasField("data_rate_index") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("data_rate_index")
		x.DataRateIndex.MarshalProtoJSON(s)
	}
	if x.MaxRetries != 0 || s.HasField("max_retries") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("max_retries")
		s.WriteUint32(x.MaxRetries)
	}
	if x.PeriodExponent != 0 || s.HasField("period_exponent") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("period_exponent")
		x.PeriodExponent.MarshalProtoJSON(s)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the MACCommand_ForceRejoinReq to JSON.
func (x *MACCommand_ForceRejoinReq) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the MACCommand_ForceRejoinReq message from JSON.
func (x *MACCommand_ForceRejoinReq) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "rejoin_type", "rejoinType":
			s.AddField("rejoin_type")
			x.RejoinType.UnmarshalProtoJSON(s)
		case "data_rate_index", "dataRateIndex":
			s.AddField("data_rate_index")
			x.DataRateIndex.UnmarshalProtoJSON(s)
		case "max_retries", "maxRetries":
			s.AddField("max_retries")
			x.MaxRetries = s.ReadUint32()
		case "period_exponent", "periodExponent":
			s.AddField("period_exponent")
			x.PeriodExponent.UnmarshalProtoJSON(s)
		}
	})
}

// UnmarshalJSON unmarshals the MACCommand_ForceRejoinReq from JSON.
func (x *MACCommand_ForceRejoinReq) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the MACCommand_RejoinParamSetupReq message to JSON.
func (x *MACCommand_RejoinParamSetupReq) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.MaxCountExponent != 0 || s.HasField("max_count_exponent") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("max_count_exponent")
		x.MaxCountExponent.MarshalProtoJSON(s)
	}
	if x.MaxTimeExponent != 0 || s.HasField("max_time_exponent") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("max_time_exponent")
		x.MaxTimeExponent.MarshalProtoJSON(s)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the MACCommand_RejoinParamSetupReq to JSON.
func (x *MACCommand_RejoinParamSetupReq) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the MACCommand_RejoinParamSetupReq message from JSON.
func (x *MACCommand_RejoinParamSetupReq) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "max_count_exponent", "maxCountExponent":
			s.AddField("max_count_exponent")
			x.MaxCountExponent.UnmarshalProtoJSON(s)
		case "max_time_exponent", "maxTimeExponent":
			s.AddField("max_time_exponent")
			x.MaxTimeExponent.UnmarshalProtoJSON(s)
		}
	})
}

// UnmarshalJSON unmarshals the MACCommand_RejoinParamSetupReq from JSON.
func (x *MACCommand_RejoinParamSetupReq) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the MACCommand_PingSlotInfoReq message to JSON.
func (x *MACCommand_PingSlotInfoReq) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Period != 0 || s.HasField("period") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("period")
		x.Period.MarshalProtoJSON(s)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the MACCommand_PingSlotInfoReq to JSON.
func (x *MACCommand_PingSlotInfoReq) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the MACCommand_PingSlotInfoReq message from JSON.
func (x *MACCommand_PingSlotInfoReq) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "period":
			s.AddField("period")
			x.Period.UnmarshalProtoJSON(s)
		}
	})
}

// UnmarshalJSON unmarshals the MACCommand_PingSlotInfoReq from JSON.
func (x *MACCommand_PingSlotInfoReq) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the MACCommand_PingSlotChannelReq message to JSON.
func (x *MACCommand_PingSlotChannelReq) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Frequency != 0 || s.HasField("frequency") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("frequency")
		s.WriteUint64(x.Frequency)
	}
	if x.DataRateIndex != 0 || s.HasField("data_rate_index") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("data_rate_index")
		x.DataRateIndex.MarshalProtoJSON(s)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the MACCommand_PingSlotChannelReq to JSON.
func (x *MACCommand_PingSlotChannelReq) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the MACCommand_PingSlotChannelReq message from JSON.
func (x *MACCommand_PingSlotChannelReq) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "frequency":
			s.AddField("frequency")
			x.Frequency = s.ReadUint64()
		case "data_rate_index", "dataRateIndex":
			s.AddField("data_rate_index")
			x.DataRateIndex.UnmarshalProtoJSON(s)
		}
	})
}

// UnmarshalJSON unmarshals the MACCommand_PingSlotChannelReq from JSON.
func (x *MACCommand_PingSlotChannelReq) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the MACCommand_DeviceModeInd message to JSON.
func (x *MACCommand_DeviceModeInd) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Class != 0 || s.HasField("class") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("class")
		x.Class.MarshalProtoJSON(s)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the MACCommand_DeviceModeInd to JSON.
func (x *MACCommand_DeviceModeInd) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the MACCommand_DeviceModeInd message from JSON.
func (x *MACCommand_DeviceModeInd) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "class":
			s.AddField("class")
			x.Class.UnmarshalProtoJSON(s)
		}
	})
}

// UnmarshalJSON unmarshals the MACCommand_DeviceModeInd from JSON.
func (x *MACCommand_DeviceModeInd) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the MACCommand_DeviceModeConf message to JSON.
func (x *MACCommand_DeviceModeConf) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Class != 0 || s.HasField("class") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("class")
		x.Class.MarshalProtoJSON(s)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the MACCommand_DeviceModeConf to JSON.
func (x *MACCommand_DeviceModeConf) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the MACCommand_DeviceModeConf message from JSON.
func (x *MACCommand_DeviceModeConf) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "class":
			s.AddField("class")
			x.Class.UnmarshalProtoJSON(s)
		}
	})
}

// UnmarshalJSON unmarshals the MACCommand_DeviceModeConf from JSON.
func (x *MACCommand_DeviceModeConf) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the MACCommand message to JSON.
func (x *MACCommand) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Cid != 0 || s.HasField("cid") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("cid")
		x.Cid.MarshalProtoJSON(s)
	}
	if x.Payload != nil {
		switch ov := x.Payload.(type) {
		case *MACCommand_RawPayload:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("raw_payload")
			s.WriteBytes(ov.RawPayload)
		case *MACCommand_ResetInd_:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("reset_ind")
			ov.ResetInd.MarshalProtoJSON(s.WithField("reset_ind"))
		case *MACCommand_ResetConf_:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("reset_conf")
			ov.ResetConf.MarshalProtoJSON(s.WithField("reset_conf"))
		case *MACCommand_LinkCheckAns_:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("link_check_ans")
			// NOTE: MACCommand_LinkCheckAns does not seem to implement MarshalProtoJSON.
			golang.MarshalMessage(s, ov.LinkCheckAns)
		case *MACCommand_LinkAdrReq:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("link_adr_req")
			ov.LinkAdrReq.MarshalProtoJSON(s.WithField("link_adr_req"))
		case *MACCommand_LinkAdrAns:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("link_adr_ans")
			// NOTE: MACCommand_LinkADRAns does not seem to implement MarshalProtoJSON.
			golang.MarshalMessage(s, ov.LinkAdrAns)
		case *MACCommand_DutyCycleReq_:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("duty_cycle_req")
			ov.DutyCycleReq.MarshalProtoJSON(s.WithField("duty_cycle_req"))
		case *MACCommand_RxParamSetupReq_:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("rx_param_setup_req")
			ov.RxParamSetupReq.MarshalProtoJSON(s.WithField("rx_param_setup_req"))
		case *MACCommand_RxParamSetupAns_:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("rx_param_setup_ans")
			// NOTE: MACCommand_RxParamSetupAns does not seem to implement MarshalProtoJSON.
			golang.MarshalMessage(s, ov.RxParamSetupAns)
		case *MACCommand_DevStatusAns_:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("dev_status_ans")
			// NOTE: MACCommand_DevStatusAns does not seem to implement MarshalProtoJSON.
			golang.MarshalMessage(s, ov.DevStatusAns)
		case *MACCommand_NewChannelReq_:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("new_channel_req")
			ov.NewChannelReq.MarshalProtoJSON(s.WithField("new_channel_req"))
		case *MACCommand_NewChannelAns_:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("new_channel_ans")
			// NOTE: MACCommand_NewChannelAns does not seem to implement MarshalProtoJSON.
			golang.MarshalMessage(s, ov.NewChannelAns)
		case *MACCommand_DlChannelReq:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("dl_channel_req")
			// NOTE: MACCommand_DLChannelReq does not seem to implement MarshalProtoJSON.
			golang.MarshalMessage(s, ov.DlChannelReq)
		case *MACCommand_DlChannelAns:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("dl_channel_ans")
			// NOTE: MACCommand_DLChannelAns does not seem to implement MarshalProtoJSON.
			golang.MarshalMessage(s, ov.DlChannelAns)
		case *MACCommand_RxTimingSetupReq_:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("rx_timing_setup_req")
			ov.RxTimingSetupReq.MarshalProtoJSON(s.WithField("rx_timing_setup_req"))
		case *MACCommand_TxParamSetupReq_:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("tx_param_setup_req")
			ov.TxParamSetupReq.MarshalProtoJSON(s.WithField("tx_param_setup_req"))
		case *MACCommand_RekeyInd_:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("rekey_ind")
			ov.RekeyInd.MarshalProtoJSON(s.WithField("rekey_ind"))
		case *MACCommand_RekeyConf_:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("rekey_conf")
			ov.RekeyConf.MarshalProtoJSON(s.WithField("rekey_conf"))
		case *MACCommand_AdrParamSetupReq:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("adr_param_setup_req")
			ov.AdrParamSetupReq.MarshalProtoJSON(s.WithField("adr_param_setup_req"))
		case *MACCommand_DeviceTimeAns_:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("device_time_ans")
			// NOTE: MACCommand_DeviceTimeAns does not seem to implement MarshalProtoJSON.
			golang.MarshalMessage(s, ov.DeviceTimeAns)
		case *MACCommand_ForceRejoinReq_:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("force_rejoin_req")
			ov.ForceRejoinReq.MarshalProtoJSON(s.WithField("force_rejoin_req"))
		case *MACCommand_RejoinParamSetupReq_:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("rejoin_param_setup_req")
			ov.RejoinParamSetupReq.MarshalProtoJSON(s.WithField("rejoin_param_setup_req"))
		case *MACCommand_RejoinParamSetupAns_:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("rejoin_param_setup_ans")
			// NOTE: MACCommand_RejoinParamSetupAns does not seem to implement MarshalProtoJSON.
			golang.MarshalMessage(s, ov.RejoinParamSetupAns)
		case *MACCommand_PingSlotInfoReq_:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("ping_slot_info_req")
			ov.PingSlotInfoReq.MarshalProtoJSON(s.WithField("ping_slot_info_req"))
		case *MACCommand_PingSlotChannelReq_:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("ping_slot_channel_req")
			ov.PingSlotChannelReq.MarshalProtoJSON(s.WithField("ping_slot_channel_req"))
		case *MACCommand_PingSlotChannelAns_:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("ping_slot_channel_ans")
			// NOTE: MACCommand_PingSlotChannelAns does not seem to implement MarshalProtoJSON.
			golang.MarshalMessage(s, ov.PingSlotChannelAns)
		case *MACCommand_BeaconTimingAns_:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("beacon_timing_ans")
			// NOTE: MACCommand_BeaconTimingAns does not seem to implement MarshalProtoJSON.
			golang.MarshalMessage(s, ov.BeaconTimingAns)
		case *MACCommand_BeaconFreqReq_:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("beacon_freq_req")
			// NOTE: MACCommand_BeaconFreqReq does not seem to implement MarshalProtoJSON.
			golang.MarshalMessage(s, ov.BeaconFreqReq)
		case *MACCommand_BeaconFreqAns_:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("beacon_freq_ans")
			// NOTE: MACCommand_BeaconFreqAns does not seem to implement MarshalProtoJSON.
			golang.MarshalMessage(s, ov.BeaconFreqAns)
		case *MACCommand_DeviceModeInd_:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("device_mode_ind")
			ov.DeviceModeInd.MarshalProtoJSON(s.WithField("device_mode_ind"))
		case *MACCommand_DeviceModeConf_:
			s.WriteMoreIf(&wroteField)
			s.WriteObjectField("device_mode_conf")
			ov.DeviceModeConf.MarshalProtoJSON(s.WithField("device_mode_conf"))
		}
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the MACCommand to JSON.
func (x *MACCommand) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the MACCommand message from JSON.
func (x *MACCommand) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "cid":
			s.AddField("cid")
			x.Cid.UnmarshalProtoJSON(s)
		case "raw_payload", "rawPayload":
			s.AddField("raw_payload")
			ov := &MACCommand_RawPayload{}
			x.Payload = ov
			ov.RawPayload = s.ReadBytes()
		case "reset_ind", "resetInd":
			ov := &MACCommand_ResetInd_{}
			x.Payload = ov
			if s.ReadNil() {
				ov.ResetInd = nil
				return
			}
			ov.ResetInd = &MACCommand_ResetInd{}
			ov.ResetInd.UnmarshalProtoJSON(s.WithField("reset_ind", true))
		case "reset_conf", "resetConf":
			ov := &MACCommand_ResetConf_{}
			x.Payload = ov
			if s.ReadNil() {
				ov.ResetConf = nil
				return
			}
			ov.ResetConf = &MACCommand_ResetConf{}
			ov.ResetConf.UnmarshalProtoJSON(s.WithField("reset_conf", true))
		case "link_check_ans", "linkCheckAns":
			s.AddField("link_check_ans")
			ov := &MACCommand_LinkCheckAns_{}
			x.Payload = ov
			if s.ReadNil() {
				ov.LinkCheckAns = nil
				return
			}
			// NOTE: MACCommand_LinkCheckAns does not seem to implement UnmarshalProtoJSON.
			var v MACCommand_LinkCheckAns
			golang.UnmarshalMessage(s, &v)
			ov.LinkCheckAns = &v
		case "link_adr_req", "linkAdrReq":
			ov := &MACCommand_LinkAdrReq{}
			x.Payload = ov
			if s.ReadNil() {
				ov.LinkAdrReq = nil
				return
			}
			ov.LinkAdrReq = &MACCommand_LinkADRReq{}
			ov.LinkAdrReq.UnmarshalProtoJSON(s.WithField("link_adr_req", true))
		case "link_adr_ans", "linkAdrAns":
			s.AddField("link_adr_ans")
			ov := &MACCommand_LinkAdrAns{}
			x.Payload = ov
			if s.ReadNil() {
				ov.LinkAdrAns = nil
				return
			}
			// NOTE: MACCommand_LinkADRAns does not seem to implement UnmarshalProtoJSON.
			var v MACCommand_LinkADRAns
			golang.UnmarshalMessage(s, &v)
			ov.LinkAdrAns = &v
		case "duty_cycle_req", "dutyCycleReq":
			ov := &MACCommand_DutyCycleReq_{}
			x.Payload = ov
			if s.ReadNil() {
				ov.DutyCycleReq = nil
				return
			}
			ov.DutyCycleReq = &MACCommand_DutyCycleReq{}
			ov.DutyCycleReq.UnmarshalProtoJSON(s.WithField("duty_cycle_req", true))
		case "rx_param_setup_req", "rxParamSetupReq":
			ov := &MACCommand_RxParamSetupReq_{}
			x.Payload = ov
			if s.ReadNil() {
				ov.RxParamSetupReq = nil
				return
			}
			ov.RxParamSetupReq = &MACCommand_RxParamSetupReq{}
			ov.RxParamSetupReq.UnmarshalProtoJSON(s.WithField("rx_param_setup_req", true))
		case "rx_param_setup_ans", "rxParamSetupAns":
			s.AddField("rx_param_setup_ans")
			ov := &MACCommand_RxParamSetupAns_{}
			x.Payload = ov
			if s.ReadNil() {
				ov.RxParamSetupAns = nil
				return
			}
			// NOTE: MACCommand_RxParamSetupAns does not seem to implement UnmarshalProtoJSON.
			var v MACCommand_RxParamSetupAns
			golang.UnmarshalMessage(s, &v)
			ov.RxParamSetupAns = &v
		case "dev_status_ans", "devStatusAns":
			s.AddField("dev_status_ans")
			ov := &MACCommand_DevStatusAns_{}
			x.Payload = ov
			if s.ReadNil() {
				ov.DevStatusAns = nil
				return
			}
			// NOTE: MACCommand_DevStatusAns does not seem to implement UnmarshalProtoJSON.
			var v MACCommand_DevStatusAns
			golang.UnmarshalMessage(s, &v)
			ov.DevStatusAns = &v
		case "new_channel_req", "newChannelReq":
			ov := &MACCommand_NewChannelReq_{}
			x.Payload = ov
			if s.ReadNil() {
				ov.NewChannelReq = nil
				return
			}
			ov.NewChannelReq = &MACCommand_NewChannelReq{}
			ov.NewChannelReq.UnmarshalProtoJSON(s.WithField("new_channel_req", true))
		case "new_channel_ans", "newChannelAns":
			s.AddField("new_channel_ans")
			ov := &MACCommand_NewChannelAns_{}
			x.Payload = ov
			if s.ReadNil() {
				ov.NewChannelAns = nil
				return
			}
			// NOTE: MACCommand_NewChannelAns does not seem to implement UnmarshalProtoJSON.
			var v MACCommand_NewChannelAns
			golang.UnmarshalMessage(s, &v)
			ov.NewChannelAns = &v
		case "dl_channel_req", "dlChannelReq":
			s.AddField("dl_channel_req")
			ov := &MACCommand_DlChannelReq{}
			x.Payload = ov
			if s.ReadNil() {
				ov.DlChannelReq = nil
				return
			}
			// NOTE: MACCommand_DLChannelReq does not seem to implement UnmarshalProtoJSON.
			var v MACCommand_DLChannelReq
			golang.UnmarshalMessage(s, &v)
			ov.DlChannelReq = &v
		case "dl_channel_ans", "dlChannelAns":
			s.AddField("dl_channel_ans")
			ov := &MACCommand_DlChannelAns{}
			x.Payload = ov
			if s.ReadNil() {
				ov.DlChannelAns = nil
				return
			}
			// NOTE: MACCommand_DLChannelAns does not seem to implement UnmarshalProtoJSON.
			var v MACCommand_DLChannelAns
			golang.UnmarshalMessage(s, &v)
			ov.DlChannelAns = &v
		case "rx_timing_setup_req", "rxTimingSetupReq":
			ov := &MACCommand_RxTimingSetupReq_{}
			x.Payload = ov
			if s.ReadNil() {
				ov.RxTimingSetupReq = nil
				return
			}
			ov.RxTimingSetupReq = &MACCommand_RxTimingSetupReq{}
			ov.RxTimingSetupReq.UnmarshalProtoJSON(s.WithField("rx_timing_setup_req", true))
		case "tx_param_setup_req", "txParamSetupReq":
			ov := &MACCommand_TxParamSetupReq_{}
			x.Payload = ov
			if s.ReadNil() {
				ov.TxParamSetupReq = nil
				return
			}
			ov.TxParamSetupReq = &MACCommand_TxParamSetupReq{}
			ov.TxParamSetupReq.UnmarshalProtoJSON(s.WithField("tx_param_setup_req", true))
		case "rekey_ind", "rekeyInd":
			ov := &MACCommand_RekeyInd_{}
			x.Payload = ov
			if s.ReadNil() {
				ov.RekeyInd = nil
				return
			}
			ov.RekeyInd = &MACCommand_RekeyInd{}
			ov.RekeyInd.UnmarshalProtoJSON(s.WithField("rekey_ind", true))
		case "rekey_conf", "rekeyConf":
			ov := &MACCommand_RekeyConf_{}
			x.Payload = ov
			if s.ReadNil() {
				ov.RekeyConf = nil
				return
			}
			ov.RekeyConf = &MACCommand_RekeyConf{}
			ov.RekeyConf.UnmarshalProtoJSON(s.WithField("rekey_conf", true))
		case "adr_param_setup_req", "adrParamSetupReq":
			ov := &MACCommand_AdrParamSetupReq{}
			x.Payload = ov
			if s.ReadNil() {
				ov.AdrParamSetupReq = nil
				return
			}
			ov.AdrParamSetupReq = &MACCommand_ADRParamSetupReq{}
			ov.AdrParamSetupReq.UnmarshalProtoJSON(s.WithField("adr_param_setup_req", true))
		case "device_time_ans", "deviceTimeAns":
			s.AddField("device_time_ans")
			ov := &MACCommand_DeviceTimeAns_{}
			x.Payload = ov
			if s.ReadNil() {
				ov.DeviceTimeAns = nil
				return
			}
			// NOTE: MACCommand_DeviceTimeAns does not seem to implement UnmarshalProtoJSON.
			var v MACCommand_DeviceTimeAns
			golang.UnmarshalMessage(s, &v)
			ov.DeviceTimeAns = &v
		case "force_rejoin_req", "forceRejoinReq":
			ov := &MACCommand_ForceRejoinReq_{}
			x.Payload = ov
			if s.ReadNil() {
				ov.ForceRejoinReq = nil
				return
			}
			ov.ForceRejoinReq = &MACCommand_ForceRejoinReq{}
			ov.ForceRejoinReq.UnmarshalProtoJSON(s.WithField("force_rejoin_req", true))
		case "rejoin_param_setup_req", "rejoinParamSetupReq":
			ov := &MACCommand_RejoinParamSetupReq_{}
			x.Payload = ov
			if s.ReadNil() {
				ov.RejoinParamSetupReq = nil
				return
			}
			ov.RejoinParamSetupReq = &MACCommand_RejoinParamSetupReq{}
			ov.RejoinParamSetupReq.UnmarshalProtoJSON(s.WithField("rejoin_param_setup_req", true))
		case "rejoin_param_setup_ans", "rejoinParamSetupAns":
			s.AddField("rejoin_param_setup_ans")
			ov := &MACCommand_RejoinParamSetupAns_{}
			x.Payload = ov
			if s.ReadNil() {
				ov.RejoinParamSetupAns = nil
				return
			}
			// NOTE: MACCommand_RejoinParamSetupAns does not seem to implement UnmarshalProtoJSON.
			var v MACCommand_RejoinParamSetupAns
			golang.UnmarshalMessage(s, &v)
			ov.RejoinParamSetupAns = &v
		case "ping_slot_info_req", "pingSlotInfoReq":
			ov := &MACCommand_PingSlotInfoReq_{}
			x.Payload = ov
			if s.ReadNil() {
				ov.PingSlotInfoReq = nil
				return
			}
			ov.PingSlotInfoReq = &MACCommand_PingSlotInfoReq{}
			ov.PingSlotInfoReq.UnmarshalProtoJSON(s.WithField("ping_slot_info_req", true))
		case "ping_slot_channel_req", "pingSlotChannelReq":
			ov := &MACCommand_PingSlotChannelReq_{}
			x.Payload = ov
			if s.ReadNil() {
				ov.PingSlotChannelReq = nil
				return
			}
			ov.PingSlotChannelReq = &MACCommand_PingSlotChannelReq{}
			ov.PingSlotChannelReq.UnmarshalProtoJSON(s.WithField("ping_slot_channel_req", true))
		case "ping_slot_channel_ans", "pingSlotChannelAns":
			s.AddField("ping_slot_channel_ans")
			ov := &MACCommand_PingSlotChannelAns_{}
			x.Payload = ov
			if s.ReadNil() {
				ov.PingSlotChannelAns = nil
				return
			}
			// NOTE: MACCommand_PingSlotChannelAns does not seem to implement UnmarshalProtoJSON.
			var v MACCommand_PingSlotChannelAns
			golang.UnmarshalMessage(s, &v)
			ov.PingSlotChannelAns = &v
		case "beacon_timing_ans", "beaconTimingAns":
			s.AddField("beacon_timing_ans")
			ov := &MACCommand_BeaconTimingAns_{}
			x.Payload = ov
			if s.ReadNil() {
				ov.BeaconTimingAns = nil
				return
			}
			// NOTE: MACCommand_BeaconTimingAns does not seem to implement UnmarshalProtoJSON.
			var v MACCommand_BeaconTimingAns
			golang.UnmarshalMessage(s, &v)
			ov.BeaconTimingAns = &v
		case "beacon_freq_req", "beaconFreqReq":
			s.AddField("beacon_freq_req")
			ov := &MACCommand_BeaconFreqReq_{}
			x.Payload = ov
			if s.ReadNil() {
				ov.BeaconFreqReq = nil
				return
			}
			// NOTE: MACCommand_BeaconFreqReq does not seem to implement UnmarshalProtoJSON.
			var v MACCommand_BeaconFreqReq
			golang.UnmarshalMessage(s, &v)
			ov.BeaconFreqReq = &v
		case "beacon_freq_ans", "beaconFreqAns":
			s.AddField("beacon_freq_ans")
			ov := &MACCommand_BeaconFreqAns_{}
			x.Payload = ov
			if s.ReadNil() {
				ov.BeaconFreqAns = nil
				return
			}
			// NOTE: MACCommand_BeaconFreqAns does not seem to implement UnmarshalProtoJSON.
			var v MACCommand_BeaconFreqAns
			golang.UnmarshalMessage(s, &v)
			ov.BeaconFreqAns = &v
		case "device_mode_ind", "deviceModeInd":
			ov := &MACCommand_DeviceModeInd_{}
			x.Payload = ov
			if s.ReadNil() {
				ov.DeviceModeInd = nil
				return
			}
			ov.DeviceModeInd = &MACCommand_DeviceModeInd{}
			ov.DeviceModeInd.UnmarshalProtoJSON(s.WithField("device_mode_ind", true))
		case "device_mode_conf", "deviceModeConf":
			ov := &MACCommand_DeviceModeConf_{}
			x.Payload = ov
			if s.ReadNil() {
				ov.DeviceModeConf = nil
				return
			}
			ov.DeviceModeConf = &MACCommand_DeviceModeConf{}
			ov.DeviceModeConf.UnmarshalProtoJSON(s.WithField("device_mode_conf", true))
		}
	})
}

// UnmarshalJSON unmarshals the MACCommand from JSON.
func (x *MACCommand) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the MACCommands message to JSON.
func (x *MACCommands) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if len(x.Commands) > 0 || s.HasField("commands") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("commands")
		s.WriteArrayStart()
		var wroteElement bool
		for _, element := range x.Commands {
			s.WriteMoreIf(&wroteElement)
			element.MarshalProtoJSON(s.WithField("commands"))
		}
		s.WriteArrayEnd()
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the MACCommands to JSON.
func (x *MACCommands) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the MACCommands message from JSON.
func (x *MACCommands) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "commands":
			s.AddField("commands")
			if s.ReadNil() {
				x.Commands = nil
				return
			}
			s.ReadArray(func() {
				if s.ReadNil() {
					x.Commands = append(x.Commands, nil)
					return
				}
				v := &MACCommand{}
				v.UnmarshalProtoJSON(s.WithField("commands", false))
				if s.Err() != nil {
					return
				}
				x.Commands = append(x.Commands, v)
			})
		}
	})
}

// UnmarshalJSON unmarshals the MACCommands from JSON.
func (x *MACCommands) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the FrequencyValue message to JSON.
func (x *FrequencyValue) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteUint64(x.Value)
	return
}

// MarshalJSON marshals the FrequencyValue to JSON.
func (x *FrequencyValue) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the FrequencyValue message from JSON.
func (x *FrequencyValue) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	x.Value = s.ReadUint64()
	return
}

// UnmarshalJSON unmarshals the FrequencyValue from JSON.
func (x *FrequencyValue) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ZeroableFrequencyValue message to JSON.
func (x *ZeroableFrequencyValue) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteUint64(x.Value)
	return
}

// MarshalJSON marshals the ZeroableFrequencyValue to JSON.
func (x *ZeroableFrequencyValue) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ZeroableFrequencyValue message from JSON.
func (x *ZeroableFrequencyValue) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	x.Value = s.ReadUint64()
	return
}

// UnmarshalJSON unmarshals the ZeroableFrequencyValue from JSON.
func (x *ZeroableFrequencyValue) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the DataRateOffsetValue message to JSON.
func (x *DataRateOffsetValue) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	x.Value.MarshalProtoJSON(s)
	return
}

// MarshalJSON marshals the DataRateOffsetValue to JSON.
func (x *DataRateOffsetValue) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the DataRateOffsetValue message from JSON.
func (x *DataRateOffsetValue) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	x.Value.UnmarshalProtoJSON(s)
	return
}

// UnmarshalJSON unmarshals the DataRateOffsetValue from JSON.
func (x *DataRateOffsetValue) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the DataRateIndexValue message to JSON.
func (x *DataRateIndexValue) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	x.Value.MarshalProtoJSON(s)
	return
}

// MarshalJSON marshals the DataRateIndexValue to JSON.
func (x *DataRateIndexValue) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the DataRateIndexValue message from JSON.
func (x *DataRateIndexValue) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	x.Value.UnmarshalProtoJSON(s)
	return
}

// UnmarshalJSON unmarshals the DataRateIndexValue from JSON.
func (x *DataRateIndexValue) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the PingSlotPeriodValue message to JSON.
func (x *PingSlotPeriodValue) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	x.Value.MarshalProtoJSON(s)
	return
}

// MarshalJSON marshals the PingSlotPeriodValue to JSON.
func (x *PingSlotPeriodValue) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the PingSlotPeriodValue message from JSON.
func (x *PingSlotPeriodValue) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	x.Value.UnmarshalProtoJSON(s)
	return
}

// UnmarshalJSON unmarshals the PingSlotPeriodValue from JSON.
func (x *PingSlotPeriodValue) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the AggregatedDutyCycleValue message to JSON.
func (x *AggregatedDutyCycleValue) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	x.Value.MarshalProtoJSON(s)
	return
}

// MarshalJSON marshals the AggregatedDutyCycleValue to JSON.
func (x *AggregatedDutyCycleValue) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the AggregatedDutyCycleValue message from JSON.
func (x *AggregatedDutyCycleValue) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	x.Value.UnmarshalProtoJSON(s)
	return
}

// UnmarshalJSON unmarshals the AggregatedDutyCycleValue from JSON.
func (x *AggregatedDutyCycleValue) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the RxDelayValue message to JSON.
func (x *RxDelayValue) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	x.Value.MarshalProtoJSON(s)
	return
}

// MarshalJSON marshals the RxDelayValue to JSON.
func (x *RxDelayValue) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the RxDelayValue message from JSON.
func (x *RxDelayValue) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	x.Value.UnmarshalProtoJSON(s)
	return
}

// UnmarshalJSON unmarshals the RxDelayValue from JSON.
func (x *RxDelayValue) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ADRAckLimitExponentValue message to JSON.
func (x *ADRAckLimitExponentValue) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	x.Value.MarshalProtoJSON(s)
	return
}

// MarshalJSON marshals the ADRAckLimitExponentValue to JSON.
func (x *ADRAckLimitExponentValue) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ADRAckLimitExponentValue message from JSON.
func (x *ADRAckLimitExponentValue) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	x.Value.UnmarshalProtoJSON(s)
	return
}

// UnmarshalJSON unmarshals the ADRAckLimitExponentValue from JSON.
func (x *ADRAckLimitExponentValue) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ADRAckDelayExponentValue message to JSON.
func (x *ADRAckDelayExponentValue) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	x.Value.MarshalProtoJSON(s)
	return
}

// MarshalJSON marshals the ADRAckDelayExponentValue to JSON.
func (x *ADRAckDelayExponentValue) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ADRAckDelayExponentValue message from JSON.
func (x *ADRAckDelayExponentValue) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	x.Value.UnmarshalProtoJSON(s)
	return
}

// UnmarshalJSON unmarshals the ADRAckDelayExponentValue from JSON.
func (x *ADRAckDelayExponentValue) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the DeviceEIRPValue message to JSON.
func (x *DeviceEIRPValue) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	x.Value.MarshalProtoJSON(s)
	return
}

// MarshalJSON marshals the DeviceEIRPValue to JSON.
func (x *DeviceEIRPValue) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the DeviceEIRPValue message from JSON.
func (x *DeviceEIRPValue) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	x.Value.UnmarshalProtoJSON(s)
	return
}

// UnmarshalJSON unmarshals the DeviceEIRPValue from JSON.
func (x *DeviceEIRPValue) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}