joinserver.pb.go

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

package ttnpb

import (
	bytes "bytes"
	context "context"
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strings "strings"

	_ "github.com/envoyproxy/protoc-gen-validate/validate"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	golang_proto "github.com/golang/protobuf/proto"
	go_thethings_network_lorawan_stack_v3_pkg_types "go.thethings.network/lorawan-stack/v3/pkg/types"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

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

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

type SessionKeyRequest struct {
	// Join Server issued identifier for the session keys.
	SessionKeyID []byte `protobuf:"bytes,1,opt,name=session_key_id,json=sessionKeyId,proto3" json:"session_key_id,omitempty"`
	// LoRaWAN DevEUI.
	DevEUI go_thethings_network_lorawan_stack_v3_pkg_types.EUI64 `protobuf:"bytes,2,opt,name=dev_eui,json=devEui,proto3,customtype=go.thethings.network/lorawan-stack/v3/pkg/types.EUI64" json:"dev_eui"`
	// The LoRaWAN JoinEUI (AppEUI until LoRaWAN 1.0.3 end devices).
	JoinEUI              go_thethings_network_lorawan_stack_v3_pkg_types.EUI64 `protobuf:"bytes,3,opt,name=join_eui,json=joinEui,proto3,customtype=go.thethings.network/lorawan-stack/v3/pkg/types.EUI64" json:"join_eui"`
	XXX_NoUnkeyedLiteral struct{}                                              `json:"-"`
	XXX_sizecache        int32                                                 `json:"-"`
}

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

var xxx_messageInfo_SessionKeyRequest proto.InternalMessageInfo

func (m *SessionKeyRequest) GetSessionKeyID() []byte {
	if m != nil {
		return m.SessionKeyID
	}
	return nil
}

type NwkSKeysResponse struct {
	// The (encrypted) Forwarding Network Session Integrity Key (or Network Session Key in 1.0 compatibility mode).
	FNwkSIntKey KeyEnvelope `protobuf:"bytes,1,opt,name=f_nwk_s_int_key,json=fNwkSIntKey,proto3" json:"f_nwk_s_int_key"`
	// The (encrypted) Serving Network Session Integrity Key.
	SNwkSIntKey KeyEnvelope `protobuf:"bytes,2,opt,name=s_nwk_s_int_key,json=sNwkSIntKey,proto3" json:"s_nwk_s_int_key"`
	// The (encrypted) Network Session Encryption Key.
	NwkSEncKey           KeyEnvelope `protobuf:"bytes,3,opt,name=nwk_s_enc_key,json=nwkSEncKey,proto3" json:"nwk_s_enc_key"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

var xxx_messageInfo_NwkSKeysResponse proto.InternalMessageInfo

func (m *NwkSKeysResponse) GetFNwkSIntKey() KeyEnvelope {
	if m != nil {
		return m.FNwkSIntKey
	}
	return KeyEnvelope{}
}

func (m *NwkSKeysResponse) GetSNwkSIntKey() KeyEnvelope {
	if m != nil {
		return m.SNwkSIntKey
	}
	return KeyEnvelope{}
}

func (m *NwkSKeysResponse) GetNwkSEncKey() KeyEnvelope {
	if m != nil {
		return m.NwkSEncKey
	}
	return KeyEnvelope{}
}

type AppSKeyResponse struct {
	// The (encrypted) Application Session Key.
	AppSKey              KeyEnvelope `protobuf:"bytes,1,opt,name=app_s_key,json=appSKey,proto3" json:"app_s_key"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

var xxx_messageInfo_AppSKeyResponse proto.InternalMessageInfo

func (m *AppSKeyResponse) GetAppSKey() KeyEnvelope {
	if m != nil {
		return m.AppSKey
	}
	return KeyEnvelope{}
}

type CryptoServicePayloadRequest struct {
	EndDeviceIdentifiers `protobuf:"bytes,1,opt,name=ids,proto3,embedded=ids" json:"ids"`
	LoRaWANVersion       MACVersion    `protobuf:"varint,2,opt,name=lorawan_version,json=lorawanVersion,proto3,enum=ttn.lorawan.v3.MACVersion" json:"lorawan_version,omitempty"`
	Payload              []byte        `protobuf:"bytes,3,opt,name=payload,proto3" json:"payload,omitempty"`
	ProvisionerID        string        `protobuf:"bytes,4,opt,name=provisioner_id,json=provisionerId,proto3" json:"provisioner_id,omitempty"`
	ProvisioningData     *types.Struct `protobuf:"bytes,5,opt,name=provisioning_data,json=provisioningData,proto3" json:"provisioning_data,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_CryptoServicePayloadRequest proto.InternalMessageInfo

func (m *CryptoServicePayloadRequest) GetLoRaWANVersion() MACVersion {
	if m != nil {
		return m.LoRaWANVersion
	}
	return MAC_UNKNOWN
}

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

func (m *CryptoServicePayloadRequest) GetProvisionerID() string {
	if m != nil {
		return m.ProvisionerID
	}
	return ""
}

func (m *CryptoServicePayloadRequest) GetProvisioningData() *types.Struct {
	if m != nil {
		return m.ProvisioningData
	}
	return nil
}

type CryptoServicePayloadResponse struct {
	Payload              []byte   `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CryptoServicePayloadResponse proto.InternalMessageInfo

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

type JoinAcceptMICRequest struct {
	CryptoServicePayloadRequest `protobuf:"bytes,1,opt,name=payload_request,json=payloadRequest,proto3,embedded=payload_request" json:"payload_request"`
	JoinRequestType             RejoinType                                               `protobuf:"varint,2,opt,name=join_request_type,json=joinRequestType,proto3,enum=ttn.lorawan.v3.RejoinType" json:"join_request_type,omitempty"`
	DevNonce                    go_thethings_network_lorawan_stack_v3_pkg_types.DevNonce `protobuf:"bytes,3,opt,name=dev_nonce,json=devNonce,proto3,customtype=go.thethings.network/lorawan-stack/v3/pkg/types.DevNonce" json:"dev_nonce"`
	XXX_NoUnkeyedLiteral        struct{}                                                 `json:"-"`
	XXX_sizecache               int32                                                    `json:"-"`
}

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

var xxx_messageInfo_JoinAcceptMICRequest proto.InternalMessageInfo

func (m *JoinAcceptMICRequest) GetJoinRequestType() RejoinType {
	if m != nil {
		return m.JoinRequestType
	}
	return RejoinType_CONTEXT
}

type DeriveSessionKeysRequest struct {
	EndDeviceIdentifiers `protobuf:"bytes,1,opt,name=ids,proto3,embedded=ids" json:"ids"`
	LoRaWANVersion       MACVersion                                                `protobuf:"varint,2,opt,name=lorawan_version,json=lorawanVersion,proto3,enum=ttn.lorawan.v3.MACVersion" json:"lorawan_version,omitempty"`
	JoinNonce            go_thethings_network_lorawan_stack_v3_pkg_types.JoinNonce `protobuf:"bytes,3,opt,name=join_nonce,json=joinNonce,proto3,customtype=go.thethings.network/lorawan-stack/v3/pkg/types.JoinNonce" json:"join_nonce"`
	DevNonce             go_thethings_network_lorawan_stack_v3_pkg_types.DevNonce  `protobuf:"bytes,4,opt,name=dev_nonce,json=devNonce,proto3,customtype=go.thethings.network/lorawan-stack/v3/pkg/types.DevNonce" json:"dev_nonce"`
	NetID                go_thethings_network_lorawan_stack_v3_pkg_types.NetID     `protobuf:"bytes,5,opt,name=net_id,json=netId,proto3,customtype=go.thethings.network/lorawan-stack/v3/pkg/types.NetID" json:"net_id"`
	ProvisionerID        string                                                    `protobuf:"bytes,6,opt,name=provisioner_id,json=provisionerId,proto3" json:"provisioner_id,omitempty"`
	ProvisioningData     *types.Struct                                             `protobuf:"bytes,7,opt,name=provisioning_data,json=provisioningData,proto3" json:"provisioning_data,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                                  `json:"-"`
	XXX_sizecache        int32                                                     `json:"-"`
}

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

var xxx_messageInfo_DeriveSessionKeysRequest proto.InternalMessageInfo

func (m *DeriveSessionKeysRequest) GetLoRaWANVersion() MACVersion {
	if m != nil {
		return m.LoRaWANVersion
	}
	return MAC_UNKNOWN
}

func (m *DeriveSessionKeysRequest) GetProvisionerID() string {
	if m != nil {
		return m.ProvisionerID
	}
	return ""
}

func (m *DeriveSessionKeysRequest) GetProvisioningData() *types.Struct {
	if m != nil {
		return m.ProvisioningData
	}
	return nil
}

type GetRootKeysRequest struct {
	EndDeviceIdentifiers `protobuf:"bytes,1,opt,name=ids,proto3,embedded=ids" json:"ids"`
	ProvisionerID        string        `protobuf:"bytes,2,opt,name=provisioner_id,json=provisionerId,proto3" json:"provisioner_id,omitempty"`
	ProvisioningData     *types.Struct `protobuf:"bytes,3,opt,name=provisioning_data,json=provisioningData,proto3" json:"provisioning_data,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_GetRootKeysRequest proto.InternalMessageInfo

func (m *GetRootKeysRequest) GetProvisionerID() string {
	if m != nil {
		return m.ProvisionerID
	}
	return ""
}

func (m *GetRootKeysRequest) GetProvisioningData() *types.Struct {
	if m != nil {
		return m.ProvisioningData
	}
	return nil
}

// Deprecated: Do not use.
type ProvisionEndDevicesRequest struct {
	ApplicationIdentifiers `protobuf:"bytes,1,opt,name=application_ids,json=applicationIds,proto3,embedded=application_ids" json:"application_ids"`
	// ID of the provisioner service as configured in the Join Server.
	ProvisionerID string `protobuf:"bytes,2,opt,name=provisioner_id,json=provisionerId,proto3" json:"provisioner_id,omitempty"`
	// Vendor-specific provisioning data.
	ProvisioningData []byte `protobuf:"bytes,3,opt,name=provisioning_data,json=provisioningData,proto3" json:"provisioning_data,omitempty"`
	// Types that are valid to be assigned to EndDevices:
	//	*ProvisionEndDevicesRequest_List
	//	*ProvisionEndDevicesRequest_Range
	//	*ProvisionEndDevicesRequest_FromData
	EndDevices           isProvisionEndDevicesRequest_EndDevices `protobuf_oneof:"end_devices"`
	XXX_NoUnkeyedLiteral struct{}                                `json:"-"`
	XXX_sizecache        int32                                   `json:"-"`
}

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

var xxx_messageInfo_ProvisionEndDevicesRequest proto.InternalMessageInfo

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

type ProvisionEndDevicesRequest_List struct {
	List *ProvisionEndDevicesRequest_IdentifiersList `protobuf:"bytes,4,opt,name=list,proto3,oneof" json:"list,omitempty"`
}
type ProvisionEndDevicesRequest_Range struct {
	Range *ProvisionEndDevicesRequest_IdentifiersRange `protobuf:"bytes,5,opt,name=range,proto3,oneof" json:"range,omitempty"`
}
type ProvisionEndDevicesRequest_FromData struct {
	FromData *ProvisionEndDevicesRequest_IdentifiersFromData `protobuf:"bytes,6,opt,name=from_data,json=fromData,proto3,oneof" json:"from_data,omitempty"`
}

func (*ProvisionEndDevicesRequest_List) isProvisionEndDevicesRequest_EndDevices()     {}
func (*ProvisionEndDevicesRequest_Range) isProvisionEndDevicesRequest_EndDevices()    {}
func (*ProvisionEndDevicesRequest_FromData) isProvisionEndDevicesRequest_EndDevices() {}

func (m *ProvisionEndDevicesRequest) GetEndDevices() isProvisionEndDevicesRequest_EndDevices {
	if m != nil {
		return m.EndDevices
	}
	return nil
}

func (m *ProvisionEndDevicesRequest) GetProvisionerID() string {
	if m != nil {
		return m.ProvisionerID
	}
	return ""
}

func (m *ProvisionEndDevicesRequest) GetProvisioningData() []byte {
	if m != nil {
		return m.ProvisioningData
	}
	return nil
}

func (m *ProvisionEndDevicesRequest) GetList() *ProvisionEndDevicesRequest_IdentifiersList {
	if x, ok := m.GetEndDevices().(*ProvisionEndDevicesRequest_List); ok {
		return x.List
	}
	return nil
}

func (m *ProvisionEndDevicesRequest) GetRange() *ProvisionEndDevicesRequest_IdentifiersRange {
	if x, ok := m.GetEndDevices().(*ProvisionEndDevicesRequest_Range); ok {
		return x.Range
	}
	return nil
}

func (m *ProvisionEndDevicesRequest) GetFromData() *ProvisionEndDevicesRequest_IdentifiersFromData {
	if x, ok := m.GetEndDevices().(*ProvisionEndDevicesRequest_FromData); ok {
		return x.FromData
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ProvisionEndDevicesRequest) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ProvisionEndDevicesRequest_List)(nil),
		(*ProvisionEndDevicesRequest_Range)(nil),
		(*ProvisionEndDevicesRequest_FromData)(nil),
	}
}

type ProvisionEndDevicesRequest_IdentifiersList struct {
	JoinEUI              *go_thethings_network_lorawan_stack_v3_pkg_types.EUI64 `protobuf:"bytes,1,opt,name=join_eui,json=joinEui,proto3,customtype=go.thethings.network/lorawan-stack/v3/pkg/types.EUI64" json:"join_eui,omitempty"`
	EndDeviceIDs         []EndDeviceIdentifiers                                 `protobuf:"bytes,2,rep,name=end_device_ids,json=endDeviceIds,proto3" json:"end_device_ids"`
	XXX_NoUnkeyedLiteral struct{}                                               `json:"-"`
	XXX_sizecache        int32                                                  `json:"-"`
}

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

var xxx_messageInfo_ProvisionEndDevicesRequest_IdentifiersList proto.InternalMessageInfo

func (m *ProvisionEndDevicesRequest_IdentifiersList) GetEndDeviceIDs() []EndDeviceIdentifiers {
	if m != nil {
		return m.EndDeviceIDs
	}
	return nil
}

type ProvisionEndDevicesRequest_IdentifiersRange struct {
	JoinEUI *go_thethings_network_lorawan_stack_v3_pkg_types.EUI64 `protobuf:"bytes,1,opt,name=join_eui,json=joinEui,proto3,customtype=go.thethings.network/lorawan-stack/v3/pkg/types.EUI64" json:"join_eui,omitempty"`
	// DevEUI to start issuing from.
	StartDevEUI          go_thethings_network_lorawan_stack_v3_pkg_types.EUI64 `protobuf:"bytes,2,opt,name=start_dev_eui,json=startDevEui,proto3,customtype=go.thethings.network/lorawan-stack/v3/pkg/types.EUI64" json:"start_dev_eui"`
	XXX_NoUnkeyedLiteral struct{}                                              `json:"-"`
	XXX_sizecache        int32                                                 `json:"-"`
}

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

var xxx_messageInfo_ProvisionEndDevicesRequest_IdentifiersRange proto.InternalMessageInfo

type ProvisionEndDevicesRequest_IdentifiersFromData struct {
	JoinEUI              *go_thethings_network_lorawan_stack_v3_pkg_types.EUI64 `protobuf:"bytes,1,opt,name=join_eui,json=joinEui,proto3,customtype=go.thethings.network/lorawan-stack/v3/pkg/types.EUI64" json:"join_eui,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                               `json:"-"`
	XXX_sizecache        int32                                                  `json:"-"`
}

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

var xxx_messageInfo_ProvisionEndDevicesRequest_IdentifiersFromData proto.InternalMessageInfo

type JoinEUIPrefix struct {
	JoinEUI              go_thethings_network_lorawan_stack_v3_pkg_types.EUI64 `protobuf:"bytes,1,opt,name=join_eui,json=joinEui,proto3,customtype=go.thethings.network/lorawan-stack/v3/pkg/types.EUI64" json:"join_eui"`
	Length               uint32                                                `protobuf:"varint,2,opt,name=length,proto3" json:"length,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                              `json:"-"`
	XXX_sizecache        int32                                                 `json:"-"`
}

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

var xxx_messageInfo_JoinEUIPrefix proto.InternalMessageInfo

func (m *JoinEUIPrefix) GetLength() uint32 {
	if m != nil {
		return m.Length
	}
	return 0
}

type JoinEUIPrefixes struct {
	Prefixes             []JoinEUIPrefix `protobuf:"bytes,1,rep,name=prefixes,proto3" json:"prefixes"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

var xxx_messageInfo_JoinEUIPrefixes proto.InternalMessageInfo

func (m *JoinEUIPrefixes) GetPrefixes() []JoinEUIPrefix {
	if m != nil {
		return m.Prefixes
	}
	return nil
}

func init() {
	proto.RegisterType((*SessionKeyRequest)(nil), "ttn.lorawan.v3.SessionKeyRequest")
	golang_proto.RegisterType((*SessionKeyRequest)(nil), "ttn.lorawan.v3.SessionKeyRequest")
	proto.RegisterType((*NwkSKeysResponse)(nil), "ttn.lorawan.v3.NwkSKeysResponse")
	golang_proto.RegisterType((*NwkSKeysResponse)(nil), "ttn.lorawan.v3.NwkSKeysResponse")
	proto.RegisterType((*AppSKeyResponse)(nil), "ttn.lorawan.v3.AppSKeyResponse")
	golang_proto.RegisterType((*AppSKeyResponse)(nil), "ttn.lorawan.v3.AppSKeyResponse")
	proto.RegisterType((*CryptoServicePayloadRequest)(nil), "ttn.lorawan.v3.CryptoServicePayloadRequest")
	golang_proto.RegisterType((*CryptoServicePayloadRequest)(nil), "ttn.lorawan.v3.CryptoServicePayloadRequest")
	proto.RegisterType((*CryptoServicePayloadResponse)(nil), "ttn.lorawan.v3.CryptoServicePayloadResponse")
	golang_proto.RegisterType((*CryptoServicePayloadResponse)(nil), "ttn.lorawan.v3.CryptoServicePayloadResponse")
	proto.RegisterType((*JoinAcceptMICRequest)(nil), "ttn.lorawan.v3.JoinAcceptMICRequest")
	golang_proto.RegisterType((*JoinAcceptMICRequest)(nil), "ttn.lorawan.v3.JoinAcceptMICRequest")
	proto.RegisterType((*DeriveSessionKeysRequest)(nil), "ttn.lorawan.v3.DeriveSessionKeysRequest")
	golang_proto.RegisterType((*DeriveSessionKeysRequest)(nil), "ttn.lorawan.v3.DeriveSessionKeysRequest")
	proto.RegisterType((*GetRootKeysRequest)(nil), "ttn.lorawan.v3.GetRootKeysRequest")
	golang_proto.RegisterType((*GetRootKeysRequest)(nil), "ttn.lorawan.v3.GetRootKeysRequest")
	proto.RegisterType((*ProvisionEndDevicesRequest)(nil), "ttn.lorawan.v3.ProvisionEndDevicesRequest")
	golang_proto.RegisterType((*ProvisionEndDevicesRequest)(nil), "ttn.lorawan.v3.ProvisionEndDevicesRequest")
	proto.RegisterType((*ProvisionEndDevicesRequest_IdentifiersList)(nil), "ttn.lorawan.v3.ProvisionEndDevicesRequest.IdentifiersList")
	golang_proto.RegisterType((*ProvisionEndDevicesRequest_IdentifiersList)(nil), "ttn.lorawan.v3.ProvisionEndDevicesRequest.IdentifiersList")
	proto.RegisterType((*ProvisionEndDevicesRequest_IdentifiersRange)(nil), "ttn.lorawan.v3.ProvisionEndDevicesRequest.IdentifiersRange")
	golang_proto.RegisterType((*ProvisionEndDevicesRequest_IdentifiersRange)(nil), "ttn.lorawan.v3.ProvisionEndDevicesRequest.IdentifiersRange")
	proto.RegisterType((*ProvisionEndDevicesRequest_IdentifiersFromData)(nil), "ttn.lorawan.v3.ProvisionEndDevicesRequest.IdentifiersFromData")
	golang_proto.RegisterType((*ProvisionEndDevicesRequest_IdentifiersFromData)(nil), "ttn.lorawan.v3.ProvisionEndDevicesRequest.IdentifiersFromData")
	proto.RegisterType((*JoinEUIPrefix)(nil), "ttn.lorawan.v3.JoinEUIPrefix")
	golang_proto.RegisterType((*JoinEUIPrefix)(nil), "ttn.lorawan.v3.JoinEUIPrefix")
	proto.RegisterType((*JoinEUIPrefixes)(nil), "ttn.lorawan.v3.JoinEUIPrefixes")
	golang_proto.RegisterType((*JoinEUIPrefixes)(nil), "ttn.lorawan.v3.JoinEUIPrefixes")
}

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

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

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

	that1, ok := that.(*SessionKeyRequest)
	if !ok {
		that2, ok := that.(SessionKeyRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.SessionKeyID, that1.SessionKeyID) {
		return false
	}
	if !this.DevEUI.Equal(that1.DevEUI) {
		return false
	}
	if !this.JoinEUI.Equal(that1.JoinEUI) {
		return false
	}
	return true
}
func (this *NwkSKeysResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*NwkSKeysResponse)
	if !ok {
		that2, ok := that.(NwkSKeysResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.FNwkSIntKey.Equal(&that1.FNwkSIntKey) {
		return false
	}
	if !this.SNwkSIntKey.Equal(&that1.SNwkSIntKey) {
		return false
	}
	if !this.NwkSEncKey.Equal(&that1.NwkSEncKey) {
		return false
	}
	return true
}
func (this *AppSKeyResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

	that1, ok := that.(*CryptoServicePayloadRequest)
	if !ok {
		that2, ok := that.(CryptoServicePayloadRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.EndDeviceIdentifiers.Equal(&that1.EndDeviceIdentifiers) {
		return false
	}
	if this.LoRaWANVersion != that1.LoRaWANVersion {
		return false
	}
	if !bytes.Equal(this.Payload, that1.Payload) {
		return false
	}
	if this.ProvisionerID != that1.ProvisionerID {
		return false
	}
	if !this.ProvisioningData.Equal(that1.ProvisioningData) {
		return false
	}
	return true
}
func (this *CryptoServicePayloadResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

	that1, ok := that.(*JoinAcceptMICRequest)
	if !ok {
		that2, ok := that.(JoinAcceptMICRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.CryptoServicePayloadRequest.Equal(&that1.CryptoServicePayloadRequest) {
		return false
	}
	if this.JoinRequestType != that1.JoinRequestType {
		return false
	}
	if !this.DevNonce.Equal(that1.DevNonce) {
		return false
	}
	return true
}
func (this *DeriveSessionKeysRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeriveSessionKeysRequest)
	if !ok {
		that2, ok := that.(DeriveSessionKeysRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.EndDeviceIdentifiers.Equal(&that1.EndDeviceIdentifiers) {
		return false
	}
	if this.LoRaWANVersion != that1.LoRaWANVersion {
		return false
	}
	if !this.JoinNonce.Equal(that1.JoinNonce) {
		return false
	}
	if !this.DevNonce.Equal(that1.DevNonce) {
		return false
	}
	if !this.NetID.Equal(that1.NetID) {
		return false
	}
	if this.ProvisionerID != that1.ProvisionerID {
		return false
	}
	if !this.ProvisioningData.Equal(that1.ProvisioningData) {
		return false
	}
	return true
}
func (this *GetRootKeysRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetRootKeysRequest)
	if !ok {
		that2, ok := that.(GetRootKeysRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.EndDeviceIdentifiers.Equal(&that1.EndDeviceIdentifiers) {
		return false
	}
	if this.ProvisionerID != that1.ProvisionerID {
		return false
	}
	if !this.ProvisioningData.Equal(that1.ProvisioningData) {
		return false
	}
	return true
}
func (this *ProvisionEndDevicesRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ProvisionEndDevicesRequest)
	if !ok {
		that2, ok := that.(ProvisionEndDevicesRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ApplicationIdentifiers.Equal(&that1.ApplicationIdentifiers) {
		return false
	}
	if this.ProvisionerID != that1.ProvisionerID {
		return false
	}
	if !bytes.Equal(this.ProvisioningData, that1.ProvisioningData) {
		return false
	}
	if that1.EndDevices == nil {
		if this.EndDevices != nil {
			return false
		}
	} else if this.EndDevices == nil {
		return false
	} else if !this.EndDevices.Equal(that1.EndDevices) {
		return false
	}
	return true
}
func (this *ProvisionEndDevicesRequest_List) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

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

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

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

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

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

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

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

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

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

// NsJsClient is the client API for NsJs service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type NsJsClient interface {
	HandleJoin(ctx context.Context, in *JoinRequest, opts ...grpc.CallOption) (*JoinResponse, error)
	GetNwkSKeys(ctx context.Context, in *SessionKeyRequest, opts ...grpc.CallOption) (*NwkSKeysResponse, error)
}

type nsJsClient struct {
	cc *grpc.ClientConn
}

func NewNsJsClient(cc *grpc.ClientConn) NsJsClient {
	return &nsJsClient{cc}
}

func (c *nsJsClient) HandleJoin(ctx context.Context, in *JoinRequest, opts ...grpc.CallOption) (*JoinResponse, error) {
	out := new(JoinResponse)
	err := c.cc.Invoke(ctx, "/ttn.lorawan.v3.NsJs/HandleJoin", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *nsJsClient) GetNwkSKeys(ctx context.Context, in *SessionKeyRequest, opts ...grpc.CallOption) (*NwkSKeysResponse, error) {
	out := new(NwkSKeysResponse)
	err := c.cc.Invoke(ctx, "/ttn.lorawan.v3.NsJs/GetNwkSKeys", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// NsJsServer is the server API for NsJs service.
type NsJsServer interface {
	HandleJoin(context.Context, *JoinRequest) (*JoinResponse, error)
	GetNwkSKeys(context.Context, *SessionKeyRequest) (*NwkSKeysResponse, error)
}

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

func (*UnimplementedNsJsServer) HandleJoin(ctx context.Context, req *JoinRequest) (*JoinResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method HandleJoin not implemented")
}
func (*UnimplementedNsJsServer) GetNwkSKeys(ctx context.Context, req *SessionKeyRequest) (*NwkSKeysResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetNwkSKeys not implemented")
}

func RegisterNsJsServer(s *grpc.Server, srv NsJsServer) {
	s.RegisterService(&_NsJs_serviceDesc, srv)
}

func _NsJs_HandleJoin_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(JoinRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NsJsServer).HandleJoin(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ttn.lorawan.v3.NsJs/HandleJoin",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NsJsServer).HandleJoin(ctx, req.(*JoinRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NsJs_GetNwkSKeys_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SessionKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NsJsServer).GetNwkSKeys(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ttn.lorawan.v3.NsJs/GetNwkSKeys",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NsJsServer).GetNwkSKeys(ctx, req.(*SessionKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _NsJs_serviceDesc = grpc.ServiceDesc{
	ServiceName: "ttn.lorawan.v3.NsJs",
	HandlerType: (*NsJsServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "HandleJoin",
			Handler:    _NsJs_HandleJoin_Handler,
		},
		{
			MethodName: "GetNwkSKeys",
			Handler:    _NsJs_GetNwkSKeys_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "lorawan-stack/api/joinserver.proto",
}

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

type asJsClient struct {
	cc *grpc.ClientConn
}

func NewAsJsClient(cc *grpc.ClientConn) AsJsClient {
	return &asJsClient{cc}
}

func (c *asJsClient) GetAppSKey(ctx context.Context, in *SessionKeyRequest, opts ...grpc.CallOption) (*AppSKeyResponse, error) {
	out := new(AppSKeyResponse)
	err := c.cc.Invoke(ctx, "/ttn.lorawan.v3.AsJs/GetAppSKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AsJsServer is the server API for AsJs service.
type AsJsServer interface {
	GetAppSKey(context.Context, *SessionKeyRequest) (*AppSKeyResponse, error)
}

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

func (*UnimplementedAsJsServer) GetAppSKey(ctx context.Context, req *SessionKeyRequest) (*AppSKeyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAppSKey not implemented")
}

func RegisterAsJsServer(s *grpc.Server, srv AsJsServer) {
	s.RegisterService(&_AsJs_serviceDesc, srv)
}

func _AsJs_GetAppSKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SessionKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AsJsServer).GetAppSKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ttn.lorawan.v3.AsJs/GetAppSKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AsJsServer).GetAppSKey(ctx, req.(*SessionKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _AsJs_serviceDesc = grpc.ServiceDesc{
	ServiceName: "ttn.lorawan.v3.AsJs",
	HandlerType: (*AsJsServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetAppSKey",
			Handler:    _AsJs_GetAppSKey_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "lorawan-stack/api/joinserver.proto",
}

// NetworkCryptoServiceClient is the client API for NetworkCryptoService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type NetworkCryptoServiceClient interface {
	JoinRequestMIC(ctx context.Context, in *CryptoServicePayloadRequest, opts ...grpc.CallOption) (*CryptoServicePayloadResponse, error)
	JoinAcceptMIC(ctx context.Context, in *JoinAcceptMICRequest, opts ...grpc.CallOption) (*CryptoServicePayloadResponse, error)
	EncryptJoinAccept(ctx context.Context, in *CryptoServicePayloadRequest, opts ...grpc.CallOption) (*CryptoServicePayloadResponse, error)
	EncryptRejoinAccept(ctx context.Context, in *CryptoServicePayloadRequest, opts ...grpc.CallOption) (*CryptoServicePayloadResponse, error)
	DeriveNwkSKeys(ctx context.Context, in *DeriveSessionKeysRequest, opts ...grpc.CallOption) (*NwkSKeysResponse, error)
	// Get the NwkKey. Crypto Servers may return status code FAILED_PRECONDITION when root keys are not exposed.
	GetNwkKey(ctx context.Context, in *GetRootKeysRequest, opts ...grpc.CallOption) (*KeyEnvelope, error)
}

type networkCryptoServiceClient struct {
	cc *grpc.ClientConn
}

func NewNetworkCryptoServiceClient(cc *grpc.ClientConn) NetworkCryptoServiceClient {
	return &networkCryptoServiceClient{cc}
}

func (c *networkCryptoServiceClient) JoinRequestMIC(ctx context.Context, in *CryptoServicePayloadRequest, opts ...grpc.CallOption) (*CryptoServicePayloadResponse, error) {
	out := new(CryptoServicePayloadResponse)
	err := c.cc.Invoke(ctx, "/ttn.lorawan.v3.NetworkCryptoService/JoinRequestMIC", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *networkCryptoServiceClient) JoinAcceptMIC(ctx context.Context, in *JoinAcceptMICRequest, opts ...grpc.CallOption) (*CryptoServicePayloadResponse, error) {
	out := new(CryptoServicePayloadResponse)
	err := c.cc.Invoke(ctx, "/ttn.lorawan.v3.NetworkCryptoService/JoinAcceptMIC", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *networkCryptoServiceClient) EncryptJoinAccept(ctx context.Context, in *CryptoServicePayloadRequest, opts ...grpc.CallOption) (*CryptoServicePayloadResponse, error) {
	out := new(CryptoServicePayloadResponse)
	err := c.cc.Invoke(ctx, "/ttn.lorawan.v3.NetworkCryptoService/EncryptJoinAccept", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *networkCryptoServiceClient) EncryptRejoinAccept(ctx context.Context, in *CryptoServicePayloadRequest, opts ...grpc.CallOption) (*CryptoServicePayloadResponse, error) {
	out := new(CryptoServicePayloadResponse)
	err := c.cc.Invoke(ctx, "/ttn.lorawan.v3.NetworkCryptoService/EncryptRejoinAccept", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *networkCryptoServiceClient) DeriveNwkSKeys(ctx context.Context, in *DeriveSessionKeysRequest, opts ...grpc.CallOption) (*NwkSKeysResponse, error) {
	out := new(NwkSKeysResponse)
	err := c.cc.Invoke(ctx, "/ttn.lorawan.v3.NetworkCryptoService/DeriveNwkSKeys", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *networkCryptoServiceClient) GetNwkKey(ctx context.Context, in *GetRootKeysRequest, opts ...grpc.CallOption) (*KeyEnvelope, error) {
	out := new(KeyEnvelope)
	err := c.cc.Invoke(ctx, "/ttn.lorawan.v3.NetworkCryptoService/GetNwkKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// NetworkCryptoServiceServer is the server API for NetworkCryptoService service.
type NetworkCryptoServiceServer interface {
	JoinRequestMIC(context.Context, *CryptoServicePayloadRequest) (*CryptoServicePayloadResponse, error)
	JoinAcceptMIC(context.Context, *JoinAcceptMICRequest) (*CryptoServicePayloadResponse, error)
	EncryptJoinAccept(context.Context, *CryptoServicePayloadRequest) (*CryptoServicePayloadResponse, error)
	EncryptRejoinAccept(context.Context, *CryptoServicePayloadRequest) (*CryptoServicePayloadResponse, error)
	DeriveNwkSKeys(context.Context, *DeriveSessionKeysRequest) (*NwkSKeysResponse, error)
	// Get the NwkKey. Crypto Servers may return status code FAILED_PRECONDITION when root keys are not exposed.
	GetNwkKey(context.Context, *GetRootKeysRequest) (*KeyEnvelope, error)
}

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

func (*UnimplementedNetworkCryptoServiceServer) JoinRequestMIC(ctx context.Context, req *CryptoServicePayloadRequest) (*CryptoServicePayloadResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method JoinRequestMIC not implemented")
}
func (*UnimplementedNetworkCryptoServiceServer) JoinAcceptMIC(ctx context.Context, req *JoinAcceptMICRequest) (*CryptoServicePayloadResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method JoinAcceptMIC not implemented")
}
func (*UnimplementedNetworkCryptoServiceServer) EncryptJoinAccept(ctx context.Context, req *CryptoServicePayloadRequest) (*CryptoServicePayloadResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EncryptJoinAccept not implemented")
}
func (*UnimplementedNetworkCryptoServiceServer) EncryptRejoinAccept(ctx context.Context, req *CryptoServicePayloadRequest) (*CryptoServicePayloadResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EncryptRejoinAccept not implemented")
}
func (*UnimplementedNetworkCryptoServiceServer) DeriveNwkSKeys(ctx context.Context, req *DeriveSessionKeysRequest) (*NwkSKeysResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeriveNwkSKeys not implemented")
}
func (*UnimplementedNetworkCryptoServiceServer) GetNwkKey(ctx context.Context, req *GetRootKeysRequest) (*KeyEnvelope, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetNwkKey not implemented")
}

func RegisterNetworkCryptoServiceServer(s *grpc.Server, srv NetworkCryptoServiceServer) {
	s.RegisterService(&_NetworkCryptoService_serviceDesc, srv)
}

func _NetworkCryptoService_JoinRequestMIC_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CryptoServicePayloadRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NetworkCryptoServiceServer).JoinRequestMIC(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ttn.lorawan.v3.NetworkCryptoService/JoinRequestMIC",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NetworkCryptoServiceServer).JoinRequestMIC(ctx, req.(*CryptoServicePayloadRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NetworkCryptoService_JoinAcceptMIC_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(JoinAcceptMICRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NetworkCryptoServiceServer).JoinAcceptMIC(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ttn.lorawan.v3.NetworkCryptoService/JoinAcceptMIC",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NetworkCryptoServiceServer).JoinAcceptMIC(ctx, req.(*JoinAcceptMICRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NetworkCryptoService_EncryptJoinAccept_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CryptoServicePayloadRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NetworkCryptoServiceServer).EncryptJoinAccept(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ttn.lorawan.v3.NetworkCryptoService/EncryptJoinAccept",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NetworkCryptoServiceServer).EncryptJoinAccept(ctx, req.(*CryptoServicePayloadRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NetworkCryptoService_EncryptRejoinAccept_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CryptoServicePayloadRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NetworkCryptoServiceServer).EncryptRejoinAccept(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ttn.lorawan.v3.NetworkCryptoService/EncryptRejoinAccept",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NetworkCryptoServiceServer).EncryptRejoinAccept(ctx, req.(*CryptoServicePayloadRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NetworkCryptoService_DeriveNwkSKeys_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeriveSessionKeysRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NetworkCryptoServiceServer).DeriveNwkSKeys(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ttn.lorawan.v3.NetworkCryptoService/DeriveNwkSKeys",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NetworkCryptoServiceServer).DeriveNwkSKeys(ctx, req.(*DeriveSessionKeysRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _NetworkCryptoService_GetNwkKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRootKeysRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(NetworkCryptoServiceServer).GetNwkKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ttn.lorawan.v3.NetworkCryptoService/GetNwkKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(NetworkCryptoServiceServer).GetNwkKey(ctx, req.(*GetRootKeysRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _NetworkCryptoService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "ttn.lorawan.v3.NetworkCryptoService",
	HandlerType: (*NetworkCryptoServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "JoinRequestMIC",
			Handler:    _NetworkCryptoService_JoinRequestMIC_Handler,
		},
		{
			MethodName: "JoinAcceptMIC",
			Handler:    _NetworkCryptoService_JoinAcceptMIC_Handler,
		},
		{
			MethodName: "EncryptJoinAccept",
			Handler:    _NetworkCryptoService_EncryptJoinAccept_Handler,
		},
		{
			MethodName: "EncryptRejoinAccept",
			Handler:    _NetworkCryptoService_EncryptRejoinAccept_Handler,
		},
		{
			MethodName: "DeriveNwkSKeys",
			Handler:    _NetworkCryptoService_DeriveNwkSKeys_Handler,
		},
		{
			MethodName: "GetNwkKey",
			Handler:    _NetworkCryptoService_GetNwkKey_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "lorawan-stack/api/joinserver.proto",
}

// ApplicationCryptoServiceClient is the client API for ApplicationCryptoService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ApplicationCryptoServiceClient interface {
	DeriveAppSKey(ctx context.Context, in *DeriveSessionKeysRequest, opts ...grpc.CallOption) (*AppSKeyResponse, error)
	// Get the AppKey. Crypto Servers may return status code FAILED_PRECONDITION when root keys are not exposed.
	GetAppKey(ctx context.Context, in *GetRootKeysRequest, opts ...grpc.CallOption) (*KeyEnvelope, error)
}

type applicationCryptoServiceClient struct {
	cc *grpc.ClientConn
}

func NewApplicationCryptoServiceClient(cc *grpc.ClientConn) ApplicationCryptoServiceClient {
	return &applicationCryptoServiceClient{cc}
}

func (c *applicationCryptoServiceClient) DeriveAppSKey(ctx context.Context, in *DeriveSessionKeysRequest, opts ...grpc.CallOption) (*AppSKeyResponse, error) {
	out := new(AppSKeyResponse)
	err := c.cc.Invoke(ctx, "/ttn.lorawan.v3.ApplicationCryptoService/DeriveAppSKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *applicationCryptoServiceClient) GetAppKey(ctx context.Context, in *GetRootKeysRequest, opts ...grpc.CallOption) (*KeyEnvelope, error) {
	out := new(KeyEnvelope)
	err := c.cc.Invoke(ctx, "/ttn.lorawan.v3.ApplicationCryptoService/GetAppKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ApplicationCryptoServiceServer is the server API for ApplicationCryptoService service.
type ApplicationCryptoServiceServer interface {
	DeriveAppSKey(context.Context, *DeriveSessionKeysRequest) (*AppSKeyResponse, error)
	// Get the AppKey. Crypto Servers may return status code FAILED_PRECONDITION when root keys are not exposed.
	GetAppKey(context.Context, *GetRootKeysRequest) (*KeyEnvelope, error)
}

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

func (*UnimplementedApplicationCryptoServiceServer) DeriveAppSKey(ctx context.Context, req *DeriveSessionKeysRequest) (*AppSKeyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeriveAppSKey not implemented")
}
func (*UnimplementedApplicationCryptoServiceServer) GetAppKey(ctx context.Context, req *GetRootKeysRequest) (*KeyEnvelope, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAppKey not implemented")
}

func RegisterApplicationCryptoServiceServer(s *grpc.Server, srv ApplicationCryptoServiceServer) {
	s.RegisterService(&_ApplicationCryptoService_serviceDesc, srv)
}

func _ApplicationCryptoService_DeriveAppSKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeriveSessionKeysRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApplicationCryptoServiceServer).DeriveAppSKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ttn.lorawan.v3.ApplicationCryptoService/DeriveAppSKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApplicationCryptoServiceServer).DeriveAppSKey(ctx, req.(*DeriveSessionKeysRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ApplicationCryptoService_GetAppKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRootKeysRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ApplicationCryptoServiceServer).GetAppKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ttn.lorawan.v3.ApplicationCryptoService/GetAppKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ApplicationCryptoServiceServer).GetAppKey(ctx, req.(*GetRootKeysRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _ApplicationCryptoService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "ttn.lorawan.v3.ApplicationCryptoService",
	HandlerType: (*ApplicationCryptoServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "DeriveAppSKey",
			Handler:    _ApplicationCryptoService_DeriveAppSKey_Handler,
		},
		{
			MethodName: "GetAppKey",
			Handler:    _ApplicationCryptoService_GetAppKey_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "lorawan-stack/api/joinserver.proto",
}

// JsEndDeviceRegistryClient is the client API for JsEndDeviceRegistry service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type JsEndDeviceRegistryClient interface {
	// Get returns the device that matches the given identifiers.
	// If there are multiple matches, an error will be returned.
	Get(ctx context.Context, in *GetEndDeviceRequest, opts ...grpc.CallOption) (*EndDevice, error)
	// Set creates or updates the device.
	Set(ctx context.Context, in *SetEndDeviceRequest, opts ...grpc.CallOption) (*EndDevice, error)
	// This rpc is deprecated; use EndDeviceTemplateConverter service instead.
	// TODO: Remove (https://github.com/TheThingsNetwork/lorawan-stack/issues/999)
	Provision(ctx context.Context, in *ProvisionEndDevicesRequest, opts ...grpc.CallOption) (JsEndDeviceRegistry_ProvisionClient, error)
	// Delete deletes the device that matches the given identifiers.
	// If there are multiple matches, an error will be returned.
	Delete(ctx context.Context, in *EndDeviceIdentifiers, opts ...grpc.CallOption) (*types.Empty, error)
}

type jsEndDeviceRegistryClient struct {
	cc *grpc.ClientConn
}

func NewJsEndDeviceRegistryClient(cc *grpc.ClientConn) JsEndDeviceRegistryClient {
	return &jsEndDeviceRegistryClient{cc}
}

func (c *jsEndDeviceRegistryClient) Get(ctx context.Context, in *GetEndDeviceRequest, opts ...grpc.CallOption) (*EndDevice, error) {
	out := new(EndDevice)
	err := c.cc.Invoke(ctx, "/ttn.lorawan.v3.JsEndDeviceRegistry/Get", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jsEndDeviceRegistryClient) Set(ctx context.Context, in *SetEndDeviceRequest, opts ...grpc.CallOption) (*EndDevice, error) {
	out := new(EndDevice)
	err := c.cc.Invoke(ctx, "/ttn.lorawan.v3.JsEndDeviceRegistry/Set", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Deprecated: Do not use.
func (c *jsEndDeviceRegistryClient) Provision(ctx context.Context, in *ProvisionEndDevicesRequest, opts ...grpc.CallOption) (JsEndDeviceRegistry_ProvisionClient, error) {
	stream, err := c.cc.NewStream(ctx, &_JsEndDeviceRegistry_serviceDesc.Streams[0], "/ttn.lorawan.v3.JsEndDeviceRegistry/Provision", opts...)
	if err != nil {
		return nil, err
	}
	x := &jsEndDeviceRegistryProvisionClient{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 JsEndDeviceRegistry_ProvisionClient interface {
	Recv() (*EndDevice, error)
	grpc.ClientStream
}

type jsEndDeviceRegistryProvisionClient struct {
	grpc.ClientStream
}

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

func (c *jsEndDeviceRegistryClient) Delete(ctx context.Context, in *EndDeviceIdentifiers, opts ...grpc.CallOption) (*types.Empty, error) {
	out := new(types.Empty)
	err := c.cc.Invoke(ctx, "/ttn.lorawan.v3.JsEndDeviceRegistry/Delete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// JsEndDeviceRegistryServer is the server API for JsEndDeviceRegistry service.
type JsEndDeviceRegistryServer interface {
	// Get returns the device that matches the given identifiers.
	// If there are multiple matches, an error will be returned.
	Get(context.Context, *GetEndDeviceRequest) (*EndDevice, error)
	// Set creates or updates the device.
	Set(context.Context, *SetEndDeviceRequest) (*EndDevice, error)
	// This rpc is deprecated; use EndDeviceTemplateConverter service instead.
	// TODO: Remove (https://github.com/TheThingsNetwork/lorawan-stack/issues/999)
	Provision(*ProvisionEndDevicesRequest, JsEndDeviceRegistry_ProvisionServer) error
	// Delete deletes the device that matches the given identifiers.
	// If there are multiple matches, an error will be returned.
	Delete(context.Context, *EndDeviceIdentifiers) (*types.Empty, error)
}

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

func (*UnimplementedJsEndDeviceRegistryServer) Get(ctx context.Context, req *GetEndDeviceRequest) (*EndDevice, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Get not implemented")
}
func (*UnimplementedJsEndDeviceRegistryServer) Set(ctx context.Context, req *SetEndDeviceRequest) (*EndDevice, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Set not implemented")
}
func (*UnimplementedJsEndDeviceRegistryServer) Provision(req *ProvisionEndDevicesRequest, srv JsEndDeviceRegistry_ProvisionServer) error {
	return status.Errorf(codes.Unimplemented, "method Provision not implemented")
}
func (*UnimplementedJsEndDeviceRegistryServer) Delete(ctx context.Context, req *EndDeviceIdentifiers) (*types.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}

func RegisterJsEndDeviceRegistryServer(s *grpc.Server, srv JsEndDeviceRegistryServer) {
	s.RegisterService(&_JsEndDeviceRegistry_serviceDesc, srv)
}

func _JsEndDeviceRegistry_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetEndDeviceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JsEndDeviceRegistryServer).Get(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ttn.lorawan.v3.JsEndDeviceRegistry/Get",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JsEndDeviceRegistryServer).Get(ctx, req.(*GetEndDeviceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _JsEndDeviceRegistry_Set_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetEndDeviceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JsEndDeviceRegistryServer).Set(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ttn.lorawan.v3.JsEndDeviceRegistry/Set",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JsEndDeviceRegistryServer).Set(ctx, req.(*SetEndDeviceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _JsEndDeviceRegistry_Provision_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ProvisionEndDevicesRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(JsEndDeviceRegistryServer).Provision(m, &jsEndDeviceRegistryProvisionServer{stream})
}

type JsEndDeviceRegistry_ProvisionServer interface {
	Send(*EndDevice) error
	grpc.ServerStream
}

type jsEndDeviceRegistryProvisionServer struct {
	grpc.ServerStream
}

func (x *jsEndDeviceRegistryProvisionServer) Send(m *EndDevice) error {
	return x.ServerStream.SendMsg(m)
}

func _JsEndDeviceRegistry_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EndDeviceIdentifiers)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JsEndDeviceRegistryServer).Delete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ttn.lorawan.v3.JsEndDeviceRegistry/Delete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JsEndDeviceRegistryServer).Delete(ctx, req.(*EndDeviceIdentifiers))
	}
	return interceptor(ctx, in, info, handler)
}

var _JsEndDeviceRegistry_serviceDesc = grpc.ServiceDesc{
	ServiceName: "ttn.lorawan.v3.JsEndDeviceRegistry",
	HandlerType: (*JsEndDeviceRegistryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Get",
			Handler:    _JsEndDeviceRegistry_Get_Handler,
		},
		{
			MethodName: "Set",
			Handler:    _JsEndDeviceRegistry_Set_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _JsEndDeviceRegistry_Delete_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Provision",
			Handler:       _JsEndDeviceRegistry_Provision_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "lorawan-stack/api/joinserver.proto",
}

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

type jsClient struct {
	cc *grpc.ClientConn
}

func NewJsClient(cc *grpc.ClientConn) JsClient {
	return &jsClient{cc}
}

func (c *jsClient) GetJoinEUIPrefixes(ctx context.Context, in *types.Empty, opts ...grpc.CallOption) (*JoinEUIPrefixes, error) {
	out := new(JoinEUIPrefixes)
	err := c.cc.Invoke(ctx, "/ttn.lorawan.v3.Js/GetJoinEUIPrefixes", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// JsServer is the server API for Js service.
type JsServer interface {
	GetJoinEUIPrefixes(context.Context, *types.Empty) (*JoinEUIPrefixes, error)
}

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

func (*UnimplementedJsServer) GetJoinEUIPrefixes(ctx context.Context, req *types.Empty) (*JoinEUIPrefixes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetJoinEUIPrefixes not implemented")
}

func RegisterJsServer(s *grpc.Server, srv JsServer) {
	s.RegisterService(&_Js_serviceDesc, srv)
}

func _Js_GetJoinEUIPrefixes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(types.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JsServer).GetJoinEUIPrefixes(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ttn.lorawan.v3.Js/GetJoinEUIPrefixes",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JsServer).GetJoinEUIPrefixes(ctx, req.(*types.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

var _Js_serviceDesc = grpc.ServiceDesc{
	ServiceName: "ttn.lorawan.v3.Js",
	HandlerType: (*JsServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetJoinEUIPrefixes",
			Handler:    _Js_GetJoinEUIPrefixes_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "lorawan-stack/api/joinserver.proto",
}

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

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

func (m *SessionKeyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.JoinEUI.Size()
		i -= size
		if _, err := m.JoinEUI.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintJoinserver(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.DevEUI.Size()
		i -= size
		if _, err := m.DevEUI.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintJoinserver(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.SessionKeyID) > 0 {
		i -= len(m.SessionKeyID)
		copy(dAtA[i:], m.SessionKeyID)
		i = encodeVarintJoinserver(dAtA, i, uint64(len(m.SessionKeyID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *NwkSKeysResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.NwkSEncKey.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintJoinserver(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.SNwkSIntKey.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintJoinserver(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.FNwkSIntKey.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintJoinserver(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *AppSKeyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.AppSKey.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintJoinserver(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *CryptoServicePayloadRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ProvisioningData != nil {
		{
			size, err := m.ProvisioningData.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintJoinserver(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if len(m.ProvisionerID) > 0 {
		i -= len(m.ProvisionerID)
		copy(dAtA[i:], m.ProvisionerID)
		i = encodeVarintJoinserver(dAtA, i, uint64(len(m.ProvisionerID)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Payload) > 0 {
		i -= len(m.Payload)
		copy(dAtA[i:], m.Payload)
		i = encodeVarintJoinserver(dAtA, i, uint64(len(m.Payload)))
		i--
		dAtA[i] = 0x1a
	}
	if m.LoRaWANVersion != 0 {
		i = encodeVarintJoinserver(dAtA, i, uint64(m.LoRaWANVersion))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.EndDeviceIdentifiers.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintJoinserver(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *JoinAcceptMICRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.DevNonce.Size()
		i -= size
		if _, err := m.DevNonce.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintJoinserver(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.JoinRequestType != 0 {
		i = encodeVarintJoinserver(dAtA, i, uint64(m.JoinRequestType))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.CryptoServicePayloadRequest.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintJoinserver(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *DeriveSessionKeysRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ProvisioningData != nil {
		{
			size, err := m.ProvisioningData.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintJoinserver(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if len(m.ProvisionerID) > 0 {
		i -= len(m.ProvisionerID)
		copy(dAtA[i:], m.ProvisionerID)
		i = encodeVarintJoinserver(dAtA, i, uint64(len(m.ProvisionerID)))
		i--
		dAtA[i] = 0x32
	}
	{
		size := m.NetID.Size()
		i -= size
		if _, err := m.NetID.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintJoinserver(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		size := m.DevNonce.Size()
		i -= size
		if _, err := m.DevNonce.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintJoinserver(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.JoinNonce.Size()
		i -= size
		if _, err := m.JoinNonce.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintJoinserver(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.LoRaWANVersion != 0 {
		i = encodeVarintJoinserver(dAtA, i, uint64(m.LoRaWANVersion))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.EndDeviceIdentifiers.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintJoinserver(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *GetRootKeysRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ProvisioningData != nil {
		{
			size, err := m.ProvisioningData.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintJoinserver(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ProvisionerID) > 0 {
		i -= len(m.ProvisionerID)
		copy(dAtA[i:], m.ProvisionerID)
		i = encodeVarintJoinserver(dAtA, i, uint64(len(m.ProvisionerID)))
		i--
		dAtA[i] = 0x12
	}
	{
		size, err := m.EndDeviceIdentifiers.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintJoinserver(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

func (m *ProvisionEndDevicesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.EndDevices != nil {
		{
			size := m.EndDevices.Size()
			i -= size
			if _, err := m.EndDevices.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if len(m.ProvisioningData) > 0 {
		i -= len(m.ProvisioningData)
		copy(dAtA[i:], m.ProvisioningData)
		i = encodeVarintJoinserver(dAtA, i, uint64(len(m.ProvisioningData)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ProvisionerID) > 0 {
		i -= len(m.ProvisionerID)
		copy(dAtA[i:], m.ProvisionerID)
		i = encodeVarintJoinserver(dAtA, i, uint64(len(m.ProvisionerID)))
		i--
		dAtA[i] = 0x12
	}
	{
		size, err := m.ApplicationIdentifiers.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintJoinserver(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *ProvisionEndDevicesRequest_List) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.List != nil {
		{
			size, err := m.List.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintJoinserver(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *ProvisionEndDevicesRequest_Range) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ProvisionEndDevicesRequest_Range) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Range != nil {
		{
			size, err := m.Range.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintJoinserver(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *ProvisionEndDevicesRequest_FromData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ProvisionEndDevicesRequest_FromData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.FromData != nil {
		{
			size, err := m.FromData.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintJoinserver(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *ProvisionEndDevicesRequest_IdentifiersList) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *ProvisionEndDevicesRequest_IdentifiersList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.EndDeviceIDs) > 0 {
		for iNdEx := len(m.EndDeviceIDs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.EndDeviceIDs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintJoinserver(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.JoinEUI != nil {
		{
			size := m.JoinEUI.Size()
			i -= size
			if _, err := m.JoinEUI.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintJoinserver(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ProvisionEndDevicesRequest_IdentifiersRange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.StartDevEUI.Size()
		i -= size
		if _, err := m.StartDevEUI.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintJoinserver(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.JoinEUI != nil {
		{
			size := m.JoinEUI.Size()
			i -= size
			if _, err := m.JoinEUI.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintJoinserver(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ProvisionEndDevicesRequest_IdentifiersFromData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.JoinEUI != nil {
		{
			size := m.JoinEUI.Size()
			i -= size
			if _, err := m.JoinEUI.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintJoinserver(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *JoinEUIPrefix) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Length != 0 {
		i = encodeVarintJoinserver(dAtA, i, uint64(m.Length))
		i--
		dAtA[i] = 0x10
	}
	{
		size := m.JoinEUI.Size()
		i -= size
		if _, err := m.JoinEUI.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintJoinserver(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

func encodeVarintJoinserver(dAtA []byte, offset int, v uint64) int {
	offset -= sovJoinserver(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func NewPopulatedSessionKeyRequest(r randyJoinserver, easy bool) *SessionKeyRequest {
	this := &SessionKeyRequest{}
	v1 := r.Intn(100)
	this.SessionKeyID = make([]byte, v1)
	for i := 0; i < v1; i++ {
		this.SessionKeyID[i] = byte(r.Intn(256))
	}
	v2 := go_thethings_network_lorawan_stack_v3_pkg_types.NewPopulatedEUI64(r)
	this.DevEUI = *v2
	v3 := go_thethings_network_lorawan_stack_v3_pkg_types.NewPopulatedEUI64(r)
	this.JoinEUI = *v3
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedNwkSKeysResponse(r randyJoinserver, easy bool) *NwkSKeysResponse {
	this := &NwkSKeysResponse{}
	v4 := NewPopulatedKeyEnvelope(r, easy)
	this.FNwkSIntKey = *v4
	v5 := NewPopulatedKeyEnvelope(r, easy)
	this.SNwkSIntKey = *v5
	v6 := NewPopulatedKeyEnvelope(r, easy)
	this.NwkSEncKey = *v6
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedAppSKeyResponse(r randyJoinserver, easy bool) *AppSKeyResponse {
	this := &AppSKeyResponse{}
	v7 := NewPopulatedKeyEnvelope(r, easy)
	this.AppSKey = *v7
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedCryptoServicePayloadRequest(r randyJoinserver, easy bool) *CryptoServicePayloadRequest {
	this := &CryptoServicePayloadRequest{}
	v8 := NewPopulatedEndDeviceIdentifiers(r, easy)
	this.EndDeviceIdentifiers = *v8
	this.LoRaWANVersion = MACVersion([]int32{0, 1, 2, 3, 4, 5, 6}[r.Intn(7)])
	v9 := r.Intn(100)
	this.Payload = make([]byte, v9)
	for i := 0; i < v9; i++ {
		this.Payload[i] = byte(r.Intn(256))
	}
	this.ProvisionerID = randStringJoinserver(r)
	if r.Intn(5) != 0 {
		this.ProvisioningData = types.NewPopulatedStruct(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedCryptoServicePayloadResponse(r randyJoinserver, easy bool) *CryptoServicePayloadResponse {
	this := &CryptoServicePayloadResponse{}
	v10 := r.Intn(100)
	this.Payload = make([]byte, v10)
	for i := 0; i < v10; i++ {
		this.Payload[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedJoinAcceptMICRequest(r randyJoinserver, easy bool) *JoinAcceptMICRequest {
	this := &JoinAcceptMICRequest{}
	v11 := NewPopulatedCryptoServicePayloadRequest(r, easy)
	this.CryptoServicePayloadRequest = *v11
	this.JoinRequestType = RejoinType([]int32{0, 1, 2}[r.Intn(3)])
	v12 := go_thethings_network_lorawan_stack_v3_pkg_types.NewPopulatedDevNonce(r)
	this.DevNonce = *v12
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedDeriveSessionKeysRequest(r randyJoinserver, easy bool) *DeriveSessionKeysRequest {
	this := &DeriveSessionKeysRequest{}
	v13 := NewPopulatedEndDeviceIdentifiers(r, easy)
	this.EndDeviceIdentifiers = *v13
	this.LoRaWANVersion = MACVersion([]int32{0, 1, 2, 3, 4, 5, 6}[r.Intn(7)])
	v14 := go_thethings_network_lorawan_stack_v3_pkg_types.NewPopulatedJoinNonce(r)
	this.JoinNonce = *v14
	v15 := go_thethings_network_lorawan_stack_v3_pkg_types.NewPopulatedDevNonce(r)
	this.DevNonce = *v15
	v16 := go_thethings_network_lorawan_stack_v3_pkg_types.NewPopulatedNetID(r)
	this.NetID = *v16
	this.ProvisionerID = randStringJoinserver(r)
	if r.Intn(5) != 0 {
		this.ProvisioningData = types.NewPopulatedStruct(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedGetRootKeysRequest(r randyJoinserver, easy bool) *GetRootKeysRequest {
	this := &GetRootKeysRequest{}
	v17 := NewPopulatedEndDeviceIdentifiers(r, easy)
	this.EndDeviceIdentifiers = *v17
	this.ProvisionerID = randStringJoinserver(r)
	if r.Intn(5) != 0 {
		this.ProvisioningData = types.NewPopulatedStruct(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedProvisionEndDevicesRequest(r randyJoinserver, easy bool) *ProvisionEndDevicesRequest {
	this := &ProvisionEndDevicesRequest{}
	v18 := NewPopulatedApplicationIdentifiers(r, easy)
	this.ApplicationIdentifiers = *v18
	this.ProvisionerID = randStringJoinserver(r)
	v19 := r.Intn(100)
	this.ProvisioningData = make([]byte, v19)
	for i := 0; i < v19; i++ {
		this.ProvisioningData[i] = byte(r.Intn(256))
	}
	oneofNumber_EndDevices := []int32{4, 5, 6}[r.Intn(3)]
	switch oneofNumber_EndDevices {
	case 4:
		this.EndDevices = NewPopulatedProvisionEndDevicesRequest_List(r, easy)
	case 5:
		this.EndDevices = NewPopulatedProvisionEndDevicesRequest_Range(r, easy)
	case 6:
		this.EndDevices = NewPopulatedProvisionEndDevicesRequest_FromData(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedProvisionEndDevicesRequest_List(r randyJoinserver, easy bool) *ProvisionEndDevicesRequest_List {
	this := &ProvisionEndDevicesRequest_List{}
	this.List = NewPopulatedProvisionEndDevicesRequest_IdentifiersList(r, easy)
	return this
}
func NewPopulatedProvisionEndDevicesRequest_Range(r randyJoinserver, easy bool) *ProvisionEndDevicesRequest_Range {
	this := &ProvisionEndDevicesRequest_Range{}
	this.Range = NewPopulatedProvisionEndDevicesRequest_IdentifiersRange(r, easy)
	return this
}
func NewPopulatedProvisionEndDevicesRequest_FromData(r randyJoinserver, easy bool) *ProvisionEndDevicesRequest_FromData {
	this := &ProvisionEndDevicesRequest_FromData{}
	this.FromData = NewPopulatedProvisionEndDevicesRequest_IdentifiersFromData(r, easy)
	return this
}
func NewPopulatedProvisionEndDevicesRequest_IdentifiersList(r randyJoinserver, easy bool) *ProvisionEndDevicesRequest_IdentifiersList {
	this := &ProvisionEndDevicesRequest_IdentifiersList{}
	this.JoinEUI = go_thethings_network_lorawan_stack_v3_pkg_types.NewPopulatedEUI64(r)
	if r.Intn(5) != 0 {
		v20 := r.Intn(5)
		this.EndDeviceIDs = make([]EndDeviceIdentifiers, v20)
		for i := 0; i < v20; i++ {
			v21 := NewPopulatedEndDeviceIdentifiers(r, easy)
			this.EndDeviceIDs[i] = *v21
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedProvisionEndDevicesRequest_IdentifiersRange(r randyJoinserver, easy bool) *ProvisionEndDevicesRequest_IdentifiersRange {
	this := &ProvisionEndDevicesRequest_IdentifiersRange{}
	this.JoinEUI = go_thethings_network_lorawan_stack_v3_pkg_types.NewPopulatedEUI64(r)
	v22 := go_thethings_network_lorawan_stack_v3_pkg_types.NewPopulatedEUI64(r)
	this.StartDevEUI = *v22
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedProvisionEndDevicesRequest_IdentifiersFromData(r randyJoinserver, easy bool) *ProvisionEndDevicesRequest_IdentifiersFromData {
	this := &ProvisionEndDevicesRequest_IdentifiersFromData{}
	this.JoinEUI = go_thethings_network_lorawan_stack_v3_pkg_types.NewPopulatedEUI64(r)
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedJoinEUIPrefix(r randyJoinserver, easy bool) *JoinEUIPrefix {
	this := &JoinEUIPrefix{}
	v23 := go_thethings_network_lorawan_stack_v3_pkg_types.NewPopulatedEUI64(r)
	this.JoinEUI = *v23
	this.Length = r.Uint32()
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedJoinEUIPrefixes(r randyJoinserver, easy bool) *JoinEUIPrefixes {
	this := &JoinEUIPrefixes{}
	if r.Intn(5) != 0 {
		v24 := r.Intn(5)
		this.Prefixes = make([]JoinEUIPrefix, v24)
		for i := 0; i < v24; i++ {
			v25 := NewPopulatedJoinEUIPrefix(r, easy)
			this.Prefixes[i] = *v25
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

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

func randUTF8RuneJoinserver(r randyJoinserver) rune {
	ru := r.Intn(62)
	if ru < 10 {
		return rune(ru + 48)
	} else if ru < 36 {
		return rune(ru + 55)
	}
	return rune(ru + 61)
}
func randStringJoinserver(r randyJoinserver) string {
	v26 := r.Intn(100)
	tmps := make([]rune, v26)
	for i := 0; i < v26; i++ {
		tmps[i] = randUTF8RuneJoinserver(r)
	}
	return string(tmps)
}
func randUnrecognizedJoinserver(r randyJoinserver, maxFieldNumber int) (dAtA []byte) {
	l := r.Intn(5)
	for i := 0; i < l; i++ {
		wire := r.Intn(4)
		if wire == 3 {
			wire = 5
		}
		fieldNumber := maxFieldNumber + r.Intn(100)
		dAtA = randFieldJoinserver(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldJoinserver(dAtA []byte, r randyJoinserver, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateJoinserver(dAtA, uint64(key))
		v27 := r.Int63()
		if r.Intn(2) == 0 {
			v27 *= -1
		}
		dAtA = encodeVarintPopulateJoinserver(dAtA, uint64(v27))
	case 1:
		dAtA = encodeVarintPopulateJoinserver(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	case 2:
		dAtA = encodeVarintPopulateJoinserver(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateJoinserver(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateJoinserver(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	}
	return dAtA
}
func encodeVarintPopulateJoinserver(dAtA []byte, v uint64) []byte {
	for v >= 1<<7 {
		dAtA = append(dAtA, uint8(v&0x7f|0x80))
		v >>= 7
	}
	dAtA = append(dAtA, uint8(v))
	return dAtA
}
func (m *SessionKeyRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SessionKeyID)
	if l > 0 {
		n += 1 + l + sovJoinserver(uint64(l))
	}
	l = m.DevEUI.Size()
	n += 1 + l + sovJoinserver(uint64(l))
	l = m.JoinEUI.Size()
	n += 1 + l + sovJoinserver(uint64(l))
	return n
}

func (m *NwkSKeysResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.FNwkSIntKey.Size()
	n += 1 + l + sovJoinserver(uint64(l))
	l = m.SNwkSIntKey.Size()
	n += 1 + l + sovJoinserver(uint64(l))
	l = m.NwkSEncKey.Size()
	n += 1 + l + sovJoinserver(uint64(l))
	return n
}

func (m *AppSKeyResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.AppSKey.Size()
	n += 1 + l + sovJoinserver(uint64(l))
	return n
}

func (m *CryptoServicePayloadRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.EndDeviceIdentifiers.Size()
	n += 1 + l + sovJoinserver(uint64(l))
	if m.LoRaWANVersion != 0 {
		n += 1 + sovJoinserver(uint64(m.LoRaWANVersion))
	}
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovJoinserver(uint64(l))
	}
	l = len(m.ProvisionerID)
	if l > 0 {
		n += 1 + l + sovJoinserver(uint64(l))
	}
	if m.ProvisioningData != nil {
		l = m.ProvisioningData.Size()
		n += 1 + l + sovJoinserver(uint64(l))
	}
	return n
}

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

func (m *JoinAcceptMICRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.CryptoServicePayloadRequest.Size()
	n += 1 + l + sovJoinserver(uint64(l))
	if m.JoinRequestType != 0 {
		n += 1 + sovJoinserver(uint64(m.JoinRequestType))
	}
	l = m.DevNonce.Size()
	n += 1 + l + sovJoinserver(uint64(l))
	return n
}

func (m *DeriveSessionKeysRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.EndDeviceIdentifiers.Size()
	n += 1 + l + sovJoinserver(uint64(l))
	if m.LoRaWANVersion != 0 {
		n += 1 + sovJoinserver(uint64(m.LoRaWANVersion))
	}
	l = m.JoinNonce.Size()
	n += 1 + l + sovJoinserver(uint64(l))
	l = m.DevNonce.Size()
	n += 1 + l + sovJoinserver(uint64(l))
	l = m.NetID.Size()
	n += 1 + l + sovJoinserver(uint64(l))
	l = len(m.ProvisionerID)
	if l > 0 {
		n += 1 + l + sovJoinserver(uint64(l))
	}
	if m.ProvisioningData != nil {
		l = m.ProvisioningData.Size()
		n += 1 + l + sovJoinserver(uint64(l))
	}
	return n
}

func (m *GetRootKeysRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.EndDeviceIdentifiers.Size()
	n += 1 + l + sovJoinserver(uint64(l))
	l = len(m.ProvisionerID)
	if l > 0 {
		n += 1 + l + sovJoinserver(uint64(l))
	}
	if m.ProvisioningData != nil {
		l = m.ProvisioningData.Size()
		n += 1 + l + sovJoinserver(uint64(l))
	}
	return n
}

func (m *ProvisionEndDevicesRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ApplicationIdentifiers.Size()
	n += 1 + l + sovJoinserver(uint64(l))
	l = len(m.ProvisionerID)
	if l > 0 {
		n += 1 + l + sovJoinserver(uint64(l))
	}
	l = len(m.ProvisioningData)
	if l > 0 {
		n += 1 + l + sovJoinserver(uint64(l))
	}
	if m.EndDevices != nil {
		n += m.EndDevices.Size()
	}
	return n
}

func (m *ProvisionEndDevicesRequest_List) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.List != nil {
		l = m.List.Size()
		n += 1 + l + sovJoinserver(uint64(l))
	}
	return n
}
func (m *ProvisionEndDevicesRequest_Range) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Range != nil {
		l = m.Range.Size()
		n += 1 + l + sovJoinserver(uint64(l))
	}
	return n
}
func (m *ProvisionEndDevicesRequest_FromData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FromData != nil {
		l = m.FromData.Size()
		n += 1 + l + sovJoinserver(uint64(l))
	}
	return n
}
func (m *ProvisionEndDevicesRequest_IdentifiersList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.JoinEUI != nil {
		l = m.JoinEUI.Size()
		n += 1 + l + sovJoinserver(uint64(l))
	}
	if len(m.EndDeviceIDs) > 0 {
		for _, e := range m.EndDeviceIDs {
			l = e.Size()
			n += 1 + l + sovJoinserver(uint64(l))
		}
	}
	return n
}

func (m *ProvisionEndDevicesRequest_IdentifiersRange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.JoinEUI != nil {
		l = m.JoinEUI.Size()
		n += 1 + l + sovJoinserver(uint64(l))
	}
	l = m.StartDevEUI.Size()
	n += 1 + l + sovJoinserver(uint64(l))
	return n
}

func (m *ProvisionEndDevicesRequest_IdentifiersFromData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.JoinEUI != nil {
		l = m.JoinEUI.Size()
		n += 1 + l + sovJoinserver(uint64(l))
	}
	return n
}

func (m *JoinEUIPrefix) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.JoinEUI.Size()
	n += 1 + l + sovJoinserver(uint64(l))
	if m.Length != 0 {
		n += 1 + sovJoinserver(uint64(m.Length))
	}
	return n
}

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

func sovJoinserver(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozJoinserver(x uint64) (n int) {
	return sovJoinserver((x << 1) ^ uint64((int64(x) >> 63)))
}
func (this *SessionKeyRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SessionKeyRequest{`,
		`SessionKeyID:` + fmt.Sprintf("%v", this.SessionKeyID) + `,`,
		`DevEUI:` + fmt.Sprintf("%v", this.DevEUI) + `,`,
		`JoinEUI:` + fmt.Sprintf("%v", this.JoinEUI) + `,`,
		`}`,
	}, "")
	return s
}
func (this *NwkSKeysResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&NwkSKeysResponse{`,
		`FNwkSIntKey:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.FNwkSIntKey), "KeyEnvelope", "KeyEnvelope", 1), `&`, ``, 1) + `,`,
		`SNwkSIntKey:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.SNwkSIntKey), "KeyEnvelope", "KeyEnvelope", 1), `&`, ``, 1) + `,`,
		`NwkSEncKey:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.NwkSEncKey), "KeyEnvelope", "KeyEnvelope", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *AppSKeyResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&AppSKeyResponse{`,
		`AppSKey:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.AppSKey), "KeyEnvelope", "KeyEnvelope", 1), `&`, ``, 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CryptoServicePayloadRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CryptoServicePayloadRequest{`,
		`EndDeviceIdentifiers:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.EndDeviceIdentifiers), "EndDeviceIdentifiers", "EndDeviceIdentifiers", 1), `&`, ``, 1) + `,`,
		`LoRaWANVersion:` + fmt.Sprintf("%v", this.LoRaWANVersion) + `,`,
		`Payload:` + fmt.Sprintf("%v", this.Payload) + `,`,
		`ProvisionerID:` + fmt.Sprintf("%v", this.ProvisionerID) + `,`,
		`ProvisioningData:` + strings.Replace(fmt.Sprintf("%v", this.ProvisioningData), "Struct", "types.Struct", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CryptoServicePayloadResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CryptoServicePayloadResponse{`,
		`Payload:` + fmt.Sprintf("%v", this.Payload) + `,`,
		`}`,
	}, "")
	return s
}
func (this *JoinAcceptMICRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&JoinAcceptMICRequest{`,
		`CryptoServicePayloadRequest:` + strings.Replace(strings.Replace(this.CryptoServicePayloadRequest.String(), "CryptoServicePayloadRequest", "CryptoServicePayloadRequest", 1), `&`, ``, 1) + `,`,
		`JoinRequestType:` + fmt.Sprintf("%v", this.JoinRequestType) + `,`,
		`DevNonce:` + fmt.Sprintf("%v", this.DevNonce) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeriveSessionKeysRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeriveSessionKeysRequest{`,
		`EndDeviceIdentifiers:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.EndDeviceIdentifiers), "EndDeviceIdentifiers", "EndDeviceIdentifiers", 1), `&`, ``, 1) + `,`,
		`LoRaWANVersion:` + fmt.Sprintf("%v", this.LoRaWANVersion) + `,`,
		`JoinNonce:` + fmt.Sprintf("%v", this.JoinNonce) + `,`,
		`DevNonce:` + fmt.Sprintf("%v", this.DevNonce) + `,`,
		`NetID:` + fmt.Sprintf("%v", this.NetID) + `,`,
		`ProvisionerID:` + fmt.Sprintf("%v", this.ProvisionerID) + `,`,
		`ProvisioningData:` + strings.Replace(fmt.Sprintf("%v", this.ProvisioningData), "Struct", "types.Struct", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetRootKeysRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetRootKeysRequest{`,
		`EndDeviceIdentifiers:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.EndDeviceIdentifiers), "EndDeviceIdentifiers", "EndDeviceIdentifiers", 1), `&`, ``, 1) + `,`,
		`ProvisionerID:` + fmt.Sprintf("%v", this.ProvisionerID) + `,`,
		`ProvisioningData:` + strings.Replace(fmt.Sprintf("%v", this.ProvisioningData), "Struct", "types.Struct", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ProvisionEndDevicesRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ProvisionEndDevicesRequest{`,
		`ApplicationIdentifiers:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ApplicationIdentifiers), "ApplicationIdentifiers", "ApplicationIdentifiers", 1), `&`, ``, 1) + `,`,
		`ProvisionerID:` + fmt.Sprintf("%v", this.ProvisionerID) + `,`,
		`ProvisioningData:` + fmt.Sprintf("%v", this.ProvisioningData) + `,`,
		`EndDevices:` + fmt.Sprintf("%v", this.EndDevices) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ProvisionEndDevicesRequest_List) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ProvisionEndDevicesRequest_List{`,
		`List:` + strings.Replace(fmt.Sprintf("%v", this.List), "ProvisionEndDevicesRequest_IdentifiersList", "ProvisionEndDevicesRequest_IdentifiersList", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ProvisionEndDevicesRequest_Range) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ProvisionEndDevicesRequest_Range{`,
		`Range:` + strings.Replace(fmt.Sprintf("%v", this.Range), "ProvisionEndDevicesRequest_IdentifiersRange", "ProvisionEndDevicesRequest_IdentifiersRange", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ProvisionEndDevicesRequest_FromData) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ProvisionEndDevicesRequest_FromData{`,
		`FromData:` + strings.Replace(fmt.Sprintf("%v", this.FromData), "ProvisionEndDevicesRequest_IdentifiersFromData", "ProvisionEndDevicesRequest_IdentifiersFromData", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ProvisionEndDevicesRequest_IdentifiersList) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForEndDeviceIDs := "[]EndDeviceIdentifiers{"
	for _, f := range this.EndDeviceIDs {
		repeatedStringForEndDeviceIDs += fmt.Sprintf("%v", f) + ","
	}
	repeatedStringForEndDeviceIDs += "}"
	s := strings.Join([]string{`&ProvisionEndDevicesRequest_IdentifiersList{`,
		`JoinEUI:` + fmt.Sprintf("%v", this.JoinEUI) + `,`,
		`EndDeviceIDs:` + repeatedStringForEndDeviceIDs + `,`,
		`}`,
	}, "")
	return s
}
func (this *ProvisionEndDevicesRequest_IdentifiersRange) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ProvisionEndDevicesRequest_IdentifiersRange{`,
		`JoinEUI:` + fmt.Sprintf("%v", this.JoinEUI) + `,`,
		`StartDevEUI:` + fmt.Sprintf("%v", this.StartDevEUI) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ProvisionEndDevicesRequest_IdentifiersFromData) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ProvisionEndDevicesRequest_IdentifiersFromData{`,
		`JoinEUI:` + fmt.Sprintf("%v", this.JoinEUI) + `,`,
		`}`,
	}, "")
	return s
}
func (this *JoinEUIPrefix) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&JoinEUIPrefix{`,
		`JoinEUI:` + fmt.Sprintf("%v", this.JoinEUI) + `,`,
		`Length:` + fmt.Sprintf("%v", this.Length) + `,`,
		`}`,
	}, "")
	return s
}
func (this *JoinEUIPrefixes) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForPrefixes := "[]JoinEUIPrefix{"
	for _, f := range this.Prefixes {
		repeatedStringForPrefixes += strings.Replace(strings.Replace(f.String(), "JoinEUIPrefix", "JoinEUIPrefix", 1), `&`, ``, 1) + ","
	}
	repeatedStringForPrefixes += "}"
	s := strings.Join([]string{`&JoinEUIPrefixes{`,
		`Prefixes:` + repeatedStringForPrefixes + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringJoinserver(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *SessionKeyRequest) 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 ErrIntOverflowJoinserver
			}
			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: SessionKeyRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SessionKeyRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SessionKeyID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJoinserver
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthJoinserver
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthJoinserver
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SessionKeyID = append(m.SessionKeyID[:0], dAtA[iNdEx:postIndex]...)
			if m.SessionKeyID == nil {
				m.SessionKeyID = []byte{}
			}
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowJoinserver
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthJoinserver
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthJoinserver
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.DevEUI.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JoinEUI", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJoinserver
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthJoinserver
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthJoinserver
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.JoinEUI.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipJoinserver(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthJoinserver
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthJoinserver
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CryptoServicePayloadResponse) 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 ErrIntOverflowJoinserver
			}
			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: CryptoServicePayloadResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CryptoServicePayloadResponse: 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 ErrIntOverflowJoinserver
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthJoinserver
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthJoinserver
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...)
			if m.Payload == nil {
				m.Payload = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipJoinserver(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthJoinserver
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthJoinserver
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeriveSessionKeysRequest) 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 ErrIntOverflowJoinserver
			}
			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: DeriveSessionKeysRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeriveSessionKeysRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndDeviceIdentifiers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJoinserver
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthJoinserver
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthJoinserver
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.EndDeviceIdentifiers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LoRaWANVersion", wireType)
			}
			m.LoRaWANVersion = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJoinserver
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LoRaWANVersion |= MACVersion(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JoinNonce", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJoinserver
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthJoinserver
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthJoinserver
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.JoinNonce.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DevNonce", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJoinserver
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthJoinserver
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthJoinserver
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.DevNonce.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NetID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJoinserver
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthJoinserver
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthJoinserver
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.NetID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProvisionerID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJoinserver
				}
				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 ErrInvalidLengthJoinserver
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthJoinserver
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProvisionerID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProvisioningData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJoinserver
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthJoinserver
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthJoinserver
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProvisioningData == nil {
				m.ProvisioningData = &types.Struct{}
			}
			if err := m.ProvisioningData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipJoinserver(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthJoinserver
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthJoinserver
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetRootKeysRequest) 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 ErrIntOverflowJoinserver
			}
			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: GetRootKeysRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetRootKeysRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndDeviceIdentifiers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJoinserver
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthJoinserver
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthJoinserver
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.EndDeviceIdentifiers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProvisionerID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJoinserver
				}
				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 ErrInvalidLengthJoinserver
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthJoinserver
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProvisionerID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProvisioningData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJoinserver
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthJoinserver
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthJoinserver
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProvisioningData == nil {
				m.ProvisioningData = &types.Struct{}
			}
			if err := m.ProvisioningData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipJoinserver(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthJoinserver
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthJoinserver
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProvisionEndDevicesRequest) 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 ErrIntOverflowJoinserver
			}
			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: ProvisionEndDevicesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProvisionEndDevicesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApplicationIdentifiers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJoinserver
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthJoinserver
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthJoinserver
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ApplicationIdentifiers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProvisionerID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJoinserver
				}
				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 ErrInvalidLengthJoinserver
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthJoinserver
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProvisionerID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProvisioningData", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJoinserver
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthJoinserver
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthJoinserver
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProvisioningData = append(m.ProvisioningData[:0], dAtA[iNdEx:postIndex]...)
			if m.ProvisioningData == nil {
				m.ProvisioningData = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field List", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJoinserver
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthJoinserver
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthJoinserver
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ProvisionEndDevicesRequest_IdentifiersList{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.EndDevices = &ProvisionEndDevicesRequest_List{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJoinserver
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthJoinserver
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthJoinserver
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ProvisionEndDevicesRequest_IdentifiersRange{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.EndDevices = &ProvisionEndDevicesRequest_Range{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FromData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJoinserver
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthJoinserver
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthJoinserver
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ProvisionEndDevicesRequest_IdentifiersFromData{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.EndDevices = &ProvisionEndDevicesRequest_FromData{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipJoinserver(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthJoinserver
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthJoinserver
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProvisionEndDevicesRequest_IdentifiersRange) 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 ErrIntOverflowJoinserver
			}
			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: IdentifiersRange: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IdentifiersRange: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JoinEUI", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJoinserver
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthJoinserver
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthJoinserver
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v go_thethings_network_lorawan_stack_v3_pkg_types.EUI64
			m.JoinEUI = &v
			if err := m.JoinEUI.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartDevEUI", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJoinserver
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthJoinserver
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthJoinserver
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.StartDevEUI.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipJoinserver(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthJoinserver
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthJoinserver
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProvisionEndDevicesRequest_IdentifiersFromData) 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 ErrIntOverflowJoinserver
			}
			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: IdentifiersFromData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IdentifiersFromData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JoinEUI", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJoinserver
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthJoinserver
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthJoinserver
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v go_thethings_network_lorawan_stack_v3_pkg_types.EUI64
			m.JoinEUI = &v
			if err := m.JoinEUI.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipJoinserver(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthJoinserver
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthJoinserver
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

var (
	ErrInvalidLengthJoinserver        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowJoinserver          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupJoinserver = fmt.Errorf("proto: unexpected end of group")
)