identifiers.pb.go

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

package ttnpb

import (
	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"
	golang_proto "github.com/golang/protobuf/proto"
	go_thethings_network_lorawan_stack_pkg_types "go.thethings.network/lorawan-stack/pkg/types"
)

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

// 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 ApplicationIdentifiers struct {
	ApplicationID        string   `protobuf:"bytes,1,opt,name=application_id,json=applicationId,proto3" json:"application_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ApplicationIdentifiers proto.InternalMessageInfo

func (m *ApplicationIdentifiers) GetApplicationID() string {
	if m != nil {
		return m.ApplicationID
	}
	return ""
}

type ClientIdentifiers struct {
	ClientID             string   `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ClientIdentifiers proto.InternalMessageInfo

func (m *ClientIdentifiers) GetClientID() string {
	if m != nil {
		return m.ClientID
	}
	return ""
}

type EndDeviceIdentifiers struct {
	DeviceID               string `protobuf:"bytes,1,opt,name=device_id,json=deviceId,proto3" json:"device_id,omitempty"`
	ApplicationIdentifiers `protobuf:"bytes,2,opt,name=application_ids,json=applicationIds,proto3,embedded=application_ids" json:"application_ids"`
	// The LoRaWAN DevEUI.
	DevEUI *go_thethings_network_lorawan_stack_pkg_types.EUI64 `protobuf:"bytes,4,opt,name=dev_eui,json=devEui,proto3,customtype=go.thethings.network/lorawan-stack/pkg/types.EUI64" json:"dev_eui,omitempty"`
	// The LoRaWAN JoinEUI (AppEUI until LoRaWAN 1.0.3 end devices).
	JoinEUI *go_thethings_network_lorawan_stack_pkg_types.EUI64 `protobuf:"bytes,5,opt,name=join_eui,json=joinEui,proto3,customtype=go.thethings.network/lorawan-stack/pkg/types.EUI64" json:"join_eui,omitempty"`
	// The LoRaWAN DevAddr.
	DevAddr              *go_thethings_network_lorawan_stack_pkg_types.DevAddr `protobuf:"bytes,6,opt,name=dev_addr,json=devAddr,proto3,customtype=go.thethings.network/lorawan-stack/pkg/types.DevAddr" json:"dev_addr,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                              `json:"-"`
	XXX_sizecache        int32                                                 `json:"-"`
}

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

var xxx_messageInfo_EndDeviceIdentifiers proto.InternalMessageInfo

func (m *EndDeviceIdentifiers) GetDeviceID() string {
	if m != nil {
		return m.DeviceID
	}
	return ""
}

type GatewayIdentifiers struct {
	GatewayID string `protobuf:"bytes,1,opt,name=gateway_id,json=gatewayId,proto3" json:"gateway_id,omitempty"`
	// Secondary identifier, which can only be used in specific requests.
	EUI                  *go_thethings_network_lorawan_stack_pkg_types.EUI64 `protobuf:"bytes,2,opt,name=eui,proto3,customtype=go.thethings.network/lorawan-stack/pkg/types.EUI64" json:"eui,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                            `json:"-"`
	XXX_sizecache        int32                                               `json:"-"`
}

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

var xxx_messageInfo_GatewayIdentifiers proto.InternalMessageInfo

func (m *GatewayIdentifiers) GetGatewayID() string {
	if m != nil {
		return m.GatewayID
	}
	return ""
}

type OrganizationIdentifiers struct {
	// This ID shares namespace with user IDs.
	OrganizationID       string   `protobuf:"bytes,1,opt,name=organization_id,json=organizationId,proto3" json:"organization_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_OrganizationIdentifiers proto.InternalMessageInfo

func (m *OrganizationIdentifiers) GetOrganizationID() string {
	if m != nil {
		return m.OrganizationID
	}
	return ""
}

type UserIdentifiers struct {
	// This ID shares namespace with organization IDs.
	UserID string `protobuf:"bytes,1,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	// Secondary identifier, which can only be used in specific requests.
	Email                string   `protobuf:"bytes,2,opt,name=email,proto3" json:"email,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_UserIdentifiers proto.InternalMessageInfo

func (m *UserIdentifiers) GetUserID() string {
	if m != nil {
		return m.UserID
	}
	return ""
}

func (m *UserIdentifiers) GetEmail() string {
	if m != nil {
		return m.Email
	}
	return ""
}

// OrganizationOrUserIdentifiers contains either organization or user identifiers.
type OrganizationOrUserIdentifiers struct {
	// Types that are valid to be assigned to Ids:
	//	*OrganizationOrUserIdentifiers_OrganizationIDs
	//	*OrganizationOrUserIdentifiers_UserIDs
	Ids                  isOrganizationOrUserIdentifiers_Ids `protobuf_oneof:"ids"`
	XXX_NoUnkeyedLiteral struct{}                            `json:"-"`
	XXX_sizecache        int32                               `json:"-"`
}

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

var xxx_messageInfo_OrganizationOrUserIdentifiers proto.InternalMessageInfo

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

type OrganizationOrUserIdentifiers_OrganizationIDs struct {
	OrganizationIDs *OrganizationIdentifiers `protobuf:"bytes,1,opt,name=organization_ids,json=organizationIds,proto3,oneof" json:"organization_ids,omitempty"`
}
type OrganizationOrUserIdentifiers_UserIDs struct {
	UserIDs *UserIdentifiers `protobuf:"bytes,2,opt,name=user_ids,json=userIds,proto3,oneof" json:"user_ids,omitempty"`
}

func (*OrganizationOrUserIdentifiers_OrganizationIDs) isOrganizationOrUserIdentifiers_Ids() {}
func (*OrganizationOrUserIdentifiers_UserIDs) isOrganizationOrUserIdentifiers_Ids()         {}

func (m *OrganizationOrUserIdentifiers) GetIds() isOrganizationOrUserIdentifiers_Ids {
	if m != nil {
		return m.Ids
	}
	return nil
}

func (m *OrganizationOrUserIdentifiers) GetOrganizationIDs() *OrganizationIdentifiers {
	if x, ok := m.GetIds().(*OrganizationOrUserIdentifiers_OrganizationIDs); ok {
		return x.OrganizationIDs
	}
	return nil
}

func (m *OrganizationOrUserIdentifiers) GetUserIDs() *UserIdentifiers {
	if x, ok := m.GetIds().(*OrganizationOrUserIdentifiers_UserIDs); ok {
		return x.UserIDs
	}
	return nil
}

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

// EntityIdentifiers contains one of the possible entity identifiers.
type EntityIdentifiers struct {
	// Types that are valid to be assigned to Ids:
	//	*EntityIdentifiers_ApplicationIDs
	//	*EntityIdentifiers_ClientIDs
	//	*EntityIdentifiers_DeviceIDs
	//	*EntityIdentifiers_GatewayIDs
	//	*EntityIdentifiers_OrganizationIDs
	//	*EntityIdentifiers_UserIDs
	Ids                  isEntityIdentifiers_Ids `protobuf_oneof:"ids"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

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

var xxx_messageInfo_EntityIdentifiers proto.InternalMessageInfo

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

type EntityIdentifiers_ApplicationIDs struct {
	ApplicationIDs *ApplicationIdentifiers `protobuf:"bytes,1,opt,name=application_ids,json=applicationIds,proto3,oneof" json:"application_ids,omitempty"`
}
type EntityIdentifiers_ClientIDs struct {
	ClientIDs *ClientIdentifiers `protobuf:"bytes,2,opt,name=client_ids,json=clientIds,proto3,oneof" json:"client_ids,omitempty"`
}
type EntityIdentifiers_DeviceIDs struct {
	DeviceIDs *EndDeviceIdentifiers `protobuf:"bytes,3,opt,name=device_ids,json=deviceIds,proto3,oneof" json:"device_ids,omitempty"`
}
type EntityIdentifiers_GatewayIDs struct {
	GatewayIDs *GatewayIdentifiers `protobuf:"bytes,4,opt,name=gateway_ids,json=gatewayIds,proto3,oneof" json:"gateway_ids,omitempty"`
}
type EntityIdentifiers_OrganizationIDs struct {
	OrganizationIDs *OrganizationIdentifiers `protobuf:"bytes,5,opt,name=organization_ids,json=organizationIds,proto3,oneof" json:"organization_ids,omitempty"`
}
type EntityIdentifiers_UserIDs struct {
	UserIDs *UserIdentifiers `protobuf:"bytes,6,opt,name=user_ids,json=userIds,proto3,oneof" json:"user_ids,omitempty"`
}

func (*EntityIdentifiers_ApplicationIDs) isEntityIdentifiers_Ids()  {}
func (*EntityIdentifiers_ClientIDs) isEntityIdentifiers_Ids()       {}
func (*EntityIdentifiers_DeviceIDs) isEntityIdentifiers_Ids()       {}
func (*EntityIdentifiers_GatewayIDs) isEntityIdentifiers_Ids()      {}
func (*EntityIdentifiers_OrganizationIDs) isEntityIdentifiers_Ids() {}
func (*EntityIdentifiers_UserIDs) isEntityIdentifiers_Ids()         {}

func (m *EntityIdentifiers) GetIds() isEntityIdentifiers_Ids {
	if m != nil {
		return m.Ids
	}
	return nil
}

func (m *EntityIdentifiers) GetApplicationIDs() *ApplicationIdentifiers {
	if x, ok := m.GetIds().(*EntityIdentifiers_ApplicationIDs); ok {
		return x.ApplicationIDs
	}
	return nil
}

func (m *EntityIdentifiers) GetClientIDs() *ClientIdentifiers {
	if x, ok := m.GetIds().(*EntityIdentifiers_ClientIDs); ok {
		return x.ClientIDs
	}
	return nil
}

func (m *EntityIdentifiers) GetDeviceIDs() *EndDeviceIdentifiers {
	if x, ok := m.GetIds().(*EntityIdentifiers_DeviceIDs); ok {
		return x.DeviceIDs
	}
	return nil
}

func (m *EntityIdentifiers) GetGatewayIDs() *GatewayIdentifiers {
	if x, ok := m.GetIds().(*EntityIdentifiers_GatewayIDs); ok {
		return x.GatewayIDs
	}
	return nil
}

func (m *EntityIdentifiers) GetOrganizationIDs() *OrganizationIdentifiers {
	if x, ok := m.GetIds().(*EntityIdentifiers_OrganizationIDs); ok {
		return x.OrganizationIDs
	}
	return nil
}

func (m *EntityIdentifiers) GetUserIDs() *UserIdentifiers {
	if x, ok := m.GetIds().(*EntityIdentifiers_UserIDs); ok {
		return x.UserIDs
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*EntityIdentifiers) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*EntityIdentifiers_ApplicationIDs)(nil),
		(*EntityIdentifiers_ClientIDs)(nil),
		(*EntityIdentifiers_DeviceIDs)(nil),
		(*EntityIdentifiers_GatewayIDs)(nil),
		(*EntityIdentifiers_OrganizationIDs)(nil),
		(*EntityIdentifiers_UserIDs)(nil),
	}
}

// Combine the identifiers of multiple entities.
// The main purpose of this message is its use in events.
type CombinedIdentifiers struct {
	EntityIdentifiers    []*EntityIdentifiers `protobuf:"bytes,1,rep,name=entity_identifiers,json=entityIdentifiers,proto3" json:"entity_identifiers,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

var xxx_messageInfo_CombinedIdentifiers proto.InternalMessageInfo

func (m *CombinedIdentifiers) GetEntityIdentifiers() []*EntityIdentifiers {
	if m != nil {
		return m.EntityIdentifiers
	}
	return nil
}

func init() {
	proto.RegisterType((*ApplicationIdentifiers)(nil), "ttn.lorawan.v3.ApplicationIdentifiers")
	golang_proto.RegisterType((*ApplicationIdentifiers)(nil), "ttn.lorawan.v3.ApplicationIdentifiers")
	proto.RegisterType((*ClientIdentifiers)(nil), "ttn.lorawan.v3.ClientIdentifiers")
	golang_proto.RegisterType((*ClientIdentifiers)(nil), "ttn.lorawan.v3.ClientIdentifiers")
	proto.RegisterType((*EndDeviceIdentifiers)(nil), "ttn.lorawan.v3.EndDeviceIdentifiers")
	golang_proto.RegisterType((*EndDeviceIdentifiers)(nil), "ttn.lorawan.v3.EndDeviceIdentifiers")
	proto.RegisterType((*GatewayIdentifiers)(nil), "ttn.lorawan.v3.GatewayIdentifiers")
	golang_proto.RegisterType((*GatewayIdentifiers)(nil), "ttn.lorawan.v3.GatewayIdentifiers")
	proto.RegisterType((*OrganizationIdentifiers)(nil), "ttn.lorawan.v3.OrganizationIdentifiers")
	golang_proto.RegisterType((*OrganizationIdentifiers)(nil), "ttn.lorawan.v3.OrganizationIdentifiers")
	proto.RegisterType((*UserIdentifiers)(nil), "ttn.lorawan.v3.UserIdentifiers")
	golang_proto.RegisterType((*UserIdentifiers)(nil), "ttn.lorawan.v3.UserIdentifiers")
	proto.RegisterType((*OrganizationOrUserIdentifiers)(nil), "ttn.lorawan.v3.OrganizationOrUserIdentifiers")
	golang_proto.RegisterType((*OrganizationOrUserIdentifiers)(nil), "ttn.lorawan.v3.OrganizationOrUserIdentifiers")
	proto.RegisterType((*EntityIdentifiers)(nil), "ttn.lorawan.v3.EntityIdentifiers")
	golang_proto.RegisterType((*EntityIdentifiers)(nil), "ttn.lorawan.v3.EntityIdentifiers")
	proto.RegisterType((*CombinedIdentifiers)(nil), "ttn.lorawan.v3.CombinedIdentifiers")
	golang_proto.RegisterType((*CombinedIdentifiers)(nil), "ttn.lorawan.v3.CombinedIdentifiers")
}

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

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

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

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

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

	that1, ok := that.(*EndDeviceIdentifiers)
	if !ok {
		that2, ok := that.(EndDeviceIdentifiers)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.DeviceID != that1.DeviceID {
		return false
	}
	if !this.ApplicationIdentifiers.Equal(&that1.ApplicationIdentifiers) {
		return false
	}
	if that1.DevEUI == nil {
		if this.DevEUI != nil {
			return false
		}
	} else if !this.DevEUI.Equal(*that1.DevEUI) {
		return false
	}
	if that1.JoinEUI == nil {
		if this.JoinEUI != nil {
			return false
		}
	} else if !this.JoinEUI.Equal(*that1.JoinEUI) {
		return false
	}
	if that1.DevAddr == nil {
		if this.DevAddr != nil {
			return false
		}
	} else if !this.DevAddr.Equal(*that1.DevAddr) {
		return false
	}
	return true
}
func (this *GatewayIdentifiers) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

	that1, ok := that.(*CombinedIdentifiers)
	if !ok {
		that2, ok := that.(CombinedIdentifiers)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.EntityIdentifiers) != len(that1.EntityIdentifiers) {
		return false
	}
	for i := range this.EntityIdentifiers {
		if !this.EntityIdentifiers[i].Equal(that1.EntityIdentifiers[i]) {
			return false
		}
	}
	return true
}
func (m *ApplicationIdentifiers) 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 *ApplicationIdentifiers) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

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

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

func (m *EndDeviceIdentifiers) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DevAddr != nil {
		{
			size := m.DevAddr.Size()
			i -= size
			if _, err := m.DevAddr.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintIdentifiers(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.JoinEUI != nil {
		{
			size := m.JoinEUI.Size()
			i -= size
			if _, err := m.JoinEUI.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintIdentifiers(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.DevEUI != nil {
		{
			size := m.DevEUI.Size()
			i -= size
			if _, err := m.DevEUI.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintIdentifiers(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	{
		size, err := m.ApplicationIdentifiers.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintIdentifiers(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.DeviceID) > 0 {
		i -= len(m.DeviceID)
		copy(dAtA[i:], m.DeviceID)
		i = encodeVarintIdentifiers(dAtA, i, uint64(len(m.DeviceID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *GatewayIdentifiers) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.EUI != nil {
		{
			size := m.EUI.Size()
			i -= size
			if _, err := m.EUI.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintIdentifiers(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.GatewayID) > 0 {
		i -= len(m.GatewayID)
		copy(dAtA[i:], m.GatewayID)
		i = encodeVarintIdentifiers(dAtA, i, uint64(len(m.GatewayID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

func (m *OrganizationOrUserIdentifiers_OrganizationIDs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.OrganizationIDs != nil {
		{
			size, err := m.OrganizationIDs.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintIdentifiers(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *OrganizationOrUserIdentifiers_UserIDs) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OrganizationOrUserIdentifiers_UserIDs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.UserIDs != nil {
		{
			size, err := m.UserIDs.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintIdentifiers(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *EntityIdentifiers) 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 *EntityIdentifiers) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *EntityIdentifiers_ApplicationIDs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ApplicationIDs != nil {
		{
			size, err := m.ApplicationIDs.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintIdentifiers(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *EntityIdentifiers_ClientIDs) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EntityIdentifiers_ClientIDs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ClientIDs != nil {
		{
			size, err := m.ClientIDs.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintIdentifiers(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *EntityIdentifiers_DeviceIDs) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EntityIdentifiers_DeviceIDs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.DeviceIDs != nil {
		{
			size, err := m.DeviceIDs.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintIdentifiers(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *EntityIdentifiers_GatewayIDs) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *EntityIdentifiers_UserIDs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.UserIDs != nil {
		{
			size, err := m.UserIDs.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintIdentifiers(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *CombinedIdentifiers) 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 *CombinedIdentifiers) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func encodeVarintIdentifiers(dAtA []byte, offset int, v uint64) int {
	offset -= sovIdentifiers(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func NewPopulatedOrganizationOrUserIdentifiers(r randyIdentifiers, easy bool) *OrganizationOrUserIdentifiers {
	this := &OrganizationOrUserIdentifiers{}
	oneofNumber_Ids := []int32{1, 2}[r.Intn(2)]
	switch oneofNumber_Ids {
	case 1:
		this.Ids = NewPopulatedOrganizationOrUserIdentifiers_OrganizationIDs(r, easy)
	case 2:
		this.Ids = NewPopulatedOrganizationOrUserIdentifiers_UserIDs(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedOrganizationOrUserIdentifiers_OrganizationIDs(r randyIdentifiers, easy bool) *OrganizationOrUserIdentifiers_OrganizationIDs {
	this := &OrganizationOrUserIdentifiers_OrganizationIDs{}
	this.OrganizationIDs = NewPopulatedOrganizationIdentifiers(r, easy)
	return this
}
func NewPopulatedOrganizationOrUserIdentifiers_UserIDs(r randyIdentifiers, easy bool) *OrganizationOrUserIdentifiers_UserIDs {
	this := &OrganizationOrUserIdentifiers_UserIDs{}
	this.UserIDs = NewPopulatedUserIdentifiers(r, easy)
	return this
}
func NewPopulatedEntityIdentifiers(r randyIdentifiers, easy bool) *EntityIdentifiers {
	this := &EntityIdentifiers{}
	oneofNumber_Ids := []int32{1, 2, 3, 4, 5, 6}[r.Intn(6)]
	switch oneofNumber_Ids {
	case 1:
		this.Ids = NewPopulatedEntityIdentifiers_ApplicationIDs(r, easy)
	case 2:
		this.Ids = NewPopulatedEntityIdentifiers_ClientIDs(r, easy)
	case 3:
		this.Ids = NewPopulatedEntityIdentifiers_DeviceIDs(r, easy)
	case 4:
		this.Ids = NewPopulatedEntityIdentifiers_GatewayIDs(r, easy)
	case 5:
		this.Ids = NewPopulatedEntityIdentifiers_OrganizationIDs(r, easy)
	case 6:
		this.Ids = NewPopulatedEntityIdentifiers_UserIDs(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedEntityIdentifiers_ApplicationIDs(r randyIdentifiers, easy bool) *EntityIdentifiers_ApplicationIDs {
	this := &EntityIdentifiers_ApplicationIDs{}
	this.ApplicationIDs = NewPopulatedApplicationIdentifiers(r, easy)
	return this
}
func NewPopulatedEntityIdentifiers_ClientIDs(r randyIdentifiers, easy bool) *EntityIdentifiers_ClientIDs {
	this := &EntityIdentifiers_ClientIDs{}
	this.ClientIDs = NewPopulatedClientIdentifiers(r, easy)
	return this
}
func NewPopulatedEntityIdentifiers_DeviceIDs(r randyIdentifiers, easy bool) *EntityIdentifiers_DeviceIDs {
	this := &EntityIdentifiers_DeviceIDs{}
	this.DeviceIDs = NewPopulatedEndDeviceIdentifiers(r, easy)
	return this
}
func NewPopulatedEntityIdentifiers_GatewayIDs(r randyIdentifiers, easy bool) *EntityIdentifiers_GatewayIDs {
	this := &EntityIdentifiers_GatewayIDs{}
	this.GatewayIDs = NewPopulatedGatewayIdentifiers(r, easy)
	return this
}
func NewPopulatedEntityIdentifiers_OrganizationIDs(r randyIdentifiers, easy bool) *EntityIdentifiers_OrganizationIDs {
	this := &EntityIdentifiers_OrganizationIDs{}
	this.OrganizationIDs = NewPopulatedOrganizationIdentifiers(r, easy)
	return this
}
func NewPopulatedEntityIdentifiers_UserIDs(r randyIdentifiers, easy bool) *EntityIdentifiers_UserIDs {
	this := &EntityIdentifiers_UserIDs{}
	this.UserIDs = NewPopulatedUserIdentifiers(r, easy)
	return this
}
func NewPopulatedCombinedIdentifiers(r randyIdentifiers, easy bool) *CombinedIdentifiers {
	this := &CombinedIdentifiers{}
	if r.Intn(5) != 0 {
		v1 := r.Intn(5)
		this.EntityIdentifiers = make([]*EntityIdentifiers, v1)
		for i := 0; i < v1; i++ {
			this.EntityIdentifiers[i] = NewPopulatedEntityIdentifiers(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

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

func randUTF8RuneIdentifiers(r randyIdentifiers) 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 randStringIdentifiers(r randyIdentifiers) string {
	v2 := r.Intn(100)
	tmps := make([]rune, v2)
	for i := 0; i < v2; i++ {
		tmps[i] = randUTF8RuneIdentifiers(r)
	}
	return string(tmps)
}
func randUnrecognizedIdentifiers(r randyIdentifiers, 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 = randFieldIdentifiers(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldIdentifiers(dAtA []byte, r randyIdentifiers, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateIdentifiers(dAtA, uint64(key))
		v3 := r.Int63()
		if r.Intn(2) == 0 {
			v3 *= -1
		}
		dAtA = encodeVarintPopulateIdentifiers(dAtA, uint64(v3))
	case 1:
		dAtA = encodeVarintPopulateIdentifiers(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 = encodeVarintPopulateIdentifiers(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateIdentifiers(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateIdentifiers(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 encodeVarintPopulateIdentifiers(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 *ApplicationIdentifiers) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ApplicationID)
	if l > 0 {
		n += 1 + l + sovIdentifiers(uint64(l))
	}
	return n
}

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

func (m *EndDeviceIdentifiers) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.DeviceID)
	if l > 0 {
		n += 1 + l + sovIdentifiers(uint64(l))
	}
	l = m.ApplicationIdentifiers.Size()
	n += 1 + l + sovIdentifiers(uint64(l))
	if m.DevEUI != nil {
		l = m.DevEUI.Size()
		n += 1 + l + sovIdentifiers(uint64(l))
	}
	if m.JoinEUI != nil {
		l = m.JoinEUI.Size()
		n += 1 + l + sovIdentifiers(uint64(l))
	}
	if m.DevAddr != nil {
		l = m.DevAddr.Size()
		n += 1 + l + sovIdentifiers(uint64(l))
	}
	return n
}

func (m *GatewayIdentifiers) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.GatewayID)
	if l > 0 {
		n += 1 + l + sovIdentifiers(uint64(l))
	}
	if m.EUI != nil {
		l = m.EUI.Size()
		n += 1 + l + sovIdentifiers(uint64(l))
	}
	return n
}

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

func (m *UserIdentifiers) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.UserID)
	if l > 0 {
		n += 1 + l + sovIdentifiers(uint64(l))
	}
	l = len(m.Email)
	if l > 0 {
		n += 1 + l + sovIdentifiers(uint64(l))
	}
	return n
}

func (m *OrganizationOrUserIdentifiers) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Ids != nil {
		n += m.Ids.Size()
	}
	return n
}

func (m *OrganizationOrUserIdentifiers_OrganizationIDs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OrganizationIDs != nil {
		l = m.OrganizationIDs.Size()
		n += 1 + l + sovIdentifiers(uint64(l))
	}
	return n
}
func (m *OrganizationOrUserIdentifiers_UserIDs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.UserIDs != nil {
		l = m.UserIDs.Size()
		n += 1 + l + sovIdentifiers(uint64(l))
	}
	return n
}
func (m *EntityIdentifiers) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Ids != nil {
		n += m.Ids.Size()
	}
	return n
}

func (m *EntityIdentifiers_ApplicationIDs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ApplicationIDs != nil {
		l = m.ApplicationIDs.Size()
		n += 1 + l + sovIdentifiers(uint64(l))
	}
	return n
}
func (m *EntityIdentifiers_ClientIDs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ClientIDs != nil {
		l = m.ClientIDs.Size()
		n += 1 + l + sovIdentifiers(uint64(l))
	}
	return n
}
func (m *EntityIdentifiers_DeviceIDs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.DeviceIDs != nil {
		l = m.DeviceIDs.Size()
		n += 1 + l + sovIdentifiers(uint64(l))
	}
	return n
}
func (m *EntityIdentifiers_GatewayIDs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GatewayIDs != nil {
		l = m.GatewayIDs.Size()
		n += 1 + l + sovIdentifiers(uint64(l))
	}
	return n
}
func (m *EntityIdentifiers_OrganizationIDs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OrganizationIDs != nil {
		l = m.OrganizationIDs.Size()
		n += 1 + l + sovIdentifiers(uint64(l))
	}
	return n
}
func (m *EntityIdentifiers_UserIDs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.UserIDs != nil {
		l = m.UserIDs.Size()
		n += 1 + l + sovIdentifiers(uint64(l))
	}
	return n
}
func (m *CombinedIdentifiers) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.EntityIdentifiers) > 0 {
		for _, e := range m.EntityIdentifiers {
			l = e.Size()
			n += 1 + l + sovIdentifiers(uint64(l))
		}
	}
	return n
}

func sovIdentifiers(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozIdentifiers(x uint64) (n int) {
	return sovIdentifiers((x << 1) ^ uint64((int64(x) >> 63)))
}
func (this *ApplicationIdentifiers) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ApplicationIdentifiers{`,
		`ApplicationID:` + fmt.Sprintf("%v", this.ApplicationID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ClientIdentifiers) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ClientIdentifiers{`,
		`ClientID:` + fmt.Sprintf("%v", this.ClientID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EndDeviceIdentifiers) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EndDeviceIdentifiers{`,
		`DeviceID:` + fmt.Sprintf("%v", this.DeviceID) + `,`,
		`ApplicationIdentifiers:` + strings.Replace(strings.Replace(this.ApplicationIdentifiers.String(), "ApplicationIdentifiers", "ApplicationIdentifiers", 1), `&`, ``, 1) + `,`,
		`DevEUI:` + fmt.Sprintf("%v", this.DevEUI) + `,`,
		`JoinEUI:` + fmt.Sprintf("%v", this.JoinEUI) + `,`,
		`DevAddr:` + fmt.Sprintf("%v", this.DevAddr) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GatewayIdentifiers) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GatewayIdentifiers{`,
		`GatewayID:` + fmt.Sprintf("%v", this.GatewayID) + `,`,
		`EUI:` + fmt.Sprintf("%v", this.EUI) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OrganizationIdentifiers) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&OrganizationIdentifiers{`,
		`OrganizationID:` + fmt.Sprintf("%v", this.OrganizationID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *UserIdentifiers) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&UserIdentifiers{`,
		`UserID:` + fmt.Sprintf("%v", this.UserID) + `,`,
		`Email:` + fmt.Sprintf("%v", this.Email) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OrganizationOrUserIdentifiers) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&OrganizationOrUserIdentifiers{`,
		`Ids:` + fmt.Sprintf("%v", this.Ids) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OrganizationOrUserIdentifiers_OrganizationIDs) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&OrganizationOrUserIdentifiers_OrganizationIDs{`,
		`OrganizationIDs:` + strings.Replace(fmt.Sprintf("%v", this.OrganizationIDs), "OrganizationIdentifiers", "OrganizationIdentifiers", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OrganizationOrUserIdentifiers_UserIDs) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&OrganizationOrUserIdentifiers_UserIDs{`,
		`UserIDs:` + strings.Replace(fmt.Sprintf("%v", this.UserIDs), "UserIdentifiers", "UserIdentifiers", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EntityIdentifiers) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EntityIdentifiers{`,
		`Ids:` + fmt.Sprintf("%v", this.Ids) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EntityIdentifiers_ApplicationIDs) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EntityIdentifiers_ApplicationIDs{`,
		`ApplicationIDs:` + strings.Replace(fmt.Sprintf("%v", this.ApplicationIDs), "ApplicationIdentifiers", "ApplicationIdentifiers", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EntityIdentifiers_ClientIDs) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EntityIdentifiers_ClientIDs{`,
		`ClientIDs:` + strings.Replace(fmt.Sprintf("%v", this.ClientIDs), "ClientIdentifiers", "ClientIdentifiers", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EntityIdentifiers_DeviceIDs) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EntityIdentifiers_DeviceIDs{`,
		`DeviceIDs:` + strings.Replace(fmt.Sprintf("%v", this.DeviceIDs), "EndDeviceIdentifiers", "EndDeviceIdentifiers", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EntityIdentifiers_GatewayIDs) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EntityIdentifiers_GatewayIDs{`,
		`GatewayIDs:` + strings.Replace(fmt.Sprintf("%v", this.GatewayIDs), "GatewayIdentifiers", "GatewayIdentifiers", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EntityIdentifiers_OrganizationIDs) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EntityIdentifiers_OrganizationIDs{`,
		`OrganizationIDs:` + strings.Replace(fmt.Sprintf("%v", this.OrganizationIDs), "OrganizationIdentifiers", "OrganizationIdentifiers", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EntityIdentifiers_UserIDs) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EntityIdentifiers_UserIDs{`,
		`UserIDs:` + strings.Replace(fmt.Sprintf("%v", this.UserIDs), "UserIdentifiers", "UserIdentifiers", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CombinedIdentifiers) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForEntityIdentifiers := "[]*EntityIdentifiers{"
	for _, f := range this.EntityIdentifiers {
		repeatedStringForEntityIdentifiers += strings.Replace(f.String(), "EntityIdentifiers", "EntityIdentifiers", 1) + ","
	}
	repeatedStringForEntityIdentifiers += "}"
	s := strings.Join([]string{`&CombinedIdentifiers{`,
		`EntityIdentifiers:` + repeatedStringForEntityIdentifiers + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringIdentifiers(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *ApplicationIdentifiers) 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 ErrIntOverflowIdentifiers
			}
			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: ApplicationIdentifiers: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ApplicationIdentifiers: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApplicationID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIdentifiers
				}
				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 ErrInvalidLengthIdentifiers
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthIdentifiers
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ApplicationID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipIdentifiers(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthIdentifiers
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthIdentifiers
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EndDeviceIdentifiers) 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 ErrIntOverflowIdentifiers
			}
			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: EndDeviceIdentifiers: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EndDeviceIdentifiers: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeviceID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIdentifiers
				}
				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 ErrInvalidLengthIdentifiers
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthIdentifiers
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DeviceID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowIdentifiers
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthIdentifiers
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthIdentifiers
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ApplicationIdentifiers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			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 ErrIntOverflowIdentifiers
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthIdentifiers
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthIdentifiers
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v go_thethings_network_lorawan_stack_pkg_types.EUI64
			m.DevEUI = &v
			if err := m.DevEUI.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			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 ErrIntOverflowIdentifiers
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthIdentifiers
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthIdentifiers
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v go_thethings_network_lorawan_stack_pkg_types.EUI64
			m.JoinEUI = &v
			if err := m.JoinEUI.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DevAddr", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIdentifiers
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthIdentifiers
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthIdentifiers
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v go_thethings_network_lorawan_stack_pkg_types.DevAddr
			m.DevAddr = &v
			if err := m.DevAddr.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipIdentifiers(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthIdentifiers
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthIdentifiers
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EntityIdentifiers) 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 ErrIntOverflowIdentifiers
			}
			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: EntityIdentifiers: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EntityIdentifiers: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ApplicationIDs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIdentifiers
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthIdentifiers
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthIdentifiers
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ApplicationIdentifiers{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Ids = &EntityIdentifiers_ApplicationIDs{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClientIDs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIdentifiers
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthIdentifiers
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthIdentifiers
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ClientIdentifiers{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Ids = &EntityIdentifiers_ClientIDs{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeviceIDs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIdentifiers
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthIdentifiers
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthIdentifiers
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EndDeviceIdentifiers{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Ids = &EntityIdentifiers_DeviceIDs{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GatewayIDs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIdentifiers
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthIdentifiers
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthIdentifiers
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &GatewayIdentifiers{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Ids = &EntityIdentifiers_GatewayIDs{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrganizationIDs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIdentifiers
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthIdentifiers
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthIdentifiers
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &OrganizationIdentifiers{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Ids = &EntityIdentifiers_OrganizationIDs{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserIDs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowIdentifiers
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthIdentifiers
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthIdentifiers
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &UserIdentifiers{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Ids = &EntityIdentifiers_UserIDs{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipIdentifiers(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthIdentifiers
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthIdentifiers
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

var (
	ErrInvalidLengthIdentifiers        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowIdentifiers          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupIdentifiers = fmt.Errorf("proto: unexpected end of group")
)