event_reporting_service.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: envoy/service/event_reporting/v3/event_reporting_service.proto

package envoy_service_event_reporting_v3

import (
	context "context"
	fmt "fmt"
	_ "github.com/cncf/udpa/go/udpa/annotations"
	v3 "github.com/datawire/ambassador/pkg/api/envoy/config/core/v3"
	_ "github.com/envoyproxy/protoc-gen-validate/validate"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	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

// [#not-implemented-hide:]
// An events envoy sends to the management server.
type StreamEventsRequest struct {
	// Identifier data that will only be sent in the first message on the stream. This is effectively
	// structured metadata and is a performance optimization.
	Identifier *StreamEventsRequest_Identifier `protobuf:"bytes,1,opt,name=identifier,proto3" json:"identifier,omitempty"`
	// Batch of events. When the stream is already active, it will be the events occurred
	// since the last message had been sent. If the server receives unknown event type, it should
	// silently ignore it.
	//
	// The following events are supported:
	//
	// * :ref:`HealthCheckEvent <envoy_api_msg_data.core.v3.HealthCheckEvent>`
	// * :ref:`OutlierDetectionEvent <envoy_api_msg_data.cluster.v3.OutlierDetectionEvent>`
	Events               []*types.Any `protobuf:"bytes,2,rep,name=events,proto3" json:"events,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

var xxx_messageInfo_StreamEventsRequest proto.InternalMessageInfo

func (m *StreamEventsRequest) GetIdentifier() *StreamEventsRequest_Identifier {
	if m != nil {
		return m.Identifier
	}
	return nil
}

func (m *StreamEventsRequest) GetEvents() []*types.Any {
	if m != nil {
		return m.Events
	}
	return nil
}

type StreamEventsRequest_Identifier struct {
	// The node sending the event messages over the stream.
	Node                 *v3.Node `protobuf:"bytes,1,opt,name=node,proto3" json:"node,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_StreamEventsRequest_Identifier proto.InternalMessageInfo

func (m *StreamEventsRequest_Identifier) GetNode() *v3.Node {
	if m != nil {
		return m.Node
	}
	return nil
}

// [#not-implemented-hide:]
// The management server may send envoy a StreamEventsResponse to tell which events the server
// is interested in. In future, with aggregated event reporting service, this message will
// contain, for example, clusters the envoy should send events for, or event types the server
// wants to process.
type StreamEventsResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_StreamEventsResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*StreamEventsRequest)(nil), "envoy.service.event_reporting.v3.StreamEventsRequest")
	proto.RegisterType((*StreamEventsRequest_Identifier)(nil), "envoy.service.event_reporting.v3.StreamEventsRequest.Identifier")
	proto.RegisterType((*StreamEventsResponse)(nil), "envoy.service.event_reporting.v3.StreamEventsResponse")
}

func init() {
	proto.RegisterFile("envoy/service/event_reporting/v3/event_reporting_service.proto", fileDescriptor_006b9de436985c31)
}

var fileDescriptor_006b9de436985c31 = []byte{
	// 450 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x92, 0x41, 0x6b, 0x13, 0x41,
	0x14, 0xc7, 0x7d, 0xa9, 0x86, 0x32, 0xf5, 0x50, 0xd6, 0x8a, 0x75, 0xc1, 0x18, 0x73, 0xca, 0x69,
	0x46, 0x12, 0x2c, 0x1a, 0x45, 0xda, 0xa0, 0x82, 0x08, 0x52, 0xb6, 0x27, 0x4f, 0x75, 0x92, 0x7d,
	0x89, 0x03, 0x71, 0xde, 0x3a, 0x33, 0x59, 0xcc, 0x4d, 0xf0, 0x60, 0xf1, 0xa8, 0x37, 0xc1, 0x2f,
	0xe2, 0x5d, 0xe8, 0x51, 0xbf, 0x81, 0xe4, 0x63, 0x78, 0x92, 0xd9, 0xd9, 0xd5, 0x5a, 0x0b, 0x8b,
	0xb9, 0xed, 0xbe, 0xf7, 0x7f, 0xbf, 0xf7, 0x7f, 0x6f, 0x1e, 0xbb, 0x8f, 0x3a, 0xa7, 0x85, 0xb0,
	0x68, 0x72, 0x35, 0x46, 0x81, 0x39, 0x6a, 0x77, 0x68, 0x30, 0x23, 0xe3, 0x94, 0x9e, 0x8a, 0xbc,
	0x7f, 0x3a, 0x74, 0x58, 0x4a, 0x79, 0x66, 0xc8, 0x51, 0xd4, 0x2e, 0xea, 0x79, 0x15, 0x3c, 0x25,
	0xe6, 0x79, 0x3f, 0xbe, 0x1e, 0x3a, 0x8c, 0x49, 0x4f, 0xd4, 0x54, 0x8c, 0xc9, 0xa0, 0xa7, 0x8e,
	0xa4, 0x2d, 0x11, 0xf1, 0xd5, 0x29, 0xd1, 0x74, 0x86, 0xa2, 0xf8, 0x1b, 0xcd, 0x27, 0x42, 0xea,
	0x45, 0x99, 0xba, 0x36, 0x4f, 0x33, 0x29, 0xa4, 0xd6, 0xe4, 0xa4, 0x53, 0xa4, 0xad, 0xb0, 0x4e,
	0xba, 0xb9, 0x2d, 0xd3, 0x37, 0xfe, 0x49, 0xe7, 0x68, 0xac, 0x22, 0xed, 0x5b, 0x07, 0xc9, 0x95,
	0x5c, 0xce, 0x54, 0x2a, 0x1d, 0x8a, 0xea, 0x23, 0x24, 0x3a, 0xef, 0xd6, 0xd8, 0xa5, 0x03, 0x67,
	0x50, 0xbe, 0x7c, 0xe8, 0x3d, 0xdb, 0x04, 0x5f, 0xcd, 0xd1, 0xba, 0xe8, 0x39, 0x63, 0x2a, 0x45,
	0xed, 0xd4, 0x44, 0xa1, 0xd9, 0x86, 0x36, 0x74, 0x37, 0x7a, 0xbb, 0xbc, 0x6e, 0x4a, 0x7e, 0x06,
	0x8a, 0x3f, 0xfe, 0xcd, 0x49, 0x4e, 0x30, 0xa3, 0x1d, 0xd6, 0x2c, 0x00, 0x76, 0xbb, 0xd1, 0x5e,
	0xeb, 0x6e, 0xf4, 0xb6, 0x78, 0x58, 0x00, 0xaf, 0x16, 0xc0, 0xf7, 0xf4, 0x62, 0xb8, 0xfe, 0x73,
	0x78, 0xe1, 0x03, 0x34, 0xd6, 0x21, 0x29, 0xd5, 0xf1, 0x47, 0x60, 0xec, 0x0f, 0x32, 0xba, 0xcd,
	0xce, 0x6b, 0x4a, 0xb1, 0xb4, 0x18, 0x97, 0x16, 0xc3, 0x9a, 0xb9, 0x5f, 0xb3, 0xb7, 0xf5, 0x94,
	0x52, 0x2c, 0x50, 0xef, 0xa1, 0xb1, 0x09, 0x49, 0x51, 0x31, 0x78, 0xf2, 0xe9, 0xeb, 0x51, 0xeb,
	0x11, 0x7b, 0x50, 0x33, 0x54, 0x4f, 0xce, 0xb2, 0x17, 0xb2, 0x66, 0xb2, 0xc1, 0xae, 0x87, 0xdd,
	0x65, 0x77, 0x56, 0x86, 0x75, 0x9e, 0xb1, 0xad, 0xbf, 0xc3, 0x36, 0x23, 0x6d, 0x71, 0xb0, 0xe7,
	0xc9, 0xf7, 0xd8, 0x60, 0x15, 0x72, 0x40, 0xf4, 0x3e, 0x03, 0xbb, 0x5c, 0x84, 0x92, 0x4a, 0x7f,
	0x10, 0x30, 0xd1, 0x5b, 0x60, 0x17, 0x4f, 0x96, 0x44, 0xb7, 0x56, 0x7a, 0xe3, 0x78, 0xe7, 0x7f,
	0xcb, 0x82, 0xb3, 0xce, 0xb9, 0x2e, 0xdc, 0x84, 0x21, 0x1e, 0x2f, 0x5b, 0xf0, 0x6d, 0xd9, 0x82,
	0x1f, 0xcb, 0x16, 0x7c, 0x79, 0x73, 0xfc, 0xbd, 0xd9, 0xd8, 0x04, 0xc6, 0x15, 0x05, 0x6a, 0x66,
	0xe8, 0xf5, 0xa2, 0xb6, 0xc1, 0x30, 0x3e, 0x73, 0xc4, 0x7d, 0x7f, 0x4d, 0xfb, 0x70, 0x04, 0x30,
	0x6a, 0x16, 0x97, 0xd5, 0xff, 0x15, 0x00, 0x00, 0xff, 0xff, 0x76, 0xe7, 0x3e, 0xde, 0xed, 0x03,
	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

// EventReportingServiceClient is the client API for EventReportingService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type EventReportingServiceClient interface {
	// Envoy will connect and send StreamEventsRequest messages forever.
	// The management server may send StreamEventsResponse to configure event stream. See below.
	// This API is designed for high throughput with the expectation that it might be lossy.
	StreamEvents(ctx context.Context, opts ...grpc.CallOption) (EventReportingService_StreamEventsClient, error)
}

type eventReportingServiceClient struct {
	cc *grpc.ClientConn
}

func NewEventReportingServiceClient(cc *grpc.ClientConn) EventReportingServiceClient {
	return &eventReportingServiceClient{cc}
}

func (c *eventReportingServiceClient) StreamEvents(ctx context.Context, opts ...grpc.CallOption) (EventReportingService_StreamEventsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_EventReportingService_serviceDesc.Streams[0], "/envoy.service.event_reporting.v3.EventReportingService/StreamEvents", opts...)
	if err != nil {
		return nil, err
	}
	x := &eventReportingServiceStreamEventsClient{stream}
	return x, nil
}

type EventReportingService_StreamEventsClient interface {
	Send(*StreamEventsRequest) error
	Recv() (*StreamEventsResponse, error)
	grpc.ClientStream
}

type eventReportingServiceStreamEventsClient struct {
	grpc.ClientStream
}

func (x *eventReportingServiceStreamEventsClient) Send(m *StreamEventsRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

// EventReportingServiceServer is the server API for EventReportingService service.
type EventReportingServiceServer interface {
	// Envoy will connect and send StreamEventsRequest messages forever.
	// The management server may send StreamEventsResponse to configure event stream. See below.
	// This API is designed for high throughput with the expectation that it might be lossy.
	StreamEvents(EventReportingService_StreamEventsServer) error
}

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

func (*UnimplementedEventReportingServiceServer) StreamEvents(srv EventReportingService_StreamEventsServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamEvents not implemented")
}

func RegisterEventReportingServiceServer(s *grpc.Server, srv EventReportingServiceServer) {
	s.RegisterService(&_EventReportingService_serviceDesc, srv)
}

func _EventReportingService_StreamEvents_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(EventReportingServiceServer).StreamEvents(&eventReportingServiceStreamEventsServer{stream})
}

type EventReportingService_StreamEventsServer interface {
	Send(*StreamEventsResponse) error
	Recv() (*StreamEventsRequest, error)
	grpc.ServerStream
}

type eventReportingServiceStreamEventsServer struct {
	grpc.ServerStream
}

func (x *eventReportingServiceStreamEventsServer) Send(m *StreamEventsResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

var _EventReportingService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "envoy.service.event_reporting.v3.EventReportingService",
	HandlerType: (*EventReportingServiceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "StreamEvents",
			Handler:       _EventReportingService_StreamEvents_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "envoy/service/event_reporting/v3/event_reporting_service.proto",
}

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

func (m *StreamEventsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Events) > 0 {
		for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Events[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEventReportingService(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Identifier != nil {
		{
			size, err := m.Identifier.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEventReportingService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *StreamEventsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

func encodeVarintEventReportingService(dAtA []byte, offset int, v uint64) int {
	offset -= sovEventReportingService(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *StreamEventsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Identifier != nil {
		l = m.Identifier.Size()
		n += 1 + l + sovEventReportingService(uint64(l))
	}
	if len(m.Events) > 0 {
		for _, e := range m.Events {
			l = e.Size()
			n += 1 + l + sovEventReportingService(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *StreamEventsRequest_Identifier) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Node != nil {
		l = m.Node.Size()
		n += 1 + l + sovEventReportingService(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func sovEventReportingService(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozEventReportingService(x uint64) (n int) {
	return sovEventReportingService(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *StreamEventsRequest) 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 ErrIntOverflowEventReportingService
			}
			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: StreamEventsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StreamEventsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Identifier", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEventReportingService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEventReportingService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEventReportingService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Identifier == nil {
				m.Identifier = &StreamEventsRequest_Identifier{}
			}
			if err := m.Identifier.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEventReportingService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEventReportingService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEventReportingService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Events = append(m.Events, &types.Any{})
			if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEventReportingService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEventReportingService
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEventReportingService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

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

var (
	ErrInvalidLengthEventReportingService        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowEventReportingService          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupEventReportingService = fmt.Errorf("proto: unexpected end of group")
)