metadata_json.pb.go

// Code generated by protoc-gen-go-json. DO NOT EDIT.
// versions:
// - protoc-gen-go-json v1.6.0
// - protoc             v4.23.4
// source: ttn/lorawan/v3/metadata.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"
	wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
)

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

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

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

// LocationSource_customvalue contains custom string values that extend LocationSource_value.
var LocationSource_customvalue = map[string]int32{
	"UNKNOWN":               0,
	"GPS":                   1,
	"REGISTRY":              3,
	"IP_GEOLOCATION":        4,
	"WIFI_RSSI_GEOLOCATION": 5,
	"BT_RSSI_GEOLOCATION":   6,
	"LORA_RSSI_GEOLOCATION": 7,
	"LORA_TDOA_GEOLOCATION": 8,
	"COMBINED_GEOLOCATION":  9,
}

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

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

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

// MarshalProtoJSON marshals the RxMetadata message to JSON.
func (x *RxMetadata) 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.PacketBroker != nil || s.HasField("packet_broker") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("packet_broker")
		x.PacketBroker.MarshalProtoJSON(s.WithField("packet_broker"))
	}
	if x.Relay != nil || s.HasField("relay") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("relay")
		x.Relay.MarshalProtoJSON(s.WithField("relay"))
	}
	if x.AntennaIndex != 0 || s.HasField("antenna_index") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("antenna_index")
		s.WriteUint32(x.AntennaIndex)
	}
	if x.Time != nil || s.HasField("time") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("time")
		if x.Time == nil {
			s.WriteNil()
		} else {
			golang.MarshalTimestamp(s, x.Time)
		}
	}
	if x.Timestamp != 0 || s.HasField("timestamp") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("timestamp")
		s.WriteUint32(x.Timestamp)
	}
	if x.FineTimestamp != 0 || s.HasField("fine_timestamp") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("fine_timestamp")
		s.WriteUint64(x.FineTimestamp)
	}
	if len(x.EncryptedFineTimestamp) > 0 || s.HasField("encrypted_fine_timestamp") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("encrypted_fine_timestamp")
		s.WriteBytes(x.EncryptedFineTimestamp)
	}
	if x.EncryptedFineTimestampKeyId != "" || s.HasField("encrypted_fine_timestamp_key_id") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("encrypted_fine_timestamp_key_id")
		s.WriteString(x.EncryptedFineTimestampKeyId)
	}
	if x.Rssi != 0 || s.HasField("rssi") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("rssi")
		s.WriteFloat32(x.Rssi)
	}
	if x.SignalRssi != nil || s.HasField("signal_rssi") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("signal_rssi")
		if x.SignalRssi == nil {
			s.WriteNil()
		} else {
			s.WriteFloat32(x.SignalRssi.Value)
		}
	}
	if x.ChannelRssi != 0 || s.HasField("channel_rssi") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("channel_rssi")
		s.WriteFloat32(x.ChannelRssi)
	}
	if x.RssiStandardDeviation != 0 || s.HasField("rssi_standard_deviation") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("rssi_standard_deviation")
		s.WriteFloat32(x.RssiStandardDeviation)
	}
	if x.Snr != 0 || s.HasField("snr") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("snr")
		s.WriteFloat32(x.Snr)
	}
	if x.FrequencyOffset != 0 || s.HasField("frequency_offset") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("frequency_offset")
		s.WriteInt64(x.FrequencyOffset)
	}
	if x.Location != nil || s.HasField("location") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("location")
		x.Location.MarshalProtoJSON(s.WithField("location"))
	}
	if x.DownlinkPathConstraint != 0 || s.HasField("downlink_path_constraint") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("downlink_path_constraint")
		x.DownlinkPathConstraint.MarshalProtoJSON(s)
	}
	if len(x.UplinkToken) > 0 || s.HasField("uplink_token") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("uplink_token")
		s.WriteBytes(x.UplinkToken)
	}
	if x.ChannelIndex != 0 || s.HasField("channel_index") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("channel_index")
		s.WriteUint32(x.ChannelIndex)
	}
	if x.HoppingWidth != 0 || s.HasField("hopping_width") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("hopping_width")
		s.WriteUint32(x.HoppingWidth)
	}
	if x.FrequencyDrift != 0 || s.HasField("frequency_drift") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("frequency_drift")
		s.WriteInt32(x.FrequencyDrift)
	}
	if x.GpsTime != nil || s.HasField("gps_time") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("gps_time")
		if x.GpsTime == nil {
			s.WriteNil()
		} else {
			golang.MarshalTimestamp(s, x.GpsTime)
		}
	}
	if x.ReceivedAt != nil || s.HasField("received_at") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("received_at")
		if x.ReceivedAt == nil {
			s.WriteNil()
		} else {
			golang.MarshalTimestamp(s, x.ReceivedAt)
		}
	}
	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 RxMetadata to JSON.
func (x *RxMetadata) MarshalJSON() ([]byte, error) {
	return jsonplugin.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the RxMetadata message from JSON.
func (x *RxMetadata) 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 "packet_broker", "packetBroker":
			if s.ReadNil() {
				x.PacketBroker = nil
				return
			}
			x.PacketBroker = &PacketBrokerMetadata{}
			x.PacketBroker.UnmarshalProtoJSON(s.WithField("packet_broker", true))
		case "relay":
			if s.ReadNil() {
				x.Relay = nil
				return
			}
			x.Relay = &RelayMetadata{}
			x.Relay.UnmarshalProtoJSON(s.WithField("relay", true))
		case "antenna_index", "antennaIndex":
			s.AddField("antenna_index")
			x.AntennaIndex = s.ReadUint32()
		case "time":
			s.AddField("time")
			if s.ReadNil() {
				x.Time = nil
				return
			}
			v := golang.UnmarshalTimestamp(s)
			if s.Err() != nil {
				return
			}
			x.Time = v
		case "timestamp":
			s.AddField("timestamp")
			x.Timestamp = s.ReadUint32()
		case "fine_timestamp", "fineTimestamp":
			s.AddField("fine_timestamp")
			x.FineTimestamp = s.ReadUint64()
		case "encrypted_fine_timestamp", "encryptedFineTimestamp":
			s.AddField("encrypted_fine_timestamp")
			x.EncryptedFineTimestamp = s.ReadBytes()
		case "encrypted_fine_timestamp_key_id", "encryptedFineTimestampKeyId":
			s.AddField("encrypted_fine_timestamp_key_id")
			x.EncryptedFineTimestampKeyId = s.ReadString()
		case "rssi":
			s.AddField("rssi")
			x.Rssi = s.ReadFloat32()
		case "signal_rssi", "signalRssi":
			s.AddField("signal_rssi")
			if s.ReadNil() {
				x.SignalRssi = nil
				return
			}
			v := s.ReadWrappedFloat32()
			if s.Err() != nil {
				return
			}
			x.SignalRssi = &wrapperspb.FloatValue{Value: v}
		case "channel_rssi", "channelRssi":
			s.AddField("channel_rssi")
			x.ChannelRssi = s.ReadFloat32()
		case "rssi_standard_deviation", "rssiStandardDeviation":
			s.AddField("rssi_standard_deviation")
			x.RssiStandardDeviation = s.ReadFloat32()
		case "snr":
			s.AddField("snr")
			x.Snr = s.ReadFloat32()
		case "frequency_offset", "frequencyOffset":
			s.AddField("frequency_offset")
			x.FrequencyOffset = s.ReadInt64()
		case "location":
			if s.ReadNil() {
				x.Location = nil
				return
			}
			x.Location = &Location{}
			x.Location.UnmarshalProtoJSON(s.WithField("location", true))
		case "downlink_path_constraint", "downlinkPathConstraint":
			s.AddField("downlink_path_constraint")
			x.DownlinkPathConstraint.UnmarshalProtoJSON(s)
		case "uplink_token", "uplinkToken":
			s.AddField("uplink_token")
			x.UplinkToken = s.ReadBytes()
		case "channel_index", "channelIndex":
			s.AddField("channel_index")
			x.ChannelIndex = s.ReadUint32()
		case "hopping_width", "hoppingWidth":
			s.AddField("hopping_width")
			x.HoppingWidth = s.ReadUint32()
		case "frequency_drift", "frequencyDrift":
			s.AddField("frequency_drift")
			x.FrequencyDrift = s.ReadInt32()
		case "gps_time", "gpsTime":
			s.AddField("gps_time")
			if s.ReadNil() {
				x.GpsTime = nil
				return
			}
			v := golang.UnmarshalTimestamp(s)
			if s.Err() != nil {
				return
			}
			x.GpsTime = v
		case "received_at", "receivedAt":
			s.AddField("received_at")
			if s.ReadNil() {
				x.ReceivedAt = nil
				return
			}
			v := golang.UnmarshalTimestamp(s)
			if s.Err() != nil {
				return
			}
			x.ReceivedAt = v
		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 RxMetadata from JSON.
func (x *RxMetadata) UnmarshalJSON(b []byte) error {
	return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the Location message to JSON.
func (x *Location) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Latitude != 0 || s.HasField("latitude") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("latitude")
		s.WriteFloat64(x.Latitude)
	}
	if x.Longitude != 0 || s.HasField("longitude") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("longitude")
		s.WriteFloat64(x.Longitude)
	}
	if x.Altitude != 0 || s.HasField("altitude") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("altitude")
		s.WriteInt32(x.Altitude)
	}
	if x.Accuracy != 0 || s.HasField("accuracy") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("accuracy")
		s.WriteInt32(x.Accuracy)
	}
	if x.Source != 0 || s.HasField("source") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("source")
		x.Source.MarshalProtoJSON(s)
	}
	s.WriteObjectEnd()
}

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

// UnmarshalProtoJSON unmarshals the Location message from JSON.
func (x *Location) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "latitude":
			s.AddField("latitude")
			x.Latitude = s.ReadFloat64()
		case "longitude":
			s.AddField("longitude")
			x.Longitude = s.ReadFloat64()
		case "altitude":
			s.AddField("altitude")
			x.Altitude = s.ReadInt32()
		case "accuracy":
			s.AddField("accuracy")
			x.Accuracy = s.ReadInt32()
		case "source":
			s.AddField("source")
			x.Source.UnmarshalProtoJSON(s)
		}
	})
}

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

// MarshalProtoJSON marshals the PacketBrokerMetadata message to JSON.
func (x *PacketBrokerMetadata) MarshalProtoJSON(s *jsonplugin.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.MessageId != "" || s.HasField("message_id") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("message_id")
		s.WriteString(x.MessageId)
	}
	if len(x.ForwarderNetId) > 0 || s.HasField("forwarder_net_id") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("forwarder_net_id")
		types.MarshalHEXBytes(s.WithField("forwarder_net_id"), x.ForwarderNetId)
	}
	if x.ForwarderTenantId != "" || s.HasField("forwarder_tenant_id") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("forwarder_tenant_id")
		s.WriteString(x.ForwarderTenantId)
	}
	if x.ForwarderClusterId != "" || s.HasField("forwarder_cluster_id") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("forwarder_cluster_id")
		s.WriteString(x.ForwarderClusterId)
	}
	if len(x.ForwarderGatewayEui) > 0 || s.HasField("forwarder_gateway_eui") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("forwarder_gateway_eui")
		types.MarshalHEXBytes(s.WithField("forwarder_gateway_eui"), x.ForwarderGatewayEui)
	}
	if x.ForwarderGatewayId != nil || s.HasField("forwarder_gateway_id") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("forwarder_gateway_id")
		if x.ForwarderGatewayId == nil {
			s.WriteNil()
		} else {
			s.WriteString(x.ForwarderGatewayId.Value)
		}
	}
	if len(x.HomeNetworkNetId) > 0 || s.HasField("home_network_net_id") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("home_network_net_id")
		types.MarshalHEXBytes(s.WithField("home_network_net_id"), x.HomeNetworkNetId)
	}
	if x.HomeNetworkTenantId != "" || s.HasField("home_network_tenant_id") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("home_network_tenant_id")
		s.WriteString(x.HomeNetworkTenantId)
	}
	if x.HomeNetworkClusterId != "" || s.HasField("home_network_cluster_id") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("home_network_cluster_id")
		s.WriteString(x.HomeNetworkClusterId)
	}
	if len(x.Hops) > 0 || s.HasField("hops") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("hops")
		s.WriteArrayStart()
		var wroteElement bool
		for _, element := range x.Hops {
			s.WriteMoreIf(&wroteElement)
			// NOTE: PacketBrokerRouteHop does not seem to implement MarshalProtoJSON.
			golang.MarshalMessage(s, element)
		}
		s.WriteArrayEnd()
	}
	s.WriteObjectEnd()
}

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

// UnmarshalProtoJSON unmarshals the PacketBrokerMetadata message from JSON.
func (x *PacketBrokerMetadata) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "message_id", "messageId":
			s.AddField("message_id")
			x.MessageId = s.ReadString()
		case "forwarder_net_id", "forwarderNetId":
			s.AddField("forwarder_net_id")
			x.ForwarderNetId = types.Unmarshal3Bytes(s.WithField("forwarder_net_id", false))
		case "forwarder_tenant_id", "forwarderTenantId":
			s.AddField("forwarder_tenant_id")
			x.ForwarderTenantId = s.ReadString()
		case "forwarder_cluster_id", "forwarderClusterId":
			s.AddField("forwarder_cluster_id")
			x.ForwarderClusterId = s.ReadString()
		case "forwarder_gateway_eui", "forwarderGatewayEui":
			s.AddField("forwarder_gateway_eui")
			x.ForwarderGatewayEui = types.Unmarshal8Bytes(s.WithField("forwarder_gateway_eui", false))
		case "forwarder_gateway_id", "forwarderGatewayId":
			s.AddField("forwarder_gateway_id")
			if s.ReadNil() {
				x.ForwarderGatewayId = nil
				return
			}
			v := s.ReadWrappedString()
			if s.Err() != nil {
				return
			}
			x.ForwarderGatewayId = &wrapperspb.StringValue{Value: v}
		case "home_network_net_id", "homeNetworkNetId":
			s.AddField("home_network_net_id")
			x.HomeNetworkNetId = types.Unmarshal3Bytes(s.WithField("home_network_net_id", false))
		case "home_network_tenant_id", "homeNetworkTenantId":
			s.AddField("home_network_tenant_id")
			x.HomeNetworkTenantId = s.ReadString()
		case "home_network_cluster_id", "homeNetworkClusterId":
			s.AddField("home_network_cluster_id")
			x.HomeNetworkClusterId = s.ReadString()
		case "hops":
			s.AddField("hops")
			if s.ReadNil() {
				x.Hops = nil
				return
			}
			s.ReadArray(func() {
				// NOTE: PacketBrokerRouteHop does not seem to implement UnmarshalProtoJSON.
				var v PacketBrokerRouteHop
				golang.UnmarshalMessage(s, &v)
				x.Hops = append(x.Hops, &v)
			})
		}
	})
}

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

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

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

// UnmarshalProtoJSON unmarshals the RelayMetadata message from JSON.
func (x *RelayMetadata) UnmarshalProtoJSON(s *jsonplugin.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.ReadAny() // ignore unknown field
		case "device_id", "deviceId":
			s.AddField("device_id")
			x.DeviceId = s.ReadString()
		case "wor_channel", "worChannel":
			s.AddField("wor_channel")
			x.WorChannel.UnmarshalProtoJSON(s)
		}
	})
}

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