metadata.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: lorawan-stack/api/metadata.proto

package ttnpb

import (
	bytes "bytes"
	encoding_binary "encoding/binary"
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strconv "strconv"
	strings "strings"
	time "time"

	_ "github.com/envoyproxy/protoc-gen-validate/validate"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	types "github.com/gogo/protobuf/types"
	golang_proto "github.com/golang/protobuf/proto"
	go_thethings_network_lorawan_stack_v3_pkg_types "go.thethings.network/lorawan-stack/v3/pkg/types"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = golang_proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
var _ = time.Kitchen

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type LocationSource int32

const (
	// The source of the location is not known or not set.
	SOURCE_UNKNOWN LocationSource = 0
	// The location is determined by GPS.
	SOURCE_GPS LocationSource = 1
	// The location is set in and updated from a registry.
	SOURCE_REGISTRY LocationSource = 3
	// The location is estimated with IP geolocation.
	SOURCE_IP_GEOLOCATION LocationSource = 4
	// The location is estimated with WiFi RSSI geolocation.
	SOURCE_WIFI_RSSI_GEOLOCATION LocationSource = 5
	// The location is estimated with BT/BLE RSSI geolocation.
	SOURCE_BT_RSSI_GEOLOCATION LocationSource = 6
	// The location is estimated with LoRa RSSI geolocation.
	SOURCE_LORA_RSSI_GEOLOCATION LocationSource = 7
	// The location is estimated with LoRa TDOA geolocation.
	SOURCE_LORA_TDOA_GEOLOCATION LocationSource = 8
	// The location is estimated by a combination of geolocation sources.
	SOURCE_COMBINED_GEOLOCATION LocationSource = 9
)

var LocationSource_name = map[int32]string{
	0: "SOURCE_UNKNOWN",
	1: "SOURCE_GPS",
	3: "SOURCE_REGISTRY",
	4: "SOURCE_IP_GEOLOCATION",
	5: "SOURCE_WIFI_RSSI_GEOLOCATION",
	6: "SOURCE_BT_RSSI_GEOLOCATION",
	7: "SOURCE_LORA_RSSI_GEOLOCATION",
	8: "SOURCE_LORA_TDOA_GEOLOCATION",
	9: "SOURCE_COMBINED_GEOLOCATION",
}

var LocationSource_value = map[string]int32{
	"SOURCE_UNKNOWN":               0,
	"SOURCE_GPS":                   1,
	"SOURCE_REGISTRY":              3,
	"SOURCE_IP_GEOLOCATION":        4,
	"SOURCE_WIFI_RSSI_GEOLOCATION": 5,
	"SOURCE_BT_RSSI_GEOLOCATION":   6,
	"SOURCE_LORA_RSSI_GEOLOCATION": 7,
	"SOURCE_LORA_TDOA_GEOLOCATION": 8,
	"SOURCE_COMBINED_GEOLOCATION":  9,
}

func (LocationSource) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_e1123b3e8fd87092, []int{0}
}

// Contains metadata for a received message. Each antenna that receives
// a message corresponds to one RxMetadata.
type RxMetadata struct {
	GatewayIdentifiers `protobuf:"bytes,1,opt,name=gateway_ids,json=gatewayIds,proto3,embedded=gateway_ids" json:"gateway_ids"`
	PacketBroker       *PacketBrokerMetadata `protobuf:"bytes,18,opt,name=packet_broker,json=packetBroker,proto3" json:"packet_broker,omitempty"`
	AntennaIndex       uint32                `protobuf:"varint,2,opt,name=antenna_index,json=antennaIndex,proto3" json:"antenna_index,omitempty"`
	Time               *time.Time            `protobuf:"bytes,3,opt,name=time,proto3,stdtime" json:"time,omitempty"`
	// Gateway concentrator timestamp when the Rx finished (microseconds).
	Timestamp uint32 `protobuf:"varint,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// Gateway's internal fine timestamp when the Rx finished (nanoseconds).
	FineTimestamp uint64 `protobuf:"varint,5,opt,name=fine_timestamp,json=fineTimestamp,proto3" json:"fine_timestamp,omitempty"`
	// Encrypted gateway's internal fine timestamp when the Rx finished (nanoseconds).
	EncryptedFineTimestamp      []byte `protobuf:"bytes,6,opt,name=encrypted_fine_timestamp,json=encryptedFineTimestamp,proto3" json:"encrypted_fine_timestamp,omitempty"`
	EncryptedFineTimestampKeyID string `protobuf:"bytes,7,opt,name=encrypted_fine_timestamp_key_id,json=encryptedFineTimestampKeyId,proto3" json:"encrypted_fine_timestamp_key_id,omitempty"`
	// Received signal strength indicator (dBm).
	// This value equals `channel_rssi`.
	RSSI float32 `protobuf:"fixed32,8,opt,name=rssi,proto3" json:"rssi,omitempty"`
	// Received signal strength indicator of the signal (dBm).
	SignalRSSI *types.FloatValue `protobuf:"bytes,16,opt,name=signal_rssi,json=signalRssi,proto3" json:"signal_rssi,omitempty"`
	// Received signal strength indicator of the channel (dBm).
	ChannelRSSI float32 `protobuf:"fixed32,9,opt,name=channel_rssi,json=channelRssi,proto3" json:"channel_rssi,omitempty"`
	// Standard deviation of the RSSI during preamble.
	RSSIStandardDeviation float32 `protobuf:"fixed32,10,opt,name=rssi_standard_deviation,json=rssiStandardDeviation,proto3" json:"rssi_standard_deviation,omitempty"`
	// Signal-to-noise ratio (dB).
	SNR float32 `protobuf:"fixed32,11,opt,name=snr,proto3" json:"snr,omitempty"`
	// Frequency offset (Hz).
	FrequencyOffset int64 `protobuf:"varint,12,opt,name=frequency_offset,json=frequencyOffset,proto3" json:"frequency_offset,omitempty"`
	// Antenna location; injected by the Gateway Server.
	Location *Location `protobuf:"bytes,13,opt,name=location,proto3" json:"location,omitempty"`
	// Gateway downlink path constraint; injected by the Gateway Server.
	DownlinkPathConstraint DownlinkPathConstraint `protobuf:"varint,14,opt,name=downlink_path_constraint,json=downlinkPathConstraint,proto3,enum=ttn.lorawan.v3.DownlinkPathConstraint" json:"downlink_path_constraint,omitempty"`
	// Uplink token to be included in the Tx request in class A downlink; injected by gateway, Gateway Server or fNS.
	UplinkToken []byte `protobuf:"bytes,15,opt,name=uplink_token,json=uplinkToken,proto3" json:"uplink_token,omitempty"`
	// Index of the gateway channel that received the message.
	ChannelIndex uint32 `protobuf:"varint,17,opt,name=channel_index,json=channelIndex,proto3" json:"channel_index,omitempty"`
	// Advanced metadata fields
	// - can be used for advanced information or experimental features that are not yet formally defined in the API
	// - field names are written in snake_case
	Advanced             *types.Struct `protobuf:"bytes,99,opt,name=advanced,proto3" json:"advanced,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *RxMetadata) Reset()      { *m = RxMetadata{} }
func (*RxMetadata) ProtoMessage() {}
func (*RxMetadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_e1123b3e8fd87092, []int{0}
}
func (m *RxMetadata) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RxMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RxMetadata.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RxMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RxMetadata.Merge(m, src)
}
func (m *RxMetadata) XXX_Size() int {
	return m.Size()
}
func (m *RxMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_RxMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_RxMetadata proto.InternalMessageInfo

func (m *RxMetadata) GetPacketBroker() *PacketBrokerMetadata {
	if m != nil {
		return m.PacketBroker
	}
	return nil
}

func (m *RxMetadata) GetAntennaIndex() uint32 {
	if m != nil {
		return m.AntennaIndex
	}
	return 0
}

func (m *RxMetadata) GetTime() *time.Time {
	if m != nil {
		return m.Time
	}
	return nil
}

func (m *RxMetadata) GetTimestamp() uint32 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

func (m *RxMetadata) GetFineTimestamp() uint64 {
	if m != nil {
		return m.FineTimestamp
	}
	return 0
}

func (m *RxMetadata) GetEncryptedFineTimestamp() []byte {
	if m != nil {
		return m.EncryptedFineTimestamp
	}
	return nil
}

func (m *RxMetadata) GetEncryptedFineTimestampKeyID() string {
	if m != nil {
		return m.EncryptedFineTimestampKeyID
	}
	return ""
}

func (m *RxMetadata) GetRSSI() float32 {
	if m != nil {
		return m.RSSI
	}
	return 0
}

func (m *RxMetadata) GetSignalRSSI() *types.FloatValue {
	if m != nil {
		return m.SignalRSSI
	}
	return nil
}

func (m *RxMetadata) GetChannelRSSI() float32 {
	if m != nil {
		return m.ChannelRSSI
	}
	return 0
}

func (m *RxMetadata) GetRSSIStandardDeviation() float32 {
	if m != nil {
		return m.RSSIStandardDeviation
	}
	return 0
}

func (m *RxMetadata) GetSNR() float32 {
	if m != nil {
		return m.SNR
	}
	return 0
}

func (m *RxMetadata) GetFrequencyOffset() int64 {
	if m != nil {
		return m.FrequencyOffset
	}
	return 0
}

func (m *RxMetadata) GetLocation() *Location {
	if m != nil {
		return m.Location
	}
	return nil
}

func (m *RxMetadata) GetDownlinkPathConstraint() DownlinkPathConstraint {
	if m != nil {
		return m.DownlinkPathConstraint
	}
	return DOWNLINK_PATH_CONSTRAINT_NONE
}

func (m *RxMetadata) GetUplinkToken() []byte {
	if m != nil {
		return m.UplinkToken
	}
	return nil
}

func (m *RxMetadata) GetChannelIndex() uint32 {
	if m != nil {
		return m.ChannelIndex
	}
	return 0
}

func (m *RxMetadata) GetAdvanced() *types.Struct {
	if m != nil {
		return m.Advanced
	}
	return nil
}

type Location struct {
	// The North–South position (degrees; -90 to +90), where 0 is the equator, North pole is positive, South pole is negative.
	Latitude float64 `protobuf:"fixed64,1,opt,name=latitude,proto3" json:"latitude,omitempty"`
	// The East-West position (degrees; -180 to +180), where 0 is the Prime Meridian (Greenwich), East is positive , West is negative.
	Longitude float64 `protobuf:"fixed64,2,opt,name=longitude,proto3" json:"longitude,omitempty"`
	// The altitude (meters), where 0 is the mean sea level.
	Altitude int32 `protobuf:"varint,3,opt,name=altitude,proto3" json:"altitude,omitempty"`
	// The accuracy of the location (meters).
	Accuracy int32 `protobuf:"varint,4,opt,name=accuracy,proto3" json:"accuracy,omitempty"`
	// Source of the location information.
	Source               LocationSource `protobuf:"varint,5,opt,name=source,proto3,enum=ttn.lorawan.v3.LocationSource" json:"source,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *Location) Reset()      { *m = Location{} }
func (*Location) ProtoMessage() {}
func (*Location) Descriptor() ([]byte, []int) {
	return fileDescriptor_e1123b3e8fd87092, []int{1}
}
func (m *Location) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Location) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Location.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Location) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Location.Merge(m, src)
}
func (m *Location) XXX_Size() int {
	return m.Size()
}
func (m *Location) XXX_DiscardUnknown() {
	xxx_messageInfo_Location.DiscardUnknown(m)
}

var xxx_messageInfo_Location proto.InternalMessageInfo

func (m *Location) GetLatitude() float64 {
	if m != nil {
		return m.Latitude
	}
	return 0
}

func (m *Location) GetLongitude() float64 {
	if m != nil {
		return m.Longitude
	}
	return 0
}

func (m *Location) GetAltitude() int32 {
	if m != nil {
		return m.Altitude
	}
	return 0
}

func (m *Location) GetAccuracy() int32 {
	if m != nil {
		return m.Accuracy
	}
	return 0
}

func (m *Location) GetSource() LocationSource {
	if m != nil {
		return m.Source
	}
	return SOURCE_UNKNOWN
}

type PacketBrokerMetadata struct {
	// Message identifier generated by Packet Broker Router.
	MessageID string `protobuf:"bytes,1,opt,name=message_id,json=messageId,proto3" json:"message_id,omitempty"`
	// LoRa Alliance NetID of the Packet Broker Forwarder Member.
	ForwarderNetID go_thethings_network_lorawan_stack_v3_pkg_types.NetID `protobuf:"bytes,2,opt,name=forwarder_net_id,json=forwarderNetId,proto3,customtype=go.thethings.network/lorawan-stack/v3/pkg/types.NetID" json:"forwarder_net_id"`
	// Tenant ID managed by the Packet Broker Forwarder Member.
	ForwarderTenantID string `protobuf:"bytes,3,opt,name=forwarder_tenant_id,json=forwarderTenantId,proto3" json:"forwarder_tenant_id,omitempty"`
	// Forwarder Cluster ID of the Packet Broker Forwarder.
	ForwarderClusterID string `protobuf:"bytes,4,opt,name=forwarder_cluster_id,json=forwarderClusterId,proto3" json:"forwarder_cluster_id,omitempty"`
	// LoRa Alliance NetID of the Packet Broker Home Network Member.
	HomeNetworkNetID go_thethings_network_lorawan_stack_v3_pkg_types.NetID `protobuf:"bytes,5,opt,name=home_network_net_id,json=homeNetworkNetId,proto3,customtype=go.thethings.network/lorawan-stack/v3/pkg/types.NetID" json:"home_network_net_id"`
	// Tenant ID managed by the Packet Broker Home Network Member.
	// This value is empty if it cannot be determined by the Packet Broker Router.
	HomeNetworkTenantID string `protobuf:"bytes,6,opt,name=home_network_tenant_id,json=homeNetworkTenantId,proto3" json:"home_network_tenant_id,omitempty"`
	// Home Network Cluster ID of the Packet Broker Home Network.
	HomeNetworkClusterID string `protobuf:"bytes,8,opt,name=home_network_cluster_id,json=homeNetworkClusterId,proto3" json:"home_network_cluster_id,omitempty"`
	// Hops that the message passed. Each Packet Broker Router service appends an entry.
	Hops                 []*PacketBrokerRouteHop `protobuf:"bytes,7,rep,name=hops,proto3" json:"hops,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *PacketBrokerMetadata) Reset()      { *m = PacketBrokerMetadata{} }
func (*PacketBrokerMetadata) ProtoMessage() {}
func (*PacketBrokerMetadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_e1123b3e8fd87092, []int{2}
}
func (m *PacketBrokerMetadata) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PacketBrokerMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PacketBrokerMetadata.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PacketBrokerMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PacketBrokerMetadata.Merge(m, src)
}
func (m *PacketBrokerMetadata) XXX_Size() int {
	return m.Size()
}
func (m *PacketBrokerMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_PacketBrokerMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_PacketBrokerMetadata proto.InternalMessageInfo

func (m *PacketBrokerMetadata) GetMessageID() string {
	if m != nil {
		return m.MessageID
	}
	return ""
}

func (m *PacketBrokerMetadata) GetForwarderTenantID() string {
	if m != nil {
		return m.ForwarderTenantID
	}
	return ""
}

func (m *PacketBrokerMetadata) GetForwarderClusterID() string {
	if m != nil {
		return m.ForwarderClusterID
	}
	return ""
}

func (m *PacketBrokerMetadata) GetHomeNetworkTenantID() string {
	if m != nil {
		return m.HomeNetworkTenantID
	}
	return ""
}

func (m *PacketBrokerMetadata) GetHomeNetworkClusterID() string {
	if m != nil {
		return m.HomeNetworkClusterID
	}
	return ""
}

func (m *PacketBrokerMetadata) GetHops() []*PacketBrokerRouteHop {
	if m != nil {
		return m.Hops
	}
	return nil
}

type PacketBrokerRouteHop struct {
	// Time when the service received the message.
	ReceivedAt time.Time `protobuf:"bytes,1,opt,name=received_at,json=receivedAt,proto3,stdtime" json:"received_at"`
	// Sender of the message, typically the authorized client identifier.
	SenderName string `protobuf:"bytes,2,opt,name=sender_name,json=senderName,proto3" json:"sender_name,omitempty"`
	// Sender IP address or host name.
	SenderAddress string `protobuf:"bytes,3,opt,name=sender_address,json=senderAddress,proto3" json:"sender_address,omitempty"`
	// Receiver of the message.
	ReceiverName string `protobuf:"bytes,4,opt,name=receiver_name,json=receiverName,proto3" json:"receiver_name,omitempty"`
	// Receiver agent.
	ReceiverAgent        string   `protobuf:"bytes,5,opt,name=receiver_agent,json=receiverAgent,proto3" json:"receiver_agent,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PacketBrokerRouteHop) Reset()      { *m = PacketBrokerRouteHop{} }
func (*PacketBrokerRouteHop) ProtoMessage() {}
func (*PacketBrokerRouteHop) Descriptor() ([]byte, []int) {
	return fileDescriptor_e1123b3e8fd87092, []int{3}
}
func (m *PacketBrokerRouteHop) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PacketBrokerRouteHop) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PacketBrokerRouteHop.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PacketBrokerRouteHop) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PacketBrokerRouteHop.Merge(m, src)
}
func (m *PacketBrokerRouteHop) XXX_Size() int {
	return m.Size()
}
func (m *PacketBrokerRouteHop) XXX_DiscardUnknown() {
	xxx_messageInfo_PacketBrokerRouteHop.DiscardUnknown(m)
}

var xxx_messageInfo_PacketBrokerRouteHop proto.InternalMessageInfo

func (m *PacketBrokerRouteHop) GetReceivedAt() time.Time {
	if m != nil {
		return m.ReceivedAt
	}
	return time.Time{}
}

func (m *PacketBrokerRouteHop) GetSenderName() string {
	if m != nil {
		return m.SenderName
	}
	return ""
}

func (m *PacketBrokerRouteHop) GetSenderAddress() string {
	if m != nil {
		return m.SenderAddress
	}
	return ""
}

func (m *PacketBrokerRouteHop) GetReceiverName() string {
	if m != nil {
		return m.ReceiverName
	}
	return ""
}

func (m *PacketBrokerRouteHop) GetReceiverAgent() string {
	if m != nil {
		return m.ReceiverAgent
	}
	return ""
}

func init() {
	proto.RegisterEnum("ttn.lorawan.v3.LocationSource", LocationSource_name, LocationSource_value)
	golang_proto.RegisterEnum("ttn.lorawan.v3.LocationSource", LocationSource_name, LocationSource_value)
	proto.RegisterType((*RxMetadata)(nil), "ttn.lorawan.v3.RxMetadata")
	golang_proto.RegisterType((*RxMetadata)(nil), "ttn.lorawan.v3.RxMetadata")
	proto.RegisterType((*Location)(nil), "ttn.lorawan.v3.Location")
	golang_proto.RegisterType((*Location)(nil), "ttn.lorawan.v3.Location")
	proto.RegisterType((*PacketBrokerMetadata)(nil), "ttn.lorawan.v3.PacketBrokerMetadata")
	golang_proto.RegisterType((*PacketBrokerMetadata)(nil), "ttn.lorawan.v3.PacketBrokerMetadata")
	proto.RegisterType((*PacketBrokerRouteHop)(nil), "ttn.lorawan.v3.PacketBrokerRouteHop")
	golang_proto.RegisterType((*PacketBrokerRouteHop)(nil), "ttn.lorawan.v3.PacketBrokerRouteHop")
}

func init() { proto.RegisterFile("lorawan-stack/api/metadata.proto", fileDescriptor_e1123b3e8fd87092) }
func init() {
	golang_proto.RegisterFile("lorawan-stack/api/metadata.proto", fileDescriptor_e1123b3e8fd87092)
}

var fileDescriptor_e1123b3e8fd87092 = []byte{
	// 1500 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0x3d, 0x8c, 0xdb, 0xc8,
	0x19, 0xe5, 0xac, 0xb4, 0x6b, 0x69, 0xf4, 0x63, 0x79, 0x76, 0xed, 0xa5, 0xd7, 0xce, 0x50, 0xd9,
	0x4b, 0x02, 0xdd, 0x21, 0x2b, 0x01, 0xf6, 0x1d, 0x70, 0x48, 0x75, 0xab, 0xd5, 0xda, 0x26, 0x6e,
	0x2d, 0xf9, 0x46, 0xeb, 0x3b, 0x24, 0x0d, 0x31, 0x4b, 0x8e, 0x24, 0x46, 0xd2, 0x90, 0x21, 0x47,
	0xbb, 0x56, 0x67, 0xa4, 0x32, 0x52, 0x5d, 0xba, 0x94, 0x07, 0x04, 0x01, 0xae, 0x48, 0x71, 0xa5,
	0x4b, 0x97, 0x2e, 0xdd, 0xe5, 0x90, 0x42, 0xb9, 0xa5, 0x9a, 0x2b, 0x9d, 0xce, 0x70, 0x93, 0x80,
	0x43, 0x52, 0xbf, 0x76, 0x82, 0x20, 0xaa, 0x38, 0xef, 0x7b, 0xef, 0x0d, 0xf9, 0x66, 0xbe, 0x19,
	0xc1, 0xf2, 0xc0, 0xf1, 0xe8, 0x05, 0xe5, 0x07, 0xbe, 0xa0, 0x66, 0xbf, 0x46, 0x5d, 0xbb, 0x36,
	0x64, 0x82, 0x5a, 0x54, 0xd0, 0xaa, 0xeb, 0x39, 0xc2, 0x41, 0x45, 0x21, 0x78, 0x35, 0x66, 0x55,
	0xcf, 0xef, 0xee, 0x1d, 0x76, 0x6d, 0xd1, 0x1b, 0x9d, 0x55, 0x4d, 0x67, 0x58, 0x63, 0xfc, 0xdc,
	0x19, 0xbb, 0x9e, 0xf3, 0x64, 0x5c, 0x93, 0x64, 0xf3, 0xa0, 0xcb, 0xf8, 0xc1, 0x39, 0x1d, 0xd8,
	0x16, 0x15, 0xac, 0xb6, 0xf6, 0x10, 0x59, 0xee, 0x1d, 0x2c, 0x58, 0x74, 0x9d, 0xae, 0x13, 0x89,
	0xcf, 0x46, 0x1d, 0x39, 0x92, 0x03, 0xf9, 0x14, 0xd3, 0x6f, 0x77, 0x1d, 0xa7, 0x3b, 0x60, 0x73,
	0x96, 0x2f, 0xbc, 0x91, 0x29, 0xe2, 0xaa, 0xb6, 0x5a, 0x15, 0xf6, 0x90, 0xf9, 0x82, 0x0e, 0xdd,
	0x98, 0x80, 0x57, 0x09, 0x17, 0x1e, 0x75, 0x5d, 0xe6, 0xf9, 0x71, 0xfd, 0x27, 0xeb, 0x11, 0x30,
	0x3e, 0x1a, 0x26, 0xe5, 0x0f, 0xd6, 0xcb, 0xb6, 0xc5, 0xb8, 0xb0, 0x3b, 0xf6, 0xcc, 0x63, 0xff,
	0x6f, 0x19, 0x08, 0xc9, 0x93, 0x87, 0x71, 0x72, 0xe8, 0x31, 0xcc, 0x75, 0xa9, 0x60, 0x17, 0x74,
	0x6c, 0xd8, 0x96, 0xaf, 0x82, 0x32, 0xa8, 0xe4, 0xee, 0xec, 0x57, 0x97, 0x93, 0xac, 0xde, 0x8f,
	0x28, 0xfa, 0xdc, 0xad, 0x5e, 0x7a, 0x5b, 0xdf, 0xfc, 0x03, 0xd8, 0x28, 0x81, 0x97, 0x13, 0x4d,
	0x79, 0x35, 0xd1, 0x00, 0x81, 0xdd, 0x84, 0xe5, 0x23, 0x1d, 0x16, 0x5c, 0x6a, 0xf6, 0x99, 0x30,
	0xce, 0x3c, 0xa7, 0xcf, 0x3c, 0x15, 0x49, 0xe3, 0x9f, 0xad, 0x1a, 0x3f, 0x92, 0xa4, 0xba, 0xe4,
	0x24, 0xef, 0x44, 0xf2, 0xee, 0x02, 0x8a, 0x3e, 0x80, 0x05, 0xca, 0x05, 0xe3, 0x9c, 0x1a, 0x36,
	0xb7, 0xd8, 0x13, 0x75, 0xa3, 0x0c, 0x2a, 0x05, 0x92, 0x8f, 0x41, 0x3d, 0xc4, 0xd0, 0xc7, 0x30,
	0x1d, 0x86, 0xa9, 0xa6, 0xe4, 0x34, 0x7b, 0xd5, 0x28, 0xc8, 0x6a, 0x12, 0x64, 0xf5, 0x34, 0x49,
	0xba, 0x9e, 0xfe, 0xfa, 0x1f, 0x1a, 0x20, 0x92, 0x8d, 0x6e, 0xc3, 0xec, 0x6c, 0x09, 0xd4, 0xb4,
	0xb4, 0x9d, 0x03, 0xe8, 0xe7, 0xb0, 0xd8, 0xb1, 0x39, 0x33, 0xe6, 0x94, 0xcd, 0x32, 0xa8, 0xa4,
	0x49, 0x21, 0x44, 0x67, 0x86, 0xe8, 0x53, 0xa8, 0x32, 0x6e, 0x7a, 0x63, 0x57, 0x30, 0xcb, 0x58,
	0x11, 0x6c, 0x95, 0x41, 0x25, 0x4f, 0x6e, 0xcc, 0xea, 0xf7, 0x96, 0x94, 0x0c, 0x6a, 0xef, 0x53,
	0x1a, 0x7d, 0x16, 0x2e, 0x88, 0x7a, 0xa5, 0x0c, 0x2a, 0xd9, 0xba, 0x16, 0x4c, 0xb4, 0x5b, 0xc7,
	0xef, 0x34, 0xf9, 0x9c, 0x8d, 0xf5, 0x06, 0xb9, 0xc5, 0xde, 0x5b, 0xb4, 0xd0, 0x6d, 0x98, 0xf6,
	0x7c, 0xdf, 0x56, 0x33, 0x65, 0x50, 0xd9, 0xa8, 0x67, 0x82, 0x89, 0x96, 0x26, 0xed, 0xb6, 0x4e,
	0x24, 0x8a, 0x4e, 0x60, 0xce, 0xb7, 0xbb, 0x9c, 0x0e, 0x0c, 0x49, 0x2a, 0xc9, 0x00, 0x6f, 0xad,
	0x05, 0x78, 0x6f, 0xe0, 0x50, 0xf1, 0x25, 0x1d, 0x8c, 0x58, 0xbd, 0x18, 0x4c, 0x34, 0xd8, 0x96,
	0x1a, 0xe9, 0x03, 0x23, 0x3d, 0x09, 0xdd, 0xee, 0xc0, 0xbc, 0xd9, 0xa3, 0x9c, 0xb3, 0xd8, 0x2e,
	0x2b, 0xe7, 0xbc, 0x1a, 0x4c, 0xb4, 0xdc, 0x51, 0x84, 0x4b, 0x49, 0x2e, 0x26, 0x49, 0xcd, 0x17,
	0x70, 0x37, 0xe4, 0x1a, 0xbe, 0xa0, 0xdc, 0xa2, 0x9e, 0x65, 0x58, 0xec, 0xdc, 0xa6, 0xc2, 0x76,
	0xb8, 0x0a, 0xa5, 0xfc, 0x66, 0x30, 0xd1, 0xae, 0x87, 0xba, 0x76, 0xcc, 0x68, 0x24, 0x04, 0x72,
	0x3d, 0x54, 0xae, 0xc1, 0xe8, 0x26, 0x4c, 0xf9, 0xdc, 0x53, 0x73, 0x52, 0x7e, 0x25, 0x98, 0x68,
	0xa9, 0x76, 0x93, 0x90, 0x10, 0x43, 0x1f, 0xc2, 0x52, 0xc7, 0x63, 0xbf, 0x1b, 0x31, 0x6e, 0x8e,
	0x0d, 0xa7, 0xd3, 0xf1, 0x99, 0x50, 0xf3, 0x65, 0x50, 0x49, 0x91, 0xab, 0x33, 0xbc, 0x25, 0x61,
	0xf4, 0x31, 0xcc, 0x0c, 0x1c, 0x33, 0x7a, 0x93, 0x82, 0xcc, 0x45, 0x5d, 0xdd, 0xbf, 0x27, 0x71,
	0x9d, 0xcc, 0x98, 0xe8, 0xb7, 0x50, 0xb5, 0x9c, 0x0b, 0x3e, 0xb0, 0x79, 0xdf, 0x70, 0xa9, 0xe8,
	0x19, 0xa6, 0xc3, 0x7d, 0xe1, 0x51, 0x9b, 0x0b, 0xb5, 0x58, 0x06, 0x95, 0xe2, 0x9d, 0x5f, 0xac,
	0xba, 0x34, 0x62, 0xfe, 0x23, 0x2a, 0x7a, 0x47, 0x33, 0x76, 0x3d, 0xf3, 0xb6, 0xbe, 0xf9, 0xfb,
	0xb0, 0xc5, 0xc8, 0x0d, 0xeb, 0x9d, 0x0c, 0xf4, 0x53, 0x98, 0x1f, 0xb9, 0x72, 0x26, 0xe1, 0xf4,
	0x19, 0x57, 0xaf, 0xca, 0xfd, 0x96, 0x8b, 0xb0, 0xd3, 0x10, 0x42, 0x07, 0xb0, 0x90, 0xac, 0x48,
	0xd4, 0x3e, 0xd7, 0xc2, 0x7d, 0x2e, 0xbd, 0x3f, 0x4a, 0xa9, 0xff, 0x02, 0x24, 0x59, 0xb0, 0xa8,
	0x91, 0xee, 0xc2, 0x0c, 0xb5, 0xce, 0x29, 0x37, 0x99, 0xa5, 0x9a, 0xf2, 0x9b, 0x77, 0xd7, 0xf6,
	0x42, 0x5b, 0x1e, 0x6a, 0x64, 0x46, 0xfc, 0x55, 0xfa, 0xf9, 0x37, 0x9a, 0xb2, 0xff, 0x1a, 0xc0,
	0x4c, 0x92, 0x47, 0xe8, 0x33, 0xa0, 0xc2, 0x16, 0x23, 0x8b, 0xc9, 0x43, 0x05, 0xd4, 0x77, 0xdf,
	0xd6, 0x77, 0x10, 0xba, 0xa9, 0x84, 0xbf, 0xa7, 0x5f, 0x7e, 0xf6, 0x61, 0xfc, 0xf0, 0x82, 0xcc,
	0x88, 0xe8, 0x13, 0x98, 0x1d, 0x38, 0xbc, 0x1b, 0xa9, 0x36, 0xd6, 0x55, 0x9d, 0x44, 0xd5, 0x79,
	0x41, 0xe6, 0x4c, 0xb4, 0x07, 0x33, 0x74, 0x10, 0xcf, 0x15, 0x1e, 0x00, 0x9b, 0x64, 0x36, 0x96,
	0x35, 0xd3, 0x1c, 0x79, 0xd4, 0x1c, 0xcb, 0x0e, 0x0f, 0x6b, 0xf1, 0x18, 0x7d, 0x06, 0xb7, 0x7c,
	0x67, 0xe4, 0x99, 0x4c, 0x36, 0x76, 0xf1, 0x0e, 0x7e, 0xdf, 0xea, 0xb6, 0x25, 0x6b, 0x61, 0x3d,
	0x62, 0xdd, 0xfe, 0x5f, 0x37, 0xe1, 0xce, 0xbb, 0x8e, 0x30, 0xf4, 0x4b, 0x08, 0x87, 0xcc, 0xf7,
	0x69, 0x97, 0x85, 0x5d, 0x0c, 0x64, 0x17, 0x17, 0x82, 0x89, 0x96, 0x7d, 0x18, 0xa1, 0x7a, 0x83,
	0x64, 0x63, 0x82, 0x6e, 0xa1, 0x31, 0x2c, 0x75, 0x1c, 0xef, 0x82, 0x7a, 0x16, 0xf3, 0x0c, 0xce,
	0x44, 0xa8, 0x09, 0x3f, 0x3f, 0x5f, 0x6f, 0x85, 0xa7, 0xeb, 0xdf, 0x27, 0xda, 0x27, 0x5d, 0xa7,
	0x2a, 0x7a, 0x4c, 0xf4, 0x6c, 0xde, 0xf5, 0xab, 0x9c, 0x89, 0x0b, 0xc7, 0xeb, 0xd7, 0x96, 0xcf,
	0xfb, 0xf3, 0xbb, 0x35, 0xb7, 0xdf, 0xad, 0x89, 0xb1, 0xcb, 0xfc, 0x6a, 0x93, 0x09, 0xbd, 0x11,
	0x4c, 0xb4, 0xe2, 0xbd, 0xc4, 0x58, 0x22, 0xa4, 0xd8, 0x59, 0x1c, 0x5b, 0xe8, 0x18, 0x6e, 0xcf,
	0xa7, 0x16, 0x8c, 0x53, 0x2e, 0x67, 0x4f, 0xc9, 0x37, 0xbe, 0x1e, 0x4c, 0xb4, 0x6b, 0x33, 0x83,
	0x53, 0x59, 0xd5, 0x1b, 0xe4, 0x5a, 0x67, 0x05, 0xb2, 0xd0, 0x03, 0xb8, 0x33, 0xb7, 0x31, 0x07,
	0x23, 0x5f, 0x30, 0x2f, 0xf4, 0x49, 0x4b, 0x9f, 0x1b, 0xc1, 0x44, 0x43, 0x33, 0x9f, 0xa3, 0xa8,
	0xac, 0x37, 0x08, 0xea, 0xac, 0x62, 0x16, 0x7a, 0x0a, 0xe0, 0x76, 0xcf, 0x19, 0x32, 0x23, 0xfe,
	0xc8, 0x24, 0x8f, 0x4d, 0x99, 0xc7, 0x17, 0xff, 0x6f, 0x1e, 0xa5, 0x07, 0xce, 0x90, 0x35, 0x23,
	0x7e, 0x94, 0x48, 0xa9, 0xb7, 0x8c, 0x58, 0xe8, 0x04, 0xde, 0x58, 0x7a, 0x83, 0x79, 0x2c, 0x5b,
	0xf2, 0x73, 0x76, 0x83, 0x89, 0xb6, 0xbd, 0xe0, 0x33, 0x0b, 0x66, 0xbb, 0xb7, 0x06, 0x5a, 0xa8,
	0x05, 0x77, 0x97, 0xdc, 0x16, 0xd2, 0xc9, 0x48, 0x3b, 0x35, 0x98, 0x68, 0x3b, 0x0b, 0x76, 0xf3,
	0x7c, 0x76, 0x7a, 0xeb, 0xa8, 0x85, 0x3e, 0x85, 0xe9, 0x9e, 0xe3, 0xfa, 0xea, 0x95, 0x72, 0xea,
	0xbf, 0x5d, 0xa9, 0xc4, 0x19, 0x09, 0xf6, 0xc0, 0x71, 0x89, 0x54, 0xec, 0xff, 0x13, 0x2c, 0x6f,
	0xd7, 0xa4, 0x8c, 0x8e, 0x61, 0xce, 0x63, 0x26, 0xb3, 0xcf, 0x99, 0x65, 0x50, 0x11, 0xff, 0x0b,
	0xf8, 0x4f, 0xb7, 0x68, 0x26, 0x5c, 0x07, 0x79, 0x93, 0xc2, 0x44, 0x78, 0x28, 0x90, 0x06, 0x73,
	0x3e, 0xe3, 0x72, 0x13, 0xd3, 0x61, 0xd4, 0xc1, 0x59, 0x02, 0x23, 0xa8, 0x49, 0x87, 0x2c, 0xbc,
	0x52, 0x63, 0x02, 0xb5, 0x2c, 0x8f, 0xf9, 0x7e, 0xb4, 0xd1, 0x48, 0x21, 0x42, 0x0f, 0x23, 0x30,
	0xbc, 0xf2, 0x63, 0xd7, 0xd8, 0x49, 0x6e, 0x23, 0x92, 0x4f, 0xc0, 0xc4, 0x6b, 0x46, 0xa2, 0x5d,
	0xc6, 0x85, 0xdc, 0x22, 0x59, 0x32, 0x93, 0x1e, 0x86, 0xe0, 0x47, 0x7f, 0xdc, 0x80, 0xc5, 0xe5,
	0x3e, 0x46, 0x08, 0x16, 0xdb, 0xad, 0xc7, 0xe4, 0xe8, 0xd8, 0x78, 0xdc, 0xfc, 0xbc, 0xd9, 0xfa,
	0xaa, 0x59, 0x52, 0x50, 0x11, 0xc2, 0x18, 0xbb, 0xff, 0xa8, 0x5d, 0x02, 0x68, 0x1b, 0x5e, 0x8d,
	0xc7, 0xe4, 0xf8, 0xbe, 0xde, 0x3e, 0x25, 0xbf, 0x2e, 0xa5, 0xd0, 0x4d, 0x78, 0x3d, 0x06, 0xf5,
	0x47, 0xc6, 0xfd, 0xe3, 0xd6, 0x49, 0xeb, 0xe8, 0xf0, 0x54, 0x6f, 0x35, 0x4b, 0x69, 0x54, 0x86,
	0xb7, 0xe3, 0xd2, 0x57, 0xfa, 0x3d, 0xdd, 0x08, 0x6f, 0xab, 0x25, 0xc6, 0x26, 0xc2, 0x70, 0x2f,
	0x66, 0xd4, 0x4f, 0xd7, 0xeb, 0x5b, 0x0b, 0x0e, 0x27, 0x2d, 0x72, 0xb8, 0xce, 0xb8, 0xb2, 0xca,
	0x38, 0x6d, 0xb4, 0x0e, 0x97, 0x18, 0x19, 0xa4, 0xc1, 0x5b, 0x31, 0xe3, 0xa8, 0xf5, 0xb0, 0xae,
	0x37, 0x8f, 0x1b, 0x4b, 0x84, 0xec, 0x5e, 0xfa, 0xd9, 0x9f, 0xb1, 0x52, 0xff, 0x0b, 0x78, 0x79,
	0x89, 0xc1, 0xab, 0x4b, 0x0c, 0xbe, 0xbf, 0xc4, 0xca, 0x0f, 0x97, 0x58, 0xf9, 0xf1, 0x12, 0x2b,
	0xaf, 0x2f, 0xb1, 0xf2, 0xe6, 0x12, 0x83, 0xa7, 0x01, 0x06, 0xcf, 0x02, 0xac, 0x7c, 0x1b, 0x60,
	0xf0, 0x5d, 0x80, 0x95, 0xe7, 0x01, 0x56, 0x5e, 0x04, 0x58, 0x79, 0x19, 0x60, 0xf0, 0x2a, 0xc0,
	0xe0, 0xfb, 0x00, 0x2b, 0x3f, 0x04, 0x18, 0xfc, 0x18, 0x60, 0xe5, 0x75, 0x80, 0xc1, 0x9b, 0x00,
	0x2b, 0x4f, 0xa7, 0x58, 0x79, 0x36, 0xc5, 0xe0, 0xeb, 0x29, 0x56, 0xfe, 0x34, 0xc5, 0xe0, 0x9b,
	0x29, 0x56, 0xbe, 0x9d, 0x62, 0xe5, 0xbb, 0x29, 0x06, 0xcf, 0xa7, 0x18, 0xbc, 0x98, 0x62, 0xf0,
	0x9b, 0xda, 0xff, 0xd0, 0xb4, 0x82, 0xbb, 0x67, 0x67, 0x5b, 0x72, 0xe7, 0xdd, 0xfd, 0x77, 0x00,
	0x00, 0x00, 0xff, 0xff, 0xa5, 0xb8, 0x5b, 0xe7, 0xfb, 0x0b, 0x00, 0x00,
}

func (x LocationSource) String() string {
	s, ok := LocationSource_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (this *RxMetadata) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RxMetadata)
	if !ok {
		that2, ok := that.(RxMetadata)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.GatewayIdentifiers.Equal(&that1.GatewayIdentifiers) {
		return false
	}
	if !this.PacketBroker.Equal(that1.PacketBroker) {
		return false
	}
	if this.AntennaIndex != that1.AntennaIndex {
		return false
	}
	if that1.Time == nil {
		if this.Time != nil {
			return false
		}
	} else if !this.Time.Equal(*that1.Time) {
		return false
	}
	if this.Timestamp != that1.Timestamp {
		return false
	}
	if this.FineTimestamp != that1.FineTimestamp {
		return false
	}
	if !bytes.Equal(this.EncryptedFineTimestamp, that1.EncryptedFineTimestamp) {
		return false
	}
	if this.EncryptedFineTimestampKeyID != that1.EncryptedFineTimestampKeyID {
		return false
	}
	if this.RSSI != that1.RSSI {
		return false
	}
	if !this.SignalRSSI.Equal(that1.SignalRSSI) {
		return false
	}
	if this.ChannelRSSI != that1.ChannelRSSI {
		return false
	}
	if this.RSSIStandardDeviation != that1.RSSIStandardDeviation {
		return false
	}
	if this.SNR != that1.SNR {
		return false
	}
	if this.FrequencyOffset != that1.FrequencyOffset {
		return false
	}
	if !this.Location.Equal(that1.Location) {
		return false
	}
	if this.DownlinkPathConstraint != that1.DownlinkPathConstraint {
		return false
	}
	if !bytes.Equal(this.UplinkToken, that1.UplinkToken) {
		return false
	}
	if this.ChannelIndex != that1.ChannelIndex {
		return false
	}
	if !this.Advanced.Equal(that1.Advanced) {
		return false
	}
	return true
}
func (this *Location) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Location)
	if !ok {
		that2, ok := that.(Location)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Latitude != that1.Latitude {
		return false
	}
	if this.Longitude != that1.Longitude {
		return false
	}
	if this.Altitude != that1.Altitude {
		return false
	}
	if this.Accuracy != that1.Accuracy {
		return false
	}
	if this.Source != that1.Source {
		return false
	}
	return true
}
func (this *PacketBrokerMetadata) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PacketBrokerMetadata)
	if !ok {
		that2, ok := that.(PacketBrokerMetadata)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.MessageID != that1.MessageID {
		return false
	}
	if !this.ForwarderNetID.Equal(that1.ForwarderNetID) {
		return false
	}
	if this.ForwarderTenantID != that1.ForwarderTenantID {
		return false
	}
	if this.ForwarderClusterID != that1.ForwarderClusterID {
		return false
	}
	if !this.HomeNetworkNetID.Equal(that1.HomeNetworkNetID) {
		return false
	}
	if this.HomeNetworkTenantID != that1.HomeNetworkTenantID {
		return false
	}
	if this.HomeNetworkClusterID != that1.HomeNetworkClusterID {
		return false
	}
	if len(this.Hops) != len(that1.Hops) {
		return false
	}
	for i := range this.Hops {
		if !this.Hops[i].Equal(that1.Hops[i]) {
			return false
		}
	}
	return true
}
func (this *PacketBrokerRouteHop) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*PacketBrokerRouteHop)
	if !ok {
		that2, ok := that.(PacketBrokerRouteHop)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ReceivedAt.Equal(that1.ReceivedAt) {
		return false
	}
	if this.SenderName != that1.SenderName {
		return false
	}
	if this.SenderAddress != that1.SenderAddress {
		return false
	}
	if this.ReceiverName != that1.ReceiverName {
		return false
	}
	if this.ReceiverAgent != that1.ReceiverAgent {
		return false
	}
	return true
}
func (m *RxMetadata) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RxMetadata) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RxMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Advanced != nil {
		{
			size, err := m.Advanced.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6
		i--
		dAtA[i] = 0x9a
	}
	if m.PacketBroker != nil {
		{
			size, err := m.PacketBroker.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x92
	}
	if m.ChannelIndex != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.ChannelIndex))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x88
	}
	if m.SignalRSSI != nil {
		{
			size, err := m.SignalRSSI.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x82
	}
	if len(m.UplinkToken) > 0 {
		i -= len(m.UplinkToken)
		copy(dAtA[i:], m.UplinkToken)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.UplinkToken)))
		i--
		dAtA[i] = 0x7a
	}
	if m.DownlinkPathConstraint != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.DownlinkPathConstraint))
		i--
		dAtA[i] = 0x70
	}
	if m.Location != nil {
		{
			size, err := m.Location.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintMetadata(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6a
	}
	if m.FrequencyOffset != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.FrequencyOffset))
		i--
		dAtA[i] = 0x60
	}
	if m.SNR != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], math.Float32bits(float32(m.SNR)))
		i--
		dAtA[i] = 0x5d
	}
	if m.RSSIStandardDeviation != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], math.Float32bits(float32(m.RSSIStandardDeviation)))
		i--
		dAtA[i] = 0x55
	}
	if m.ChannelRSSI != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], math.Float32bits(float32(m.ChannelRSSI)))
		i--
		dAtA[i] = 0x4d
	}
	if m.RSSI != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], math.Float32bits(float32(m.RSSI)))
		i--
		dAtA[i] = 0x45
	}
	if len(m.EncryptedFineTimestampKeyID) > 0 {
		i -= len(m.EncryptedFineTimestampKeyID)
		copy(dAtA[i:], m.EncryptedFineTimestampKeyID)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.EncryptedFineTimestampKeyID)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.EncryptedFineTimestamp) > 0 {
		i -= len(m.EncryptedFineTimestamp)
		copy(dAtA[i:], m.EncryptedFineTimestamp)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.EncryptedFineTimestamp)))
		i--
		dAtA[i] = 0x32
	}
	if m.FineTimestamp != 0 {
		i = encodeVarintMetadata(dAtA, i, m.FineTimestamp)
		i--
		dAtA[i] = 0x28
	}
	if m.Timestamp != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Timestamp))
		i--
		dAtA[i] = 0x20
	}
	if m.Time != nil {
		n5, err5 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.Time):])
		if err5 != nil {
			return 0, err5
		}
		i -= n5
		i = encodeVarintMetadata(dAtA, i, uint64(n5))
		i--
		dAtA[i] = 0x1a
	}
	if m.AntennaIndex != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.AntennaIndex))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.GatewayIdentifiers.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintMetadata(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *Location) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Location) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Location) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Source != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Source))
		i--
		dAtA[i] = 0x28
	}
	if m.Accuracy != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Accuracy))
		i--
		dAtA[i] = 0x20
	}
	if m.Altitude != 0 {
		i = encodeVarintMetadata(dAtA, i, uint64(m.Altitude))
		i--
		dAtA[i] = 0x18
	}
	if m.Longitude != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], math.Float64bits(float64(m.Longitude)))
		i--
		dAtA[i] = 0x11
	}
	if m.Latitude != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], math.Float64bits(float64(m.Latitude)))
		i--
		dAtA[i] = 0x9
	}
	return len(dAtA) - i, nil
}

func (m *PacketBrokerMetadata) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PacketBrokerMetadata) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PacketBrokerMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.HomeNetworkClusterID) > 0 {
		i -= len(m.HomeNetworkClusterID)
		copy(dAtA[i:], m.HomeNetworkClusterID)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.HomeNetworkClusterID)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.Hops) > 0 {
		for iNdEx := len(m.Hops) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Hops[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintMetadata(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.HomeNetworkTenantID) > 0 {
		i -= len(m.HomeNetworkTenantID)
		copy(dAtA[i:], m.HomeNetworkTenantID)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.HomeNetworkTenantID)))
		i--
		dAtA[i] = 0x32
	}
	{
		size := m.HomeNetworkNetID.Size()
		i -= size
		if _, err := m.HomeNetworkNetID.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetadata(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if len(m.ForwarderClusterID) > 0 {
		i -= len(m.ForwarderClusterID)
		copy(dAtA[i:], m.ForwarderClusterID)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.ForwarderClusterID)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.ForwarderTenantID) > 0 {
		i -= len(m.ForwarderTenantID)
		copy(dAtA[i:], m.ForwarderTenantID)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.ForwarderTenantID)))
		i--
		dAtA[i] = 0x1a
	}
	{
		size := m.ForwarderNetID.Size()
		i -= size
		if _, err := m.ForwarderNetID.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintMetadata(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.MessageID) > 0 {
		i -= len(m.MessageID)
		copy(dAtA[i:], m.MessageID)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.MessageID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PacketBrokerRouteHop) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PacketBrokerRouteHop) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PacketBrokerRouteHop) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ReceiverAgent) > 0 {
		i -= len(m.ReceiverAgent)
		copy(dAtA[i:], m.ReceiverAgent)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.ReceiverAgent)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.ReceiverName) > 0 {
		i -= len(m.ReceiverName)
		copy(dAtA[i:], m.ReceiverName)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.ReceiverName)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.SenderAddress) > 0 {
		i -= len(m.SenderAddress)
		copy(dAtA[i:], m.SenderAddress)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.SenderAddress)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.SenderName) > 0 {
		i -= len(m.SenderName)
		copy(dAtA[i:], m.SenderName)
		i = encodeVarintMetadata(dAtA, i, uint64(len(m.SenderName)))
		i--
		dAtA[i] = 0x12
	}
	n7, err7 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ReceivedAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.ReceivedAt):])
	if err7 != nil {
		return 0, err7
	}
	i -= n7
	i = encodeVarintMetadata(dAtA, i, uint64(n7))
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func encodeVarintMetadata(dAtA []byte, offset int, v uint64) int {
	offset -= sovMetadata(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func NewPopulatedLocation(r randyMetadata, easy bool) *Location {
	this := &Location{}
	this.Latitude = float64(r.Float64())
	if r.Intn(2) == 0 {
		this.Latitude *= -1
	}
	this.Longitude = float64(r.Float64())
	if r.Intn(2) == 0 {
		this.Longitude *= -1
	}
	this.Altitude = r.Int31()
	if r.Intn(2) == 0 {
		this.Altitude *= -1
	}
	this.Accuracy = r.Int31()
	if r.Intn(2) == 0 {
		this.Accuracy *= -1
	}
	this.Source = LocationSource([]int32{0, 1, 3, 4, 5, 6, 7, 8, 9}[r.Intn(9)])
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedPacketBrokerMetadata(r randyMetadata, easy bool) *PacketBrokerMetadata {
	this := &PacketBrokerMetadata{}
	this.MessageID = randStringMetadata(r)
	v1 := go_thethings_network_lorawan_stack_v3_pkg_types.NewPopulatedNetID(r)
	this.ForwarderNetID = *v1
	this.ForwarderTenantID = randStringMetadata(r)
	this.ForwarderClusterID = randStringMetadata(r)
	v2 := go_thethings_network_lorawan_stack_v3_pkg_types.NewPopulatedNetID(r)
	this.HomeNetworkNetID = *v2
	this.HomeNetworkTenantID = randStringMetadata(r)
	if r.Intn(5) != 0 {
		v3 := r.Intn(5)
		this.Hops = make([]*PacketBrokerRouteHop, v3)
		for i := 0; i < v3; i++ {
			this.Hops[i] = NewPopulatedPacketBrokerRouteHop(r, easy)
		}
	}
	this.HomeNetworkClusterID = randStringMetadata(r)
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedPacketBrokerRouteHop(r randyMetadata, easy bool) *PacketBrokerRouteHop {
	this := &PacketBrokerRouteHop{}
	v4 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy)
	this.ReceivedAt = *v4
	this.SenderName = randStringMetadata(r)
	this.SenderAddress = randStringMetadata(r)
	this.ReceiverName = randStringMetadata(r)
	this.ReceiverAgent = randStringMetadata(r)
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

type randyMetadata interface {
	Float32() float32
	Float64() float64
	Int63() int64
	Int31() int32
	Uint32() uint32
	Intn(n int) int
}

func randUTF8RuneMetadata(r randyMetadata) rune {
	ru := r.Intn(62)
	if ru < 10 {
		return rune(ru + 48)
	} else if ru < 36 {
		return rune(ru + 55)
	}
	return rune(ru + 61)
}
func randStringMetadata(r randyMetadata) string {
	v5 := r.Intn(100)
	tmps := make([]rune, v5)
	for i := 0; i < v5; i++ {
		tmps[i] = randUTF8RuneMetadata(r)
	}
	return string(tmps)
}
func randUnrecognizedMetadata(r randyMetadata, maxFieldNumber int) (dAtA []byte) {
	l := r.Intn(5)
	for i := 0; i < l; i++ {
		wire := r.Intn(4)
		if wire == 3 {
			wire = 5
		}
		fieldNumber := maxFieldNumber + r.Intn(100)
		dAtA = randFieldMetadata(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldMetadata(dAtA []byte, r randyMetadata, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateMetadata(dAtA, uint64(key))
		v6 := r.Int63()
		if r.Intn(2) == 0 {
			v6 *= -1
		}
		dAtA = encodeVarintPopulateMetadata(dAtA, uint64(v6))
	case 1:
		dAtA = encodeVarintPopulateMetadata(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	case 2:
		dAtA = encodeVarintPopulateMetadata(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateMetadata(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateMetadata(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	}
	return dAtA
}
func encodeVarintPopulateMetadata(dAtA []byte, v uint64) []byte {
	for v >= 1<<7 {
		dAtA = append(dAtA, uint8(v&0x7f|0x80))
		v >>= 7
	}
	dAtA = append(dAtA, uint8(v))
	return dAtA
}
func (m *RxMetadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.GatewayIdentifiers.Size()
	n += 1 + l + sovMetadata(uint64(l))
	if m.AntennaIndex != 0 {
		n += 1 + sovMetadata(uint64(m.AntennaIndex))
	}
	if m.Time != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.Time)
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.Timestamp != 0 {
		n += 1 + sovMetadata(uint64(m.Timestamp))
	}
	if m.FineTimestamp != 0 {
		n += 1 + sovMetadata(m.FineTimestamp)
	}
	l = len(m.EncryptedFineTimestamp)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.EncryptedFineTimestampKeyID)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.RSSI != 0 {
		n += 5
	}
	if m.ChannelRSSI != 0 {
		n += 5
	}
	if m.RSSIStandardDeviation != 0 {
		n += 5
	}
	if m.SNR != 0 {
		n += 5
	}
	if m.FrequencyOffset != 0 {
		n += 1 + sovMetadata(uint64(m.FrequencyOffset))
	}
	if m.Location != nil {
		l = m.Location.Size()
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.DownlinkPathConstraint != 0 {
		n += 1 + sovMetadata(uint64(m.DownlinkPathConstraint))
	}
	l = len(m.UplinkToken)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if m.SignalRSSI != nil {
		l = m.SignalRSSI.Size()
		n += 2 + l + sovMetadata(uint64(l))
	}
	if m.ChannelIndex != 0 {
		n += 2 + sovMetadata(uint64(m.ChannelIndex))
	}
	if m.PacketBroker != nil {
		l = m.PacketBroker.Size()
		n += 2 + l + sovMetadata(uint64(l))
	}
	if m.Advanced != nil {
		l = m.Advanced.Size()
		n += 2 + l + sovMetadata(uint64(l))
	}
	return n
}

func (m *Location) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Latitude != 0 {
		n += 9
	}
	if m.Longitude != 0 {
		n += 9
	}
	if m.Altitude != 0 {
		n += 1 + sovMetadata(uint64(m.Altitude))
	}
	if m.Accuracy != 0 {
		n += 1 + sovMetadata(uint64(m.Accuracy))
	}
	if m.Source != 0 {
		n += 1 + sovMetadata(uint64(m.Source))
	}
	return n
}

func (m *PacketBrokerMetadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.MessageID)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = m.ForwarderNetID.Size()
	n += 1 + l + sovMetadata(uint64(l))
	l = len(m.ForwarderTenantID)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.ForwarderClusterID)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = m.HomeNetworkNetID.Size()
	n += 1 + l + sovMetadata(uint64(l))
	l = len(m.HomeNetworkTenantID)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	if len(m.Hops) > 0 {
		for _, e := range m.Hops {
			l = e.Size()
			n += 1 + l + sovMetadata(uint64(l))
		}
	}
	l = len(m.HomeNetworkClusterID)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

func (m *PacketBrokerRouteHop) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.ReceivedAt)
	n += 1 + l + sovMetadata(uint64(l))
	l = len(m.SenderName)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.SenderAddress)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.ReceiverName)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	l = len(m.ReceiverAgent)
	if l > 0 {
		n += 1 + l + sovMetadata(uint64(l))
	}
	return n
}

func sovMetadata(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozMetadata(x uint64) (n int) {
	return sovMetadata((x << 1) ^ uint64((int64(x) >> 63)))
}
func (this *RxMetadata) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RxMetadata{`,
		`GatewayIdentifiers:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.GatewayIdentifiers), "GatewayIdentifiers", "GatewayIdentifiers", 1), `&`, ``, 1) + `,`,
		`AntennaIndex:` + fmt.Sprintf("%v", this.AntennaIndex) + `,`,
		`Time:` + strings.Replace(fmt.Sprintf("%v", this.Time), "Timestamp", "types.Timestamp", 1) + `,`,
		`Timestamp:` + fmt.Sprintf("%v", this.Timestamp) + `,`,
		`FineTimestamp:` + fmt.Sprintf("%v", this.FineTimestamp) + `,`,
		`EncryptedFineTimestamp:` + fmt.Sprintf("%v", this.EncryptedFineTimestamp) + `,`,
		`EncryptedFineTimestampKeyID:` + fmt.Sprintf("%v", this.EncryptedFineTimestampKeyID) + `,`,
		`RSSI:` + fmt.Sprintf("%v", this.RSSI) + `,`,
		`ChannelRSSI:` + fmt.Sprintf("%v", this.ChannelRSSI) + `,`,
		`RSSIStandardDeviation:` + fmt.Sprintf("%v", this.RSSIStandardDeviation) + `,`,
		`SNR:` + fmt.Sprintf("%v", this.SNR) + `,`,
		`FrequencyOffset:` + fmt.Sprintf("%v", this.FrequencyOffset) + `,`,
		`Location:` + strings.Replace(this.Location.String(), "Location", "Location", 1) + `,`,
		`DownlinkPathConstraint:` + fmt.Sprintf("%v", this.DownlinkPathConstraint) + `,`,
		`UplinkToken:` + fmt.Sprintf("%v", this.UplinkToken) + `,`,
		`SignalRSSI:` + strings.Replace(fmt.Sprintf("%v", this.SignalRSSI), "FloatValue", "types.FloatValue", 1) + `,`,
		`ChannelIndex:` + fmt.Sprintf("%v", this.ChannelIndex) + `,`,
		`PacketBroker:` + strings.Replace(this.PacketBroker.String(), "PacketBrokerMetadata", "PacketBrokerMetadata", 1) + `,`,
		`Advanced:` + strings.Replace(fmt.Sprintf("%v", this.Advanced), "Struct", "types.Struct", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Location) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Location{`,
		`Latitude:` + fmt.Sprintf("%v", this.Latitude) + `,`,
		`Longitude:` + fmt.Sprintf("%v", this.Longitude) + `,`,
		`Altitude:` + fmt.Sprintf("%v", this.Altitude) + `,`,
		`Accuracy:` + fmt.Sprintf("%v", this.Accuracy) + `,`,
		`Source:` + fmt.Sprintf("%v", this.Source) + `,`,
		`}`,
	}, "")
	return s
}
func (this *PacketBrokerMetadata) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForHops := "[]*PacketBrokerRouteHop{"
	for _, f := range this.Hops {
		repeatedStringForHops += strings.Replace(f.String(), "PacketBrokerRouteHop", "PacketBrokerRouteHop", 1) + ","
	}
	repeatedStringForHops += "}"
	s := strings.Join([]string{`&PacketBrokerMetadata{`,
		`MessageID:` + fmt.Sprintf("%v", this.MessageID) + `,`,
		`ForwarderNetID:` + fmt.Sprintf("%v", this.ForwarderNetID) + `,`,
		`ForwarderTenantID:` + fmt.Sprintf("%v", this.ForwarderTenantID) + `,`,
		`ForwarderClusterID:` + fmt.Sprintf("%v", this.ForwarderClusterID) + `,`,
		`HomeNetworkNetID:` + fmt.Sprintf("%v", this.HomeNetworkNetID) + `,`,
		`HomeNetworkTenantID:` + fmt.Sprintf("%v", this.HomeNetworkTenantID) + `,`,
		`Hops:` + repeatedStringForHops + `,`,
		`HomeNetworkClusterID:` + fmt.Sprintf("%v", this.HomeNetworkClusterID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *PacketBrokerRouteHop) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&PacketBrokerRouteHop{`,
		`ReceivedAt:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ReceivedAt), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`,
		`SenderName:` + fmt.Sprintf("%v", this.SenderName) + `,`,
		`SenderAddress:` + fmt.Sprintf("%v", this.SenderAddress) + `,`,
		`ReceiverName:` + fmt.Sprintf("%v", this.ReceiverName) + `,`,
		`ReceiverAgent:` + fmt.Sprintf("%v", this.ReceiverAgent) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringMetadata(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *RxMetadata) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RxMetadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RxMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GatewayIdentifiers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GatewayIdentifiers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AntennaIndex", wireType)
			}
			m.AntennaIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AntennaIndex |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Time == nil {
				m.Time = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.Time, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			m.Timestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Timestamp |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FineTimestamp", wireType)
			}
			m.FineTimestamp = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FineTimestamp |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EncryptedFineTimestamp", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EncryptedFineTimestamp = append(m.EncryptedFineTimestamp[:0], dAtA[iNdEx:postIndex]...)
			if m.EncryptedFineTimestamp == nil {
				m.EncryptedFineTimestamp = []byte{}
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EncryptedFineTimestampKeyID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EncryptedFineTimestampKeyID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field RSSI", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:])
			iNdEx += 4
			m.RSSI = float32(math.Float32frombits(v))
		case 9:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChannelRSSI", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:])
			iNdEx += 4
			m.ChannelRSSI = float32(math.Float32frombits(v))
		case 10:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field RSSIStandardDeviation", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:])
			iNdEx += 4
			m.RSSIStandardDeviation = float32(math.Float32frombits(v))
		case 11:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field SNR", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:])
			iNdEx += 4
			m.SNR = float32(math.Float32frombits(v))
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FrequencyOffset", wireType)
			}
			m.FrequencyOffset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FrequencyOffset |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Location", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Location == nil {
				m.Location = &Location{}
			}
			if err := m.Location.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DownlinkPathConstraint", wireType)
			}
			m.DownlinkPathConstraint = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DownlinkPathConstraint |= DownlinkPathConstraint(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UplinkToken", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UplinkToken = append(m.UplinkToken[:0], dAtA[iNdEx:postIndex]...)
			if m.UplinkToken == nil {
				m.UplinkToken = []byte{}
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignalRSSI", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SignalRSSI == nil {
				m.SignalRSSI = &types.FloatValue{}
			}
			if err := m.SignalRSSI.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChannelIndex", wireType)
			}
			m.ChannelIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChannelIndex |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PacketBroker", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PacketBroker == nil {
				m.PacketBroker = &PacketBrokerMetadata{}
			}
			if err := m.PacketBroker.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 99:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Advanced", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Advanced == nil {
				m.Advanced = &types.Struct{}
			}
			if err := m.Advanced.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Location) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Location: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Location: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Latitude", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])
			iNdEx += 8
			m.Latitude = float64(math.Float64frombits(v))
		case 2:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Longitude", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])
			iNdEx += 8
			m.Longitude = float64(math.Float64frombits(v))
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Altitude", wireType)
			}
			m.Altitude = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Altitude |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Accuracy", wireType)
			}
			m.Accuracy = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Accuracy |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
			}
			m.Source = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Source |= LocationSource(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PacketBrokerMetadata) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PacketBrokerMetadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PacketBrokerMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MessageID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MessageID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ForwarderNetID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ForwarderNetID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ForwarderTenantID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ForwarderTenantID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ForwarderClusterID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ForwarderClusterID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HomeNetworkNetID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.HomeNetworkNetID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HomeNetworkTenantID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HomeNetworkTenantID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hops", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hops = append(m.Hops, &PacketBrokerRouteHop{})
			if err := m.Hops[len(m.Hops)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HomeNetworkClusterID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HomeNetworkClusterID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PacketBrokerRouteHop) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PacketBrokerRouteHop: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PacketBrokerRouteHop: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReceivedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.ReceivedAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SenderName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SenderName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SenderAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SenderAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReceiverName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReceiverName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReceiverAgent", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthMetadata
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMetadata
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReceiverAgent = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMetadata(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMetadata
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipMetadata(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowMetadata
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowMetadata
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthMetadata
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupMetadata
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthMetadata
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthMetadata        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowMetadata          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupMetadata = fmt.Errorf("proto: unexpected end of group")
)