// Code generated by protoc-gen-go. DO NOT EDIT.
// source: as/external/api/debug.proto

package api

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
	math "math"
)

// 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.ProtoPackageIsVersion3 // please upgrade the proto package

type GetVPNRequest struct {
	Mode                 string   `protobuf:"bytes,1,opt,name=mode,proto3" json:"mode,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetVPNRequest) Reset()         { *m = GetVPNRequest{} }
func (m *GetVPNRequest) String() string { return proto.CompactTextString(m) }
func (*GetVPNRequest) ProtoMessage()    {}
func (*GetVPNRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_7461c370b91be4e8, []int{0}
}

func (m *GetVPNRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetVPNRequest.Unmarshal(m, b)
}
func (m *GetVPNRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetVPNRequest.Marshal(b, m, deterministic)
}
func (m *GetVPNRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetVPNRequest.Merge(m, src)
}
func (m *GetVPNRequest) XXX_Size() int {
	return xxx_messageInfo_GetVPNRequest.Size(m)
}
func (m *GetVPNRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetVPNRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetVPNRequest proto.InternalMessageInfo

func (m *GetVPNRequest) GetMode() string {
	if m != nil {
		return m.Mode
	}
	return ""
}

type SetVPNRequest struct {
	Enable bool `protobuf:"varint,4,opt,name=enable,proto3" json:"enable,omitempty"`
	// Types that are valid to be assigned to Vpn:
	//
	//	*SetVPNRequest_Pptp
	//	*SetVPNRequest_L2Tp
	//	*SetVPNRequest_Ipsec
	Vpn                  isSetVPNRequest_Vpn `protobuf_oneof:"vpn"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *SetVPNRequest) Reset()         { *m = SetVPNRequest{} }
func (m *SetVPNRequest) String() string { return proto.CompactTextString(m) }
func (*SetVPNRequest) ProtoMessage()    {}
func (*SetVPNRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_7461c370b91be4e8, []int{1}
}

func (m *SetVPNRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SetVPNRequest.Unmarshal(m, b)
}
func (m *SetVPNRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SetVPNRequest.Marshal(b, m, deterministic)
}
func (m *SetVPNRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetVPNRequest.Merge(m, src)
}
func (m *SetVPNRequest) XXX_Size() int {
	return xxx_messageInfo_SetVPNRequest.Size(m)
}
func (m *SetVPNRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SetVPNRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SetVPNRequest proto.InternalMessageInfo

func (m *SetVPNRequest) GetEnable() bool {
	if m != nil {
		return m.Enable
	}
	return false
}

type isSetVPNRequest_Vpn interface {
	isSetVPNRequest_Vpn()
}

type SetVPNRequest_Pptp struct {
	Pptp *VPN_PPTP `protobuf:"bytes,1,opt,name=pptp,json=PPTP,proto3,oneof"`
}

type SetVPNRequest_L2Tp struct {
	L2Tp *VPN_L2TP `protobuf:"bytes,2,opt,name=l2tp,json=L2TP,proto3,oneof"`
}

type SetVPNRequest_Ipsec struct {
	Ipsec *VPN_IPSec `protobuf:"bytes,3,opt,name=ipsec,json=IPSec,proto3,oneof"`
}

func (*SetVPNRequest_Pptp) isSetVPNRequest_Vpn() {}

func (*SetVPNRequest_L2Tp) isSetVPNRequest_Vpn() {}

func (*SetVPNRequest_Ipsec) isSetVPNRequest_Vpn() {}

func (m *SetVPNRequest) GetVpn() isSetVPNRequest_Vpn {
	if m != nil {
		return m.Vpn
	}
	return nil
}

func (m *SetVPNRequest) GetPptp() *VPN_PPTP {
	if x, ok := m.GetVpn().(*SetVPNRequest_Pptp); ok {
		return x.Pptp
	}
	return nil
}

func (m *SetVPNRequest) GetL2Tp() *VPN_L2TP {
	if x, ok := m.GetVpn().(*SetVPNRequest_L2Tp); ok {
		return x.L2Tp
	}
	return nil
}

func (m *SetVPNRequest) GetIpsec() *VPN_IPSec {
	if x, ok := m.GetVpn().(*SetVPNRequest_Ipsec); ok {
		return x.Ipsec
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*SetVPNRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*SetVPNRequest_Pptp)(nil),
		(*SetVPNRequest_L2Tp)(nil),
		(*SetVPNRequest_Ipsec)(nil),
	}
}

type GetVPNResponse struct {
	// oneof vpn{
	Pptp                 *VPN_PPTP  `protobuf:"bytes,1,opt,name=pptp,json=PPTP,proto3" json:"pptp,omitempty"`
	L2Tp                 *VPN_L2TP  `protobuf:"bytes,2,opt,name=l2tp,json=L2TP,proto3" json:"l2tp,omitempty"`
	Ipsec                *VPN_IPSec `protobuf:"bytes,3,opt,name=ipsec,json=IPSec,proto3" json:"ipsec,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *GetVPNResponse) Reset()         { *m = GetVPNResponse{} }
func (m *GetVPNResponse) String() string { return proto.CompactTextString(m) }
func (*GetVPNResponse) ProtoMessage()    {}
func (*GetVPNResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_7461c370b91be4e8, []int{2}
}

func (m *GetVPNResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetVPNResponse.Unmarshal(m, b)
}
func (m *GetVPNResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetVPNResponse.Marshal(b, m, deterministic)
}
func (m *GetVPNResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetVPNResponse.Merge(m, src)
}
func (m *GetVPNResponse) XXX_Size() int {
	return xxx_messageInfo_GetVPNResponse.Size(m)
}
func (m *GetVPNResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetVPNResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetVPNResponse proto.InternalMessageInfo

func (m *GetVPNResponse) GetPptp() *VPN_PPTP {
	if m != nil {
		return m.Pptp
	}
	return nil
}

func (m *GetVPNResponse) GetL2Tp() *VPN_L2TP {
	if m != nil {
		return m.L2Tp
	}
	return nil
}

func (m *GetVPNResponse) GetIpsec() *VPN_IPSec {
	if m != nil {
		return m.Ipsec
	}
	return nil
}

type VPN_PPTP struct {
	Server               string   `protobuf:"bytes,2,opt,name=server,proto3" json:"server,omitempty"`
	User                 string   `protobuf:"bytes,3,opt,name=user,proto3" json:"user,omitempty"`
	Passwd               string   `protobuf:"bytes,4,opt,name=passwd,proto3" json:"passwd,omitempty"`
	Enable               bool     `protobuf:"varint,7,opt,name=enable,proto3" json:"enable,omitempty"`
	Status               string   `protobuf:"bytes,8,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *VPN_PPTP) Reset()         { *m = VPN_PPTP{} }
func (m *VPN_PPTP) String() string { return proto.CompactTextString(m) }
func (*VPN_PPTP) ProtoMessage()    {}
func (*VPN_PPTP) Descriptor() ([]byte, []int) {
	return fileDescriptor_7461c370b91be4e8, []int{3}
}

func (m *VPN_PPTP) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_VPN_PPTP.Unmarshal(m, b)
}
func (m *VPN_PPTP) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_VPN_PPTP.Marshal(b, m, deterministic)
}
func (m *VPN_PPTP) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VPN_PPTP.Merge(m, src)
}
func (m *VPN_PPTP) XXX_Size() int {
	return xxx_messageInfo_VPN_PPTP.Size(m)
}
func (m *VPN_PPTP) XXX_DiscardUnknown() {
	xxx_messageInfo_VPN_PPTP.DiscardUnknown(m)
}

var xxx_messageInfo_VPN_PPTP proto.InternalMessageInfo

func (m *VPN_PPTP) GetServer() string {
	if m != nil {
		return m.Server
	}
	return ""
}

func (m *VPN_PPTP) GetUser() string {
	if m != nil {
		return m.User
	}
	return ""
}

func (m *VPN_PPTP) GetPasswd() string {
	if m != nil {
		return m.Passwd
	}
	return ""
}

func (m *VPN_PPTP) GetEnable() bool {
	if m != nil {
		return m.Enable
	}
	return false
}

func (m *VPN_PPTP) GetStatus() string {
	if m != nil {
		return m.Status
	}
	return ""
}

type VPN_L2TP struct {
	Server               string   `protobuf:"bytes,2,opt,name=server,proto3" json:"server,omitempty"`
	User                 string   `protobuf:"bytes,3,opt,name=user,proto3" json:"user,omitempty"`
	Passwd               string   `protobuf:"bytes,4,opt,name=passwd,proto3" json:"passwd,omitempty"`
	Psk                  string   `protobuf:"bytes,5,opt,name=psk,proto3" json:"psk,omitempty"`
	Enable               bool     `protobuf:"varint,7,opt,name=enable,proto3" json:"enable,omitempty"`
	Status               string   `protobuf:"bytes,8,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *VPN_L2TP) Reset()         { *m = VPN_L2TP{} }
func (m *VPN_L2TP) String() string { return proto.CompactTextString(m) }
func (*VPN_L2TP) ProtoMessage()    {}
func (*VPN_L2TP) Descriptor() ([]byte, []int) {
	return fileDescriptor_7461c370b91be4e8, []int{4}
}

func (m *VPN_L2TP) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_VPN_L2TP.Unmarshal(m, b)
}
func (m *VPN_L2TP) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_VPN_L2TP.Marshal(b, m, deterministic)
}
func (m *VPN_L2TP) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VPN_L2TP.Merge(m, src)
}
func (m *VPN_L2TP) XXX_Size() int {
	return xxx_messageInfo_VPN_L2TP.Size(m)
}
func (m *VPN_L2TP) XXX_DiscardUnknown() {
	xxx_messageInfo_VPN_L2TP.DiscardUnknown(m)
}

var xxx_messageInfo_VPN_L2TP proto.InternalMessageInfo

func (m *VPN_L2TP) GetServer() string {
	if m != nil {
		return m.Server
	}
	return ""
}

func (m *VPN_L2TP) GetUser() string {
	if m != nil {
		return m.User
	}
	return ""
}

func (m *VPN_L2TP) GetPasswd() string {
	if m != nil {
		return m.Passwd
	}
	return ""
}

func (m *VPN_L2TP) GetPsk() string {
	if m != nil {
		return m.Psk
	}
	return ""
}

func (m *VPN_L2TP) GetEnable() bool {
	if m != nil {
		return m.Enable
	}
	return false
}

func (m *VPN_L2TP) GetStatus() string {
	if m != nil {
		return m.Status
	}
	return ""
}

type VPN_IPSec struct {
	PeerAddress          string   `protobuf:"bytes,2,opt,name=peerAddress,proto3" json:"peerAddress,omitempty"`
	LocalSubnet          string   `protobuf:"bytes,3,opt,name=localSubnet,proto3" json:"localSubnet,omitempty"`
	RemoteSubnet         string   `protobuf:"bytes,4,opt,name=remoteSubnet,proto3" json:"remoteSubnet,omitempty"`
	Psk                  string   `protobuf:"bytes,5,opt,name=psk,proto3" json:"psk,omitempty"`
	Enable               bool     `protobuf:"varint,7,opt,name=enable,proto3" json:"enable,omitempty"`
	Status               string   `protobuf:"bytes,8,opt,name=status,proto3" json:"status,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *VPN_IPSec) Reset()         { *m = VPN_IPSec{} }
func (m *VPN_IPSec) String() string { return proto.CompactTextString(m) }
func (*VPN_IPSec) ProtoMessage()    {}
func (*VPN_IPSec) Descriptor() ([]byte, []int) {
	return fileDescriptor_7461c370b91be4e8, []int{5}
}

func (m *VPN_IPSec) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_VPN_IPSec.Unmarshal(m, b)
}
func (m *VPN_IPSec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_VPN_IPSec.Marshal(b, m, deterministic)
}
func (m *VPN_IPSec) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VPN_IPSec.Merge(m, src)
}
func (m *VPN_IPSec) XXX_Size() int {
	return xxx_messageInfo_VPN_IPSec.Size(m)
}
func (m *VPN_IPSec) XXX_DiscardUnknown() {
	xxx_messageInfo_VPN_IPSec.DiscardUnknown(m)
}

var xxx_messageInfo_VPN_IPSec proto.InternalMessageInfo

func (m *VPN_IPSec) GetPeerAddress() string {
	if m != nil {
		return m.PeerAddress
	}
	return ""
}

func (m *VPN_IPSec) GetLocalSubnet() string {
	if m != nil {
		return m.LocalSubnet
	}
	return ""
}

func (m *VPN_IPSec) GetRemoteSubnet() string {
	if m != nil {
		return m.RemoteSubnet
	}
	return ""
}

func (m *VPN_IPSec) GetPsk() string {
	if m != nil {
		return m.Psk
	}
	return ""
}

func (m *VPN_IPSec) GetEnable() bool {
	if m != nil {
		return m.Enable
	}
	return false
}

func (m *VPN_IPSec) GetStatus() string {
	if m != nil {
		return m.Status
	}
	return ""
}

type SetLogsRequest struct {
	LogLevel             string   `protobuf:"bytes,1,opt,name=logLevel,proto3" json:"logLevel,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SetLogsRequest) Reset()         { *m = SetLogsRequest{} }
func (m *SetLogsRequest) String() string { return proto.CompactTextString(m) }
func (*SetLogsRequest) ProtoMessage()    {}
func (*SetLogsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_7461c370b91be4e8, []int{6}
}

func (m *SetLogsRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SetLogsRequest.Unmarshal(m, b)
}
func (m *SetLogsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SetLogsRequest.Marshal(b, m, deterministic)
}
func (m *SetLogsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetLogsRequest.Merge(m, src)
}
func (m *SetLogsRequest) XXX_Size() int {
	return xxx_messageInfo_SetLogsRequest.Size(m)
}
func (m *SetLogsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SetLogsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SetLogsRequest proto.InternalMessageInfo

func (m *SetLogsRequest) GetLogLevel() string {
	if m != nil {
		return m.LogLevel
	}
	return ""
}

type GetLorawanTxResponse struct {
	Config               *LorawanTX `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *GetLorawanTxResponse) Reset()         { *m = GetLorawanTxResponse{} }
func (m *GetLorawanTxResponse) String() string { return proto.CompactTextString(m) }
func (*GetLorawanTxResponse) ProtoMessage()    {}
func (*GetLorawanTxResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_7461c370b91be4e8, []int{7}
}

func (m *GetLorawanTxResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetLorawanTxResponse.Unmarshal(m, b)
}
func (m *GetLorawanTxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetLorawanTxResponse.Marshal(b, m, deterministic)
}
func (m *GetLorawanTxResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetLorawanTxResponse.Merge(m, src)
}
func (m *GetLorawanTxResponse) XXX_Size() int {
	return xxx_messageInfo_GetLorawanTxResponse.Size(m)
}
func (m *GetLorawanTxResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetLorawanTxResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetLorawanTxResponse proto.InternalMessageInfo

func (m *GetLorawanTxResponse) GetConfig() *LorawanTX {
	if m != nil {
		return m.Config
	}
	return nil
}

type SetLorawanTxRequest struct {
	Disable              bool       `protobuf:"varint,2,opt,name=disable,proto3" json:"disable,omitempty"`
	Config               *LorawanTX `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *SetLorawanTxRequest) Reset()         { *m = SetLorawanTxRequest{} }
func (m *SetLorawanTxRequest) String() string { return proto.CompactTextString(m) }
func (*SetLorawanTxRequest) ProtoMessage()    {}
func (*SetLorawanTxRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_7461c370b91be4e8, []int{8}
}

func (m *SetLorawanTxRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SetLorawanTxRequest.Unmarshal(m, b)
}
func (m *SetLorawanTxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SetLorawanTxRequest.Marshal(b, m, deterministic)
}
func (m *SetLorawanTxRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetLorawanTxRequest.Merge(m, src)
}
func (m *SetLorawanTxRequest) XXX_Size() int {
	return xxx_messageInfo_SetLorawanTxRequest.Size(m)
}
func (m *SetLorawanTxRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SetLorawanTxRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SetLorawanTxRequest proto.InternalMessageInfo

func (m *SetLorawanTxRequest) GetDisable() bool {
	if m != nil {
		return m.Disable
	}
	return false
}

func (m *SetLorawanTxRequest) GetConfig() *LorawanTX {
	if m != nil {
		return m.Config
	}
	return nil
}

type GetLorawanRxResponse struct {
	Freq                 int64    `protobuf:"varint,1,opt,name=freq,proto3" json:"freq,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetLorawanRxResponse) Reset()         { *m = GetLorawanRxResponse{} }
func (m *GetLorawanRxResponse) String() string { return proto.CompactTextString(m) }
func (*GetLorawanRxResponse) ProtoMessage()    {}
func (*GetLorawanRxResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_7461c370b91be4e8, []int{9}
}

func (m *GetLorawanRxResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetLorawanRxResponse.Unmarshal(m, b)
}
func (m *GetLorawanRxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetLorawanRxResponse.Marshal(b, m, deterministic)
}
func (m *GetLorawanRxResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetLorawanRxResponse.Merge(m, src)
}
func (m *GetLorawanRxResponse) XXX_Size() int {
	return xxx_messageInfo_GetLorawanRxResponse.Size(m)
}
func (m *GetLorawanRxResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetLorawanRxResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetLorawanRxResponse proto.InternalMessageInfo

func (m *GetLorawanRxResponse) GetFreq() int64 {
	if m != nil {
		return m.Freq
	}
	return 0
}

type LorawanTX struct {
	Freq                 int64    `protobuf:"varint,1,opt,name=freq,proto3" json:"freq,omitempty"`
	Sf                   int32    `protobuf:"varint,2,opt,name=sf,proto3" json:"sf,omitempty"`
	Bw                   int64    `protobuf:"varint,3,opt,name=bw,proto3" json:"bw,omitempty"`
	Txpower              int32    `protobuf:"varint,4,opt,name=txpower,proto3" json:"txpower,omitempty"`
	PacketNum            int64    `protobuf:"varint,5,opt,name=packetNum,proto3" json:"packetNum,omitempty"`
	PacketLen            int64    `protobuf:"varint,6,opt,name=packetLen,proto3" json:"packetLen,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LorawanTX) Reset()         { *m = LorawanTX{} }
func (m *LorawanTX) String() string { return proto.CompactTextString(m) }
func (*LorawanTX) ProtoMessage()    {}
func (*LorawanTX) Descriptor() ([]byte, []int) {
	return fileDescriptor_7461c370b91be4e8, []int{10}
}

func (m *LorawanTX) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LorawanTX.Unmarshal(m, b)
}
func (m *LorawanTX) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LorawanTX.Marshal(b, m, deterministic)
}
func (m *LorawanTX) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LorawanTX.Merge(m, src)
}
func (m *LorawanTX) XXX_Size() int {
	return xxx_messageInfo_LorawanTX.Size(m)
}
func (m *LorawanTX) XXX_DiscardUnknown() {
	xxx_messageInfo_LorawanTX.DiscardUnknown(m)
}

var xxx_messageInfo_LorawanTX proto.InternalMessageInfo

func (m *LorawanTX) GetFreq() int64 {
	if m != nil {
		return m.Freq
	}
	return 0
}

func (m *LorawanTX) GetSf() int32 {
	if m != nil {
		return m.Sf
	}
	return 0
}

func (m *LorawanTX) GetBw() int64 {
	if m != nil {
		return m.Bw
	}
	return 0
}

func (m *LorawanTX) GetTxpower() int32 {
	if m != nil {
		return m.Txpower
	}
	return 0
}

func (m *LorawanTX) GetPacketNum() int64 {
	if m != nil {
		return m.PacketNum
	}
	return 0
}

func (m *LorawanTX) GetPacketLen() int64 {
	if m != nil {
		return m.PacketLen
	}
	return 0
}

type LorawanRX struct {
	Freq                 int64    `protobuf:"varint,1,opt,name=freq,proto3" json:"freq,omitempty"`
	Sf                   int32    `protobuf:"varint,2,opt,name=sf,proto3" json:"sf,omitempty"`
	Bw                   int64    `protobuf:"varint,3,opt,name=bw,proto3" json:"bw,omitempty"`
	Txpower              int32    `protobuf:"varint,4,opt,name=txpower,proto3" json:"txpower,omitempty"`
	PacketNum            int64    `protobuf:"varint,5,opt,name=packetNum,proto3" json:"packetNum,omitempty"`
	Snr                  float64  `protobuf:"fixed64,7,opt,name=snr,proto3" json:"snr,omitempty"`
	Rssi                 int32    `protobuf:"varint,8,opt,name=rssi,proto3" json:"rssi,omitempty"`
	Lostrate             float32  `protobuf:"fixed32,9,opt,name=lostrate,proto3" json:"lostrate,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *LorawanRX) Reset()         { *m = LorawanRX{} }
func (m *LorawanRX) String() string { return proto.CompactTextString(m) }
func (*LorawanRX) ProtoMessage()    {}
func (*LorawanRX) Descriptor() ([]byte, []int) {
	return fileDescriptor_7461c370b91be4e8, []int{11}
}

func (m *LorawanRX) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_LorawanRX.Unmarshal(m, b)
}
func (m *LorawanRX) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_LorawanRX.Marshal(b, m, deterministic)
}
func (m *LorawanRX) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LorawanRX.Merge(m, src)
}
func (m *LorawanRX) XXX_Size() int {
	return xxx_messageInfo_LorawanRX.Size(m)
}
func (m *LorawanRX) XXX_DiscardUnknown() {
	xxx_messageInfo_LorawanRX.DiscardUnknown(m)
}

var xxx_messageInfo_LorawanRX proto.InternalMessageInfo

func (m *LorawanRX) GetFreq() int64 {
	if m != nil {
		return m.Freq
	}
	return 0
}

func (m *LorawanRX) GetSf() int32 {
	if m != nil {
		return m.Sf
	}
	return 0
}

func (m *LorawanRX) GetBw() int64 {
	if m != nil {
		return m.Bw
	}
	return 0
}

func (m *LorawanRX) GetTxpower() int32 {
	if m != nil {
		return m.Txpower
	}
	return 0
}

func (m *LorawanRX) GetPacketNum() int64 {
	if m != nil {
		return m.PacketNum
	}
	return 0
}

func (m *LorawanRX) GetSnr() float64 {
	if m != nil {
		return m.Snr
	}
	return 0
}

func (m *LorawanRX) GetRssi() int32 {
	if m != nil {
		return m.Rssi
	}
	return 0
}

func (m *LorawanRX) GetLostrate() float32 {
	if m != nil {
		return m.Lostrate
	}
	return 0
}

type StreamLorawanRxRequest struct {
	Freq                 int64    `protobuf:"varint,1,opt,name=freq,proto3" json:"freq,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StreamLorawanRxRequest) Reset()         { *m = StreamLorawanRxRequest{} }
func (m *StreamLorawanRxRequest) String() string { return proto.CompactTextString(m) }
func (*StreamLorawanRxRequest) ProtoMessage()    {}
func (*StreamLorawanRxRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_7461c370b91be4e8, []int{12}
}

func (m *StreamLorawanRxRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamLorawanRxRequest.Unmarshal(m, b)
}
func (m *StreamLorawanRxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamLorawanRxRequest.Marshal(b, m, deterministic)
}
func (m *StreamLorawanRxRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamLorawanRxRequest.Merge(m, src)
}
func (m *StreamLorawanRxRequest) XXX_Size() int {
	return xxx_messageInfo_StreamLorawanRxRequest.Size(m)
}
func (m *StreamLorawanRxRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamLorawanRxRequest.DiscardUnknown(m)
}

var xxx_messageInfo_StreamLorawanRxRequest proto.InternalMessageInfo

func (m *StreamLorawanRxRequest) GetFreq() int64 {
	if m != nil {
		return m.Freq
	}
	return 0
}

type StreamLorawanRxResponse struct {
	Freq                 int64    `protobuf:"varint,1,opt,name=freq,proto3" json:"freq,omitempty"`
	Sf                   int32    `protobuf:"varint,2,opt,name=sf,proto3" json:"sf,omitempty"`
	Bw                   int64    `protobuf:"varint,3,opt,name=bw,proto3" json:"bw,omitempty"`
	Txpower              int32    `protobuf:"varint,4,opt,name=txpower,proto3" json:"txpower,omitempty"`
	PacketNum            int64    `protobuf:"varint,5,opt,name=packetNum,proto3" json:"packetNum,omitempty"`
	Snr                  float64  `protobuf:"fixed64,7,opt,name=snr,proto3" json:"snr,omitempty"`
	Rssi                 int32    `protobuf:"varint,8,opt,name=rssi,proto3" json:"rssi,omitempty"`
	Lostrate             float64  `protobuf:"fixed64,9,opt,name=lostrate,proto3" json:"lostrate,omitempty"`
	Logs                 string   `protobuf:"bytes,10,opt,name=logs,proto3" json:"logs,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StreamLorawanRxResponse) Reset()         { *m = StreamLorawanRxResponse{} }
func (m *StreamLorawanRxResponse) String() string { return proto.CompactTextString(m) }
func (*StreamLorawanRxResponse) ProtoMessage()    {}
func (*StreamLorawanRxResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_7461c370b91be4e8, []int{13}
}

func (m *StreamLorawanRxResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamLorawanRxResponse.Unmarshal(m, b)
}
func (m *StreamLorawanRxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamLorawanRxResponse.Marshal(b, m, deterministic)
}
func (m *StreamLorawanRxResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamLorawanRxResponse.Merge(m, src)
}
func (m *StreamLorawanRxResponse) XXX_Size() int {
	return xxx_messageInfo_StreamLorawanRxResponse.Size(m)
}
func (m *StreamLorawanRxResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamLorawanRxResponse.DiscardUnknown(m)
}

var xxx_messageInfo_StreamLorawanRxResponse proto.InternalMessageInfo

func (m *StreamLorawanRxResponse) GetFreq() int64 {
	if m != nil {
		return m.Freq
	}
	return 0
}

func (m *StreamLorawanRxResponse) GetSf() int32 {
	if m != nil {
		return m.Sf
	}
	return 0
}

func (m *StreamLorawanRxResponse) GetBw() int64 {
	if m != nil {
		return m.Bw
	}
	return 0
}

func (m *StreamLorawanRxResponse) GetTxpower() int32 {
	if m != nil {
		return m.Txpower
	}
	return 0
}

func (m *StreamLorawanRxResponse) GetPacketNum() int64 {
	if m != nil {
		return m.PacketNum
	}
	return 0
}

func (m *StreamLorawanRxResponse) GetSnr() float64 {
	if m != nil {
		return m.Snr
	}
	return 0
}

func (m *StreamLorawanRxResponse) GetRssi() int32 {
	if m != nil {
		return m.Rssi
	}
	return 0
}

func (m *StreamLorawanRxResponse) GetLostrate() float64 {
	if m != nil {
		return m.Lostrate
	}
	return 0
}

func (m *StreamLorawanRxResponse) GetLogs() string {
	if m != nil {
		return m.Logs
	}
	return ""
}

type StreamLorawanTxResponse struct {
	PacketNum            int64    `protobuf:"varint,1,opt,name=packetNum,proto3" json:"packetNum,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StreamLorawanTxResponse) Reset()         { *m = StreamLorawanTxResponse{} }
func (m *StreamLorawanTxResponse) String() string { return proto.CompactTextString(m) }
func (*StreamLorawanTxResponse) ProtoMessage()    {}
func (*StreamLorawanTxResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_7461c370b91be4e8, []int{14}
}

func (m *StreamLorawanTxResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamLorawanTxResponse.Unmarshal(m, b)
}
func (m *StreamLorawanTxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamLorawanTxResponse.Marshal(b, m, deterministic)
}
func (m *StreamLorawanTxResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamLorawanTxResponse.Merge(m, src)
}
func (m *StreamLorawanTxResponse) XXX_Size() int {
	return xxx_messageInfo_StreamLorawanTxResponse.Size(m)
}
func (m *StreamLorawanTxResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamLorawanTxResponse.DiscardUnknown(m)
}

var xxx_messageInfo_StreamLorawanTxResponse proto.InternalMessageInfo

func (m *StreamLorawanTxResponse) GetPacketNum() int64 {
	if m != nil {
		return m.PacketNum
	}
	return 0
}

type StreamLogsResponse struct {
	LogLevel             string   `protobuf:"bytes,1,opt,name=logLevel,proto3" json:"logLevel,omitempty"`
	Logs                 string   `protobuf:"bytes,2,opt,name=logs,proto3" json:"logs,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StreamLogsResponse) Reset()         { *m = StreamLogsResponse{} }
func (m *StreamLogsResponse) String() string { return proto.CompactTextString(m) }
func (*StreamLogsResponse) ProtoMessage()    {}
func (*StreamLogsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_7461c370b91be4e8, []int{15}
}

func (m *StreamLogsResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_StreamLogsResponse.Unmarshal(m, b)
}
func (m *StreamLogsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_StreamLogsResponse.Marshal(b, m, deterministic)
}
func (m *StreamLogsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamLogsResponse.Merge(m, src)
}
func (m *StreamLogsResponse) XXX_Size() int {
	return xxx_messageInfo_StreamLogsResponse.Size(m)
}
func (m *StreamLogsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamLogsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_StreamLogsResponse proto.InternalMessageInfo

func (m *StreamLogsResponse) GetLogLevel() string {
	if m != nil {
		return m.LogLevel
	}
	return ""
}

func (m *StreamLogsResponse) GetLogs() string {
	if m != nil {
		return m.Logs
	}
	return ""
}

func init() {
	proto.RegisterType((*GetVPNRequest)(nil), "api.GetVPNRequest")
	proto.RegisterType((*SetVPNRequest)(nil), "api.SetVPNRequest")
	proto.RegisterType((*GetVPNResponse)(nil), "api.GetVPNResponse")
	proto.RegisterType((*VPN_PPTP)(nil), "api.VPN_PPTP")
	proto.RegisterType((*VPN_L2TP)(nil), "api.VPN_L2TP")
	proto.RegisterType((*VPN_IPSec)(nil), "api.VPN_IPSec")
	proto.RegisterType((*SetLogsRequest)(nil), "api.SetLogsRequest")
	proto.RegisterType((*GetLorawanTxResponse)(nil), "api.GetLorawanTxResponse")
	proto.RegisterType((*SetLorawanTxRequest)(nil), "api.SetLorawanTxRequest")
	proto.RegisterType((*GetLorawanRxResponse)(nil), "api.GetLorawanRxResponse")
	proto.RegisterType((*LorawanTX)(nil), "api.LorawanTX")
	proto.RegisterType((*LorawanRX)(nil), "api.LorawanRX")
	proto.RegisterType((*StreamLorawanRxRequest)(nil), "api.StreamLorawanRxRequest")
	proto.RegisterType((*StreamLorawanRxResponse)(nil), "api.StreamLorawanRxResponse")
	proto.RegisterType((*StreamLorawanTxResponse)(nil), "api.StreamLorawanTxResponse")
	proto.RegisterType((*StreamLogsResponse)(nil), "api.StreamLogsResponse")
}

func init() {
	proto.RegisterFile("as/external/api/debug.proto", fileDescriptor_7461c370b91be4e8)
}

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

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

// 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.SupportPackageIsVersion6

// DebugServiceClient is the client API for DebugService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type DebugServiceClient interface {
	GetLorawanTx(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GetLorawanTxResponse, error)
	SetLorawanTx(ctx context.Context, in *SetLorawanTxRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	StreamLorawanTx(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (DebugService_StreamLorawanTxClient, error)
	GetLorawanRx(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GetLorawanRxResponse, error)
	StreamLorawanRx(ctx context.Context, in *StreamLorawanRxRequest, opts ...grpc.CallOption) (DebugService_StreamLorawanRxClient, error)
	StreamLogs(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (DebugService_StreamLogsClient, error)
	SetLogs(ctx context.Context, in *SetLogsRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetVPN(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GetVPNResponse, error)
	SetVPN(ctx context.Context, in *SetVPNRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

type debugServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewDebugServiceClient(cc grpc.ClientConnInterface) DebugServiceClient {
	return &debugServiceClient{cc}
}

func (c *debugServiceClient) GetLorawanTx(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GetLorawanTxResponse, error) {
	out := new(GetLorawanTxResponse)
	err := c.cc.Invoke(ctx, "/api.DebugService/GetLorawanTx", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *debugServiceClient) SetLorawanTx(ctx context.Context, in *SetLorawanTxRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/api.DebugService/SetLorawanTx", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *debugServiceClient) StreamLorawanTx(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (DebugService_StreamLorawanTxClient, error) {
	stream, err := c.cc.NewStream(ctx, &_DebugService_serviceDesc.Streams[0], "/api.DebugService/StreamLorawanTx", opts...)
	if err != nil {
		return nil, err
	}
	x := &debugServiceStreamLorawanTxClient{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 DebugService_StreamLorawanTxClient interface {
	Recv() (*StreamLorawanTxResponse, error)
	grpc.ClientStream
}

type debugServiceStreamLorawanTxClient struct {
	grpc.ClientStream
}

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

func (c *debugServiceClient) GetLorawanRx(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GetLorawanRxResponse, error) {
	out := new(GetLorawanRxResponse)
	err := c.cc.Invoke(ctx, "/api.DebugService/GetLorawanRx", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *debugServiceClient) StreamLorawanRx(ctx context.Context, in *StreamLorawanRxRequest, opts ...grpc.CallOption) (DebugService_StreamLorawanRxClient, error) {
	stream, err := c.cc.NewStream(ctx, &_DebugService_serviceDesc.Streams[1], "/api.DebugService/StreamLorawanRx", opts...)
	if err != nil {
		return nil, err
	}
	x := &debugServiceStreamLorawanRxClient{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 DebugService_StreamLorawanRxClient interface {
	Recv() (*StreamLorawanRxResponse, error)
	grpc.ClientStream
}

type debugServiceStreamLorawanRxClient struct {
	grpc.ClientStream
}

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

func (c *debugServiceClient) StreamLogs(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (DebugService_StreamLogsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_DebugService_serviceDesc.Streams[2], "/api.DebugService/StreamLogs", opts...)
	if err != nil {
		return nil, err
	}
	x := &debugServiceStreamLogsClient{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 DebugService_StreamLogsClient interface {
	Recv() (*StreamLogsResponse, error)
	grpc.ClientStream
}

type debugServiceStreamLogsClient struct {
	grpc.ClientStream
}

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

func (c *debugServiceClient) SetLogs(ctx context.Context, in *SetLogsRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/api.DebugService/SetLogs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *debugServiceClient) GetVPN(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GetVPNResponse, error) {
	out := new(GetVPNResponse)
	err := c.cc.Invoke(ctx, "/api.DebugService/GetVPN", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *debugServiceClient) SetVPN(ctx context.Context, in *SetVPNRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, "/api.DebugService/SetVPN", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// DebugServiceServer is the server API for DebugService service.
type DebugServiceServer interface {
	GetLorawanTx(context.Context, *emptypb.Empty) (*GetLorawanTxResponse, error)
	SetLorawanTx(context.Context, *SetLorawanTxRequest) (*emptypb.Empty, error)
	StreamLorawanTx(*emptypb.Empty, DebugService_StreamLorawanTxServer) error
	GetLorawanRx(context.Context, *emptypb.Empty) (*GetLorawanRxResponse, error)
	StreamLorawanRx(*StreamLorawanRxRequest, DebugService_StreamLorawanRxServer) error
	StreamLogs(*emptypb.Empty, DebugService_StreamLogsServer) error
	SetLogs(context.Context, *SetLogsRequest) (*emptypb.Empty, error)
	GetVPN(context.Context, *emptypb.Empty) (*GetVPNResponse, error)
	SetVPN(context.Context, *SetVPNRequest) (*emptypb.Empty, error)
}

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

func (*UnimplementedDebugServiceServer) GetLorawanTx(ctx context.Context, req *emptypb.Empty) (*GetLorawanTxResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetLorawanTx not implemented")
}
func (*UnimplementedDebugServiceServer) SetLorawanTx(ctx context.Context, req *SetLorawanTxRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetLorawanTx not implemented")
}
func (*UnimplementedDebugServiceServer) StreamLorawanTx(req *emptypb.Empty, srv DebugService_StreamLorawanTxServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamLorawanTx not implemented")
}
func (*UnimplementedDebugServiceServer) GetLorawanRx(ctx context.Context, req *emptypb.Empty) (*GetLorawanRxResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetLorawanRx not implemented")
}
func (*UnimplementedDebugServiceServer) StreamLorawanRx(req *StreamLorawanRxRequest, srv DebugService_StreamLorawanRxServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamLorawanRx not implemented")
}
func (*UnimplementedDebugServiceServer) StreamLogs(req *emptypb.Empty, srv DebugService_StreamLogsServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamLogs not implemented")
}
func (*UnimplementedDebugServiceServer) SetLogs(ctx context.Context, req *SetLogsRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetLogs not implemented")
}
func (*UnimplementedDebugServiceServer) GetVPN(ctx context.Context, req *emptypb.Empty) (*GetVPNResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetVPN not implemented")
}
func (*UnimplementedDebugServiceServer) SetVPN(ctx context.Context, req *SetVPNRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetVPN not implemented")
}

func RegisterDebugServiceServer(s *grpc.Server, srv DebugServiceServer) {
	s.RegisterService(&_DebugService_serviceDesc, srv)
}

func _DebugService_GetLorawanTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServiceServer).GetLorawanTx(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.DebugService/GetLorawanTx",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServiceServer).GetLorawanTx(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _DebugService_SetLorawanTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetLorawanTxRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServiceServer).SetLorawanTx(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.DebugService/SetLorawanTx",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServiceServer).SetLorawanTx(ctx, req.(*SetLorawanTxRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DebugService_StreamLorawanTx_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(emptypb.Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(DebugServiceServer).StreamLorawanTx(m, &debugServiceStreamLorawanTxServer{stream})
}

type DebugService_StreamLorawanTxServer interface {
	Send(*StreamLorawanTxResponse) error
	grpc.ServerStream
}

type debugServiceStreamLorawanTxServer struct {
	grpc.ServerStream
}

func (x *debugServiceStreamLorawanTxServer) Send(m *StreamLorawanTxResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _DebugService_GetLorawanRx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServiceServer).GetLorawanRx(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.DebugService/GetLorawanRx",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServiceServer).GetLorawanRx(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _DebugService_StreamLorawanRx_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(StreamLorawanRxRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(DebugServiceServer).StreamLorawanRx(m, &debugServiceStreamLorawanRxServer{stream})
}

type DebugService_StreamLorawanRxServer interface {
	Send(*StreamLorawanRxResponse) error
	grpc.ServerStream
}

type debugServiceStreamLorawanRxServer struct {
	grpc.ServerStream
}

func (x *debugServiceStreamLorawanRxServer) Send(m *StreamLorawanRxResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _DebugService_StreamLogs_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(emptypb.Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(DebugServiceServer).StreamLogs(m, &debugServiceStreamLogsServer{stream})
}

type DebugService_StreamLogsServer interface {
	Send(*StreamLogsResponse) error
	grpc.ServerStream
}

type debugServiceStreamLogsServer struct {
	grpc.ServerStream
}

func (x *debugServiceStreamLogsServer) Send(m *StreamLogsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _DebugService_SetLogs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetLogsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServiceServer).SetLogs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.DebugService/SetLogs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServiceServer).SetLogs(ctx, req.(*SetLogsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DebugService_GetVPN_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServiceServer).GetVPN(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.DebugService/GetVPN",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServiceServer).GetVPN(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _DebugService_SetVPN_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetVPNRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServiceServer).SetVPN(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.DebugService/SetVPN",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServiceServer).SetVPN(ctx, req.(*SetVPNRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _DebugService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "api.DebugService",
	HandlerType: (*DebugServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetLorawanTx",
			Handler:    _DebugService_GetLorawanTx_Handler,
		},
		{
			MethodName: "SetLorawanTx",
			Handler:    _DebugService_SetLorawanTx_Handler,
		},
		{
			MethodName: "GetLorawanRx",
			Handler:    _DebugService_GetLorawanRx_Handler,
		},
		{
			MethodName: "SetLogs",
			Handler:    _DebugService_SetLogs_Handler,
		},
		{
			MethodName: "GetVPN",
			Handler:    _DebugService_GetVPN_Handler,
		},
		{
			MethodName: "SetVPN",
			Handler:    _DebugService_SetVPN_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "StreamLorawanTx",
			Handler:       _DebugService_StreamLorawanTx_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "StreamLorawanRx",
			Handler:       _DebugService_StreamLorawanRx_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "StreamLogs",
			Handler:       _DebugService_StreamLogs_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "as/external/api/debug.proto",
}