handler.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: github.com/TheThingsNetwork/api/handler/handler.proto

package handler

import (
	bytes "bytes"
	context "context"
	encoding_binary "encoding/binary"
	fmt "fmt"
	api "github.com/TheThingsNetwork/api"
	broker "github.com/TheThingsNetwork/api/broker"
	protocol "github.com/TheThingsNetwork/api/protocol"
	lorawan "github.com/TheThingsNetwork/api/protocol/lorawan"
	trace "github.com/TheThingsNetwork/api/trace"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	types "github.com/gogo/protobuf/types"
	golang_proto "github.com/golang/protobuf/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strings "strings"
)

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

// 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 DeviceActivationResponse struct {
	Payload              []byte                      `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
	Message              *protocol.Message           `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	DownlinkOption       broker.DownlinkOption       `protobuf:"bytes,11,opt,name=downlink_option,json=downlinkOption,proto3" json:"downlink_option"`
	ActivationMetadata   protocol.ActivationMetadata `protobuf:"bytes,23,opt,name=activation_metadata,json=activationMetadata,proto3" json:"activation_metadata"`
	Trace                *trace.Trace                `protobuf:"bytes,31,opt,name=trace,proto3" json:"trace,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

func (m *DeviceActivationResponse) Reset()      { *m = DeviceActivationResponse{} }
func (*DeviceActivationResponse) ProtoMessage() {}
func (*DeviceActivationResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_345fea40b9d1024c, []int{0}
}
func (m *DeviceActivationResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeviceActivationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeviceActivationResponse.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 *DeviceActivationResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeviceActivationResponse.Merge(m, src)
}
func (m *DeviceActivationResponse) XXX_Size() int {
	return m.Size()
}
func (m *DeviceActivationResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DeviceActivationResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DeviceActivationResponse proto.InternalMessageInfo

func (m *DeviceActivationResponse) GetPayload() []byte {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *DeviceActivationResponse) GetMessage() *protocol.Message {
	if m != nil {
		return m.Message
	}
	return nil
}

func (m *DeviceActivationResponse) GetDownlinkOption() broker.DownlinkOption {
	if m != nil {
		return m.DownlinkOption
	}
	return broker.DownlinkOption{}
}

func (m *DeviceActivationResponse) GetActivationMetadata() protocol.ActivationMetadata {
	if m != nil {
		return m.ActivationMetadata
	}
	return protocol.ActivationMetadata{}
}

func (m *DeviceActivationResponse) GetTrace() *trace.Trace {
	if m != nil {
		return m.Trace
	}
	return nil
}

// message StatusRequest is used to request the status of this Handler
type StatusRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StatusRequest) Reset()      { *m = StatusRequest{} }
func (*StatusRequest) ProtoMessage() {}
func (*StatusRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_345fea40b9d1024c, []int{1}
}
func (m *StatusRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StatusRequest.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 *StatusRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StatusRequest.Merge(m, src)
}
func (m *StatusRequest) XXX_Size() int {
	return m.Size()
}
func (m *StatusRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_StatusRequest.DiscardUnknown(m)
}

var xxx_messageInfo_StatusRequest proto.InternalMessageInfo

// message Status is the response to the StatusRequest
type Status struct {
	System               api.SystemStats    `protobuf:"bytes,1,opt,name=system,proto3" json:"system"`
	Component            api.ComponentStats `protobuf:"bytes,2,opt,name=component,proto3" json:"component"`
	Uplink               *api.Rates         `protobuf:"bytes,11,opt,name=uplink,proto3" json:"uplink,omitempty"`
	Downlink             *api.Rates         `protobuf:"bytes,12,opt,name=downlink,proto3" json:"downlink,omitempty"`
	Activations          *api.Rates         `protobuf:"bytes,13,opt,name=activations,proto3" json:"activations,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *Status) Reset()      { *m = Status{} }
func (*Status) ProtoMessage() {}
func (*Status) Descriptor() ([]byte, []int) {
	return fileDescriptor_345fea40b9d1024c, []int{2}
}
func (m *Status) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Status) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Status.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 *Status) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Status.Merge(m, src)
}
func (m *Status) XXX_Size() int {
	return m.Size()
}
func (m *Status) XXX_DiscardUnknown() {
	xxx_messageInfo_Status.DiscardUnknown(m)
}

var xxx_messageInfo_Status proto.InternalMessageInfo

func (m *Status) GetSystem() api.SystemStats {
	if m != nil {
		return m.System
	}
	return api.SystemStats{}
}

func (m *Status) GetComponent() api.ComponentStats {
	if m != nil {
		return m.Component
	}
	return api.ComponentStats{}
}

func (m *Status) GetUplink() *api.Rates {
	if m != nil {
		return m.Uplink
	}
	return nil
}

func (m *Status) GetDownlink() *api.Rates {
	if m != nil {
		return m.Downlink
	}
	return nil
}

func (m *Status) GetActivations() *api.Rates {
	if m != nil {
		return m.Activations
	}
	return nil
}

type ApplicationIdentifier struct {
	AppID                string   `protobuf:"bytes,1,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ApplicationIdentifier) Reset()      { *m = ApplicationIdentifier{} }
func (*ApplicationIdentifier) ProtoMessage() {}
func (*ApplicationIdentifier) Descriptor() ([]byte, []int) {
	return fileDescriptor_345fea40b9d1024c, []int{3}
}
func (m *ApplicationIdentifier) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ApplicationIdentifier) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ApplicationIdentifier.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 *ApplicationIdentifier) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ApplicationIdentifier.Merge(m, src)
}
func (m *ApplicationIdentifier) XXX_Size() int {
	return m.Size()
}
func (m *ApplicationIdentifier) XXX_DiscardUnknown() {
	xxx_messageInfo_ApplicationIdentifier.DiscardUnknown(m)
}

var xxx_messageInfo_ApplicationIdentifier proto.InternalMessageInfo

func (m *ApplicationIdentifier) GetAppID() string {
	if m != nil {
		return m.AppID
	}
	return ""
}

// The Application settings
type Application struct {
	AppID string `protobuf:"bytes,1,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty"`
	// The payload format indicates how payload is formatted.
	PayloadFormat string `protobuf:"bytes,6,opt,name=payload_format,json=payloadFormat,proto3" json:"payload_format,omitempty"`
	// The decoder is a JavaScript function that decodes a byte array to an object.
	// This function is used when the payload format is set to custom.
	Decoder string `protobuf:"bytes,2,opt,name=decoder,proto3" json:"decoder,omitempty"`
	// The converter is a JavaScript function that can be used to convert values
	// in the object returned from the decoder. This can for example be useful to
	// convert a voltage to a temperature. This function is used when the payload format is set to custom.
	Converter string `protobuf:"bytes,3,opt,name=converter,proto3" json:"converter,omitempty"`
	// The validator is a JavaScript function that checks the validity of the
	// object returned by the decoder or converter. If validation fails, the
	// message is dropped. This function is used when the payload format is set to custom.
	Validator string `protobuf:"bytes,4,opt,name=validator,proto3" json:"validator,omitempty"`
	// The encoder is a JavaScript function that encodes an object to a byte array.
	// This function is used when the payload format is set to custom.
	Encoder string `protobuf:"bytes,5,opt,name=encoder,proto3" json:"encoder,omitempty"`
	// The "register on join" access key should only be set if devices need to be registered on join
	RegisterOnJoinAccessKey string   `protobuf:"bytes,7,opt,name=register_on_join_access_key,json=registerOnJoinAccessKey,proto3" json:"register_on_join_access_key,omitempty"`
	XXX_NoUnkeyedLiteral    struct{} `json:"-"`
	XXX_sizecache           int32    `json:"-"`
}

func (m *Application) Reset()      { *m = Application{} }
func (*Application) ProtoMessage() {}
func (*Application) Descriptor() ([]byte, []int) {
	return fileDescriptor_345fea40b9d1024c, []int{4}
}
func (m *Application) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Application) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Application.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 *Application) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Application.Merge(m, src)
}
func (m *Application) XXX_Size() int {
	return m.Size()
}
func (m *Application) XXX_DiscardUnknown() {
	xxx_messageInfo_Application.DiscardUnknown(m)
}

var xxx_messageInfo_Application proto.InternalMessageInfo

func (m *Application) GetAppID() string {
	if m != nil {
		return m.AppID
	}
	return ""
}

func (m *Application) GetPayloadFormat() string {
	if m != nil {
		return m.PayloadFormat
	}
	return ""
}

func (m *Application) GetDecoder() string {
	if m != nil {
		return m.Decoder
	}
	return ""
}

func (m *Application) GetConverter() string {
	if m != nil {
		return m.Converter
	}
	return ""
}

func (m *Application) GetValidator() string {
	if m != nil {
		return m.Validator
	}
	return ""
}

func (m *Application) GetEncoder() string {
	if m != nil {
		return m.Encoder
	}
	return ""
}

func (m *Application) GetRegisterOnJoinAccessKey() string {
	if m != nil {
		return m.RegisterOnJoinAccessKey
	}
	return ""
}

type DeviceIdentifier struct {
	AppID                string   `protobuf:"bytes,1,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty"`
	DevID                string   `protobuf:"bytes,2,opt,name=dev_id,json=devId,proto3" json:"dev_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DeviceIdentifier) Reset()      { *m = DeviceIdentifier{} }
func (*DeviceIdentifier) ProtoMessage() {}
func (*DeviceIdentifier) Descriptor() ([]byte, []int) {
	return fileDescriptor_345fea40b9d1024c, []int{5}
}
func (m *DeviceIdentifier) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeviceIdentifier) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeviceIdentifier.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 *DeviceIdentifier) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeviceIdentifier.Merge(m, src)
}
func (m *DeviceIdentifier) XXX_Size() int {
	return m.Size()
}
func (m *DeviceIdentifier) XXX_DiscardUnknown() {
	xxx_messageInfo_DeviceIdentifier.DiscardUnknown(m)
}

var xxx_messageInfo_DeviceIdentifier proto.InternalMessageInfo

func (m *DeviceIdentifier) GetAppID() string {
	if m != nil {
		return m.AppID
	}
	return ""
}

func (m *DeviceIdentifier) GetDevID() string {
	if m != nil {
		return m.DevID
	}
	return ""
}

// The Device settings
type Device struct {
	AppID string `protobuf:"bytes,1,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty"`
	DevID string `protobuf:"bytes,2,opt,name=dev_id,json=devId,proto3" json:"dev_id,omitempty"`
	// The device can be of different kinds
	//
	// Types that are valid to be assigned to Device:
	//	*Device_LoRaWANDevice
	Device               isDevice_Device   `protobuf_oneof:"device"`
	Latitude             float32           `protobuf:"fixed32,10,opt,name=latitude,proto3" json:"latitude,omitempty"`
	Longitude            float32           `protobuf:"fixed32,11,opt,name=longitude,proto3" json:"longitude,omitempty"`
	Altitude             int32             `protobuf:"varint,12,opt,name=altitude,proto3" json:"altitude,omitempty"`
	Attributes           map[string]string `protobuf:"bytes,13,rep,name=attributes,proto3" json:"attributes,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Description          string            `protobuf:"bytes,20,opt,name=description,proto3" json:"description,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *Device) Reset()      { *m = Device{} }
func (*Device) ProtoMessage() {}
func (*Device) Descriptor() ([]byte, []int) {
	return fileDescriptor_345fea40b9d1024c, []int{6}
}
func (m *Device) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Device) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Device.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 *Device) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Device.Merge(m, src)
}
func (m *Device) XXX_Size() int {
	return m.Size()
}
func (m *Device) XXX_DiscardUnknown() {
	xxx_messageInfo_Device.DiscardUnknown(m)
}

var xxx_messageInfo_Device proto.InternalMessageInfo

type isDevice_Device interface {
	isDevice_Device()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type Device_LoRaWANDevice struct {
	LoRaWANDevice *lorawan.Device `protobuf:"bytes,3,opt,name=lorawan_device,json=lorawanDevice,proto3,oneof" json:"lorawan_device,omitempty"`
}

func (*Device_LoRaWANDevice) isDevice_Device() {}

func (m *Device) GetDevice() isDevice_Device {
	if m != nil {
		return m.Device
	}
	return nil
}

func (m *Device) GetAppID() string {
	if m != nil {
		return m.AppID
	}
	return ""
}

func (m *Device) GetDevID() string {
	if m != nil {
		return m.DevID
	}
	return ""
}

func (m *Device) GetLoRaWANDevice() *lorawan.Device {
	if x, ok := m.GetDevice().(*Device_LoRaWANDevice); ok {
		return x.LoRaWANDevice
	}
	return nil
}

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

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

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

func (m *Device) GetAttributes() map[string]string {
	if m != nil {
		return m.Attributes
	}
	return nil
}

func (m *Device) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Device) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Device_LoRaWANDevice)(nil),
	}
}

type DeviceList struct {
	Devices              []*Device `protobuf:"bytes,1,rep,name=devices,proto3" json:"devices,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *DeviceList) Reset()      { *m = DeviceList{} }
func (*DeviceList) ProtoMessage() {}
func (*DeviceList) Descriptor() ([]byte, []int) {
	return fileDescriptor_345fea40b9d1024c, []int{7}
}
func (m *DeviceList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeviceList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeviceList.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 *DeviceList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeviceList.Merge(m, src)
}
func (m *DeviceList) XXX_Size() int {
	return m.Size()
}
func (m *DeviceList) XXX_DiscardUnknown() {
	xxx_messageInfo_DeviceList.DiscardUnknown(m)
}

var xxx_messageInfo_DeviceList proto.InternalMessageInfo

func (m *DeviceList) GetDevices() []*Device {
	if m != nil {
		return m.Devices
	}
	return nil
}

// DryDownlinkMessage is a simulated message to test downlink processing
type DryDownlinkMessage struct {
	// The binary payload to use
	Payload []byte `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
	// JSON-encoded object with fields to encode
	Fields string `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"`
	// The Application containing the payload functions that should be executed
	App Application `protobuf:"bytes,3,opt,name=app,proto3" json:"app"`
	// The port number that should be passed to the payload function
	Port                 uint32   `protobuf:"varint,4,opt,name=port,proto3" json:"port,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DryDownlinkMessage) Reset()      { *m = DryDownlinkMessage{} }
func (*DryDownlinkMessage) ProtoMessage() {}
func (*DryDownlinkMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_345fea40b9d1024c, []int{8}
}
func (m *DryDownlinkMessage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DryDownlinkMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DryDownlinkMessage.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 *DryDownlinkMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DryDownlinkMessage.Merge(m, src)
}
func (m *DryDownlinkMessage) XXX_Size() int {
	return m.Size()
}
func (m *DryDownlinkMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_DryDownlinkMessage.DiscardUnknown(m)
}

var xxx_messageInfo_DryDownlinkMessage proto.InternalMessageInfo

func (m *DryDownlinkMessage) GetPayload() []byte {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *DryDownlinkMessage) GetFields() string {
	if m != nil {
		return m.Fields
	}
	return ""
}

func (m *DryDownlinkMessage) GetApp() Application {
	if m != nil {
		return m.App
	}
	return Application{}
}

func (m *DryDownlinkMessage) GetPort() uint32 {
	if m != nil {
		return m.Port
	}
	return 0
}

// DryUplinkMessage is a simulated message to test uplink processing
type DryUplinkMessage struct {
	// The binary payload to use
	Payload []byte `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
	// The Application containing the payload functions that should be executed
	App Application `protobuf:"bytes,2,opt,name=app,proto3" json:"app"`
	// The port number that should be passed to the payload function
	Port                 uint32   `protobuf:"varint,3,opt,name=port,proto3" json:"port,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DryUplinkMessage) Reset()      { *m = DryUplinkMessage{} }
func (*DryUplinkMessage) ProtoMessage() {}
func (*DryUplinkMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_345fea40b9d1024c, []int{9}
}
func (m *DryUplinkMessage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DryUplinkMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DryUplinkMessage.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 *DryUplinkMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DryUplinkMessage.Merge(m, src)
}
func (m *DryUplinkMessage) XXX_Size() int {
	return m.Size()
}
func (m *DryUplinkMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_DryUplinkMessage.DiscardUnknown(m)
}

var xxx_messageInfo_DryUplinkMessage proto.InternalMessageInfo

func (m *DryUplinkMessage) GetPayload() []byte {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *DryUplinkMessage) GetApp() Application {
	if m != nil {
		return m.App
	}
	return Application{}
}

func (m *DryUplinkMessage) GetPort() uint32 {
	if m != nil {
		return m.Port
	}
	return 0
}

// SimulatedUplinkMessage is a simulated uplink message
type SimulatedUplinkMessage struct {
	AppID string `protobuf:"bytes,1,opt,name=app_id,json=appId,proto3" json:"app_id,omitempty"`
	DevID string `protobuf:"bytes,2,opt,name=dev_id,json=devId,proto3" json:"dev_id,omitempty"`
	// The binary payload to use
	Payload []byte `protobuf:"bytes,3,opt,name=payload,proto3" json:"payload,omitempty"`
	// The port number
	Port                 uint32   `protobuf:"varint,4,opt,name=port,proto3" json:"port,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SimulatedUplinkMessage) Reset()      { *m = SimulatedUplinkMessage{} }
func (*SimulatedUplinkMessage) ProtoMessage() {}
func (*SimulatedUplinkMessage) Descriptor() ([]byte, []int) {
	return fileDescriptor_345fea40b9d1024c, []int{10}
}
func (m *SimulatedUplinkMessage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SimulatedUplinkMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SimulatedUplinkMessage.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 *SimulatedUplinkMessage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SimulatedUplinkMessage.Merge(m, src)
}
func (m *SimulatedUplinkMessage) XXX_Size() int {
	return m.Size()
}
func (m *SimulatedUplinkMessage) XXX_DiscardUnknown() {
	xxx_messageInfo_SimulatedUplinkMessage.DiscardUnknown(m)
}

var xxx_messageInfo_SimulatedUplinkMessage proto.InternalMessageInfo

func (m *SimulatedUplinkMessage) GetAppID() string {
	if m != nil {
		return m.AppID
	}
	return ""
}

func (m *SimulatedUplinkMessage) GetDevID() string {
	if m != nil {
		return m.DevID
	}
	return ""
}

func (m *SimulatedUplinkMessage) GetPayload() []byte {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *SimulatedUplinkMessage) GetPort() uint32 {
	if m != nil {
		return m.Port
	}
	return 0
}

type LogEntry struct {
	// The location where the log was created (what payload function)
	Function string `protobuf:"bytes,1,opt,name=function,proto3" json:"function,omitempty"`
	// A list of JSON-encoded fields that were logged
	Fields               []string `protobuf:"bytes,2,rep,name=fields,proto3" json:"fields,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LogEntry) Reset()      { *m = LogEntry{} }
func (*LogEntry) ProtoMessage() {}
func (*LogEntry) Descriptor() ([]byte, []int) {
	return fileDescriptor_345fea40b9d1024c, []int{11}
}
func (m *LogEntry) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LogEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LogEntry.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 *LogEntry) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LogEntry.Merge(m, src)
}
func (m *LogEntry) XXX_Size() int {
	return m.Size()
}
func (m *LogEntry) XXX_DiscardUnknown() {
	xxx_messageInfo_LogEntry.DiscardUnknown(m)
}

var xxx_messageInfo_LogEntry proto.InternalMessageInfo

func (m *LogEntry) GetFunction() string {
	if m != nil {
		return m.Function
	}
	return ""
}

func (m *LogEntry) GetFields() []string {
	if m != nil {
		return m.Fields
	}
	return nil
}

// DryUplinkResult is the result from an uplink simulation
type DryUplinkResult struct {
	// The binary payload
	Payload []byte `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
	// The decoded fields
	Fields string `protobuf:"bytes,2,opt,name=fields,proto3" json:"fields,omitempty"`
	// Was validation of the message successful
	Valid bool `protobuf:"varint,3,opt,name=valid,proto3" json:"valid,omitempty"`
	// Logs that have been generated while processing
	Logs                 []*LogEntry `protobuf:"bytes,4,rep,name=logs,proto3" json:"logs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *DryUplinkResult) Reset()      { *m = DryUplinkResult{} }
func (*DryUplinkResult) ProtoMessage() {}
func (*DryUplinkResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_345fea40b9d1024c, []int{12}
}
func (m *DryUplinkResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DryUplinkResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DryUplinkResult.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 *DryUplinkResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DryUplinkResult.Merge(m, src)
}
func (m *DryUplinkResult) XXX_Size() int {
	return m.Size()
}
func (m *DryUplinkResult) XXX_DiscardUnknown() {
	xxx_messageInfo_DryUplinkResult.DiscardUnknown(m)
}

var xxx_messageInfo_DryUplinkResult proto.InternalMessageInfo

func (m *DryUplinkResult) GetPayload() []byte {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *DryUplinkResult) GetFields() string {
	if m != nil {
		return m.Fields
	}
	return ""
}

func (m *DryUplinkResult) GetValid() bool {
	if m != nil {
		return m.Valid
	}
	return false
}

func (m *DryUplinkResult) GetLogs() []*LogEntry {
	if m != nil {
		return m.Logs
	}
	return nil
}

// DryDownlinkResult is the result from a downlink simulation
type DryDownlinkResult struct {
	// The payload that was encoded
	Payload []byte `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
	// Logs that have been generated while processing
	Logs                 []*LogEntry `protobuf:"bytes,2,rep,name=logs,proto3" json:"logs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *DryDownlinkResult) Reset()      { *m = DryDownlinkResult{} }
func (*DryDownlinkResult) ProtoMessage() {}
func (*DryDownlinkResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_345fea40b9d1024c, []int{13}
}
func (m *DryDownlinkResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DryDownlinkResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DryDownlinkResult.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 *DryDownlinkResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DryDownlinkResult.Merge(m, src)
}
func (m *DryDownlinkResult) XXX_Size() int {
	return m.Size()
}
func (m *DryDownlinkResult) XXX_DiscardUnknown() {
	xxx_messageInfo_DryDownlinkResult.DiscardUnknown(m)
}

var xxx_messageInfo_DryDownlinkResult proto.InternalMessageInfo

func (m *DryDownlinkResult) GetPayload() []byte {
	if m != nil {
		return m.Payload
	}
	return nil
}

func (m *DryDownlinkResult) GetLogs() []*LogEntry {
	if m != nil {
		return m.Logs
	}
	return nil
}

func init() {
	proto.RegisterType((*DeviceActivationResponse)(nil), "handler.DeviceActivationResponse")
	golang_proto.RegisterType((*DeviceActivationResponse)(nil), "handler.DeviceActivationResponse")
	proto.RegisterType((*StatusRequest)(nil), "handler.StatusRequest")
	golang_proto.RegisterType((*StatusRequest)(nil), "handler.StatusRequest")
	proto.RegisterType((*Status)(nil), "handler.Status")
	golang_proto.RegisterType((*Status)(nil), "handler.Status")
	proto.RegisterType((*ApplicationIdentifier)(nil), "handler.ApplicationIdentifier")
	golang_proto.RegisterType((*ApplicationIdentifier)(nil), "handler.ApplicationIdentifier")
	proto.RegisterType((*Application)(nil), "handler.Application")
	golang_proto.RegisterType((*Application)(nil), "handler.Application")
	proto.RegisterType((*DeviceIdentifier)(nil), "handler.DeviceIdentifier")
	golang_proto.RegisterType((*DeviceIdentifier)(nil), "handler.DeviceIdentifier")
	proto.RegisterType((*Device)(nil), "handler.Device")
	golang_proto.RegisterType((*Device)(nil), "handler.Device")
	proto.RegisterMapType((map[string]string)(nil), "handler.Device.AttributesEntry")
	golang_proto.RegisterMapType((map[string]string)(nil), "handler.Device.AttributesEntry")
	proto.RegisterType((*DeviceList)(nil), "handler.DeviceList")
	golang_proto.RegisterType((*DeviceList)(nil), "handler.DeviceList")
	proto.RegisterType((*DryDownlinkMessage)(nil), "handler.DryDownlinkMessage")
	golang_proto.RegisterType((*DryDownlinkMessage)(nil), "handler.DryDownlinkMessage")
	proto.RegisterType((*DryUplinkMessage)(nil), "handler.DryUplinkMessage")
	golang_proto.RegisterType((*DryUplinkMessage)(nil), "handler.DryUplinkMessage")
	proto.RegisterType((*SimulatedUplinkMessage)(nil), "handler.SimulatedUplinkMessage")
	golang_proto.RegisterType((*SimulatedUplinkMessage)(nil), "handler.SimulatedUplinkMessage")
	proto.RegisterType((*LogEntry)(nil), "handler.LogEntry")
	golang_proto.RegisterType((*LogEntry)(nil), "handler.LogEntry")
	proto.RegisterType((*DryUplinkResult)(nil), "handler.DryUplinkResult")
	golang_proto.RegisterType((*DryUplinkResult)(nil), "handler.DryUplinkResult")
	proto.RegisterType((*DryDownlinkResult)(nil), "handler.DryDownlinkResult")
	golang_proto.RegisterType((*DryDownlinkResult)(nil), "handler.DryDownlinkResult")
}

func init() {
	proto.RegisterFile("github.com/TheThingsNetwork/api/handler/handler.proto", fileDescriptor_345fea40b9d1024c)
}
func init() {
	golang_proto.RegisterFile("github.com/TheThingsNetwork/api/handler/handler.proto", fileDescriptor_345fea40b9d1024c)
}

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

func (this *DeviceActivationResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeviceActivationResponse)
	if !ok {
		that2, ok := that.(DeviceActivationResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.Payload, that1.Payload) {
		return false
	}
	if !this.Message.Equal(that1.Message) {
		return false
	}
	if !this.DownlinkOption.Equal(&that1.DownlinkOption) {
		return false
	}
	if !this.ActivationMetadata.Equal(&that1.ActivationMetadata) {
		return false
	}
	if !this.Trace.Equal(that1.Trace) {
		return false
	}
	return true
}
func (this *StatusRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*StatusRequest)
	if !ok {
		that2, ok := that.(StatusRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	return true
}
func (this *Status) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Status)
	if !ok {
		that2, ok := that.(Status)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.System.Equal(&that1.System) {
		return false
	}
	if !this.Component.Equal(&that1.Component) {
		return false
	}
	if !this.Uplink.Equal(that1.Uplink) {
		return false
	}
	if !this.Downlink.Equal(that1.Downlink) {
		return false
	}
	if !this.Activations.Equal(that1.Activations) {
		return false
	}
	return true
}
func (this *ApplicationIdentifier) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ApplicationIdentifier)
	if !ok {
		that2, ok := that.(ApplicationIdentifier)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.AppID != that1.AppID {
		return false
	}
	return true
}
func (this *Application) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Application)
	if !ok {
		that2, ok := that.(Application)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.AppID != that1.AppID {
		return false
	}
	if this.PayloadFormat != that1.PayloadFormat {
		return false
	}
	if this.Decoder != that1.Decoder {
		return false
	}
	if this.Converter != that1.Converter {
		return false
	}
	if this.Validator != that1.Validator {
		return false
	}
	if this.Encoder != that1.Encoder {
		return false
	}
	if this.RegisterOnJoinAccessKey != that1.RegisterOnJoinAccessKey {
		return false
	}
	return true
}
func (this *DeviceIdentifier) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeviceIdentifier)
	if !ok {
		that2, ok := that.(DeviceIdentifier)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.AppID != that1.AppID {
		return false
	}
	if this.DevID != that1.DevID {
		return false
	}
	return true
}
func (this *Device) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Device)
	if !ok {
		that2, ok := that.(Device)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.AppID != that1.AppID {
		return false
	}
	if this.DevID != that1.DevID {
		return false
	}
	if that1.Device == nil {
		if this.Device != nil {
			return false
		}
	} else if this.Device == nil {
		return false
	} else if !this.Device.Equal(that1.Device) {
		return false
	}
	if this.Latitude != that1.Latitude {
		return false
	}
	if this.Longitude != that1.Longitude {
		return false
	}
	if this.Altitude != that1.Altitude {
		return false
	}
	if len(this.Attributes) != len(that1.Attributes) {
		return false
	}
	for i := range this.Attributes {
		if this.Attributes[i] != that1.Attributes[i] {
			return false
		}
	}
	if this.Description != that1.Description {
		return false
	}
	return true
}
func (this *Device_LoRaWANDevice) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Device_LoRaWANDevice)
	if !ok {
		that2, ok := that.(Device_LoRaWANDevice)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.LoRaWANDevice.Equal(that1.LoRaWANDevice) {
		return false
	}
	return true
}
func (this *DeviceList) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeviceList)
	if !ok {
		that2, ok := that.(DeviceList)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Devices) != len(that1.Devices) {
		return false
	}
	for i := range this.Devices {
		if !this.Devices[i].Equal(that1.Devices[i]) {
			return false
		}
	}
	return true
}
func (this *DryDownlinkMessage) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DryDownlinkMessage)
	if !ok {
		that2, ok := that.(DryDownlinkMessage)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.Payload, that1.Payload) {
		return false
	}
	if this.Fields != that1.Fields {
		return false
	}
	if !this.App.Equal(&that1.App) {
		return false
	}
	if this.Port != that1.Port {
		return false
	}
	return true
}
func (this *DryUplinkMessage) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DryUplinkMessage)
	if !ok {
		that2, ok := that.(DryUplinkMessage)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.Payload, that1.Payload) {
		return false
	}
	if !this.App.Equal(&that1.App) {
		return false
	}
	if this.Port != that1.Port {
		return false
	}
	return true
}
func (this *SimulatedUplinkMessage) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*SimulatedUplinkMessage)
	if !ok {
		that2, ok := that.(SimulatedUplinkMessage)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.AppID != that1.AppID {
		return false
	}
	if this.DevID != that1.DevID {
		return false
	}
	if !bytes.Equal(this.Payload, that1.Payload) {
		return false
	}
	if this.Port != that1.Port {
		return false
	}
	return true
}
func (this *LogEntry) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*LogEntry)
	if !ok {
		that2, ok := that.(LogEntry)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Function != that1.Function {
		return false
	}
	if len(this.Fields) != len(that1.Fields) {
		return false
	}
	for i := range this.Fields {
		if this.Fields[i] != that1.Fields[i] {
			return false
		}
	}
	return true
}
func (this *DryUplinkResult) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DryUplinkResult)
	if !ok {
		that2, ok := that.(DryUplinkResult)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.Payload, that1.Payload) {
		return false
	}
	if this.Fields != that1.Fields {
		return false
	}
	if this.Valid != that1.Valid {
		return false
	}
	if len(this.Logs) != len(that1.Logs) {
		return false
	}
	for i := range this.Logs {
		if !this.Logs[i].Equal(that1.Logs[i]) {
			return false
		}
	}
	return true
}
func (this *DryDownlinkResult) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DryDownlinkResult)
	if !ok {
		that2, ok := that.(DryDownlinkResult)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.Payload, that1.Payload) {
		return false
	}
	if len(this.Logs) != len(that1.Logs) {
		return false
	}
	for i := range this.Logs {
		if !this.Logs[i].Equal(that1.Logs[i]) {
			return false
		}
	}
	return true
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// HandlerClient is the client API for Handler service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type HandlerClient interface {
	ActivationChallenge(ctx context.Context, in *broker.ActivationChallengeRequest, opts ...grpc.CallOption) (*broker.ActivationChallengeResponse, error)
	Activate(ctx context.Context, in *broker.DeduplicatedDeviceActivationRequest, opts ...grpc.CallOption) (*DeviceActivationResponse, error)
}

type handlerClient struct {
	cc *grpc.ClientConn
}

func NewHandlerClient(cc *grpc.ClientConn) HandlerClient {
	return &handlerClient{cc}
}

func (c *handlerClient) ActivationChallenge(ctx context.Context, in *broker.ActivationChallengeRequest, opts ...grpc.CallOption) (*broker.ActivationChallengeResponse, error) {
	out := new(broker.ActivationChallengeResponse)
	err := c.cc.Invoke(ctx, "/handler.Handler/ActivationChallenge", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *handlerClient) Activate(ctx context.Context, in *broker.DeduplicatedDeviceActivationRequest, opts ...grpc.CallOption) (*DeviceActivationResponse, error) {
	out := new(DeviceActivationResponse)
	err := c.cc.Invoke(ctx, "/handler.Handler/Activate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// HandlerServer is the server API for Handler service.
type HandlerServer interface {
	ActivationChallenge(context.Context, *broker.ActivationChallengeRequest) (*broker.ActivationChallengeResponse, error)
	Activate(context.Context, *broker.DeduplicatedDeviceActivationRequest) (*DeviceActivationResponse, error)
}

// UnimplementedHandlerServer can be embedded to have forward compatible implementations.
type UnimplementedHandlerServer struct {
}

func (*UnimplementedHandlerServer) ActivationChallenge(ctx context.Context, req *broker.ActivationChallengeRequest) (*broker.ActivationChallengeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ActivationChallenge not implemented")
}
func (*UnimplementedHandlerServer) Activate(ctx context.Context, req *broker.DeduplicatedDeviceActivationRequest) (*DeviceActivationResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Activate not implemented")
}

func RegisterHandlerServer(s *grpc.Server, srv HandlerServer) {
	s.RegisterService(&_Handler_serviceDesc, srv)
}

func _Handler_ActivationChallenge_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(broker.ActivationChallengeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HandlerServer).ActivationChallenge(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/handler.Handler/ActivationChallenge",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HandlerServer).ActivationChallenge(ctx, req.(*broker.ActivationChallengeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Handler_Activate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(broker.DeduplicatedDeviceActivationRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HandlerServer).Activate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/handler.Handler/Activate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HandlerServer).Activate(ctx, req.(*broker.DeduplicatedDeviceActivationRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Handler_serviceDesc = grpc.ServiceDesc{
	ServiceName: "handler.Handler",
	HandlerType: (*HandlerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ActivationChallenge",
			Handler:    _Handler_ActivationChallenge_Handler,
		},
		{
			MethodName: "Activate",
			Handler:    _Handler_Activate_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "github.com/TheThingsNetwork/api/handler/handler.proto",
}

// ApplicationManagerClient is the client API for ApplicationManager service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ApplicationManagerClient interface {
	// Applications should first be registered to the Handler with the `RegisterApplication` method
	RegisterApplication(ctx context.Context, in *ApplicationIdentifier, opts ...grpc.CallOption) (*types.Empty, error)
	// GetApplication returns the application with the given identifier (app_id)
	GetApplication(ctx context.Context, in *ApplicationIdentifier, opts ...grpc.CallOption) (*Application, error)
	// SetApplication updates the settings for the application. All fields must be supplied.
	SetApplication(ctx context.Context, in *Application, opts ...grpc.CallOption) (*types.Empty, error)
	// DeleteApplication deletes the application with the given identifier (app_id)
	DeleteApplication(ctx context.Context, in *ApplicationIdentifier, opts ...grpc.CallOption) (*types.Empty, error)
	// GetDevice returns the device with the given identifier (app_id and dev_id)
	GetDevice(ctx context.Context, in *DeviceIdentifier, opts ...grpc.CallOption) (*Device, error)
	// SetDevice creates or updates a device. All fields must be supplied.
	SetDevice(ctx context.Context, in *Device, opts ...grpc.CallOption) (*types.Empty, error)
	// DeleteDevice deletes the device with the given identifier (app_id and dev_id)
	DeleteDevice(ctx context.Context, in *DeviceIdentifier, opts ...grpc.CallOption) (*types.Empty, error)
	// GetDevicesForApplication returns all devices that belong to the application with the given identifier (app_id)
	GetDevicesForApplication(ctx context.Context, in *ApplicationIdentifier, opts ...grpc.CallOption) (*DeviceList, error)
	// DryUplink simulates processing a downlink message and returns the result
	DryDownlink(ctx context.Context, in *DryDownlinkMessage, opts ...grpc.CallOption) (*DryDownlinkResult, error)
	// DryUplink simulates processing an uplink message and returns the result
	DryUplink(ctx context.Context, in *DryUplinkMessage, opts ...grpc.CallOption) (*DryUplinkResult, error)
	// SimulateUplink simulates an uplink message
	SimulateUplink(ctx context.Context, in *SimulatedUplinkMessage, opts ...grpc.CallOption) (*types.Empty, error)
}

type applicationManagerClient struct {
	cc *grpc.ClientConn
}

func NewApplicationManagerClient(cc *grpc.ClientConn) ApplicationManagerClient {
	return &applicationManagerClient{cc}
}

func (c *applicationManagerClient) RegisterApplication(ctx context.Context, in *ApplicationIdentifier, opts ...grpc.CallOption) (*types.Empty, error) {
	out := new(types.Empty)
	err := c.cc.Invoke(ctx, "/handler.ApplicationManager/RegisterApplication", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *applicationManagerClient) GetApplication(ctx context.Context, in *ApplicationIdentifier, opts ...grpc.CallOption) (*Application, error) {
	out := new(Application)
	err := c.cc.Invoke(ctx, "/handler.ApplicationManager/GetApplication", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *applicationManagerClient) SetApplication(ctx context.Context, in *Application, opts ...grpc.CallOption) (*types.Empty, error) {
	out := new(types.Empty)
	err := c.cc.Invoke(ctx, "/handler.ApplicationManager/SetApplication", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *applicationManagerClient) DeleteApplication(ctx context.Context, in *ApplicationIdentifier, opts ...grpc.CallOption) (*types.Empty, error) {
	out := new(types.Empty)
	err := c.cc.Invoke(ctx, "/handler.ApplicationManager/DeleteApplication", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *applicationManagerClient) GetDevice(ctx context.Context, in *DeviceIdentifier, opts ...grpc.CallOption) (*Device, error) {
	out := new(Device)
	err := c.cc.Invoke(ctx, "/handler.ApplicationManager/GetDevice", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *applicationManagerClient) SetDevice(ctx context.Context, in *Device, opts ...grpc.CallOption) (*types.Empty, error) {
	out := new(types.Empty)
	err := c.cc.Invoke(ctx, "/handler.ApplicationManager/SetDevice", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *applicationManagerClient) DeleteDevice(ctx context.Context, in *DeviceIdentifier, opts ...grpc.CallOption) (*types.Empty, error) {
	out := new(types.Empty)
	err := c.cc.Invoke(ctx, "/handler.ApplicationManager/DeleteDevice", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *applicationManagerClient) GetDevicesForApplication(ctx context.Context, in *ApplicationIdentifier, opts ...grpc.CallOption) (*DeviceList, error) {
	out := new(DeviceList)
	err := c.cc.Invoke(ctx, "/handler.ApplicationManager/GetDevicesForApplication", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *applicationManagerClient) DryDownlink(ctx context.Context, in *DryDownlinkMessage, opts ...grpc.CallOption) (*DryDownlinkResult, error) {
	out := new(DryDownlinkResult)
	err := c.cc.Invoke(ctx, "/handler.ApplicationManager/DryDownlink", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *applicationManagerClient) DryUplink(ctx context.Context, in *DryUplinkMessage, opts ...grpc.CallOption) (*DryUplinkResult, error) {
	out := new(DryUplinkResult)
	err := c.cc.Invoke(ctx, "/handler.ApplicationManager/DryUplink", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *applicationManagerClient) SimulateUplink(ctx context.Context, in *SimulatedUplinkMessage, opts ...grpc.CallOption) (*types.Empty, error) {
	out := new(types.Empty)
	err := c.cc.Invoke(ctx, "/handler.ApplicationManager/SimulateUplink", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ApplicationManagerServer is the server API for ApplicationManager service.
type ApplicationManagerServer interface {
	// Applications should first be registered to the Handler with the `RegisterApplication` method
	RegisterApplication(context.Context, *ApplicationIdentifier) (*types.Empty, error)
	// GetApplication returns the application with the given identifier (app_id)
	GetApplication(context.Context, *ApplicationIdentifier) (*Application, error)
	// SetApplication updates the settings for the application. All fields must be supplied.
	SetApplication(context.Context, *Application) (*types.Empty, error)
	// DeleteApplication deletes the application with the given identifier (app_id)
	DeleteApplication(context.Context, *ApplicationIdentifier) (*types.Empty, error)
	// GetDevice returns the device with the given identifier (app_id and dev_id)
	GetDevice(context.Context, *DeviceIdentifier) (*Device, error)
	// SetDevice creates or updates a device. All fields must be supplied.
	SetDevice(context.Context, *Device) (*types.Empty, error)
	// DeleteDevice deletes the device with the given identifier (app_id and dev_id)
	DeleteDevice(context.Context, *DeviceIdentifier) (*types.Empty, error)
	// GetDevicesForApplication returns all devices that belong to the application with the given identifier (app_id)
	GetDevicesForApplication(context.Context, *ApplicationIdentifier) (*DeviceList, error)
	// DryUplink simulates processing a downlink message and returns the result
	DryDownlink(context.Context, *DryDownlinkMessage) (*DryDownlinkResult, error)
	// DryUplink simulates processing an uplink message and returns the result
	DryUplink(context.Context, *DryUplinkMessage) (*DryUplinkResult, error)
	// SimulateUplink simulates an uplink message
	SimulateUplink(context.Context, *SimulatedUplinkMessage) (*types.Empty, error)
}

// UnimplementedApplicationManagerServer can be embedded to have forward compatible implementations.
type UnimplementedApplicationManagerServer struct {
}

func (*UnimplementedApplicationManagerServer) RegisterApplication(ctx context.Context, req *ApplicationIdentifier) (*types.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegisterApplication not implemented")
}
func (*UnimplementedApplicationManagerServer) GetApplication(ctx context.Context, req *ApplicationIdentifier) (*Application, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetApplication not implemented")
}
func (*UnimplementedApplicationManagerServer) SetApplication(ctx context.Context, req *Application) (*types.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetApplication not implemented")
}
func (*UnimplementedApplicationManagerServer) DeleteApplication(ctx context.Context, req *ApplicationIdentifier) (*types.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteApplication not implemented")
}
func (*UnimplementedApplicationManagerServer) GetDevice(ctx context.Context, req *DeviceIdentifier) (*Device, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetDevice not implemented")
}
func (*UnimplementedApplicationManagerServer) SetDevice(ctx context.Context, req *Device) (*types.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetDevice not implemented")
}
func (*UnimplementedApplicationManagerServer) DeleteDevice(ctx context.Context, req *DeviceIdentifier) (*types.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteDevice not implemented")
}
func (*UnimplementedApplicationManagerServer) GetDevicesForApplication(ctx context.Context, req *ApplicationIdentifier) (*DeviceList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetDevicesForApplication not implemented")
}
func (*UnimplementedApplicationManagerServer) DryDownlink(ctx context.Context, req *DryDownlinkMessage) (*DryDownlinkResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DryDownlink not implemented")
}
func (*UnimplementedApplicationManagerServer) DryUplink(ctx context.Context, req *DryUplinkMessage) (*DryUplinkResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DryUplink not implemented")
}
func (*UnimplementedApplicationManagerServer) SimulateUplink(ctx context.Context, req *SimulatedUplinkMessage) (*types.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SimulateUplink not implemented")
}

func RegisterApplicationManagerServer(s *grpc.Server, srv ApplicationManagerServer) {
	s.RegisterService(&_ApplicationManager_serviceDesc, srv)
}

func _ApplicationManager_RegisterApplication_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ApplicationIdentifier)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApplicationManagerServer).RegisterApplication(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/handler.ApplicationManager/RegisterApplication",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApplicationManagerServer).RegisterApplication(ctx, req.(*ApplicationIdentifier))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApplicationManager_GetApplication_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ApplicationIdentifier)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApplicationManagerServer).GetApplication(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/handler.ApplicationManager/GetApplication",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApplicationManagerServer).GetApplication(ctx, req.(*ApplicationIdentifier))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApplicationManager_SetApplication_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Application)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApplicationManagerServer).SetApplication(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/handler.ApplicationManager/SetApplication",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApplicationManagerServer).SetApplication(ctx, req.(*Application))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApplicationManager_DeleteApplication_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ApplicationIdentifier)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApplicationManagerServer).DeleteApplication(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/handler.ApplicationManager/DeleteApplication",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApplicationManagerServer).DeleteApplication(ctx, req.(*ApplicationIdentifier))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApplicationManager_GetDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeviceIdentifier)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApplicationManagerServer).GetDevice(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/handler.ApplicationManager/GetDevice",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApplicationManagerServer).GetDevice(ctx, req.(*DeviceIdentifier))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApplicationManager_SetDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Device)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApplicationManagerServer).SetDevice(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/handler.ApplicationManager/SetDevice",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApplicationManagerServer).SetDevice(ctx, req.(*Device))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApplicationManager_DeleteDevice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeviceIdentifier)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApplicationManagerServer).DeleteDevice(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/handler.ApplicationManager/DeleteDevice",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApplicationManagerServer).DeleteDevice(ctx, req.(*DeviceIdentifier))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApplicationManager_GetDevicesForApplication_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ApplicationIdentifier)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApplicationManagerServer).GetDevicesForApplication(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/handler.ApplicationManager/GetDevicesForApplication",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApplicationManagerServer).GetDevicesForApplication(ctx, req.(*ApplicationIdentifier))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApplicationManager_DryDownlink_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DryDownlinkMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApplicationManagerServer).DryDownlink(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/handler.ApplicationManager/DryDownlink",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApplicationManagerServer).DryDownlink(ctx, req.(*DryDownlinkMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApplicationManager_DryUplink_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DryUplinkMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApplicationManagerServer).DryUplink(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/handler.ApplicationManager/DryUplink",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApplicationManagerServer).DryUplink(ctx, req.(*DryUplinkMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApplicationManager_SimulateUplink_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SimulatedUplinkMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApplicationManagerServer).SimulateUplink(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/handler.ApplicationManager/SimulateUplink",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApplicationManagerServer).SimulateUplink(ctx, req.(*SimulatedUplinkMessage))
	}
	return interceptor(ctx, in, info, handler)
}

var _ApplicationManager_serviceDesc = grpc.ServiceDesc{
	ServiceName: "handler.ApplicationManager",
	HandlerType: (*ApplicationManagerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "RegisterApplication",
			Handler:    _ApplicationManager_RegisterApplication_Handler,
		},
		{
			MethodName: "GetApplication",
			Handler:    _ApplicationManager_GetApplication_Handler,
		},
		{
			MethodName: "SetApplication",
			Handler:    _ApplicationManager_SetApplication_Handler,
		},
		{
			MethodName: "DeleteApplication",
			Handler:    _ApplicationManager_DeleteApplication_Handler,
		},
		{
			MethodName: "GetDevice",
			Handler:    _ApplicationManager_GetDevice_Handler,
		},
		{
			MethodName: "SetDevice",
			Handler:    _ApplicationManager_SetDevice_Handler,
		},
		{
			MethodName: "DeleteDevice",
			Handler:    _ApplicationManager_DeleteDevice_Handler,
		},
		{
			MethodName: "GetDevicesForApplication",
			Handler:    _ApplicationManager_GetDevicesForApplication_Handler,
		},
		{
			MethodName: "DryDownlink",
			Handler:    _ApplicationManager_DryDownlink_Handler,
		},
		{
			MethodName: "DryUplink",
			Handler:    _ApplicationManager_DryUplink_Handler,
		},
		{
			MethodName: "SimulateUplink",
			Handler:    _ApplicationManager_SimulateUplink_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "github.com/TheThingsNetwork/api/handler/handler.proto",
}

// HandlerManagerClient is the client API for HandlerManager service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type HandlerManagerClient interface {
	GetStatus(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*Status, error)
}

type handlerManagerClient struct {
	cc *grpc.ClientConn
}

func NewHandlerManagerClient(cc *grpc.ClientConn) HandlerManagerClient {
	return &handlerManagerClient{cc}
}

func (c *handlerManagerClient) GetStatus(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*Status, error) {
	out := new(Status)
	err := c.cc.Invoke(ctx, "/handler.HandlerManager/GetStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// HandlerManagerServer is the server API for HandlerManager service.
type HandlerManagerServer interface {
	GetStatus(context.Context, *StatusRequest) (*Status, error)
}

// UnimplementedHandlerManagerServer can be embedded to have forward compatible implementations.
type UnimplementedHandlerManagerServer struct {
}

func (*UnimplementedHandlerManagerServer) GetStatus(ctx context.Context, req *StatusRequest) (*Status, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetStatus not implemented")
}

func RegisterHandlerManagerServer(s *grpc.Server, srv HandlerManagerServer) {
	s.RegisterService(&_HandlerManager_serviceDesc, srv)
}

func _HandlerManager_GetStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HandlerManagerServer).GetStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/handler.HandlerManager/GetStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HandlerManagerServer).GetStatus(ctx, req.(*StatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _HandlerManager_serviceDesc = grpc.ServiceDesc{
	ServiceName: "handler.HandlerManager",
	HandlerType: (*HandlerManagerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetStatus",
			Handler:    _HandlerManager_GetStatus_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "github.com/TheThingsNetwork/api/handler/handler.proto",
}

func (m *DeviceActivationResponse) 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 *DeviceActivationResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeviceActivationResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Trace != nil {
		{
			size, err := m.Trace.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHandler(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xfa
	}
	{
		size, err := m.ActivationMetadata.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintHandler(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xba
	{
		size, err := m.DownlinkOption.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintHandler(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x5a
	if m.Message != nil {
		{
			size, err := m.Message.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHandler(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Payload) > 0 {
		i -= len(m.Payload)
		copy(dAtA[i:], m.Payload)
		i = encodeVarintHandler(dAtA, i, uint64(len(m.Payload)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *StatusRequest) 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 *StatusRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *Status) 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 *Status) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Status) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Activations != nil {
		{
			size, err := m.Activations.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHandler(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x6a
	}
	if m.Downlink != nil {
		{
			size, err := m.Downlink.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHandler(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x62
	}
	if m.Uplink != nil {
		{
			size, err := m.Uplink.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHandler(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	{
		size, err := m.Component.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintHandler(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.System.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintHandler(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *ApplicationIdentifier) 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 *ApplicationIdentifier) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ApplicationIdentifier) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AppID) > 0 {
		i -= len(m.AppID)
		copy(dAtA[i:], m.AppID)
		i = encodeVarintHandler(dAtA, i, uint64(len(m.AppID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Application) 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 *Application) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Application) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RegisterOnJoinAccessKey) > 0 {
		i -= len(m.RegisterOnJoinAccessKey)
		copy(dAtA[i:], m.RegisterOnJoinAccessKey)
		i = encodeVarintHandler(dAtA, i, uint64(len(m.RegisterOnJoinAccessKey)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.PayloadFormat) > 0 {
		i -= len(m.PayloadFormat)
		copy(dAtA[i:], m.PayloadFormat)
		i = encodeVarintHandler(dAtA, i, uint64(len(m.PayloadFormat)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Encoder) > 0 {
		i -= len(m.Encoder)
		copy(dAtA[i:], m.Encoder)
		i = encodeVarintHandler(dAtA, i, uint64(len(m.Encoder)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Validator) > 0 {
		i -= len(m.Validator)
		copy(dAtA[i:], m.Validator)
		i = encodeVarintHandler(dAtA, i, uint64(len(m.Validator)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Converter) > 0 {
		i -= len(m.Converter)
		copy(dAtA[i:], m.Converter)
		i = encodeVarintHandler(dAtA, i, uint64(len(m.Converter)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Decoder) > 0 {
		i -= len(m.Decoder)
		copy(dAtA[i:], m.Decoder)
		i = encodeVarintHandler(dAtA, i, uint64(len(m.Decoder)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.AppID) > 0 {
		i -= len(m.AppID)
		copy(dAtA[i:], m.AppID)
		i = encodeVarintHandler(dAtA, i, uint64(len(m.AppID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DeviceIdentifier) 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 *DeviceIdentifier) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeviceIdentifier) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.DevID) > 0 {
		i -= len(m.DevID)
		copy(dAtA[i:], m.DevID)
		i = encodeVarintHandler(dAtA, i, uint64(len(m.DevID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.AppID) > 0 {
		i -= len(m.AppID)
		copy(dAtA[i:], m.AppID)
		i = encodeVarintHandler(dAtA, i, uint64(len(m.AppID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Device) 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 *Device) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Device) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintHandler(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa2
	}
	if len(m.Attributes) > 0 {
		for k := range m.Attributes {
			v := m.Attributes[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintHandler(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintHandler(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintHandler(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x6a
		}
	}
	if m.Altitude != 0 {
		i = encodeVarintHandler(dAtA, i, uint64(m.Altitude))
		i--
		dAtA[i] = 0x60
	}
	if m.Longitude != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Longitude))))
		i--
		dAtA[i] = 0x5d
	}
	if m.Latitude != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.Latitude))))
		i--
		dAtA[i] = 0x55
	}
	if m.Device != nil {
		{
			size := m.Device.Size()
			i -= size
			if _, err := m.Device.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if len(m.DevID) > 0 {
		i -= len(m.DevID)
		copy(dAtA[i:], m.DevID)
		i = encodeVarintHandler(dAtA, i, uint64(len(m.DevID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.AppID) > 0 {
		i -= len(m.AppID)
		copy(dAtA[i:], m.AppID)
		i = encodeVarintHandler(dAtA, i, uint64(len(m.AppID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Device_LoRaWANDevice) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.LoRaWANDevice != nil {
		{
			size, err := m.LoRaWANDevice.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintHandler(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *DeviceList) 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 *DeviceList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeviceList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Devices) > 0 {
		for iNdEx := len(m.Devices) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Devices[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintHandler(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *DryDownlinkMessage) 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 *DryDownlinkMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DryDownlinkMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Port != 0 {
		i = encodeVarintHandler(dAtA, i, uint64(m.Port))
		i--
		dAtA[i] = 0x20
	}
	{
		size, err := m.App.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintHandler(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.Fields) > 0 {
		i -= len(m.Fields)
		copy(dAtA[i:], m.Fields)
		i = encodeVarintHandler(dAtA, i, uint64(len(m.Fields)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Payload) > 0 {
		i -= len(m.Payload)
		copy(dAtA[i:], m.Payload)
		i = encodeVarintHandler(dAtA, i, uint64(len(m.Payload)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DryUplinkMessage) 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 *DryUplinkMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DryUplinkMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Port != 0 {
		i = encodeVarintHandler(dAtA, i, uint64(m.Port))
		i--
		dAtA[i] = 0x18
	}
	{
		size, err := m.App.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintHandler(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Payload) > 0 {
		i -= len(m.Payload)
		copy(dAtA[i:], m.Payload)
		i = encodeVarintHandler(dAtA, i, uint64(len(m.Payload)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *SimulatedUplinkMessage) 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 *SimulatedUplinkMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SimulatedUplinkMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Port != 0 {
		i = encodeVarintHandler(dAtA, i, uint64(m.Port))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Payload) > 0 {
		i -= len(m.Payload)
		copy(dAtA[i:], m.Payload)
		i = encodeVarintHandler(dAtA, i, uint64(len(m.Payload)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.DevID) > 0 {
		i -= len(m.DevID)
		copy(dAtA[i:], m.DevID)
		i = encodeVarintHandler(dAtA, i, uint64(len(m.DevID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.AppID) > 0 {
		i -= len(m.AppID)
		copy(dAtA[i:], m.AppID)
		i = encodeVarintHandler(dAtA, i, uint64(len(m.AppID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *LogEntry) 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 *LogEntry) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LogEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Fields) > 0 {
		for iNdEx := len(m.Fields) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Fields[iNdEx])
			copy(dAtA[i:], m.Fields[iNdEx])
			i = encodeVarintHandler(dAtA, i, uint64(len(m.Fields[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Function) > 0 {
		i -= len(m.Function)
		copy(dAtA[i:], m.Function)
		i = encodeVarintHandler(dAtA, i, uint64(len(m.Function)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DryUplinkResult) 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 *DryUplinkResult) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DryUplinkResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Logs) > 0 {
		for iNdEx := len(m.Logs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Logs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintHandler(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if m.Valid {
		i--
		if m.Valid {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.Fields) > 0 {
		i -= len(m.Fields)
		copy(dAtA[i:], m.Fields)
		i = encodeVarintHandler(dAtA, i, uint64(len(m.Fields)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Payload) > 0 {
		i -= len(m.Payload)
		copy(dAtA[i:], m.Payload)
		i = encodeVarintHandler(dAtA, i, uint64(len(m.Payload)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DryDownlinkResult) 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 *DryDownlinkResult) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DryDownlinkResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Logs) > 0 {
		for iNdEx := len(m.Logs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Logs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintHandler(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Payload) > 0 {
		i -= len(m.Payload)
		copy(dAtA[i:], m.Payload)
		i = encodeVarintHandler(dAtA, i, uint64(len(m.Payload)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintHandler(dAtA []byte, offset int, v uint64) int {
	offset -= sovHandler(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func NewPopulatedDeviceActivationResponse(r randyHandler, easy bool) *DeviceActivationResponse {
	this := &DeviceActivationResponse{}
	v1 := r.Intn(100)
	this.Payload = make([]byte, v1)
	for i := 0; i < v1; i++ {
		this.Payload[i] = byte(r.Intn(256))
	}
	if r.Intn(5) != 0 {
		this.Message = protocol.NewPopulatedMessage(r, easy)
	}
	v2 := broker.NewPopulatedDownlinkOption(r, easy)
	this.DownlinkOption = *v2
	v3 := protocol.NewPopulatedActivationMetadata(r, easy)
	this.ActivationMetadata = *v3
	if r.Intn(5) != 0 {
		this.Trace = trace.NewPopulatedTrace(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedStatusRequest(r randyHandler, easy bool) *StatusRequest {
	this := &StatusRequest{}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedStatus(r randyHandler, easy bool) *Status {
	this := &Status{}
	v4 := api.NewPopulatedSystemStats(r, easy)
	this.System = *v4
	v5 := api.NewPopulatedComponentStats(r, easy)
	this.Component = *v5
	if r.Intn(5) != 0 {
		this.Uplink = api.NewPopulatedRates(r, easy)
	}
	if r.Intn(5) != 0 {
		this.Downlink = api.NewPopulatedRates(r, easy)
	}
	if r.Intn(5) != 0 {
		this.Activations = api.NewPopulatedRates(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedApplicationIdentifier(r randyHandler, easy bool) *ApplicationIdentifier {
	this := &ApplicationIdentifier{}
	this.AppID = string(randStringHandler(r))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedApplication(r randyHandler, easy bool) *Application {
	this := &Application{}
	this.AppID = string(randStringHandler(r))
	this.Decoder = string(randStringHandler(r))
	this.Converter = string(randStringHandler(r))
	this.Validator = string(randStringHandler(r))
	this.Encoder = string(randStringHandler(r))
	this.PayloadFormat = string(randStringHandler(r))
	this.RegisterOnJoinAccessKey = string(randStringHandler(r))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedDeviceIdentifier(r randyHandler, easy bool) *DeviceIdentifier {
	this := &DeviceIdentifier{}
	this.AppID = string(randStringHandler(r))
	this.DevID = string(randStringHandler(r))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedDevice(r randyHandler, easy bool) *Device {
	this := &Device{}
	this.AppID = string(randStringHandler(r))
	this.DevID = string(randStringHandler(r))
	oneofNumber_Device := []int32{3}[r.Intn(1)]
	switch oneofNumber_Device {
	case 3:
		this.Device = NewPopulatedDevice_LoRaWANDevice(r, easy)
	}
	this.Latitude = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Latitude *= -1
	}
	this.Longitude = float32(r.Float32())
	if r.Intn(2) == 0 {
		this.Longitude *= -1
	}
	this.Altitude = int32(r.Int31())
	if r.Intn(2) == 0 {
		this.Altitude *= -1
	}
	if r.Intn(5) != 0 {
		v6 := r.Intn(10)
		this.Attributes = make(map[string]string)
		for i := 0; i < v6; i++ {
			this.Attributes[randStringHandler(r)] = randStringHandler(r)
		}
	}
	this.Description = string(randStringHandler(r))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedDevice_LoRaWANDevice(r randyHandler, easy bool) *Device_LoRaWANDevice {
	this := &Device_LoRaWANDevice{}
	this.LoRaWANDevice = lorawan.NewPopulatedDevice(r, easy)
	return this
}
func NewPopulatedDeviceList(r randyHandler, easy bool) *DeviceList {
	this := &DeviceList{}
	if r.Intn(5) != 0 {
		v7 := r.Intn(5)
		this.Devices = make([]*Device, v7)
		for i := 0; i < v7; i++ {
			this.Devices[i] = NewPopulatedDevice(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedDryDownlinkMessage(r randyHandler, easy bool) *DryDownlinkMessage {
	this := &DryDownlinkMessage{}
	v8 := r.Intn(100)
	this.Payload = make([]byte, v8)
	for i := 0; i < v8; i++ {
		this.Payload[i] = byte(r.Intn(256))
	}
	this.Fields = string(randStringHandler(r))
	v9 := NewPopulatedApplication(r, easy)
	this.App = *v9
	this.Port = uint32(r.Uint32())
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedDryUplinkMessage(r randyHandler, easy bool) *DryUplinkMessage {
	this := &DryUplinkMessage{}
	v10 := r.Intn(100)
	this.Payload = make([]byte, v10)
	for i := 0; i < v10; i++ {
		this.Payload[i] = byte(r.Intn(256))
	}
	v11 := NewPopulatedApplication(r, easy)
	this.App = *v11
	this.Port = uint32(r.Uint32())
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedSimulatedUplinkMessage(r randyHandler, easy bool) *SimulatedUplinkMessage {
	this := &SimulatedUplinkMessage{}
	this.AppID = string(randStringHandler(r))
	this.DevID = string(randStringHandler(r))
	v12 := r.Intn(100)
	this.Payload = make([]byte, v12)
	for i := 0; i < v12; i++ {
		this.Payload[i] = byte(r.Intn(256))
	}
	this.Port = uint32(r.Uint32())
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedLogEntry(r randyHandler, easy bool) *LogEntry {
	this := &LogEntry{}
	this.Function = string(randStringHandler(r))
	v13 := r.Intn(10)
	this.Fields = make([]string, v13)
	for i := 0; i < v13; i++ {
		this.Fields[i] = string(randStringHandler(r))
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedDryUplinkResult(r randyHandler, easy bool) *DryUplinkResult {
	this := &DryUplinkResult{}
	v14 := r.Intn(100)
	this.Payload = make([]byte, v14)
	for i := 0; i < v14; i++ {
		this.Payload[i] = byte(r.Intn(256))
	}
	this.Fields = string(randStringHandler(r))
	this.Valid = bool(bool(r.Intn(2) == 0))
	if r.Intn(5) != 0 {
		v15 := r.Intn(5)
		this.Logs = make([]*LogEntry, v15)
		for i := 0; i < v15; i++ {
			this.Logs[i] = NewPopulatedLogEntry(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedDryDownlinkResult(r randyHandler, easy bool) *DryDownlinkResult {
	this := &DryDownlinkResult{}
	v16 := r.Intn(100)
	this.Payload = make([]byte, v16)
	for i := 0; i < v16; i++ {
		this.Payload[i] = byte(r.Intn(256))
	}
	if r.Intn(5) != 0 {
		v17 := r.Intn(5)
		this.Logs = make([]*LogEntry, v17)
		for i := 0; i < v17; i++ {
			this.Logs[i] = NewPopulatedLogEntry(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

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

func randUTF8RuneHandler(r randyHandler) 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 randStringHandler(r randyHandler) string {
	v18 := r.Intn(100)
	tmps := make([]rune, v18)
	for i := 0; i < v18; i++ {
		tmps[i] = randUTF8RuneHandler(r)
	}
	return string(tmps)
}
func randUnrecognizedHandler(r randyHandler, 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 = randFieldHandler(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldHandler(dAtA []byte, r randyHandler, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateHandler(dAtA, uint64(key))
		v19 := r.Int63()
		if r.Intn(2) == 0 {
			v19 *= -1
		}
		dAtA = encodeVarintPopulateHandler(dAtA, uint64(v19))
	case 1:
		dAtA = encodeVarintPopulateHandler(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 = encodeVarintPopulateHandler(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateHandler(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateHandler(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 encodeVarintPopulateHandler(dAtA []byte, v uint64) []byte {
	for v >= 1<<7 {
		dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
		v >>= 7
	}
	dAtA = append(dAtA, uint8(v))
	return dAtA
}
func (m *DeviceActivationResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovHandler(uint64(l))
	}
	if m.Message != nil {
		l = m.Message.Size()
		n += 1 + l + sovHandler(uint64(l))
	}
	l = m.DownlinkOption.Size()
	n += 1 + l + sovHandler(uint64(l))
	l = m.ActivationMetadata.Size()
	n += 2 + l + sovHandler(uint64(l))
	if m.Trace != nil {
		l = m.Trace.Size()
		n += 2 + l + sovHandler(uint64(l))
	}
	return n
}

func (m *StatusRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *Status) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.System.Size()
	n += 1 + l + sovHandler(uint64(l))
	l = m.Component.Size()
	n += 1 + l + sovHandler(uint64(l))
	if m.Uplink != nil {
		l = m.Uplink.Size()
		n += 1 + l + sovHandler(uint64(l))
	}
	if m.Downlink != nil {
		l = m.Downlink.Size()
		n += 1 + l + sovHandler(uint64(l))
	}
	if m.Activations != nil {
		l = m.Activations.Size()
		n += 1 + l + sovHandler(uint64(l))
	}
	return n
}

func (m *ApplicationIdentifier) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AppID)
	if l > 0 {
		n += 1 + l + sovHandler(uint64(l))
	}
	return n
}

func (m *Application) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AppID)
	if l > 0 {
		n += 1 + l + sovHandler(uint64(l))
	}
	l = len(m.Decoder)
	if l > 0 {
		n += 1 + l + sovHandler(uint64(l))
	}
	l = len(m.Converter)
	if l > 0 {
		n += 1 + l + sovHandler(uint64(l))
	}
	l = len(m.Validator)
	if l > 0 {
		n += 1 + l + sovHandler(uint64(l))
	}
	l = len(m.Encoder)
	if l > 0 {
		n += 1 + l + sovHandler(uint64(l))
	}
	l = len(m.PayloadFormat)
	if l > 0 {
		n += 1 + l + sovHandler(uint64(l))
	}
	l = len(m.RegisterOnJoinAccessKey)
	if l > 0 {
		n += 1 + l + sovHandler(uint64(l))
	}
	return n
}

func (m *DeviceIdentifier) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AppID)
	if l > 0 {
		n += 1 + l + sovHandler(uint64(l))
	}
	l = len(m.DevID)
	if l > 0 {
		n += 1 + l + sovHandler(uint64(l))
	}
	return n
}

func (m *Device) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AppID)
	if l > 0 {
		n += 1 + l + sovHandler(uint64(l))
	}
	l = len(m.DevID)
	if l > 0 {
		n += 1 + l + sovHandler(uint64(l))
	}
	if m.Device != nil {
		n += m.Device.Size()
	}
	if m.Latitude != 0 {
		n += 5
	}
	if m.Longitude != 0 {
		n += 5
	}
	if m.Altitude != 0 {
		n += 1 + sovHandler(uint64(m.Altitude))
	}
	if len(m.Attributes) > 0 {
		for k, v := range m.Attributes {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovHandler(uint64(len(k))) + 1 + len(v) + sovHandler(uint64(len(v)))
			n += mapEntrySize + 1 + sovHandler(uint64(mapEntrySize))
		}
	}
	l = len(m.Description)
	if l > 0 {
		n += 2 + l + sovHandler(uint64(l))
	}
	return n
}

func (m *Device_LoRaWANDevice) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.LoRaWANDevice != nil {
		l = m.LoRaWANDevice.Size()
		n += 1 + l + sovHandler(uint64(l))
	}
	return n
}
func (m *DeviceList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Devices) > 0 {
		for _, e := range m.Devices {
			l = e.Size()
			n += 1 + l + sovHandler(uint64(l))
		}
	}
	return n
}

func (m *DryDownlinkMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovHandler(uint64(l))
	}
	l = len(m.Fields)
	if l > 0 {
		n += 1 + l + sovHandler(uint64(l))
	}
	l = m.App.Size()
	n += 1 + l + sovHandler(uint64(l))
	if m.Port != 0 {
		n += 1 + sovHandler(uint64(m.Port))
	}
	return n
}

func (m *DryUplinkMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovHandler(uint64(l))
	}
	l = m.App.Size()
	n += 1 + l + sovHandler(uint64(l))
	if m.Port != 0 {
		n += 1 + sovHandler(uint64(m.Port))
	}
	return n
}

func (m *SimulatedUplinkMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AppID)
	if l > 0 {
		n += 1 + l + sovHandler(uint64(l))
	}
	l = len(m.DevID)
	if l > 0 {
		n += 1 + l + sovHandler(uint64(l))
	}
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovHandler(uint64(l))
	}
	if m.Port != 0 {
		n += 1 + sovHandler(uint64(m.Port))
	}
	return n
}

func (m *LogEntry) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Function)
	if l > 0 {
		n += 1 + l + sovHandler(uint64(l))
	}
	if len(m.Fields) > 0 {
		for _, s := range m.Fields {
			l = len(s)
			n += 1 + l + sovHandler(uint64(l))
		}
	}
	return n
}

func (m *DryUplinkResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovHandler(uint64(l))
	}
	l = len(m.Fields)
	if l > 0 {
		n += 1 + l + sovHandler(uint64(l))
	}
	if m.Valid {
		n += 2
	}
	if len(m.Logs) > 0 {
		for _, e := range m.Logs {
			l = e.Size()
			n += 1 + l + sovHandler(uint64(l))
		}
	}
	return n
}

func (m *DryDownlinkResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovHandler(uint64(l))
	}
	if len(m.Logs) > 0 {
		for _, e := range m.Logs {
			l = e.Size()
			n += 1 + l + sovHandler(uint64(l))
		}
	}
	return n
}

func sovHandler(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozHandler(x uint64) (n int) {
	return sovHandler(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *DeviceActivationResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeviceActivationResponse{`,
		`Payload:` + fmt.Sprintf("%v", this.Payload) + `,`,
		`Message:` + strings.Replace(fmt.Sprintf("%v", this.Message), "Message", "protocol.Message", 1) + `,`,
		`DownlinkOption:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.DownlinkOption), "DownlinkOption", "broker.DownlinkOption", 1), `&`, ``, 1) + `,`,
		`ActivationMetadata:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ActivationMetadata), "ActivationMetadata", "protocol.ActivationMetadata", 1), `&`, ``, 1) + `,`,
		`Trace:` + strings.Replace(fmt.Sprintf("%v", this.Trace), "Trace", "trace.Trace", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *StatusRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&StatusRequest{`,
		`}`,
	}, "")
	return s
}
func (this *Status) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Status{`,
		`System:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.System), "SystemStats", "api.SystemStats", 1), `&`, ``, 1) + `,`,
		`Component:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Component), "ComponentStats", "api.ComponentStats", 1), `&`, ``, 1) + `,`,
		`Uplink:` + strings.Replace(fmt.Sprintf("%v", this.Uplink), "Rates", "api.Rates", 1) + `,`,
		`Downlink:` + strings.Replace(fmt.Sprintf("%v", this.Downlink), "Rates", "api.Rates", 1) + `,`,
		`Activations:` + strings.Replace(fmt.Sprintf("%v", this.Activations), "Rates", "api.Rates", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ApplicationIdentifier) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ApplicationIdentifier{`,
		`AppID:` + fmt.Sprintf("%v", this.AppID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Application) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Application{`,
		`AppID:` + fmt.Sprintf("%v", this.AppID) + `,`,
		`Decoder:` + fmt.Sprintf("%v", this.Decoder) + `,`,
		`Converter:` + fmt.Sprintf("%v", this.Converter) + `,`,
		`Validator:` + fmt.Sprintf("%v", this.Validator) + `,`,
		`Encoder:` + fmt.Sprintf("%v", this.Encoder) + `,`,
		`PayloadFormat:` + fmt.Sprintf("%v", this.PayloadFormat) + `,`,
		`RegisterOnJoinAccessKey:` + fmt.Sprintf("%v", this.RegisterOnJoinAccessKey) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeviceIdentifier) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeviceIdentifier{`,
		`AppID:` + fmt.Sprintf("%v", this.AppID) + `,`,
		`DevID:` + fmt.Sprintf("%v", this.DevID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Device) String() string {
	if this == nil {
		return "nil"
	}
	keysForAttributes := make([]string, 0, len(this.Attributes))
	for k, _ := range this.Attributes {
		keysForAttributes = append(keysForAttributes, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForAttributes)
	mapStringForAttributes := "map[string]string{"
	for _, k := range keysForAttributes {
		mapStringForAttributes += fmt.Sprintf("%v: %v,", k, this.Attributes[k])
	}
	mapStringForAttributes += "}"
	s := strings.Join([]string{`&Device{`,
		`AppID:` + fmt.Sprintf("%v", this.AppID) + `,`,
		`DevID:` + fmt.Sprintf("%v", this.DevID) + `,`,
		`Device:` + fmt.Sprintf("%v", this.Device) + `,`,
		`Latitude:` + fmt.Sprintf("%v", this.Latitude) + `,`,
		`Longitude:` + fmt.Sprintf("%v", this.Longitude) + `,`,
		`Altitude:` + fmt.Sprintf("%v", this.Altitude) + `,`,
		`Attributes:` + mapStringForAttributes + `,`,
		`Description:` + fmt.Sprintf("%v", this.Description) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Device_LoRaWANDevice) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Device_LoRaWANDevice{`,
		`LoRaWANDevice:` + strings.Replace(fmt.Sprintf("%v", this.LoRaWANDevice), "Device", "lorawan.Device", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeviceList) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForDevices := "[]*Device{"
	for _, f := range this.Devices {
		repeatedStringForDevices += strings.Replace(f.String(), "Device", "Device", 1) + ","
	}
	repeatedStringForDevices += "}"
	s := strings.Join([]string{`&DeviceList{`,
		`Devices:` + repeatedStringForDevices + `,`,
		`}`,
	}, "")
	return s
}
func (this *DryDownlinkMessage) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DryDownlinkMessage{`,
		`Payload:` + fmt.Sprintf("%v", this.Payload) + `,`,
		`Fields:` + fmt.Sprintf("%v", this.Fields) + `,`,
		`App:` + strings.Replace(strings.Replace(this.App.String(), "Application", "Application", 1), `&`, ``, 1) + `,`,
		`Port:` + fmt.Sprintf("%v", this.Port) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DryUplinkMessage) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DryUplinkMessage{`,
		`Payload:` + fmt.Sprintf("%v", this.Payload) + `,`,
		`App:` + strings.Replace(strings.Replace(this.App.String(), "Application", "Application", 1), `&`, ``, 1) + `,`,
		`Port:` + fmt.Sprintf("%v", this.Port) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SimulatedUplinkMessage) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SimulatedUplinkMessage{`,
		`AppID:` + fmt.Sprintf("%v", this.AppID) + `,`,
		`DevID:` + fmt.Sprintf("%v", this.DevID) + `,`,
		`Payload:` + fmt.Sprintf("%v", this.Payload) + `,`,
		`Port:` + fmt.Sprintf("%v", this.Port) + `,`,
		`}`,
	}, "")
	return s
}
func (this *LogEntry) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&LogEntry{`,
		`Function:` + fmt.Sprintf("%v", this.Function) + `,`,
		`Fields:` + fmt.Sprintf("%v", this.Fields) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DryUplinkResult) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForLogs := "[]*LogEntry{"
	for _, f := range this.Logs {
		repeatedStringForLogs += strings.Replace(f.String(), "LogEntry", "LogEntry", 1) + ","
	}
	repeatedStringForLogs += "}"
	s := strings.Join([]string{`&DryUplinkResult{`,
		`Payload:` + fmt.Sprintf("%v", this.Payload) + `,`,
		`Fields:` + fmt.Sprintf("%v", this.Fields) + `,`,
		`Valid:` + fmt.Sprintf("%v", this.Valid) + `,`,
		`Logs:` + repeatedStringForLogs + `,`,
		`}`,
	}, "")
	return s
}
func (this *DryDownlinkResult) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForLogs := "[]*LogEntry{"
	for _, f := range this.Logs {
		repeatedStringForLogs += strings.Replace(f.String(), "LogEntry", "LogEntry", 1) + ","
	}
	repeatedStringForLogs += "}"
	s := strings.Join([]string{`&DryDownlinkResult{`,
		`Payload:` + fmt.Sprintf("%v", this.Payload) + `,`,
		`Logs:` + repeatedStringForLogs + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringHandler(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *DeviceActivationResponse) 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 ErrIntOverflowHandler
			}
			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: DeviceActivationResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeviceActivationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthHandler
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...)
			if m.Payload == nil {
				m.Payload = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHandler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Message == nil {
				m.Message = &protocol.Message{}
			}
			if err := m.Message.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DownlinkOption", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHandler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.DownlinkOption.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 23:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActivationMetadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHandler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ActivationMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 31:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Trace", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHandler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Trace == nil {
				m.Trace = &trace.Trace{}
			}
			if err := m.Trace.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHandler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StatusRequest) 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 ErrIntOverflowHandler
			}
			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: StatusRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StatusRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipHandler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Status) 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 ErrIntOverflowHandler
			}
			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: Status: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Status: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field System", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHandler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.System.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Component", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHandler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Component.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uplink", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHandler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Uplink == nil {
				m.Uplink = &api.Rates{}
			}
			if err := m.Uplink.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Downlink", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHandler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Downlink == nil {
				m.Downlink = &api.Rates{}
			}
			if err := m.Downlink.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Activations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHandler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Activations == nil {
				m.Activations = &api.Rates{}
			}
			if err := m.Activations.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHandler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ApplicationIdentifier) 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 ErrIntOverflowHandler
			}
			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: ApplicationIdentifier: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ApplicationIdentifier: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				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 ErrInvalidLengthHandler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AppID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHandler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Application) 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 ErrIntOverflowHandler
			}
			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: Application: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Application: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				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 ErrInvalidLengthHandler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AppID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Decoder", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				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 ErrInvalidLengthHandler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Decoder = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Converter", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				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 ErrInvalidLengthHandler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Converter = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				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 ErrInvalidLengthHandler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Validator = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Encoder", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				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 ErrInvalidLengthHandler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Encoder = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PayloadFormat", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				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 ErrInvalidLengthHandler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PayloadFormat = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegisterOnJoinAccessKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				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 ErrInvalidLengthHandler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RegisterOnJoinAccessKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHandler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeviceIdentifier) 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 ErrIntOverflowHandler
			}
			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: DeviceIdentifier: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeviceIdentifier: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				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 ErrInvalidLengthHandler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AppID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DevID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				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 ErrInvalidLengthHandler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DevID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHandler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Device) 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 ErrIntOverflowHandler
			}
			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: Device: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Device: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				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 ErrInvalidLengthHandler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AppID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DevID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				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 ErrInvalidLengthHandler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DevID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LoRaWANDevice", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHandler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &lorawan.Device{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Device = &Device_LoRaWANDevice{v}
			iNdEx = postIndex
		case 10:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Latitude", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Latitude = float32(math.Float32frombits(v))
		case 11:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Longitude", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.Longitude = float32(math.Float32frombits(v))
		case 12:
			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 ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Altitude |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHandler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Attributes == nil {
				m.Attributes = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowHandler
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowHandler
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthHandler
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthHandler
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowHandler
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthHandler
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthHandler
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipHandler(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthHandler
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Attributes[mapkey] = mapvalue
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				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 ErrInvalidLengthHandler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHandler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeviceList) 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 ErrIntOverflowHandler
			}
			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: DeviceList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeviceList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Devices", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHandler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Devices = append(m.Devices, &Device{})
			if err := m.Devices[len(m.Devices)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHandler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DryDownlinkMessage) 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 ErrIntOverflowHandler
			}
			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: DryDownlinkMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DryDownlinkMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthHandler
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...)
			if m.Payload == nil {
				m.Payload = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fields", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				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 ErrInvalidLengthHandler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Fields = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field App", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHandler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.App.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
			}
			m.Port = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Port |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHandler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DryUplinkMessage) 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 ErrIntOverflowHandler
			}
			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: DryUplinkMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DryUplinkMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthHandler
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...)
			if m.Payload == nil {
				m.Payload = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field App", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHandler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.App.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
			}
			m.Port = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Port |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHandler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SimulatedUplinkMessage) 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 ErrIntOverflowHandler
			}
			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: SimulatedUplinkMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SimulatedUplinkMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				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 ErrInvalidLengthHandler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AppID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DevID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				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 ErrInvalidLengthHandler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DevID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthHandler
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...)
			if m.Payload == nil {
				m.Payload = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType)
			}
			m.Port = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Port |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipHandler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LogEntry) 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 ErrIntOverflowHandler
			}
			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: LogEntry: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LogEntry: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Function", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				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 ErrInvalidLengthHandler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Function = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fields", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				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 ErrInvalidLengthHandler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Fields = append(m.Fields, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHandler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DryUplinkResult) 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 ErrIntOverflowHandler
			}
			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: DryUplinkResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DryUplinkResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthHandler
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...)
			if m.Payload == nil {
				m.Payload = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fields", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				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 ErrInvalidLengthHandler
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Fields = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Valid", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Valid = bool(v != 0)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Logs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHandler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Logs = append(m.Logs, &LogEntry{})
			if err := m.Logs[len(m.Logs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHandler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DryDownlinkResult) 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 ErrIntOverflowHandler
			}
			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: DryDownlinkResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DryDownlinkResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthHandler
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...)
			if m.Payload == nil {
				m.Payload = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Logs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowHandler
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthHandler
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthHandler
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Logs = append(m.Logs, &LogEntry{})
			if err := m.Logs[len(m.Logs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipHandler(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthHandler
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipHandler(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, ErrIntOverflowHandler
			}
			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, ErrIntOverflowHandler
				}
				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, ErrIntOverflowHandler
				}
				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, ErrInvalidLengthHandler
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupHandler
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthHandler
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthHandler        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowHandler          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupHandler = fmt.Errorf("proto: unexpected end of group")
)