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

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

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

package e2

import (
	context "context"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

// EncodingType determines encoding type for the response messages
type EncodingType int32

const (
	EncodingType_PROTO    EncodingType = 0
	EncodingType_ASN1_PER EncodingType = 1
	EncodingType_ASN1_XER EncodingType = 2
)

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

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

func (x EncodingType) String() string {
	return proto.EnumName(EncodingType_name, int32(x))
}

func (EncodingType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_706d69473e8d707d, []int{0}
}

// ResponseStatus
type ResponseStatus int32

const (
	ResponseStatus_FAILED    ResponseStatus = 0
	ResponseStatus_SUCCEEDED ResponseStatus = 1
	ResponseStatus_REJECTED  ResponseStatus = 2
)

var ResponseStatus_name = map[int32]string{
	0: "FAILED",
	1: "SUCCEEDED",
	2: "REJECTED",
}

var ResponseStatus_value = map[string]int32{
	"FAILED":    0,
	"SUCCEEDED": 1,
	"REJECTED":  2,
}

func (x ResponseStatus) String() string {
	return proto.EnumName(ResponseStatus_name, int32(x))
}

func (ResponseStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_706d69473e8d707d, []int{1}
}

// Cause is a failure cause
type Cause int32

const (
	Cause_CAUSE_UNKNOWN                                                    Cause = 0
	Cause_CAUSE_MISC_CONTROL_PROCESSING_OVERLOAD                           Cause = 1
	Cause_CAUSE_MISC_HARDWARE_FAILURE                                      Cause = 2
	Cause_CAUSE_MISC_OM_INTERVENTION                                       Cause = 3
	Cause_CAUSE_MISC_UNSPECIFIED                                           Cause = 4
	Cause_CAUSE_PROTOCOL_TRANSFER_SYNTAX_ERROR                             Cause = 5
	Cause_CAUSE_PROTOCOL_ABSTRACT_SYNTAX_ERROR_REJECT                      Cause = 6
	Cause_CAUSE_PROTOCOL_ABSTRACT_SYNTAX_ERROR_IGNORE_AND_NOTIFY           Cause = 7
	Cause_CAUSE_PROTOCOL_MESSAGE_NOT_COMPATIBLE_WITH_RECEIVER_STATE        Cause = 8
	Cause_CAUSE_PROTOCOL_SEMANTIC_ERROR                                    Cause = 9
	Cause_CAUSE_PROTOCOL_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE Cause = 10
	Cause_CAUSE_PROTOCOL_UNSPECIFIED                                       Cause = 11
	Cause_CAUSE_RIC_RAN_FUNCTION_ID_INVALID                                Cause = 12
	Cause_CAUSE_RIC_ACTION_NOT_SUPPORTED                                   Cause = 13
	Cause_CAUSE_RIC_EXCESSIVE_ACTIONS                                      Cause = 14
	Cause_CAUSE_RIC_DUPLICATE_ACTION                                       Cause = 15
	Cause_CAUSE_RIC_DUPLICATE_EVENT                                        Cause = 16
	Cause_CAUSE_RIC_FUNCTION_RESOURCE_LIMIT                                Cause = 17
	Cause_CAUSE_RIC_REQUEST_ID_UNKNOWN                                     Cause = 18
	Cause_CAUSE_RIC_INCONSISTENT_ACTION_SUBSEQUENT_ACTION_SEQUENCE         Cause = 19
	Cause_CAUSE_RIC_CONTROL_MESSAGE_INVALID                                Cause = 20
	Cause_CAUSE_RIC_CALL_PROCESS_ID_INVALID                                Cause = 21
	Cause_CAUSE_RIC_UNSPECIFIED                                            Cause = 22
	Cause_CAUSE_RICSERVICE_FUNCTION_NOT_REQUIRED                           Cause = 23
	Cause_CAUSE_RICSERVICE_EXCESSIVE_FUNCTIONS                             Cause = 24
	Cause_CAUSE_RICSERVICE_RIC_RESOURCE_LIMIT                              Cause = 25
	Cause_CAUSE_TRANSPORT_UNSPECIFIED                                      Cause = 26
	Cause_CAUSE_TRANSPORT_TRANSPORT_RESOURCE_UNAVAILABLE                   Cause = 27
)

var Cause_name = map[int32]string{
	0:  "CAUSE_UNKNOWN",
	1:  "CAUSE_MISC_CONTROL_PROCESSING_OVERLOAD",
	2:  "CAUSE_MISC_HARDWARE_FAILURE",
	3:  "CAUSE_MISC_OM_INTERVENTION",
	4:  "CAUSE_MISC_UNSPECIFIED",
	5:  "CAUSE_PROTOCOL_TRANSFER_SYNTAX_ERROR",
	6:  "CAUSE_PROTOCOL_ABSTRACT_SYNTAX_ERROR_REJECT",
	7:  "CAUSE_PROTOCOL_ABSTRACT_SYNTAX_ERROR_IGNORE_AND_NOTIFY",
	8:  "CAUSE_PROTOCOL_MESSAGE_NOT_COMPATIBLE_WITH_RECEIVER_STATE",
	9:  "CAUSE_PROTOCOL_SEMANTIC_ERROR",
	10: "CAUSE_PROTOCOL_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE",
	11: "CAUSE_PROTOCOL_UNSPECIFIED",
	12: "CAUSE_RIC_RAN_FUNCTION_ID_INVALID",
	13: "CAUSE_RIC_ACTION_NOT_SUPPORTED",
	14: "CAUSE_RIC_EXCESSIVE_ACTIONS",
	15: "CAUSE_RIC_DUPLICATE_ACTION",
	16: "CAUSE_RIC_DUPLICATE_EVENT",
	17: "CAUSE_RIC_FUNCTION_RESOURCE_LIMIT",
	18: "CAUSE_RIC_REQUEST_ID_UNKNOWN",
	19: "CAUSE_RIC_INCONSISTENT_ACTION_SUBSEQUENT_ACTION_SEQUENCE",
	20: "CAUSE_RIC_CONTROL_MESSAGE_INVALID",
	21: "CAUSE_RIC_CALL_PROCESS_ID_INVALID",
	22: "CAUSE_RIC_UNSPECIFIED",
	23: "CAUSE_RICSERVICE_FUNCTION_NOT_REQUIRED",
	24: "CAUSE_RICSERVICE_EXCESSIVE_FUNCTIONS",
	25: "CAUSE_RICSERVICE_RIC_RESOURCE_LIMIT",
	26: "CAUSE_TRANSPORT_UNSPECIFIED",
	27: "CAUSE_TRANSPORT_TRANSPORT_RESOURCE_UNAVAILABLE",
}

var Cause_value = map[string]int32{
	"CAUSE_UNKNOWN":                                                    0,
	"CAUSE_MISC_CONTROL_PROCESSING_OVERLOAD":                           1,
	"CAUSE_MISC_HARDWARE_FAILURE":                                      2,
	"CAUSE_MISC_OM_INTERVENTION":                                       3,
	"CAUSE_MISC_UNSPECIFIED":                                           4,
	"CAUSE_PROTOCOL_TRANSFER_SYNTAX_ERROR":                             5,
	"CAUSE_PROTOCOL_ABSTRACT_SYNTAX_ERROR_REJECT":                      6,
	"CAUSE_PROTOCOL_ABSTRACT_SYNTAX_ERROR_IGNORE_AND_NOTIFY":           7,
	"CAUSE_PROTOCOL_MESSAGE_NOT_COMPATIBLE_WITH_RECEIVER_STATE":        8,
	"CAUSE_PROTOCOL_SEMANTIC_ERROR":                                    9,
	"CAUSE_PROTOCOL_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE": 10,
	"CAUSE_PROTOCOL_UNSPECIFIED":                                       11,
	"CAUSE_RIC_RAN_FUNCTION_ID_INVALID":                                12,
	"CAUSE_RIC_ACTION_NOT_SUPPORTED":                                   13,
	"CAUSE_RIC_EXCESSIVE_ACTIONS":                                      14,
	"CAUSE_RIC_DUPLICATE_ACTION":                                       15,
	"CAUSE_RIC_DUPLICATE_EVENT":                                        16,
	"CAUSE_RIC_FUNCTION_RESOURCE_LIMIT":                                17,
	"CAUSE_RIC_REQUEST_ID_UNKNOWN":                                     18,
	"CAUSE_RIC_INCONSISTENT_ACTION_SUBSEQUENT_ACTION_SEQUENCE":         19,
	"CAUSE_RIC_CONTROL_MESSAGE_INVALID":                                20,
	"CAUSE_RIC_CALL_PROCESS_ID_INVALID":                                21,
	"CAUSE_RIC_UNSPECIFIED":                                            22,
	"CAUSE_RICSERVICE_FUNCTION_NOT_REQUIRED":                           23,
	"CAUSE_RICSERVICE_EXCESSIVE_FUNCTIONS":                             24,
	"CAUSE_RICSERVICE_RIC_RESOURCE_LIMIT":                              25,
	"CAUSE_TRANSPORT_UNSPECIFIED":                                      26,
	"CAUSE_TRANSPORT_TRANSPORT_RESOURCE_UNAVAILABLE":                   27,
}

func (x Cause) String() string {
	return proto.EnumName(Cause_name, int32(x))
}

func (Cause) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_706d69473e8d707d, []int{2}
}

type ControlAckRequest int32

const (
	// Optional RIC Control Acknowledgement is required
	ControlAckRequest_ACK ControlAckRequest = 0
	// Optional RIC Control Acknowledgement is not required
	ControlAckRequest_NO_ACK ControlAckRequest = 1
	// Optional RIC Control Acknowledgement is only required to report failure
	ControlAckRequest_NACK ControlAckRequest = 2
)

var ControlAckRequest_name = map[int32]string{
	0: "ACK",
	1: "NO_ACK",
	2: "NACK",
}

var ControlAckRequest_value = map[string]int32{
	"ACK":    0,
	"NO_ACK": 1,
	"NACK":   2,
}

func (x ControlAckRequest) String() string {
	return proto.EnumName(ControlAckRequest_name, int32(x))
}

func (ControlAckRequest) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_706d69473e8d707d, []int{3}
}

// ServiceModelInfo E2 service model information
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_706d69473e8d707d, []int{0}
}
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 ""
}

// RequestHeader a common request header for all requests including encoding type, client/xApp/session info, ordering info, etc
type RequestHeader struct {
	EncodingType EncodingType  `protobuf:"varint,1,opt,name=encoding_type,json=encodingType,proto3,enum=onos.e2t.e2.EncodingType" json:"encoding_type,omitempty"`
	ServiceModel *ServiceModel `protobuf:"bytes,2,opt,name=service_model,json=serviceModel,proto3" json:"service_model,omitempty"`
}

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

var xxx_messageInfo_RequestHeader proto.InternalMessageInfo

func (m *RequestHeader) GetEncodingType() EncodingType {
	if m != nil {
		return m.EncodingType
	}
	return EncodingType_PROTO
}

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

// ResponseHeader a common response header for all responses including encoding type, client/xApp/session info, ordering info, etc
type ResponseHeader struct {
	EncodingType   EncodingType   `protobuf:"varint,1,opt,name=encoding_type,json=encodingType,proto3,enum=onos.e2t.e2.EncodingType" json:"encoding_type,omitempty"`
	ServiceModel   *ServiceModel  `protobuf:"bytes,2,opt,name=service_model,json=serviceModel,proto3" json:"service_model,omitempty"`
	ResponseStatus ResponseStatus `protobuf:"varint,3,opt,name=response_status,json=responseStatus,proto3,enum=onos.e2t.e2.ResponseStatus" json:"response_status,omitempty"`
}

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

var xxx_messageInfo_ResponseHeader proto.InternalMessageInfo

func (m *ResponseHeader) GetEncodingType() EncodingType {
	if m != nil {
		return m.EncodingType
	}
	return EncodingType_PROTO
}

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

func (m *ResponseHeader) GetResponseStatus() ResponseStatus {
	if m != nil {
		return m.ResponseStatus
	}
	return ResponseStatus_FAILED
}

// StreamRequest
type StreamRequest struct {
	Header         *RequestHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	AppID          AppID          `protobuf:"bytes,2,opt,name=app_id,json=appId,proto3,casttype=AppID" json:"app_id,omitempty"`
	InstanceID     InstanceID     `protobuf:"bytes,3,opt,name=instance_id,json=instanceId,proto3,casttype=InstanceID" json:"instance_id,omitempty"`
	SubscriptionID SubscriptionID `protobuf:"bytes,4,opt,name=subscription_id,json=subscriptionId,proto3,casttype=SubscriptionID" json:"subscription_id,omitempty"`
}

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

var xxx_messageInfo_StreamRequest proto.InternalMessageInfo

func (m *StreamRequest) GetHeader() *RequestHeader {
	if m != nil {
		return m.Header
	}
	return nil
}

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

func (m *StreamRequest) GetInstanceID() InstanceID {
	if m != nil {
		return m.InstanceID
	}
	return ""
}

func (m *StreamRequest) GetSubscriptionID() SubscriptionID {
	if m != nil {
		return m.SubscriptionID
	}
	return ""
}

// StreamResponse
type StreamResponse struct {
	Header            *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	IndicationHeader  []byte          `protobuf:"bytes,2,opt,name=indication_header,json=indicationHeader,proto3" json:"indication_header,omitempty"`
	IndicationMessage []byte          `protobuf:"bytes,3,opt,name=indication_message,json=indicationMessage,proto3" json:"indication_message,omitempty"`
}

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

var xxx_messageInfo_StreamResponse proto.InternalMessageInfo

func (m *StreamResponse) GetHeader() *ResponseHeader {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *StreamResponse) GetIndicationHeader() []byte {
	if m != nil {
		return m.IndicationHeader
	}
	return nil
}

func (m *StreamResponse) GetIndicationMessage() []byte {
	if m != nil {
		return m.IndicationMessage
	}
	return nil
}

// ControlRequest E2 control request
type ControlRequest struct {
	Header            *RequestHeader    `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	E2NodeID          E2NodeID          `protobuf:"bytes,2,opt,name=e2_node_id,json=e2NodeId,proto3,casttype=E2NodeID" json:"e2_node_id,omitempty"`
	ControlHeader     []byte            `protobuf:"bytes,3,opt,name=control_header,json=controlHeader,proto3" json:"control_header,omitempty"`
	ControlMessage    []byte            `protobuf:"bytes,4,opt,name=control_message,json=controlMessage,proto3" json:"control_message,omitempty"`
	ControlAckRequest ControlAckRequest `protobuf:"varint,5,opt,name=control_ack_request,json=controlAckRequest,proto3,enum=onos.e2t.e2.ControlAckRequest" json:"control_ack_request,omitempty"`
}

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

var xxx_messageInfo_ControlRequest proto.InternalMessageInfo

func (m *ControlRequest) GetHeader() *RequestHeader {
	if m != nil {
		return m.Header
	}
	return nil
}

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

func (m *ControlRequest) GetControlHeader() []byte {
	if m != nil {
		return m.ControlHeader
	}
	return nil
}

func (m *ControlRequest) GetControlMessage() []byte {
	if m != nil {
		return m.ControlMessage
	}
	return nil
}

func (m *ControlRequest) GetControlAckRequest() ControlAckRequest {
	if m != nil {
		return m.ControlAckRequest
	}
	return ControlAckRequest_ACK
}

// ControlResponse E2 control response
type ControlResponse struct {
	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
	// Types that are valid to be assigned to Response:
	//
	//	*ControlResponse_ControlAcknowledge
	//	*ControlResponse_ControlFailure
	Response isControlResponse_Response `protobuf_oneof:"response"`
}

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

var xxx_messageInfo_ControlResponse proto.InternalMessageInfo

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

type ControlResponse_ControlAcknowledge struct {
	ControlAcknowledge *ControlAcknowledge `protobuf:"bytes,2,opt,name=control_acknowledge,json=controlAcknowledge,proto3,oneof" json:"control_acknowledge,omitempty"`
}
type ControlResponse_ControlFailure struct {
	ControlFailure *ControlFailure `protobuf:"bytes,3,opt,name=control_failure,json=controlFailure,proto3,oneof" json:"control_failure,omitempty"`
}

func (*ControlResponse_ControlAcknowledge) isControlResponse_Response() {}
func (*ControlResponse_ControlFailure) isControlResponse_Response()     {}

func (m *ControlResponse) GetResponse() isControlResponse_Response {
	if m != nil {
		return m.Response
	}
	return nil
}

func (m *ControlResponse) GetHeader() *ResponseHeader {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *ControlResponse) GetControlAcknowledge() *ControlAcknowledge {
	if x, ok := m.GetResponse().(*ControlResponse_ControlAcknowledge); ok {
		return x.ControlAcknowledge
	}
	return nil
}

func (m *ControlResponse) GetControlFailure() *ControlFailure {
	if x, ok := m.GetResponse().(*ControlResponse_ControlFailure); ok {
		return x.ControlFailure
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*ControlResponse) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*ControlResponse_ControlAcknowledge)(nil),
		(*ControlResponse_ControlFailure)(nil),
	}
}

// ControlAcknowledge control acknowledgement
type ControlAcknowledge struct {
	ControlOutcome []byte `protobuf:"bytes,1,opt,name=control_outcome,json=controlOutcome,proto3" json:"control_outcome,omitempty"`
}

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

var xxx_messageInfo_ControlAcknowledge proto.InternalMessageInfo

func (m *ControlAcknowledge) GetControlOutcome() []byte {
	if m != nil {
		return m.ControlOutcome
	}
	return nil
}

// ControlFailure control failure message
type ControlFailure struct {
	Cause          Cause  `protobuf:"varint,1,opt,name=cause,proto3,enum=onos.e2t.e2.Cause" json:"cause,omitempty"`
	ControlOutcome []byte `protobuf:"bytes,2,opt,name=control_outcome,json=controlOutcome,proto3" json:"control_outcome,omitempty"`
	Message        string `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
}

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

var xxx_messageInfo_ControlFailure proto.InternalMessageInfo

func (m *ControlFailure) GetCause() Cause {
	if m != nil {
		return m.Cause
	}
	return Cause_CAUSE_UNKNOWN
}

func (m *ControlFailure) GetControlOutcome() []byte {
	if m != nil {
		return m.ControlOutcome
	}
	return nil
}

func (m *ControlFailure) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func init() {
	proto.RegisterEnum("onos.e2t.e2.EncodingType", EncodingType_name, EncodingType_value)
	proto.RegisterEnum("onos.e2t.e2.ResponseStatus", ResponseStatus_name, ResponseStatus_value)
	proto.RegisterEnum("onos.e2t.e2.Cause", Cause_name, Cause_value)
	proto.RegisterEnum("onos.e2t.e2.ControlAckRequest", ControlAckRequest_name, ControlAckRequest_value)
	proto.RegisterType((*ServiceModel)(nil), "onos.e2t.e2.ServiceModel")
	proto.RegisterType((*RequestHeader)(nil), "onos.e2t.e2.RequestHeader")
	proto.RegisterType((*ResponseHeader)(nil), "onos.e2t.e2.ResponseHeader")
	proto.RegisterType((*StreamRequest)(nil), "onos.e2t.e2.StreamRequest")
	proto.RegisterType((*StreamResponse)(nil), "onos.e2t.e2.StreamResponse")
	proto.RegisterType((*ControlRequest)(nil), "onos.e2t.e2.ControlRequest")
	proto.RegisterType((*ControlResponse)(nil), "onos.e2t.e2.ControlResponse")
	proto.RegisterType((*ControlAcknowledge)(nil), "onos.e2t.e2.ControlAcknowledge")
	proto.RegisterType((*ControlFailure)(nil), "onos.e2t.e2.ControlFailure")
}

func init() { proto.RegisterFile("onos/e2t/e2/e2.proto", fileDescriptor_706d69473e8d707d) }

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

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

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

// E2TServiceClient is the client API for E2TService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type E2TServiceClient interface {
	// Stream opens an indications stream
	Stream(ctx context.Context, opts ...grpc.CallOption) (E2TService_StreamClient, error)
	// Control sends a E2 control request
	Control(ctx context.Context, in *ControlRequest, opts ...grpc.CallOption) (*ControlResponse, error)
}

type e2TServiceClient struct {
	cc *grpc.ClientConn
}

func NewE2TServiceClient(cc *grpc.ClientConn) E2TServiceClient {
	return &e2TServiceClient{cc}
}

func (c *e2TServiceClient) Stream(ctx context.Context, opts ...grpc.CallOption) (E2TService_StreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_E2TService_serviceDesc.Streams[0], "/onos.e2t.e2.E2TService/Stream", opts...)
	if err != nil {
		return nil, err
	}
	x := &e2TServiceStreamClient{stream}
	return x, nil
}

type E2TService_StreamClient interface {
	Send(*StreamRequest) error
	Recv() (*StreamResponse, error)
	grpc.ClientStream
}

type e2TServiceStreamClient struct {
	grpc.ClientStream
}

func (x *e2TServiceStreamClient) Send(m *StreamRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *e2TServiceClient) Control(ctx context.Context, in *ControlRequest, opts ...grpc.CallOption) (*ControlResponse, error) {
	out := new(ControlResponse)
	err := c.cc.Invoke(ctx, "/onos.e2t.e2.E2TService/Control", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// E2TServiceServer is the server API for E2TService service.
type E2TServiceServer interface {
	// Stream opens an indications stream
	Stream(E2TService_StreamServer) error
	// Control sends a E2 control request
	Control(context.Context, *ControlRequest) (*ControlResponse, error)
}

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

func (*UnimplementedE2TServiceServer) Stream(srv E2TService_StreamServer) error {
	return status.Errorf(codes.Unimplemented, "method Stream not implemented")
}
func (*UnimplementedE2TServiceServer) Control(ctx context.Context, req *ControlRequest) (*ControlResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Control not implemented")
}

func RegisterE2TServiceServer(s *grpc.Server, srv E2TServiceServer) {
	s.RegisterService(&_E2TService_serviceDesc, srv)
}

func _E2TService_Stream_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(E2TServiceServer).Stream(&e2TServiceStreamServer{stream})
}

type E2TService_StreamServer interface {
	Send(*StreamResponse) error
	Recv() (*StreamRequest, error)
	grpc.ServerStream
}

type e2TServiceStreamServer struct {
	grpc.ServerStream
}

func (x *e2TServiceStreamServer) Send(m *StreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _E2TService_Control_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ControlRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(E2TServiceServer).Control(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/onos.e2t.e2.E2TService/Control",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(E2TServiceServer).Control(ctx, req.(*ControlRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _E2TService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "onos.e2t.e2.E2TService",
	HandlerType: (*E2TServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Control",
			Handler:    _E2TService_Control_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Stream",
			Handler:       _E2TService_Stream_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "onos/e2t/e2/e2.proto",
}

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

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

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

func (m *ResponseHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ResponseStatus != 0 {
		i = encodeVarintE2(dAtA, i, uint64(m.ResponseStatus))
		i--
		dAtA[i] = 0x18
	}
	if m.ServiceModel != nil {
		{
			size, err := m.ServiceModel.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintE2(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.EncodingType != 0 {
		i = encodeVarintE2(dAtA, i, uint64(m.EncodingType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *StreamRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SubscriptionID) > 0 {
		i -= len(m.SubscriptionID)
		copy(dAtA[i:], m.SubscriptionID)
		i = encodeVarintE2(dAtA, i, uint64(len(m.SubscriptionID)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.InstanceID) > 0 {
		i -= len(m.InstanceID)
		copy(dAtA[i:], m.InstanceID)
		i = encodeVarintE2(dAtA, i, uint64(len(m.InstanceID)))
		i--
		dAtA[i] = 0x1a
	}
	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] = 0x12
	}
	if m.Header != nil {
		{
			size, err := m.Header.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 *StreamResponse) 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 *StreamResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StreamResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.IndicationMessage) > 0 {
		i -= len(m.IndicationMessage)
		copy(dAtA[i:], m.IndicationMessage)
		i = encodeVarintE2(dAtA, i, uint64(len(m.IndicationMessage)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.IndicationHeader) > 0 {
		i -= len(m.IndicationHeader)
		copy(dAtA[i:], m.IndicationHeader)
		i = encodeVarintE2(dAtA, i, uint64(len(m.IndicationHeader)))
		i--
		dAtA[i] = 0x12
	}
	if m.Header != nil {
		{
			size, err := m.Header.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 *ControlRequest) 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 *ControlRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ControlRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ControlAckRequest != 0 {
		i = encodeVarintE2(dAtA, i, uint64(m.ControlAckRequest))
		i--
		dAtA[i] = 0x28
	}
	if len(m.ControlMessage) > 0 {
		i -= len(m.ControlMessage)
		copy(dAtA[i:], m.ControlMessage)
		i = encodeVarintE2(dAtA, i, uint64(len(m.ControlMessage)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.ControlHeader) > 0 {
		i -= len(m.ControlHeader)
		copy(dAtA[i:], m.ControlHeader)
		i = encodeVarintE2(dAtA, i, uint64(len(m.ControlHeader)))
		i--
		dAtA[i] = 0x1a
	}
	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] = 0x12
	}
	if m.Header != nil {
		{
			size, err := m.Header.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 *ControlResponse) 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 *ControlResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ControlResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Response != nil {
		{
			size := m.Response.Size()
			i -= size
			if _, err := m.Response.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.Header != nil {
		{
			size, err := m.Header.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 *ControlResponse_ControlAcknowledge) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ControlResponse_ControlAcknowledge) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ControlAcknowledge != nil {
		{
			size, err := m.ControlAcknowledge.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 *ControlResponse_ControlFailure) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ControlResponse_ControlFailure) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ControlFailure != nil {
		{
			size, err := m.ControlFailure.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 *ControlAcknowledge) 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 *ControlAcknowledge) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *ControlFailure) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintE2(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ControlOutcome) > 0 {
		i -= len(m.ControlOutcome)
		copy(dAtA[i:], m.ControlOutcome)
		i = encodeVarintE2(dAtA, i, uint64(len(m.ControlOutcome)))
		i--
		dAtA[i] = 0x12
	}
	if m.Cause != 0 {
		i = encodeVarintE2(dAtA, i, uint64(m.Cause))
		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 *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 *RequestHeader) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EncodingType != 0 {
		n += 1 + sovE2(uint64(m.EncodingType))
	}
	if m.ServiceModel != nil {
		l = m.ServiceModel.Size()
		n += 1 + l + sovE2(uint64(l))
	}
	return n
}

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

func (m *StreamRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovE2(uint64(l))
	}
	l = len(m.AppID)
	if l > 0 {
		n += 1 + l + sovE2(uint64(l))
	}
	l = len(m.InstanceID)
	if l > 0 {
		n += 1 + l + sovE2(uint64(l))
	}
	l = len(m.SubscriptionID)
	if l > 0 {
		n += 1 + l + sovE2(uint64(l))
	}
	return n
}

func (m *StreamResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovE2(uint64(l))
	}
	l = len(m.IndicationHeader)
	if l > 0 {
		n += 1 + l + sovE2(uint64(l))
	}
	l = len(m.IndicationMessage)
	if l > 0 {
		n += 1 + l + sovE2(uint64(l))
	}
	return n
}

func (m *ControlRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovE2(uint64(l))
	}
	l = len(m.E2NodeID)
	if l > 0 {
		n += 1 + l + sovE2(uint64(l))
	}
	l = len(m.ControlHeader)
	if l > 0 {
		n += 1 + l + sovE2(uint64(l))
	}
	l = len(m.ControlMessage)
	if l > 0 {
		n += 1 + l + sovE2(uint64(l))
	}
	if m.ControlAckRequest != 0 {
		n += 1 + sovE2(uint64(m.ControlAckRequest))
	}
	return n
}

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

func (m *ControlResponse_ControlAcknowledge) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ControlAcknowledge != nil {
		l = m.ControlAcknowledge.Size()
		n += 1 + l + sovE2(uint64(l))
	}
	return n
}
func (m *ControlResponse_ControlFailure) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ControlFailure != nil {
		l = m.ControlFailure.Size()
		n += 1 + l + sovE2(uint64(l))
	}
	return n
}
func (m *ControlAcknowledge) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ControlOutcome)
	if l > 0 {
		n += 1 + l + sovE2(uint64(l))
	}
	return n
}

func (m *ControlFailure) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Cause != 0 {
		n += 1 + sovE2(uint64(m.Cause))
	}
	l = len(m.ControlOutcome)
	if l > 0 {
		n += 1 + l + sovE2(uint64(l))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovE2(uint64(l))
	}
	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 *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 *RequestHeader) 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: RequestHeader: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RequestHeader: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EncodingType", wireType)
			}
			m.EncodingType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EncodingType |= EncodingType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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 m.ServiceModel == nil {
				m.ServiceModel = &ServiceModel{}
			}
			if err := m.ServiceModel.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 *ResponseHeader) 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: ResponseHeader: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ResponseHeader: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EncodingType", wireType)
			}
			m.EncodingType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EncodingType |= EncodingType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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 m.ServiceModel == nil {
				m.ServiceModel = &ServiceModel{}
			}
			if err := m.ServiceModel.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResponseStatus", wireType)
			}
			m.ResponseStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ResponseStatus |= ResponseStatus(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 *StreamRequest) 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: StreamRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StreamRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Header", 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.Header == nil {
				m.Header = &RequestHeader{}
			}
			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			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 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InstanceID", 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.InstanceID = InstanceID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubscriptionID", 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.SubscriptionID = SubscriptionID(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 *StreamResponse) 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: StreamResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StreamResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Header", 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.Header == nil {
				m.Header = &ResponseHeader{}
			}
			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IndicationHeader", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthE2
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthE2
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IndicationHeader = append(m.IndicationHeader[:0], dAtA[iNdEx:postIndex]...)
			if m.IndicationHeader == nil {
				m.IndicationHeader = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IndicationMessage", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthE2
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthE2
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IndicationMessage = append(m.IndicationMessage[:0], dAtA[iNdEx:postIndex]...)
			if m.IndicationMessage == nil {
				m.IndicationMessage = []byte{}
			}
			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 *ControlRequest) 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: ControlRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ControlRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Header", 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.Header == nil {
				m.Header = &RequestHeader{}
			}
			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			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 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ControlHeader", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthE2
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthE2
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ControlHeader = append(m.ControlHeader[:0], dAtA[iNdEx:postIndex]...)
			if m.ControlHeader == nil {
				m.ControlHeader = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ControlMessage", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthE2
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthE2
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ControlMessage = append(m.ControlMessage[:0], dAtA[iNdEx:postIndex]...)
			if m.ControlMessage == nil {
				m.ControlMessage = []byte{}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ControlAckRequest", wireType)
			}
			m.ControlAckRequest = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ControlAckRequest |= ControlAckRequest(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 *ControlResponse) 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: ControlResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ControlResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Header", 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.Header == nil {
				m.Header = &ResponseHeader{}
			}
			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ControlAcknowledge", 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 := &ControlAcknowledge{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &ControlResponse_ControlAcknowledge{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ControlFailure", 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 := &ControlFailure{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &ControlResponse_ControlFailure{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 *ControlAcknowledge) 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: ControlAcknowledge: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ControlAcknowledge: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ControlOutcome", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthE2
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthE2
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ControlOutcome = append(m.ControlOutcome[:0], dAtA[iNdEx:postIndex]...)
			if m.ControlOutcome == nil {
				m.ControlOutcome = []byte{}
			}
			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 *ControlFailure) 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: ControlFailure: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ControlFailure: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cause", wireType)
			}
			m.Cause = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Cause |= Cause(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ControlOutcome", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowE2
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthE2
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthE2
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ControlOutcome = append(m.ControlOutcome[:0], dAtA[iNdEx:postIndex]...)
			if m.ControlOutcome == nil {
				m.ControlOutcome = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", 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.Message = string(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 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")
)