github.com/onosproject/onos-api/go@v0.10.32/onos/e2t/e2/v1beta1/e2.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: onos/e2t/e2/v1beta1/e2.proto

// Package onos.e2t.e2.v1beta1 defines the interior gRPC interfaces for xApps to interact with E2T.

package v1beta1

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	golang_proto "github.com/golang/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

// 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 Encoding int32

const (
	Encoding_PROTO    Encoding = 0
	Encoding_ASN1_PER Encoding = 1
	Encoding_ASN1_XER Encoding = 2
)

var Encoding_name = map[int32]string{
	0: "PROTO",
	1: "ASN1_PER",
	2: "ASN1_XER",
}

var Encoding_value = map[string]int32{
	"PROTO":    0,
	"ASN1_PER": 1,
	"ASN1_XER": 2,
}

func (x Encoding) String() string {
	return proto.EnumName(Encoding_name, int32(x))
}

func (Encoding) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_39739724a62a6409, []int{0}
}

type Error_Cause_Misc_Type int32

const (
	Error_Cause_Misc_UNSPECIFIED                 Error_Cause_Misc_Type = 0
	Error_Cause_Misc_CONTROL_PROCESSING_OVERLOAD Error_Cause_Misc_Type = 1
	Error_Cause_Misc_HARDWARE_FAILURE            Error_Cause_Misc_Type = 2
	Error_Cause_Misc_OM_INTERVENTION             Error_Cause_Misc_Type = 3
)

var Error_Cause_Misc_Type_name = map[int32]string{
	0: "UNSPECIFIED",
	1: "CONTROL_PROCESSING_OVERLOAD",
	2: "HARDWARE_FAILURE",
	3: "OM_INTERVENTION",
}

var Error_Cause_Misc_Type_value = map[string]int32{
	"UNSPECIFIED":                 0,
	"CONTROL_PROCESSING_OVERLOAD": 1,
	"HARDWARE_FAILURE":            2,
	"OM_INTERVENTION":             3,
}

func (x Error_Cause_Misc_Type) String() string {
	return proto.EnumName(Error_Cause_Misc_Type_name, int32(x))
}

func (Error_Cause_Misc_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_39739724a62a6409, []int{3, 0, 1, 0}
}

type Error_Cause_Protocol_Type int32

const (
	Error_Cause_Protocol_UNSPECIFIED                                       Error_Cause_Protocol_Type = 0
	Error_Cause_Protocol_TRANSFER_SYNTAX_ERROR                             Error_Cause_Protocol_Type = 1
	Error_Cause_Protocol_ABSTRACT_SYNTAX_ERROR_REJECT                      Error_Cause_Protocol_Type = 2
	Error_Cause_Protocol_ABSTRACT_SYNTAX_ERROR_IGNORE_AND_NOTIFY           Error_Cause_Protocol_Type = 3
	Error_Cause_Protocol_MESSAGE_NOT_COMPATIBLE_WITH_RECEIVER_STATE        Error_Cause_Protocol_Type = 4
	Error_Cause_Protocol_SEMANTIC_ERROR                                    Error_Cause_Protocol_Type = 5
	Error_Cause_Protocol_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE Error_Cause_Protocol_Type = 6
)

var Error_Cause_Protocol_Type_name = map[int32]string{
	0: "UNSPECIFIED",
	1: "TRANSFER_SYNTAX_ERROR",
	2: "ABSTRACT_SYNTAX_ERROR_REJECT",
	3: "ABSTRACT_SYNTAX_ERROR_IGNORE_AND_NOTIFY",
	4: "MESSAGE_NOT_COMPATIBLE_WITH_RECEIVER_STATE",
	5: "SEMANTIC_ERROR",
	6: "ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE",
}

var Error_Cause_Protocol_Type_value = map[string]int32{
	"UNSPECIFIED":                                       0,
	"TRANSFER_SYNTAX_ERROR":                             1,
	"ABSTRACT_SYNTAX_ERROR_REJECT":                      2,
	"ABSTRACT_SYNTAX_ERROR_IGNORE_AND_NOTIFY":           3,
	"MESSAGE_NOT_COMPATIBLE_WITH_RECEIVER_STATE":        4,
	"SEMANTIC_ERROR":                                    5,
	"ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE": 6,
}

func (x Error_Cause_Protocol_Type) String() string {
	return proto.EnumName(Error_Cause_Protocol_Type_name, int32(x))
}

func (Error_Cause_Protocol_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_39739724a62a6409, []int{3, 0, 2, 0}
}

type Error_Cause_Ric_Type int32

const (
	Error_Cause_Ric_UNSPECIFIED                                    Error_Cause_Ric_Type = 0
	Error_Cause_Ric_RAN_FUNCTION_ID_INVALID                        Error_Cause_Ric_Type = 1
	Error_Cause_Ric_ACTION_NOT_SUPPORTED                           Error_Cause_Ric_Type = 2
	Error_Cause_Ric_EXCESSIVE_ACTIONS                              Error_Cause_Ric_Type = 3
	Error_Cause_Ric_DUPLICATE_ACTION                               Error_Cause_Ric_Type = 4
	Error_Cause_Ric_DUPLICATE_EVENT                                Error_Cause_Ric_Type = 5
	Error_Cause_Ric_FUNCTION_RESOURCE_LIMIT                        Error_Cause_Ric_Type = 6
	Error_Cause_Ric_REQUEST_ID_UNKNOWN                             Error_Cause_Ric_Type = 7
	Error_Cause_Ric_INCONSISTENT_ACTION_SUBSEQUENT_ACTION_SEQUENCE Error_Cause_Ric_Type = 8
	Error_Cause_Ric_CONTROL_MESSAGE_INVALID                        Error_Cause_Ric_Type = 9
	Error_Cause_Ric_CALL_PROCESS_ID_INVALID                        Error_Cause_Ric_Type = 10
	Error_Cause_Ric_CONTROL_TIMER_EXPIRED                          Error_Cause_Ric_Type = 11
	Error_Cause_Ric_CONTROL_FAILED_TO_EXECUTE                      Error_Cause_Ric_Type = 12
	Error_Cause_Ric_CONTROL_SYSTEM_NOT_READY                       Error_Cause_Ric_Type = 13
)

var Error_Cause_Ric_Type_name = map[int32]string{
	0:  "UNSPECIFIED",
	1:  "RAN_FUNCTION_ID_INVALID",
	2:  "ACTION_NOT_SUPPORTED",
	3:  "EXCESSIVE_ACTIONS",
	4:  "DUPLICATE_ACTION",
	5:  "DUPLICATE_EVENT",
	6:  "FUNCTION_RESOURCE_LIMIT",
	7:  "REQUEST_ID_UNKNOWN",
	8:  "INCONSISTENT_ACTION_SUBSEQUENT_ACTION_SEQUENCE",
	9:  "CONTROL_MESSAGE_INVALID",
	10: "CALL_PROCESS_ID_INVALID",
	11: "CONTROL_TIMER_EXPIRED",
	12: "CONTROL_FAILED_TO_EXECUTE",
	13: "CONTROL_SYSTEM_NOT_READY",
}

var Error_Cause_Ric_Type_value = map[string]int32{
	"UNSPECIFIED":                                    0,
	"RAN_FUNCTION_ID_INVALID":                        1,
	"ACTION_NOT_SUPPORTED":                           2,
	"EXCESSIVE_ACTIONS":                              3,
	"DUPLICATE_ACTION":                               4,
	"DUPLICATE_EVENT":                                5,
	"FUNCTION_RESOURCE_LIMIT":                        6,
	"REQUEST_ID_UNKNOWN":                             7,
	"INCONSISTENT_ACTION_SUBSEQUENT_ACTION_SEQUENCE": 8,
	"CONTROL_MESSAGE_INVALID":                        9,
	"CALL_PROCESS_ID_INVALID":                        10,
	"CONTROL_TIMER_EXPIRED":                          11,
	"CONTROL_FAILED_TO_EXECUTE":                      12,
	"CONTROL_SYSTEM_NOT_READY":                       13,
}

func (x Error_Cause_Ric_Type) String() string {
	return proto.EnumName(Error_Cause_Ric_Type_name, int32(x))
}

func (Error_Cause_Ric_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_39739724a62a6409, []int{3, 0, 3, 0}
}

type Error_Cause_RicService_Type int32

const (
	Error_Cause_RicService_UNSPECIFIED           Error_Cause_RicService_Type = 0
	Error_Cause_RicService_FUNCTION_NOT_REQUIRED Error_Cause_RicService_Type = 1
	Error_Cause_RicService_EXCESSIVE_FUNCTIONS   Error_Cause_RicService_Type = 2
	Error_Cause_RicService_RIC_RESOURCE_LIMIT    Error_Cause_RicService_Type = 3
)

var Error_Cause_RicService_Type_name = map[int32]string{
	0: "UNSPECIFIED",
	1: "FUNCTION_NOT_REQUIRED",
	2: "EXCESSIVE_FUNCTIONS",
	3: "RIC_RESOURCE_LIMIT",
}

var Error_Cause_RicService_Type_value = map[string]int32{
	"UNSPECIFIED":           0,
	"FUNCTION_NOT_REQUIRED": 1,
	"EXCESSIVE_FUNCTIONS":   2,
	"RIC_RESOURCE_LIMIT":    3,
}

func (x Error_Cause_RicService_Type) String() string {
	return proto.EnumName(Error_Cause_RicService_Type_name, int32(x))
}

func (Error_Cause_RicService_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_39739724a62a6409, []int{3, 0, 4, 0}
}

type Error_Cause_Transport_Type int32

const (
	Error_Cause_Transport_UNSPECIFIED                    Error_Cause_Transport_Type = 0
	Error_Cause_Transport_TRANSPORT_RESOURCE_UNAVAILABLE Error_Cause_Transport_Type = 1
)

var Error_Cause_Transport_Type_name = map[int32]string{
	0: "UNSPECIFIED",
	1: "TRANSPORT_RESOURCE_UNAVAILABLE",
}

var Error_Cause_Transport_Type_value = map[string]int32{
	"UNSPECIFIED":                    0,
	"TRANSPORT_RESOURCE_UNAVAILABLE": 1,
}

func (x Error_Cause_Transport_Type) String() string {
	return proto.EnumName(Error_Cause_Transport_Type_name, int32(x))
}

func (Error_Cause_Transport_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_39739724a62a6409, []int{3, 0, 5, 0}
}

type RequestHeaders struct {
	AppID         AppID         `protobuf:"bytes,1,opt,name=app_id,json=appId,proto3,casttype=AppID" json:"app_id,omitempty"`
	AppInstanceID AppInstanceID `protobuf:"bytes,2,opt,name=app_instance_id,json=appInstanceId,proto3,casttype=AppInstanceID" json:"app_instance_id,omitempty"`
	E2NodeID      E2NodeID      `protobuf:"bytes,3,opt,name=e2_node_id,json=e2NodeId,proto3,casttype=E2NodeID" json:"e2_node_id,omitempty"`
	ServiceModel  ServiceModel  `protobuf:"bytes,4,opt,name=service_model,json=serviceModel,proto3" json:"service_model"`
	Encoding      Encoding      `protobuf:"varint,5,opt,name=encoding,proto3,enum=onos.e2t.e2.v1beta1.Encoding" json:"encoding,omitempty"`
}

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

var xxx_messageInfo_RequestHeaders proto.InternalMessageInfo

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

func (m *RequestHeaders) GetAppInstanceID() AppInstanceID {
	if m != nil {
		return m.AppInstanceID
	}
	return ""
}

func (m *RequestHeaders) GetE2NodeID() E2NodeID {
	if m != nil {
		return m.E2NodeID
	}
	return ""
}

func (m *RequestHeaders) GetServiceModel() ServiceModel {
	if m != nil {
		return m.ServiceModel
	}
	return ServiceModel{}
}

func (m *RequestHeaders) GetEncoding() Encoding {
	if m != nil {
		return m.Encoding
	}
	return Encoding_PROTO
}

type ResponseHeaders struct {
	Encoding Encoding `protobuf:"varint,1,opt,name=encoding,proto3,enum=onos.e2t.e2.v1beta1.Encoding" json:"encoding,omitempty"`
}

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

var xxx_messageInfo_ResponseHeaders proto.InternalMessageInfo

func (m *ResponseHeaders) GetEncoding() Encoding {
	if m != nil {
		return m.Encoding
	}
	return Encoding_PROTO
}

type ServiceModel struct {
	Name    ServiceModelName    `protobuf:"bytes,1,opt,name=name,proto3,casttype=ServiceModelName" json:"name,omitempty"`
	Version ServiceModelVersion `protobuf:"bytes,2,opt,name=version,proto3,casttype=ServiceModelVersion" json:"version,omitempty"`
}

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

var xxx_messageInfo_ServiceModel proto.InternalMessageInfo

func (m *ServiceModel) GetName() ServiceModelName {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ServiceModel) GetVersion() ServiceModelVersion {
	if m != nil {
		return m.Version
	}
	return ""
}

// Error is an E2AP protocol error
type Error struct {
	Cause *Error_Cause `protobuf:"bytes,1,opt,name=cause,proto3" json:"cause,omitempty"`
}

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

var xxx_messageInfo_Error proto.InternalMessageInfo

func (m *Error) GetCause() *Error_Cause {
	if m != nil {
		return m.Cause
	}
	return nil
}

type Error_Cause struct {
	// Types that are valid to be assigned to Cause:
	//
	//	*Error_Cause_Unknown_
	//	*Error_Cause_Protocol_
	//	*Error_Cause_Ric_
	//	*Error_Cause_RicService_
	//	*Error_Cause_Transport_
	//	*Error_Cause_Misc_
	Cause isError_Cause_Cause `protobuf_oneof:"cause"`
}

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

var xxx_messageInfo_Error_Cause proto.InternalMessageInfo

type isError_Cause_Cause interface {
	isError_Cause_Cause()
	MarshalTo([]byte) (int, error)
	Size() int
}

type Error_Cause_Unknown_ struct {
	Unknown *Error_Cause_Unknown `protobuf:"bytes,1,opt,name=unknown,proto3,oneof" json:"unknown,omitempty"`
}
type Error_Cause_Protocol_ struct {
	Protocol *Error_Cause_Protocol `protobuf:"bytes,2,opt,name=protocol,proto3,oneof" json:"protocol,omitempty"`
}
type Error_Cause_Ric_ struct {
	Ric *Error_Cause_Ric `protobuf:"bytes,3,opt,name=ric,proto3,oneof" json:"ric,omitempty"`
}
type Error_Cause_RicService_ struct {
	RicService *Error_Cause_RicService `protobuf:"bytes,4,opt,name=ric_service,json=ricService,proto3,oneof" json:"ric_service,omitempty"`
}
type Error_Cause_Transport_ struct {
	Transport *Error_Cause_Transport `protobuf:"bytes,5,opt,name=transport,proto3,oneof" json:"transport,omitempty"`
}
type Error_Cause_Misc_ struct {
	Misc *Error_Cause_Misc `protobuf:"bytes,6,opt,name=misc,proto3,oneof" json:"misc,omitempty"`
}

func (*Error_Cause_Unknown_) isError_Cause_Cause()    {}
func (*Error_Cause_Protocol_) isError_Cause_Cause()   {}
func (*Error_Cause_Ric_) isError_Cause_Cause()        {}
func (*Error_Cause_RicService_) isError_Cause_Cause() {}
func (*Error_Cause_Transport_) isError_Cause_Cause()  {}
func (*Error_Cause_Misc_) isError_Cause_Cause()       {}

func (m *Error_Cause) GetCause() isError_Cause_Cause {
	if m != nil {
		return m.Cause
	}
	return nil
}

func (m *Error_Cause) GetUnknown() *Error_Cause_Unknown {
	if x, ok := m.GetCause().(*Error_Cause_Unknown_); ok {
		return x.Unknown
	}
	return nil
}

func (m *Error_Cause) GetProtocol() *Error_Cause_Protocol {
	if x, ok := m.GetCause().(*Error_Cause_Protocol_); ok {
		return x.Protocol
	}
	return nil
}

func (m *Error_Cause) GetRic() *Error_Cause_Ric {
	if x, ok := m.GetCause().(*Error_Cause_Ric_); ok {
		return x.Ric
	}
	return nil
}

func (m *Error_Cause) GetRicService() *Error_Cause_RicService {
	if x, ok := m.GetCause().(*Error_Cause_RicService_); ok {
		return x.RicService
	}
	return nil
}

func (m *Error_Cause) GetTransport() *Error_Cause_Transport {
	if x, ok := m.GetCause().(*Error_Cause_Transport_); ok {
		return x.Transport
	}
	return nil
}

func (m *Error_Cause) GetMisc() *Error_Cause_Misc {
	if x, ok := m.GetCause().(*Error_Cause_Misc_); ok {
		return x.Misc
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Error_Cause) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Error_Cause_Unknown_)(nil),
		(*Error_Cause_Protocol_)(nil),
		(*Error_Cause_Ric_)(nil),
		(*Error_Cause_RicService_)(nil),
		(*Error_Cause_Transport_)(nil),
		(*Error_Cause_Misc_)(nil),
	}
}

type Error_Cause_Unknown struct {
}

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

var xxx_messageInfo_Error_Cause_Unknown proto.InternalMessageInfo

type Error_Cause_Misc struct {
	Type Error_Cause_Misc_Type `protobuf:"varint,1,opt,name=type,proto3,enum=onos.e2t.e2.v1beta1.Error_Cause_Misc_Type" json:"type,omitempty"`
}

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

var xxx_messageInfo_Error_Cause_Misc proto.InternalMessageInfo

func (m *Error_Cause_Misc) GetType() Error_Cause_Misc_Type {
	if m != nil {
		return m.Type
	}
	return Error_Cause_Misc_UNSPECIFIED
}

type Error_Cause_Protocol struct {
	Type Error_Cause_Protocol_Type `protobuf:"varint,1,opt,name=type,proto3,enum=onos.e2t.e2.v1beta1.Error_Cause_Protocol_Type" json:"type,omitempty"`
}

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

var xxx_messageInfo_Error_Cause_Protocol proto.InternalMessageInfo

func (m *Error_Cause_Protocol) GetType() Error_Cause_Protocol_Type {
	if m != nil {
		return m.Type
	}
	return Error_Cause_Protocol_UNSPECIFIED
}

type Error_Cause_Ric struct {
	Type Error_Cause_Ric_Type `protobuf:"varint,1,opt,name=type,proto3,enum=onos.e2t.e2.v1beta1.Error_Cause_Ric_Type" json:"type,omitempty"`
}

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

var xxx_messageInfo_Error_Cause_Ric proto.InternalMessageInfo

func (m *Error_Cause_Ric) GetType() Error_Cause_Ric_Type {
	if m != nil {
		return m.Type
	}
	return Error_Cause_Ric_UNSPECIFIED
}

type Error_Cause_RicService struct {
	Type Error_Cause_RicService_Type `protobuf:"varint,1,opt,name=type,proto3,enum=onos.e2t.e2.v1beta1.Error_Cause_RicService_Type" json:"type,omitempty"`
}

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

var xxx_messageInfo_Error_Cause_RicService proto.InternalMessageInfo

func (m *Error_Cause_RicService) GetType() Error_Cause_RicService_Type {
	if m != nil {
		return m.Type
	}
	return Error_Cause_RicService_UNSPECIFIED
}

type Error_Cause_Transport struct {
	Type Error_Cause_Transport_Type `protobuf:"varint,1,opt,name=type,proto3,enum=onos.e2t.e2.v1beta1.Error_Cause_Transport_Type" json:"type,omitempty"`
}

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

var xxx_messageInfo_Error_Cause_Transport proto.InternalMessageInfo

func (m *Error_Cause_Transport) GetType() Error_Cause_Transport_Type {
	if m != nil {
		return m.Type
	}
	return Error_Cause_Transport_UNSPECIFIED
}

func init() {
	proto.RegisterEnum("onos.e2t.e2.v1beta1.Encoding", Encoding_name, Encoding_value)
	golang_proto.RegisterEnum("onos.e2t.e2.v1beta1.Encoding", Encoding_name, Encoding_value)
	proto.RegisterEnum("onos.e2t.e2.v1beta1.Error_Cause_Misc_Type", Error_Cause_Misc_Type_name, Error_Cause_Misc_Type_value)
	golang_proto.RegisterEnum("onos.e2t.e2.v1beta1.Error_Cause_Misc_Type", Error_Cause_Misc_Type_name, Error_Cause_Misc_Type_value)
	proto.RegisterEnum("onos.e2t.e2.v1beta1.Error_Cause_Protocol_Type", Error_Cause_Protocol_Type_name, Error_Cause_Protocol_Type_value)
	golang_proto.RegisterEnum("onos.e2t.e2.v1beta1.Error_Cause_Protocol_Type", Error_Cause_Protocol_Type_name, Error_Cause_Protocol_Type_value)
	proto.RegisterEnum("onos.e2t.e2.v1beta1.Error_Cause_Ric_Type", Error_Cause_Ric_Type_name, Error_Cause_Ric_Type_value)
	golang_proto.RegisterEnum("onos.e2t.e2.v1beta1.Error_Cause_Ric_Type", Error_Cause_Ric_Type_name, Error_Cause_Ric_Type_value)
	proto.RegisterEnum("onos.e2t.e2.v1beta1.Error_Cause_RicService_Type", Error_Cause_RicService_Type_name, Error_Cause_RicService_Type_value)
	golang_proto.RegisterEnum("onos.e2t.e2.v1beta1.Error_Cause_RicService_Type", Error_Cause_RicService_Type_name, Error_Cause_RicService_Type_value)
	proto.RegisterEnum("onos.e2t.e2.v1beta1.Error_Cause_Transport_Type", Error_Cause_Transport_Type_name, Error_Cause_Transport_Type_value)
	golang_proto.RegisterEnum("onos.e2t.e2.v1beta1.Error_Cause_Transport_Type", Error_Cause_Transport_Type_name, Error_Cause_Transport_Type_value)
	proto.RegisterType((*RequestHeaders)(nil), "onos.e2t.e2.v1beta1.RequestHeaders")
	golang_proto.RegisterType((*RequestHeaders)(nil), "onos.e2t.e2.v1beta1.RequestHeaders")
	proto.RegisterType((*ResponseHeaders)(nil), "onos.e2t.e2.v1beta1.ResponseHeaders")
	golang_proto.RegisterType((*ResponseHeaders)(nil), "onos.e2t.e2.v1beta1.ResponseHeaders")
	proto.RegisterType((*ServiceModel)(nil), "onos.e2t.e2.v1beta1.ServiceModel")
	golang_proto.RegisterType((*ServiceModel)(nil), "onos.e2t.e2.v1beta1.ServiceModel")
	proto.RegisterType((*Error)(nil), "onos.e2t.e2.v1beta1.Error")
	golang_proto.RegisterType((*Error)(nil), "onos.e2t.e2.v1beta1.Error")
	proto.RegisterType((*Error_Cause)(nil), "onos.e2t.e2.v1beta1.Error.Cause")
	golang_proto.RegisterType((*Error_Cause)(nil), "onos.e2t.e2.v1beta1.Error.Cause")
	proto.RegisterType((*Error_Cause_Unknown)(nil), "onos.e2t.e2.v1beta1.Error.Cause.Unknown")
	golang_proto.RegisterType((*Error_Cause_Unknown)(nil), "onos.e2t.e2.v1beta1.Error.Cause.Unknown")
	proto.RegisterType((*Error_Cause_Misc)(nil), "onos.e2t.e2.v1beta1.Error.Cause.Misc")
	golang_proto.RegisterType((*Error_Cause_Misc)(nil), "onos.e2t.e2.v1beta1.Error.Cause.Misc")
	proto.RegisterType((*Error_Cause_Protocol)(nil), "onos.e2t.e2.v1beta1.Error.Cause.Protocol")
	golang_proto.RegisterType((*Error_Cause_Protocol)(nil), "onos.e2t.e2.v1beta1.Error.Cause.Protocol")
	proto.RegisterType((*Error_Cause_Ric)(nil), "onos.e2t.e2.v1beta1.Error.Cause.Ric")
	golang_proto.RegisterType((*Error_Cause_Ric)(nil), "onos.e2t.e2.v1beta1.Error.Cause.Ric")
	proto.RegisterType((*Error_Cause_RicService)(nil), "onos.e2t.e2.v1beta1.Error.Cause.RicService")
	golang_proto.RegisterType((*Error_Cause_RicService)(nil), "onos.e2t.e2.v1beta1.Error.Cause.RicService")
	proto.RegisterType((*Error_Cause_Transport)(nil), "onos.e2t.e2.v1beta1.Error.Cause.Transport")
	golang_proto.RegisterType((*Error_Cause_Transport)(nil), "onos.e2t.e2.v1beta1.Error.Cause.Transport")
}

func init() { proto.RegisterFile("onos/e2t/e2/v1beta1/e2.proto", fileDescriptor_39739724a62a6409) }
func init() {
	golang_proto.RegisterFile("onos/e2t/e2/v1beta1/e2.proto", fileDescriptor_39739724a62a6409)
}

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

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

func (m *RequestHeaders) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Encoding != 0 {
		i = encodeVarintE2(dAtA, i, uint64(m.Encoding))
		i--
		dAtA[i] = 0x28
	}
	{
		size, err := m.ServiceModel.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintE2(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if len(m.E2NodeID) > 0 {
		i -= len(m.E2NodeID)
		copy(dAtA[i:], m.E2NodeID)
		i = encodeVarintE2(dAtA, i, uint64(len(m.E2NodeID)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.AppInstanceID) > 0 {
		i -= len(m.AppInstanceID)
		copy(dAtA[i:], m.AppInstanceID)
		i = encodeVarintE2(dAtA, i, uint64(len(m.AppInstanceID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.AppID) > 0 {
		i -= len(m.AppID)
		copy(dAtA[i:], m.AppID)
		i = encodeVarintE2(dAtA, i, uint64(len(m.AppID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ResponseHeaders) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Encoding != 0 {
		i = encodeVarintE2(dAtA, i, uint64(m.Encoding))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *Error_Cause_Misc) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		i = encodeVarintE2(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *Error_Cause_Protocol) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		i = encodeVarintE2(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *Error_Cause_Ric) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		i = encodeVarintE2(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *Error_Cause_RicService) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		i = encodeVarintE2(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *Error_Cause_Transport) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		i = encodeVarintE2(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintE2(dAtA []byte, offset int, v uint64) int {
	offset -= sovE2(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *RequestHeaders) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AppID)
	if l > 0 {
		n += 1 + l + sovE2(uint64(l))
	}
	l = len(m.AppInstanceID)
	if l > 0 {
		n += 1 + l + sovE2(uint64(l))
	}
	l = len(m.E2NodeID)
	if l > 0 {
		n += 1 + l + sovE2(uint64(l))
	}
	l = m.ServiceModel.Size()
	n += 1 + l + sovE2(uint64(l))
	if m.Encoding != 0 {
		n += 1 + sovE2(uint64(m.Encoding))
	}
	return n
}

func (m *ResponseHeaders) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Encoding != 0 {
		n += 1 + sovE2(uint64(m.Encoding))
	}
	return n
}

func (m *ServiceModel) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovE2(uint64(l))
	}
	l = len(m.Version)
	if l > 0 {
		n += 1 + l + sovE2(uint64(l))
	}
	return n
}

func (m *Error) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Cause != nil {
		l = m.Cause.Size()
		n += 1 + l + sovE2(uint64(l))
	}
	return n
}

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

func (m *Error_Cause_Unknown_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Unknown != nil {
		l = m.Unknown.Size()
		n += 1 + l + sovE2(uint64(l))
	}
	return n
}
func (m *Error_Cause_Protocol_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Protocol != nil {
		l = m.Protocol.Size()
		n += 1 + l + sovE2(uint64(l))
	}
	return n
}
func (m *Error_Cause_Ric_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Ric != nil {
		l = m.Ric.Size()
		n += 1 + l + sovE2(uint64(l))
	}
	return n
}
func (m *Error_Cause_RicService_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RicService != nil {
		l = m.RicService.Size()
		n += 1 + l + sovE2(uint64(l))
	}
	return n
}
func (m *Error_Cause_Transport_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Transport != nil {
		l = m.Transport.Size()
		n += 1 + l + sovE2(uint64(l))
	}
	return n
}
func (m *Error_Cause_Misc_) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Misc != nil {
		l = m.Misc.Size()
		n += 1 + l + sovE2(uint64(l))
	}
	return n
}
func (m *Error_Cause_Unknown) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *Error_Cause_Misc) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovE2(uint64(m.Type))
	}
	return n
}

func (m *Error_Cause_Protocol) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovE2(uint64(m.Type))
	}
	return n
}

func (m *Error_Cause_Ric) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovE2(uint64(m.Type))
	}
	return n
}

func (m *Error_Cause_RicService) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovE2(uint64(m.Type))
	}
	return n
}

func (m *Error_Cause_Transport) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovE2(uint64(m.Type))
	}
	return n
}

func sovE2(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozE2(x uint64) (n int) {
	return sovE2(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *RequestHeaders) 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 ErrIntOverflowE2
			}
			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: RequestHeaders: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RequestHeaders: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				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 ErrInvalidLengthE2
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthE2
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AppID = AppID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppInstanceID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				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 ErrInvalidLengthE2
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthE2
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AppInstanceID = AppInstanceID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field E2NodeID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				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 ErrInvalidLengthE2
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthE2
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.E2NodeID = E2NodeID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceModel", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthE2
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthE2
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ServiceModel.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Encoding", wireType)
			}
			m.Encoding = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Encoding |= Encoding(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipE2(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthE2
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Error_Cause) 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 ErrIntOverflowE2
			}
			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: Cause: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Cause: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Unknown", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthE2
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthE2
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Error_Cause_Unknown{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cause = &Error_Cause_Unknown_{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthE2
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthE2
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Error_Cause_Protocol{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cause = &Error_Cause_Protocol_{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ric", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthE2
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthE2
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Error_Cause_Ric{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cause = &Error_Cause_Ric_{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RicService", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthE2
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthE2
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Error_Cause_RicService{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cause = &Error_Cause_RicService_{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Transport", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthE2
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthE2
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Error_Cause_Transport{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cause = &Error_Cause_Transport_{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Misc", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthE2
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthE2
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Error_Cause_Misc{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cause = &Error_Cause_Misc_{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipE2(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthE2
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Error_Cause_Misc) 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 ErrIntOverflowE2
			}
			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: Misc: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Misc: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= Error_Cause_Misc_Type(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipE2(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthE2
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Error_Cause_Protocol) 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 ErrIntOverflowE2
			}
			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: Protocol: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Protocol: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= Error_Cause_Protocol_Type(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipE2(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthE2
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Error_Cause_Ric) 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 ErrIntOverflowE2
			}
			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: Ric: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Ric: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= Error_Cause_Ric_Type(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipE2(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthE2
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Error_Cause_RicService) 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 ErrIntOverflowE2
			}
			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: RicService: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RicService: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= Error_Cause_RicService_Type(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipE2(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthE2
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Error_Cause_Transport) 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 ErrIntOverflowE2
			}
			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: Transport: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Transport: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= Error_Cause_Transport_Type(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipE2(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthE2
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthE2        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowE2          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupE2 = fmt.Errorf("proto: unexpected end of group")
)