router.pb.go

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

/*
	Package router is a generated protocol buffer package.

	It is generated from these files:
		github.com/TheThingsNetwork/ttn/api/router/router.proto

	It has these top-level messages:
		SubscribeRequest
		UplinkMessage
		DownlinkMessage
		DeviceActivationRequest
		DeviceActivationResponse
		GatewayStatusRequest
		GatewayStatusResponse
		StatusRequest
		Status
*/
package router

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import google_protobuf "github.com/golang/protobuf/ptypes/empty"
import _ "github.com/gogo/protobuf/gogoproto"
import api "github.com/TheThingsNetwork/ttn/api"
import protocol "github.com/TheThingsNetwork/ttn/api/protocol"
import gateway "github.com/TheThingsNetwork/ttn/api/gateway"
import trace "github.com/TheThingsNetwork/ttn/api/trace"

import github_com_TheThingsNetwork_ttn_core_types "github.com/TheThingsNetwork/ttn/core/types"

import bytes "bytes"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

import strings "strings"
import reflect "reflect"

import io "io"

// Reference imports to suppress errors if they are not otherwise used.
var _ = 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.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type SubscribeRequest struct {
}

func (m *SubscribeRequest) Reset()                    { *m = SubscribeRequest{} }
func (*SubscribeRequest) ProtoMessage()               {}
func (*SubscribeRequest) Descriptor() ([]byte, []int) { return fileDescriptorRouter, []int{0} }

type UplinkMessage struct {
	Payload          []byte               `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
	Message          *protocol.Message    `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
	ProtocolMetadata *protocol.RxMetadata `protobuf:"bytes,11,opt,name=protocol_metadata,json=protocolMetadata" json:"protocol_metadata,omitempty"`
	GatewayMetadata  *gateway.RxMetadata  `protobuf:"bytes,12,opt,name=gateway_metadata,json=gatewayMetadata" json:"gateway_metadata,omitempty"`
	Trace            *trace.Trace         `protobuf:"bytes,21,opt,name=trace" json:"trace,omitempty"`
}

func (m *UplinkMessage) Reset()                    { *m = UplinkMessage{} }
func (*UplinkMessage) ProtoMessage()               {}
func (*UplinkMessage) Descriptor() ([]byte, []int) { return fileDescriptorRouter, []int{1} }

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

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

func (m *UplinkMessage) GetProtocolMetadata() *protocol.RxMetadata {
	if m != nil {
		return m.ProtocolMetadata
	}
	return nil
}

func (m *UplinkMessage) GetGatewayMetadata() *gateway.RxMetadata {
	if m != nil {
		return m.GatewayMetadata
	}
	return nil
}

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

type DownlinkMessage struct {
	Payload               []byte                    `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
	Message               *protocol.Message         `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
	ProtocolConfiguration *protocol.TxConfiguration `protobuf:"bytes,11,opt,name=protocol_configuration,json=protocolConfiguration" json:"protocol_configuration,omitempty"`
	GatewayConfiguration  *gateway.TxConfiguration  `protobuf:"bytes,12,opt,name=gateway_configuration,json=gatewayConfiguration" json:"gateway_configuration,omitempty"`
	Trace                 *trace.Trace              `protobuf:"bytes,21,opt,name=trace" json:"trace,omitempty"`
}

func (m *DownlinkMessage) Reset()                    { *m = DownlinkMessage{} }
func (*DownlinkMessage) ProtoMessage()               {}
func (*DownlinkMessage) Descriptor() ([]byte, []int) { return fileDescriptorRouter, []int{2} }

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

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

func (m *DownlinkMessage) GetProtocolConfiguration() *protocol.TxConfiguration {
	if m != nil {
		return m.ProtocolConfiguration
	}
	return nil
}

func (m *DownlinkMessage) GetGatewayConfiguration() *gateway.TxConfiguration {
	if m != nil {
		return m.GatewayConfiguration
	}
	return nil
}

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

type DeviceActivationRequest struct {
	Payload            []byte                                             `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
	Message            *protocol.Message                                  `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
	DevEui             *github_com_TheThingsNetwork_ttn_core_types.DevEUI `protobuf:"bytes,11,opt,name=dev_eui,json=devEui,proto3,customtype=github.com/TheThingsNetwork/ttn/core/types.DevEUI" json:"dev_eui,omitempty"`
	AppEui             *github_com_TheThingsNetwork_ttn_core_types.AppEUI `protobuf:"bytes,12,opt,name=app_eui,json=appEui,proto3,customtype=github.com/TheThingsNetwork/ttn/core/types.AppEUI" json:"app_eui,omitempty"`
	ProtocolMetadata   *protocol.RxMetadata                               `protobuf:"bytes,21,opt,name=protocol_metadata,json=protocolMetadata" json:"protocol_metadata,omitempty"`
	GatewayMetadata    *gateway.RxMetadata                                `protobuf:"bytes,22,opt,name=gateway_metadata,json=gatewayMetadata" json:"gateway_metadata,omitempty"`
	ActivationMetadata *protocol.ActivationMetadata                       `protobuf:"bytes,23,opt,name=activation_metadata,json=activationMetadata" json:"activation_metadata,omitempty"`
	Trace              *trace.Trace                                       `protobuf:"bytes,31,opt,name=trace" json:"trace,omitempty"`
}

func (m *DeviceActivationRequest) Reset()                    { *m = DeviceActivationRequest{} }
func (*DeviceActivationRequest) ProtoMessage()               {}
func (*DeviceActivationRequest) Descriptor() ([]byte, []int) { return fileDescriptorRouter, []int{3} }

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

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

func (m *DeviceActivationRequest) GetProtocolMetadata() *protocol.RxMetadata {
	if m != nil {
		return m.ProtocolMetadata
	}
	return nil
}

func (m *DeviceActivationRequest) GetGatewayMetadata() *gateway.RxMetadata {
	if m != nil {
		return m.GatewayMetadata
	}
	return nil
}

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

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

type DeviceActivationResponse struct {
}

func (m *DeviceActivationResponse) Reset()                    { *m = DeviceActivationResponse{} }
func (*DeviceActivationResponse) ProtoMessage()               {}
func (*DeviceActivationResponse) Descriptor() ([]byte, []int) { return fileDescriptorRouter, []int{4} }

// message GatewayStatusRequest is used to request the status of a gateway from
// this Router
type GatewayStatusRequest struct {
	GatewayId string `protobuf:"bytes,1,opt,name=gateway_id,json=gatewayId,proto3" json:"gateway_id,omitempty"`
}

func (m *GatewayStatusRequest) Reset()                    { *m = GatewayStatusRequest{} }
func (*GatewayStatusRequest) ProtoMessage()               {}
func (*GatewayStatusRequest) Descriptor() ([]byte, []int) { return fileDescriptorRouter, []int{5} }

func (m *GatewayStatusRequest) GetGatewayId() string {
	if m != nil {
		return m.GatewayId
	}
	return ""
}

type GatewayStatusResponse struct {
	LastSeen int64           `protobuf:"varint,1,opt,name=last_seen,json=lastSeen,proto3" json:"last_seen,omitempty"`
	Status   *gateway.Status `protobuf:"bytes,2,opt,name=status" json:"status,omitempty"`
}

func (m *GatewayStatusResponse) Reset()                    { *m = GatewayStatusResponse{} }
func (*GatewayStatusResponse) ProtoMessage()               {}
func (*GatewayStatusResponse) Descriptor() ([]byte, []int) { return fileDescriptorRouter, []int{6} }

func (m *GatewayStatusResponse) GetLastSeen() int64 {
	if m != nil {
		return m.LastSeen
	}
	return 0
}

func (m *GatewayStatusResponse) GetStatus() *gateway.Status {
	if m != nil {
		return m.Status
	}
	return nil
}

// message StatusRequest is used to request the status of this Router
type StatusRequest struct {
}

func (m *StatusRequest) Reset()                    { *m = StatusRequest{} }
func (*StatusRequest) ProtoMessage()               {}
func (*StatusRequest) Descriptor() ([]byte, []int) { return fileDescriptorRouter, []int{7} }

// message Status is the response to the StatusRequest
type Status struct {
	System        *api.SystemStats    `protobuf:"bytes,1,opt,name=system" json:"system,omitempty"`
	Component     *api.ComponentStats `protobuf:"bytes,2,opt,name=component" json:"component,omitempty"`
	GatewayStatus *api.Rates          `protobuf:"bytes,11,opt,name=gateway_status,json=gatewayStatus" json:"gateway_status,omitempty"`
	Uplink        *api.Rates          `protobuf:"bytes,12,opt,name=uplink" json:"uplink,omitempty"`
	Downlink      *api.Rates          `protobuf:"bytes,13,opt,name=downlink" json:"downlink,omitempty"`
	Activations   *api.Rates          `protobuf:"bytes,14,opt,name=activations" json:"activations,omitempty"`
	// Connections
	ConnectedGateways uint32 `protobuf:"varint,21,opt,name=connected_gateways,json=connectedGateways,proto3" json:"connected_gateways,omitempty"`
	ConnectedBrokers  uint32 `protobuf:"varint,22,opt,name=connected_brokers,json=connectedBrokers,proto3" json:"connected_brokers,omitempty"`
}

func (m *Status) Reset()                    { *m = Status{} }
func (*Status) ProtoMessage()               {}
func (*Status) Descriptor() ([]byte, []int) { return fileDescriptorRouter, []int{8} }

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

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

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

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
}

func (m *Status) GetConnectedGateways() uint32 {
	if m != nil {
		return m.ConnectedGateways
	}
	return 0
}

func (m *Status) GetConnectedBrokers() uint32 {
	if m != nil {
		return m.ConnectedBrokers
	}
	return 0
}

func init() {
	proto.RegisterType((*SubscribeRequest)(nil), "router.SubscribeRequest")
	proto.RegisterType((*UplinkMessage)(nil), "router.UplinkMessage")
	proto.RegisterType((*DownlinkMessage)(nil), "router.DownlinkMessage")
	proto.RegisterType((*DeviceActivationRequest)(nil), "router.DeviceActivationRequest")
	proto.RegisterType((*DeviceActivationResponse)(nil), "router.DeviceActivationResponse")
	proto.RegisterType((*GatewayStatusRequest)(nil), "router.GatewayStatusRequest")
	proto.RegisterType((*GatewayStatusResponse)(nil), "router.GatewayStatusResponse")
	proto.RegisterType((*StatusRequest)(nil), "router.StatusRequest")
	proto.RegisterType((*Status)(nil), "router.Status")
}
func (this *SubscribeRequest) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*SubscribeRequest)
	if !ok {
		that2, ok := that.(SubscribeRequest)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *SubscribeRequest")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *SubscribeRequest but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *SubscribeRequest but is not nil && this == nil")
	}
	return nil
}
func (this *SubscribeRequest) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*SubscribeRequest)
	if !ok {
		that2, ok := that.(SubscribeRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	return true
}
func (this *UplinkMessage) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*UplinkMessage)
	if !ok {
		that2, ok := that.(UplinkMessage)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *UplinkMessage")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *UplinkMessage but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *UplinkMessage but is not nil && this == nil")
	}
	if !bytes.Equal(this.Payload, that1.Payload) {
		return fmt.Errorf("Payload this(%v) Not Equal that(%v)", this.Payload, that1.Payload)
	}
	if !this.Message.Equal(that1.Message) {
		return fmt.Errorf("Message this(%v) Not Equal that(%v)", this.Message, that1.Message)
	}
	if !this.ProtocolMetadata.Equal(that1.ProtocolMetadata) {
		return fmt.Errorf("ProtocolMetadata this(%v) Not Equal that(%v)", this.ProtocolMetadata, that1.ProtocolMetadata)
	}
	if !this.GatewayMetadata.Equal(that1.GatewayMetadata) {
		return fmt.Errorf("GatewayMetadata this(%v) Not Equal that(%v)", this.GatewayMetadata, that1.GatewayMetadata)
	}
	if !this.Trace.Equal(that1.Trace) {
		return fmt.Errorf("Trace this(%v) Not Equal that(%v)", this.Trace, that1.Trace)
	}
	return nil
}
func (this *UplinkMessage) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*UplinkMessage)
	if !ok {
		that2, ok := that.(UplinkMessage)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} 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.ProtocolMetadata.Equal(that1.ProtocolMetadata) {
		return false
	}
	if !this.GatewayMetadata.Equal(that1.GatewayMetadata) {
		return false
	}
	if !this.Trace.Equal(that1.Trace) {
		return false
	}
	return true
}
func (this *DownlinkMessage) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*DownlinkMessage)
	if !ok {
		that2, ok := that.(DownlinkMessage)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *DownlinkMessage")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *DownlinkMessage but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *DownlinkMessage but is not nil && this == nil")
	}
	if !bytes.Equal(this.Payload, that1.Payload) {
		return fmt.Errorf("Payload this(%v) Not Equal that(%v)", this.Payload, that1.Payload)
	}
	if !this.Message.Equal(that1.Message) {
		return fmt.Errorf("Message this(%v) Not Equal that(%v)", this.Message, that1.Message)
	}
	if !this.ProtocolConfiguration.Equal(that1.ProtocolConfiguration) {
		return fmt.Errorf("ProtocolConfiguration this(%v) Not Equal that(%v)", this.ProtocolConfiguration, that1.ProtocolConfiguration)
	}
	if !this.GatewayConfiguration.Equal(that1.GatewayConfiguration) {
		return fmt.Errorf("GatewayConfiguration this(%v) Not Equal that(%v)", this.GatewayConfiguration, that1.GatewayConfiguration)
	}
	if !this.Trace.Equal(that1.Trace) {
		return fmt.Errorf("Trace this(%v) Not Equal that(%v)", this.Trace, that1.Trace)
	}
	return nil
}
func (this *DownlinkMessage) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*DownlinkMessage)
	if !ok {
		that2, ok := that.(DownlinkMessage)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} 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.ProtocolConfiguration.Equal(that1.ProtocolConfiguration) {
		return false
	}
	if !this.GatewayConfiguration.Equal(that1.GatewayConfiguration) {
		return false
	}
	if !this.Trace.Equal(that1.Trace) {
		return false
	}
	return true
}
func (this *DeviceActivationRequest) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*DeviceActivationRequest)
	if !ok {
		that2, ok := that.(DeviceActivationRequest)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *DeviceActivationRequest")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *DeviceActivationRequest but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *DeviceActivationRequest but is not nil && this == nil")
	}
	if !bytes.Equal(this.Payload, that1.Payload) {
		return fmt.Errorf("Payload this(%v) Not Equal that(%v)", this.Payload, that1.Payload)
	}
	if !this.Message.Equal(that1.Message) {
		return fmt.Errorf("Message this(%v) Not Equal that(%v)", this.Message, that1.Message)
	}
	if that1.DevEui == nil {
		if this.DevEui != nil {
			return fmt.Errorf("this.DevEui != nil && that1.DevEui == nil")
		}
	} else if !this.DevEui.Equal(*that1.DevEui) {
		return fmt.Errorf("DevEui this(%v) Not Equal that(%v)", this.DevEui, that1.DevEui)
	}
	if that1.AppEui == nil {
		if this.AppEui != nil {
			return fmt.Errorf("this.AppEui != nil && that1.AppEui == nil")
		}
	} else if !this.AppEui.Equal(*that1.AppEui) {
		return fmt.Errorf("AppEui this(%v) Not Equal that(%v)", this.AppEui, that1.AppEui)
	}
	if !this.ProtocolMetadata.Equal(that1.ProtocolMetadata) {
		return fmt.Errorf("ProtocolMetadata this(%v) Not Equal that(%v)", this.ProtocolMetadata, that1.ProtocolMetadata)
	}
	if !this.GatewayMetadata.Equal(that1.GatewayMetadata) {
		return fmt.Errorf("GatewayMetadata this(%v) Not Equal that(%v)", this.GatewayMetadata, that1.GatewayMetadata)
	}
	if !this.ActivationMetadata.Equal(that1.ActivationMetadata) {
		return fmt.Errorf("ActivationMetadata this(%v) Not Equal that(%v)", this.ActivationMetadata, that1.ActivationMetadata)
	}
	if !this.Trace.Equal(that1.Trace) {
		return fmt.Errorf("Trace this(%v) Not Equal that(%v)", this.Trace, that1.Trace)
	}
	return nil
}
func (this *DeviceActivationRequest) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*DeviceActivationRequest)
	if !ok {
		that2, ok := that.(DeviceActivationRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.Payload, that1.Payload) {
		return false
	}
	if !this.Message.Equal(that1.Message) {
		return false
	}
	if that1.DevEui == nil {
		if this.DevEui != nil {
			return false
		}
	} else if !this.DevEui.Equal(*that1.DevEui) {
		return false
	}
	if that1.AppEui == nil {
		if this.AppEui != nil {
			return false
		}
	} else if !this.AppEui.Equal(*that1.AppEui) {
		return false
	}
	if !this.ProtocolMetadata.Equal(that1.ProtocolMetadata) {
		return false
	}
	if !this.GatewayMetadata.Equal(that1.GatewayMetadata) {
		return false
	}
	if !this.ActivationMetadata.Equal(that1.ActivationMetadata) {
		return false
	}
	if !this.Trace.Equal(that1.Trace) {
		return false
	}
	return true
}
func (this *DeviceActivationResponse) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*DeviceActivationResponse)
	if !ok {
		that2, ok := that.(DeviceActivationResponse)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *DeviceActivationResponse")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *DeviceActivationResponse but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *DeviceActivationResponse but is not nil && this == nil")
	}
	return nil
}
func (this *DeviceActivationResponse) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*DeviceActivationResponse)
	if !ok {
		that2, ok := that.(DeviceActivationResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	return true
}
func (this *GatewayStatusRequest) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*GatewayStatusRequest)
	if !ok {
		that2, ok := that.(GatewayStatusRequest)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *GatewayStatusRequest")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *GatewayStatusRequest but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *GatewayStatusRequest but is not nil && this == nil")
	}
	if this.GatewayId != that1.GatewayId {
		return fmt.Errorf("GatewayId this(%v) Not Equal that(%v)", this.GatewayId, that1.GatewayId)
	}
	return nil
}
func (this *GatewayStatusRequest) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*GatewayStatusRequest)
	if !ok {
		that2, ok := that.(GatewayStatusRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.GatewayId != that1.GatewayId {
		return false
	}
	return true
}
func (this *GatewayStatusResponse) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*GatewayStatusResponse)
	if !ok {
		that2, ok := that.(GatewayStatusResponse)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *GatewayStatusResponse")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *GatewayStatusResponse but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *GatewayStatusResponse but is not nil && this == nil")
	}
	if this.LastSeen != that1.LastSeen {
		return fmt.Errorf("LastSeen this(%v) Not Equal that(%v)", this.LastSeen, that1.LastSeen)
	}
	if !this.Status.Equal(that1.Status) {
		return fmt.Errorf("Status this(%v) Not Equal that(%v)", this.Status, that1.Status)
	}
	return nil
}
func (this *GatewayStatusResponse) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*GatewayStatusResponse)
	if !ok {
		that2, ok := that.(GatewayStatusResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.LastSeen != that1.LastSeen {
		return false
	}
	if !this.Status.Equal(that1.Status) {
		return false
	}
	return true
}
func (this *StatusRequest) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*StatusRequest)
	if !ok {
		that2, ok := that.(StatusRequest)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *StatusRequest")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *StatusRequest but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *StatusRequest but is not nil && this == nil")
	}
	return nil
}
func (this *StatusRequest) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*StatusRequest)
	if !ok {
		that2, ok := that.(StatusRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	return true
}
func (this *Status) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Status)
	if !ok {
		that2, ok := that.(Status)
		if ok {
			that1 = &that2
		} else {
			return fmt.Errorf("that is not of type *Status")
		}
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Status but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Status but is not nil && this == nil")
	}
	if !this.System.Equal(that1.System) {
		return fmt.Errorf("System this(%v) Not Equal that(%v)", this.System, that1.System)
	}
	if !this.Component.Equal(that1.Component) {
		return fmt.Errorf("Component this(%v) Not Equal that(%v)", this.Component, that1.Component)
	}
	if !this.GatewayStatus.Equal(that1.GatewayStatus) {
		return fmt.Errorf("GatewayStatus this(%v) Not Equal that(%v)", this.GatewayStatus, that1.GatewayStatus)
	}
	if !this.Uplink.Equal(that1.Uplink) {
		return fmt.Errorf("Uplink this(%v) Not Equal that(%v)", this.Uplink, that1.Uplink)
	}
	if !this.Downlink.Equal(that1.Downlink) {
		return fmt.Errorf("Downlink this(%v) Not Equal that(%v)", this.Downlink, that1.Downlink)
	}
	if !this.Activations.Equal(that1.Activations) {
		return fmt.Errorf("Activations this(%v) Not Equal that(%v)", this.Activations, that1.Activations)
	}
	if this.ConnectedGateways != that1.ConnectedGateways {
		return fmt.Errorf("ConnectedGateways this(%v) Not Equal that(%v)", this.ConnectedGateways, that1.ConnectedGateways)
	}
	if this.ConnectedBrokers != that1.ConnectedBrokers {
		return fmt.Errorf("ConnectedBrokers this(%v) Not Equal that(%v)", this.ConnectedBrokers, that1.ConnectedBrokers)
	}
	return nil
}
func (this *Status) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Status)
	if !ok {
		that2, ok := that.(Status)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.System.Equal(that1.System) {
		return false
	}
	if !this.Component.Equal(that1.Component) {
		return false
	}
	if !this.GatewayStatus.Equal(that1.GatewayStatus) {
		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
	}
	if this.ConnectedGateways != that1.ConnectedGateways {
		return false
	}
	if this.ConnectedBrokers != that1.ConnectedBrokers {
		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

// Client API for Router service

type RouterClient interface {
	// Gateway streams status messages to Router
	GatewayStatus(ctx context.Context, opts ...grpc.CallOption) (Router_GatewayStatusClient, error)
	// Gateway streams uplink messages to Router
	Uplink(ctx context.Context, opts ...grpc.CallOption) (Router_UplinkClient, error)
	// Gateway subscribes to downlink messages from Router
	// It is possible to open multiple subscriptions (but not recommended).
	// If you do this, you are responsible for de-duplication of downlink messages.
	Subscribe(ctx context.Context, in *SubscribeRequest, opts ...grpc.CallOption) (Router_SubscribeClient, error)
	// Gateway requests device activation
	Activate(ctx context.Context, in *DeviceActivationRequest, opts ...grpc.CallOption) (*DeviceActivationResponse, error)
}

type routerClient struct {
	cc *grpc.ClientConn
}

func NewRouterClient(cc *grpc.ClientConn) RouterClient {
	return &routerClient{cc}
}

func (c *routerClient) GatewayStatus(ctx context.Context, opts ...grpc.CallOption) (Router_GatewayStatusClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_Router_serviceDesc.Streams[0], c.cc, "/router.Router/GatewayStatus", opts...)
	if err != nil {
		return nil, err
	}
	x := &routerGatewayStatusClient{stream}
	return x, nil
}

type Router_GatewayStatusClient interface {
	Send(*gateway.Status) error
	CloseAndRecv() (*google_protobuf.Empty, error)
	grpc.ClientStream
}

type routerGatewayStatusClient struct {
	grpc.ClientStream
}

func (x *routerGatewayStatusClient) Send(m *gateway.Status) error {
	return x.ClientStream.SendMsg(m)
}

func (x *routerGatewayStatusClient) CloseAndRecv() (*google_protobuf.Empty, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(google_protobuf.Empty)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *routerClient) Uplink(ctx context.Context, opts ...grpc.CallOption) (Router_UplinkClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_Router_serviceDesc.Streams[1], c.cc, "/router.Router/Uplink", opts...)
	if err != nil {
		return nil, err
	}
	x := &routerUplinkClient{stream}
	return x, nil
}

type Router_UplinkClient interface {
	Send(*UplinkMessage) error
	CloseAndRecv() (*google_protobuf.Empty, error)
	grpc.ClientStream
}

type routerUplinkClient struct {
	grpc.ClientStream
}

func (x *routerUplinkClient) Send(m *UplinkMessage) error {
	return x.ClientStream.SendMsg(m)
}

func (x *routerUplinkClient) CloseAndRecv() (*google_protobuf.Empty, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(google_protobuf.Empty)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *routerClient) Subscribe(ctx context.Context, in *SubscribeRequest, opts ...grpc.CallOption) (Router_SubscribeClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_Router_serviceDesc.Streams[2], c.cc, "/router.Router/Subscribe", opts...)
	if err != nil {
		return nil, err
	}
	x := &routerSubscribeClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Router_SubscribeClient interface {
	Recv() (*DownlinkMessage, error)
	grpc.ClientStream
}

type routerSubscribeClient struct {
	grpc.ClientStream
}

func (x *routerSubscribeClient) Recv() (*DownlinkMessage, error) {
	m := new(DownlinkMessage)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *routerClient) Activate(ctx context.Context, in *DeviceActivationRequest, opts ...grpc.CallOption) (*DeviceActivationResponse, error) {
	out := new(DeviceActivationResponse)
	err := grpc.Invoke(ctx, "/router.Router/Activate", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for Router service

type RouterServer interface {
	// Gateway streams status messages to Router
	GatewayStatus(Router_GatewayStatusServer) error
	// Gateway streams uplink messages to Router
	Uplink(Router_UplinkServer) error
	// Gateway subscribes to downlink messages from Router
	// It is possible to open multiple subscriptions (but not recommended).
	// If you do this, you are responsible for de-duplication of downlink messages.
	Subscribe(*SubscribeRequest, Router_SubscribeServer) error
	// Gateway requests device activation
	Activate(context.Context, *DeviceActivationRequest) (*DeviceActivationResponse, error)
}

func RegisterRouterServer(s *grpc.Server, srv RouterServer) {
	s.RegisterService(&_Router_serviceDesc, srv)
}

func _Router_GatewayStatus_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(RouterServer).GatewayStatus(&routerGatewayStatusServer{stream})
}

type Router_GatewayStatusServer interface {
	SendAndClose(*google_protobuf.Empty) error
	Recv() (*gateway.Status, error)
	grpc.ServerStream
}

type routerGatewayStatusServer struct {
	grpc.ServerStream
}

func (x *routerGatewayStatusServer) SendAndClose(m *google_protobuf.Empty) error {
	return x.ServerStream.SendMsg(m)
}

func (x *routerGatewayStatusServer) Recv() (*gateway.Status, error) {
	m := new(gateway.Status)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Router_Uplink_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(RouterServer).Uplink(&routerUplinkServer{stream})
}

type Router_UplinkServer interface {
	SendAndClose(*google_protobuf.Empty) error
	Recv() (*UplinkMessage, error)
	grpc.ServerStream
}

type routerUplinkServer struct {
	grpc.ServerStream
}

func (x *routerUplinkServer) SendAndClose(m *google_protobuf.Empty) error {
	return x.ServerStream.SendMsg(m)
}

func (x *routerUplinkServer) Recv() (*UplinkMessage, error) {
	m := new(UplinkMessage)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Router_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubscribeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(RouterServer).Subscribe(m, &routerSubscribeServer{stream})
}

type Router_SubscribeServer interface {
	Send(*DownlinkMessage) error
	grpc.ServerStream
}

type routerSubscribeServer struct {
	grpc.ServerStream
}

func (x *routerSubscribeServer) Send(m *DownlinkMessage) error {
	return x.ServerStream.SendMsg(m)
}

func _Router_Activate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeviceActivationRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RouterServer).Activate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/router.Router/Activate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RouterServer).Activate(ctx, req.(*DeviceActivationRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Router_serviceDesc = grpc.ServiceDesc{
	ServiceName: "router.Router",
	HandlerType: (*RouterServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Activate",
			Handler:    _Router_Activate_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GatewayStatus",
			Handler:       _Router_GatewayStatus_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "Uplink",
			Handler:       _Router_Uplink_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "Subscribe",
			Handler:       _Router_Subscribe_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "github.com/TheThingsNetwork/ttn/api/router/router.proto",
}

// Client API for RouterManager service

type RouterManagerClient interface {
	// Gateway owner or network operator requests Gateway status from Router Manager
	// Deprecated: Use monitor API (NOC) instead of this
	GatewayStatus(ctx context.Context, in *GatewayStatusRequest, opts ...grpc.CallOption) (*GatewayStatusResponse, error)
	// Network operator requests Router status
	GetStatus(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*Status, error)
}

type routerManagerClient struct {
	cc *grpc.ClientConn
}

func NewRouterManagerClient(cc *grpc.ClientConn) RouterManagerClient {
	return &routerManagerClient{cc}
}

func (c *routerManagerClient) GatewayStatus(ctx context.Context, in *GatewayStatusRequest, opts ...grpc.CallOption) (*GatewayStatusResponse, error) {
	out := new(GatewayStatusResponse)
	err := grpc.Invoke(ctx, "/router.RouterManager/GatewayStatus", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

// Server API for RouterManager service

type RouterManagerServer interface {
	// Gateway owner or network operator requests Gateway status from Router Manager
	// Deprecated: Use monitor API (NOC) instead of this
	GatewayStatus(context.Context, *GatewayStatusRequest) (*GatewayStatusResponse, error)
	// Network operator requests Router status
	GetStatus(context.Context, *StatusRequest) (*Status, error)
}

func RegisterRouterManagerServer(s *grpc.Server, srv RouterManagerServer) {
	s.RegisterService(&_RouterManager_serviceDesc, srv)
}

func _RouterManager_GatewayStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GatewayStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RouterManagerServer).GatewayStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/router.RouterManager/GatewayStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RouterManagerServer).GatewayStatus(ctx, req.(*GatewayStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RouterManager_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.(RouterManagerServer).GetStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/router.RouterManager/GetStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RouterManagerServer).GetStatus(ctx, req.(*StatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _RouterManager_serviceDesc = grpc.ServiceDesc{
	ServiceName: "router.RouterManager",
	HandlerType: (*RouterManagerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GatewayStatus",
			Handler:    _RouterManager_GatewayStatus_Handler,
		},
		{
			MethodName: "GetStatus",
			Handler:    _RouterManager_GetStatus_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "github.com/TheThingsNetwork/ttn/api/router/router.proto",
}

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

func (m *SubscribeRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

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

func (m *UplinkMessage) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Payload) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintRouter(dAtA, i, uint64(len(m.Payload)))
		i += copy(dAtA[i:], m.Payload)
	}
	if m.Message != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintRouter(dAtA, i, uint64(m.Message.Size()))
		n1, err := m.Message.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if m.ProtocolMetadata != nil {
		dAtA[i] = 0x5a
		i++
		i = encodeVarintRouter(dAtA, i, uint64(m.ProtocolMetadata.Size()))
		n2, err := m.ProtocolMetadata.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.GatewayMetadata != nil {
		dAtA[i] = 0x62
		i++
		i = encodeVarintRouter(dAtA, i, uint64(m.GatewayMetadata.Size()))
		n3, err := m.GatewayMetadata.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.Trace != nil {
		dAtA[i] = 0xaa
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintRouter(dAtA, i, uint64(m.Trace.Size()))
		n4, err := m.Trace.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	return i, nil
}

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

func (m *DownlinkMessage) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Payload) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintRouter(dAtA, i, uint64(len(m.Payload)))
		i += copy(dAtA[i:], m.Payload)
	}
	if m.Message != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintRouter(dAtA, i, uint64(m.Message.Size()))
		n5, err := m.Message.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	if m.ProtocolConfiguration != nil {
		dAtA[i] = 0x5a
		i++
		i = encodeVarintRouter(dAtA, i, uint64(m.ProtocolConfiguration.Size()))
		n6, err := m.ProtocolConfiguration.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	if m.GatewayConfiguration != nil {
		dAtA[i] = 0x62
		i++
		i = encodeVarintRouter(dAtA, i, uint64(m.GatewayConfiguration.Size()))
		n7, err := m.GatewayConfiguration.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	if m.Trace != nil {
		dAtA[i] = 0xaa
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintRouter(dAtA, i, uint64(m.Trace.Size()))
		n8, err := m.Trace.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	return i, nil
}

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

func (m *DeviceActivationRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Payload) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintRouter(dAtA, i, uint64(len(m.Payload)))
		i += copy(dAtA[i:], m.Payload)
	}
	if m.Message != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintRouter(dAtA, i, uint64(m.Message.Size()))
		n9, err := m.Message.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n9
	}
	if m.DevEui != nil {
		dAtA[i] = 0x5a
		i++
		i = encodeVarintRouter(dAtA, i, uint64(m.DevEui.Size()))
		n10, err := m.DevEui.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n10
	}
	if m.AppEui != nil {
		dAtA[i] = 0x62
		i++
		i = encodeVarintRouter(dAtA, i, uint64(m.AppEui.Size()))
		n11, err := m.AppEui.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n11
	}
	if m.ProtocolMetadata != nil {
		dAtA[i] = 0xaa
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintRouter(dAtA, i, uint64(m.ProtocolMetadata.Size()))
		n12, err := m.ProtocolMetadata.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n12
	}
	if m.GatewayMetadata != nil {
		dAtA[i] = 0xb2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintRouter(dAtA, i, uint64(m.GatewayMetadata.Size()))
		n13, err := m.GatewayMetadata.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n13
	}
	if m.ActivationMetadata != nil {
		dAtA[i] = 0xba
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintRouter(dAtA, i, uint64(m.ActivationMetadata.Size()))
		n14, err := m.ActivationMetadata.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n14
	}
	if m.Trace != nil {
		dAtA[i] = 0xfa
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintRouter(dAtA, i, uint64(m.Trace.Size()))
		n15, err := m.Trace.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n15
	}
	return i, nil
}

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

func (m *DeviceActivationResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

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

func (m *GatewayStatusRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.GatewayId) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintRouter(dAtA, i, uint64(len(m.GatewayId)))
		i += copy(dAtA[i:], m.GatewayId)
	}
	return i, nil
}

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

func (m *GatewayStatusResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.LastSeen != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintRouter(dAtA, i, uint64(m.LastSeen))
	}
	if m.Status != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintRouter(dAtA, i, uint64(m.Status.Size()))
		n16, err := m.Status.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n16
	}
	return i, nil
}

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

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

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

func (m *Status) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.System != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintRouter(dAtA, i, uint64(m.System.Size()))
		n17, err := m.System.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n17
	}
	if m.Component != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintRouter(dAtA, i, uint64(m.Component.Size()))
		n18, err := m.Component.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n18
	}
	if m.GatewayStatus != nil {
		dAtA[i] = 0x5a
		i++
		i = encodeVarintRouter(dAtA, i, uint64(m.GatewayStatus.Size()))
		n19, err := m.GatewayStatus.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n19
	}
	if m.Uplink != nil {
		dAtA[i] = 0x62
		i++
		i = encodeVarintRouter(dAtA, i, uint64(m.Uplink.Size()))
		n20, err := m.Uplink.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n20
	}
	if m.Downlink != nil {
		dAtA[i] = 0x6a
		i++
		i = encodeVarintRouter(dAtA, i, uint64(m.Downlink.Size()))
		n21, err := m.Downlink.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n21
	}
	if m.Activations != nil {
		dAtA[i] = 0x72
		i++
		i = encodeVarintRouter(dAtA, i, uint64(m.Activations.Size()))
		n22, err := m.Activations.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n22
	}
	if m.ConnectedGateways != 0 {
		dAtA[i] = 0xa8
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintRouter(dAtA, i, uint64(m.ConnectedGateways))
	}
	if m.ConnectedBrokers != 0 {
		dAtA[i] = 0xb0
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintRouter(dAtA, i, uint64(m.ConnectedBrokers))
	}
	return i, nil
}

func encodeFixed64Router(dAtA []byte, offset int, v uint64) int {
	dAtA[offset] = uint8(v)
	dAtA[offset+1] = uint8(v >> 8)
	dAtA[offset+2] = uint8(v >> 16)
	dAtA[offset+3] = uint8(v >> 24)
	dAtA[offset+4] = uint8(v >> 32)
	dAtA[offset+5] = uint8(v >> 40)
	dAtA[offset+6] = uint8(v >> 48)
	dAtA[offset+7] = uint8(v >> 56)
	return offset + 8
}
func encodeFixed32Router(dAtA []byte, offset int, v uint32) int {
	dAtA[offset] = uint8(v)
	dAtA[offset+1] = uint8(v >> 8)
	dAtA[offset+2] = uint8(v >> 16)
	dAtA[offset+3] = uint8(v >> 24)
	return offset + 4
}
func encodeVarintRouter(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *SubscribeRequest) Size() (n int) {
	var l int
	_ = l
	return n
}

func (m *UplinkMessage) Size() (n int) {
	var l int
	_ = l
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovRouter(uint64(l))
	}
	if m.Message != nil {
		l = m.Message.Size()
		n += 1 + l + sovRouter(uint64(l))
	}
	if m.ProtocolMetadata != nil {
		l = m.ProtocolMetadata.Size()
		n += 1 + l + sovRouter(uint64(l))
	}
	if m.GatewayMetadata != nil {
		l = m.GatewayMetadata.Size()
		n += 1 + l + sovRouter(uint64(l))
	}
	if m.Trace != nil {
		l = m.Trace.Size()
		n += 2 + l + sovRouter(uint64(l))
	}
	return n
}

func (m *DownlinkMessage) Size() (n int) {
	var l int
	_ = l
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovRouter(uint64(l))
	}
	if m.Message != nil {
		l = m.Message.Size()
		n += 1 + l + sovRouter(uint64(l))
	}
	if m.ProtocolConfiguration != nil {
		l = m.ProtocolConfiguration.Size()
		n += 1 + l + sovRouter(uint64(l))
	}
	if m.GatewayConfiguration != nil {
		l = m.GatewayConfiguration.Size()
		n += 1 + l + sovRouter(uint64(l))
	}
	if m.Trace != nil {
		l = m.Trace.Size()
		n += 2 + l + sovRouter(uint64(l))
	}
	return n
}

func (m *DeviceActivationRequest) Size() (n int) {
	var l int
	_ = l
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovRouter(uint64(l))
	}
	if m.Message != nil {
		l = m.Message.Size()
		n += 1 + l + sovRouter(uint64(l))
	}
	if m.DevEui != nil {
		l = m.DevEui.Size()
		n += 1 + l + sovRouter(uint64(l))
	}
	if m.AppEui != nil {
		l = m.AppEui.Size()
		n += 1 + l + sovRouter(uint64(l))
	}
	if m.ProtocolMetadata != nil {
		l = m.ProtocolMetadata.Size()
		n += 2 + l + sovRouter(uint64(l))
	}
	if m.GatewayMetadata != nil {
		l = m.GatewayMetadata.Size()
		n += 2 + l + sovRouter(uint64(l))
	}
	if m.ActivationMetadata != nil {
		l = m.ActivationMetadata.Size()
		n += 2 + l + sovRouter(uint64(l))
	}
	if m.Trace != nil {
		l = m.Trace.Size()
		n += 2 + l + sovRouter(uint64(l))
	}
	return n
}

func (m *DeviceActivationResponse) Size() (n int) {
	var l int
	_ = l
	return n
}

func (m *GatewayStatusRequest) Size() (n int) {
	var l int
	_ = l
	l = len(m.GatewayId)
	if l > 0 {
		n += 1 + l + sovRouter(uint64(l))
	}
	return n
}

func (m *GatewayStatusResponse) Size() (n int) {
	var l int
	_ = l
	if m.LastSeen != 0 {
		n += 1 + sovRouter(uint64(m.LastSeen))
	}
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovRouter(uint64(l))
	}
	return n
}

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

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

func sovRouter(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozRouter(x uint64) (n int) {
	return sovRouter(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *SubscribeRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SubscribeRequest{`,
		`}`,
	}, "")
	return s
}
func (this *UplinkMessage) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&UplinkMessage{`,
		`Payload:` + fmt.Sprintf("%v", this.Payload) + `,`,
		`Message:` + strings.Replace(fmt.Sprintf("%v", this.Message), "Message", "protocol.Message", 1) + `,`,
		`ProtocolMetadata:` + strings.Replace(fmt.Sprintf("%v", this.ProtocolMetadata), "RxMetadata", "protocol.RxMetadata", 1) + `,`,
		`GatewayMetadata:` + strings.Replace(fmt.Sprintf("%v", this.GatewayMetadata), "RxMetadata", "gateway.RxMetadata", 1) + `,`,
		`Trace:` + strings.Replace(fmt.Sprintf("%v", this.Trace), "Trace", "trace.Trace", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DownlinkMessage) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DownlinkMessage{`,
		`Payload:` + fmt.Sprintf("%v", this.Payload) + `,`,
		`Message:` + strings.Replace(fmt.Sprintf("%v", this.Message), "Message", "protocol.Message", 1) + `,`,
		`ProtocolConfiguration:` + strings.Replace(fmt.Sprintf("%v", this.ProtocolConfiguration), "TxConfiguration", "protocol.TxConfiguration", 1) + `,`,
		`GatewayConfiguration:` + strings.Replace(fmt.Sprintf("%v", this.GatewayConfiguration), "TxConfiguration", "gateway.TxConfiguration", 1) + `,`,
		`Trace:` + strings.Replace(fmt.Sprintf("%v", this.Trace), "Trace", "trace.Trace", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeviceActivationRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeviceActivationRequest{`,
		`Payload:` + fmt.Sprintf("%v", this.Payload) + `,`,
		`Message:` + strings.Replace(fmt.Sprintf("%v", this.Message), "Message", "protocol.Message", 1) + `,`,
		`DevEui:` + fmt.Sprintf("%v", this.DevEui) + `,`,
		`AppEui:` + fmt.Sprintf("%v", this.AppEui) + `,`,
		`ProtocolMetadata:` + strings.Replace(fmt.Sprintf("%v", this.ProtocolMetadata), "RxMetadata", "protocol.RxMetadata", 1) + `,`,
		`GatewayMetadata:` + strings.Replace(fmt.Sprintf("%v", this.GatewayMetadata), "RxMetadata", "gateway.RxMetadata", 1) + `,`,
		`ActivationMetadata:` + strings.Replace(fmt.Sprintf("%v", this.ActivationMetadata), "ActivationMetadata", "protocol.ActivationMetadata", 1) + `,`,
		`Trace:` + strings.Replace(fmt.Sprintf("%v", this.Trace), "Trace", "trace.Trace", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeviceActivationResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeviceActivationResponse{`,
		`}`,
	}, "")
	return s
}
func (this *GatewayStatusRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GatewayStatusRequest{`,
		`GatewayId:` + fmt.Sprintf("%v", this.GatewayId) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GatewayStatusResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GatewayStatusResponse{`,
		`LastSeen:` + fmt.Sprintf("%v", this.LastSeen) + `,`,
		`Status:` + strings.Replace(fmt.Sprintf("%v", this.Status), "Status", "gateway.Status", 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(fmt.Sprintf("%v", this.System), "SystemStats", "api.SystemStats", 1) + `,`,
		`Component:` + strings.Replace(fmt.Sprintf("%v", this.Component), "ComponentStats", "api.ComponentStats", 1) + `,`,
		`GatewayStatus:` + strings.Replace(fmt.Sprintf("%v", this.GatewayStatus), "Rates", "api.Rates", 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) + `,`,
		`ConnectedGateways:` + fmt.Sprintf("%v", this.ConnectedGateways) + `,`,
		`ConnectedBrokers:` + fmt.Sprintf("%v", this.ConnectedBrokers) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringRouter(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *SubscribeRequest) 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 ErrIntOverflowRouter
			}
			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: SubscribeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SubscribeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipRouter(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRouter
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UplinkMessage) 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 ErrIntOverflowRouter
			}
			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: UplinkMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UplinkMessage: 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 ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRouter
			}
			postIndex := iNdEx + byteLen
			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 ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRouter
			}
			postIndex := iNdEx + msglen
			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 ProtocolMetadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRouter
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProtocolMetadata == nil {
				m.ProtocolMetadata = &protocol.RxMetadata{}
			}
			if err := m.ProtocolMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GatewayMetadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRouter
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GatewayMetadata == nil {
				m.GatewayMetadata = &gateway.RxMetadata{}
			}
			if err := m.GatewayMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 21:
			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 ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRouter
			}
			postIndex := iNdEx + msglen
			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 := skipRouter(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRouter
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DownlinkMessage) 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 ErrIntOverflowRouter
			}
			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: DownlinkMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DownlinkMessage: 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 ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRouter
			}
			postIndex := iNdEx + byteLen
			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 ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRouter
			}
			postIndex := iNdEx + msglen
			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 ProtocolConfiguration", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRouter
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProtocolConfiguration == nil {
				m.ProtocolConfiguration = &protocol.TxConfiguration{}
			}
			if err := m.ProtocolConfiguration.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GatewayConfiguration", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRouter
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GatewayConfiguration == nil {
				m.GatewayConfiguration = &gateway.TxConfiguration{}
			}
			if err := m.GatewayConfiguration.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 21:
			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 ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRouter
			}
			postIndex := iNdEx + msglen
			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 := skipRouter(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRouter
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeviceActivationRequest) 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 ErrIntOverflowRouter
			}
			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: DeviceActivationRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeviceActivationRequest: 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 ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRouter
			}
			postIndex := iNdEx + byteLen
			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 ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRouter
			}
			postIndex := iNdEx + msglen
			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 DevEui", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRouter
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_TheThingsNetwork_ttn_core_types.DevEUI
			m.DevEui = &v
			if err := m.DevEui.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppEui", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRouter
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_TheThingsNetwork_ttn_core_types.AppEUI
			m.AppEui = &v
			if err := m.AppEui.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProtocolMetadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRouter
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProtocolMetadata == nil {
				m.ProtocolMetadata = &protocol.RxMetadata{}
			}
			if err := m.ProtocolMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GatewayMetadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRouter
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GatewayMetadata == nil {
				m.GatewayMetadata = &gateway.RxMetadata{}
			}
			if err := m.GatewayMetadata.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 ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRouter
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ActivationMetadata == nil {
				m.ActivationMetadata = &protocol.ActivationMetadata{}
			}
			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 ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRouter
			}
			postIndex := iNdEx + msglen
			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 := skipRouter(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRouter
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
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 ErrIntOverflowRouter
			}
			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 {
		default:
			iNdEx = preIndex
			skippy, err := skipRouter(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRouter
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GatewayStatusResponse) 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 ErrIntOverflowRouter
			}
			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: GatewayStatusResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GatewayStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastSeen", wireType)
			}
			m.LastSeen = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastSeen |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRouter
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &gateway.Status{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRouter(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRouter
			}
			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 ErrIntOverflowRouter
			}
			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 := skipRouter(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRouter
			}
			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 ErrIntOverflowRouter
			}
			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 ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRouter
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.System == nil {
				m.System = &api.SystemStats{}
			}
			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 ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRouter
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Component == nil {
				m.Component = &api.ComponentStats{}
			}
			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 GatewayStatus", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRouter
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GatewayStatus == nil {
				m.GatewayStatus = &api.Rates{}
			}
			if err := m.GatewayStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			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 ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRouter
			}
			postIndex := iNdEx + msglen
			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 13:
			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 ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRouter
			}
			postIndex := iNdEx + msglen
			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 14:
			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 ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRouter
			}
			postIndex := iNdEx + msglen
			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
		case 21:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConnectedGateways", wireType)
			}
			m.ConnectedGateways = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ConnectedGateways |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 22:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConnectedBrokers", wireType)
			}
			m.ConnectedBrokers = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ConnectedBrokers |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRouter(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRouter
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipRouter(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowRouter
			}
			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, ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowRouter
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthRouter
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowRouter
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipRouter(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthRouter = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowRouter   = fmt.Errorf("proto: integer overflow")
)

func init() {
	proto.RegisterFile("github.com/TheThingsNetwork/ttn/api/router/router.proto", fileDescriptorRouter)
}

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