github.com/tickoalcantara12/micro/v3@v3.0.0-20221007104245-9d75b9bcbab9/proto/events/events.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: events/events.proto

package events

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	math "math"
)

// 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.ProtoPackageIsVersion3 // please upgrade the proto package

type PublishRequest struct {
	Topic                string            `protobuf:"bytes,1,opt,name=topic,proto3" json:"topic,omitempty"`
	Metadata             map[string]string `protobuf:"bytes,2,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Payload              []byte            `protobuf:"bytes,3,opt,name=payload,proto3" json:"payload,omitempty"`
	Timestamp            int64             `protobuf:"varint,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *PublishRequest) Reset()         { *m = PublishRequest{} }
func (m *PublishRequest) String() string { return proto.CompactTextString(m) }
func (*PublishRequest) ProtoMessage()    {}
func (*PublishRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8ec31f2d2a3db598, []int{0}
}

func (m *PublishRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PublishRequest.Unmarshal(m, b)
}
func (m *PublishRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PublishRequest.Marshal(b, m, deterministic)
}
func (m *PublishRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PublishRequest.Merge(m, src)
}
func (m *PublishRequest) XXX_Size() int {
	return xxx_messageInfo_PublishRequest.Size(m)
}
func (m *PublishRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_PublishRequest.DiscardUnknown(m)
}

var xxx_messageInfo_PublishRequest proto.InternalMessageInfo

func (m *PublishRequest) GetTopic() string {
	if m != nil {
		return m.Topic
	}
	return ""
}

func (m *PublishRequest) GetMetadata() map[string]string {
	if m != nil {
		return m.Metadata
	}
	return nil
}

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

func (m *PublishRequest) GetTimestamp() int64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

type PublishResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PublishResponse) Reset()         { *m = PublishResponse{} }
func (m *PublishResponse) String() string { return proto.CompactTextString(m) }
func (*PublishResponse) ProtoMessage()    {}
func (*PublishResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8ec31f2d2a3db598, []int{1}
}

func (m *PublishResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PublishResponse.Unmarshal(m, b)
}
func (m *PublishResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PublishResponse.Marshal(b, m, deterministic)
}
func (m *PublishResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PublishResponse.Merge(m, src)
}
func (m *PublishResponse) XXX_Size() int {
	return xxx_messageInfo_PublishResponse.Size(m)
}
func (m *PublishResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_PublishResponse.DiscardUnknown(m)
}

var xxx_messageInfo_PublishResponse proto.InternalMessageInfo

type ConsumeRequest struct {
	Group   string `protobuf:"bytes,1,opt,name=group,proto3" json:"group,omitempty"`
	Topic   string `protobuf:"bytes,2,opt,name=topic,proto3" json:"topic,omitempty"`
	Offset  int64  `protobuf:"varint,3,opt,name=offset,proto3" json:"offset,omitempty"`
	AutoAck bool   `protobuf:"varint,4,opt,name=auto_ack,json=autoAck,proto3" json:"auto_ack,omitempty"`
	// duration in nanoseconds
	AckWait              int64    `protobuf:"varint,5,opt,name=ack_wait,json=ackWait,proto3" json:"ack_wait,omitempty"`
	RetryLimit           int64    `protobuf:"varint,6,opt,name=retry_limit,json=retryLimit,proto3" json:"retry_limit,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ConsumeRequest) Reset()         { *m = ConsumeRequest{} }
func (m *ConsumeRequest) String() string { return proto.CompactTextString(m) }
func (*ConsumeRequest) ProtoMessage()    {}
func (*ConsumeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8ec31f2d2a3db598, []int{2}
}

func (m *ConsumeRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ConsumeRequest.Unmarshal(m, b)
}
func (m *ConsumeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ConsumeRequest.Marshal(b, m, deterministic)
}
func (m *ConsumeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConsumeRequest.Merge(m, src)
}
func (m *ConsumeRequest) XXX_Size() int {
	return xxx_messageInfo_ConsumeRequest.Size(m)
}
func (m *ConsumeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ConsumeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ConsumeRequest proto.InternalMessageInfo

func (m *ConsumeRequest) GetGroup() string {
	if m != nil {
		return m.Group
	}
	return ""
}

func (m *ConsumeRequest) GetTopic() string {
	if m != nil {
		return m.Topic
	}
	return ""
}

func (m *ConsumeRequest) GetOffset() int64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *ConsumeRequest) GetAutoAck() bool {
	if m != nil {
		return m.AutoAck
	}
	return false
}

func (m *ConsumeRequest) GetAckWait() int64 {
	if m != nil {
		return m.AckWait
	}
	return 0
}

func (m *ConsumeRequest) GetRetryLimit() int64 {
	if m != nil {
		return m.RetryLimit
	}
	return 0
}

type Event struct {
	Id                   string            `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Topic                string            `protobuf:"bytes,2,opt,name=topic,proto3" json:"topic,omitempty"`
	Metadata             map[string]string `protobuf:"bytes,3,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Payload              []byte            `protobuf:"bytes,4,opt,name=payload,proto3" json:"payload,omitempty"`
	Timestamp            int64             `protobuf:"varint,5,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *Event) Reset()         { *m = Event{} }
func (m *Event) String() string { return proto.CompactTextString(m) }
func (*Event) ProtoMessage()    {}
func (*Event) Descriptor() ([]byte, []int) {
	return fileDescriptor_8ec31f2d2a3db598, []int{3}
}

func (m *Event) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Event.Unmarshal(m, b)
}
func (m *Event) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Event.Marshal(b, m, deterministic)
}
func (m *Event) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Event.Merge(m, src)
}
func (m *Event) XXX_Size() int {
	return xxx_messageInfo_Event.Size(m)
}
func (m *Event) XXX_DiscardUnknown() {
	xxx_messageInfo_Event.DiscardUnknown(m)
}

var xxx_messageInfo_Event proto.InternalMessageInfo

func (m *Event) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *Event) GetTopic() string {
	if m != nil {
		return m.Topic
	}
	return ""
}

func (m *Event) GetMetadata() map[string]string {
	if m != nil {
		return m.Metadata
	}
	return nil
}

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

func (m *Event) GetTimestamp() int64 {
	if m != nil {
		return m.Timestamp
	}
	return 0
}

type ReadRequest struct {
	Topic                string   `protobuf:"bytes,1,opt,name=topic,proto3" json:"topic,omitempty"`
	Limit                uint64   `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"`
	Offset               uint64   `protobuf:"varint,3,opt,name=offset,proto3" json:"offset,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReadRequest) Reset()         { *m = ReadRequest{} }
func (m *ReadRequest) String() string { return proto.CompactTextString(m) }
func (*ReadRequest) ProtoMessage()    {}
func (*ReadRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8ec31f2d2a3db598, []int{4}
}

func (m *ReadRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReadRequest.Unmarshal(m, b)
}
func (m *ReadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReadRequest.Marshal(b, m, deterministic)
}
func (m *ReadRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReadRequest.Merge(m, src)
}
func (m *ReadRequest) XXX_Size() int {
	return xxx_messageInfo_ReadRequest.Size(m)
}
func (m *ReadRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ReadRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ReadRequest proto.InternalMessageInfo

func (m *ReadRequest) GetTopic() string {
	if m != nil {
		return m.Topic
	}
	return ""
}

func (m *ReadRequest) GetLimit() uint64 {
	if m != nil {
		return m.Limit
	}
	return 0
}

func (m *ReadRequest) GetOffset() uint64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

type ReadResponse struct {
	Events               []*Event `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ReadResponse) Reset()         { *m = ReadResponse{} }
func (m *ReadResponse) String() string { return proto.CompactTextString(m) }
func (*ReadResponse) ProtoMessage()    {}
func (*ReadResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8ec31f2d2a3db598, []int{5}
}

func (m *ReadResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ReadResponse.Unmarshal(m, b)
}
func (m *ReadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ReadResponse.Marshal(b, m, deterministic)
}
func (m *ReadResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReadResponse.Merge(m, src)
}
func (m *ReadResponse) XXX_Size() int {
	return xxx_messageInfo_ReadResponse.Size(m)
}
func (m *ReadResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ReadResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ReadResponse proto.InternalMessageInfo

func (m *ReadResponse) GetEvents() []*Event {
	if m != nil {
		return m.Events
	}
	return nil
}

type WriteRequest struct {
	Event                *Event   `protobuf:"bytes,1,opt,name=event,proto3" json:"event,omitempty"`
	Ttl                  int64    `protobuf:"varint,2,opt,name=ttl,proto3" json:"ttl,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *WriteRequest) Reset()         { *m = WriteRequest{} }
func (m *WriteRequest) String() string { return proto.CompactTextString(m) }
func (*WriteRequest) ProtoMessage()    {}
func (*WriteRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8ec31f2d2a3db598, []int{6}
}

func (m *WriteRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_WriteRequest.Unmarshal(m, b)
}
func (m *WriteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_WriteRequest.Marshal(b, m, deterministic)
}
func (m *WriteRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WriteRequest.Merge(m, src)
}
func (m *WriteRequest) XXX_Size() int {
	return xxx_messageInfo_WriteRequest.Size(m)
}
func (m *WriteRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_WriteRequest.DiscardUnknown(m)
}

var xxx_messageInfo_WriteRequest proto.InternalMessageInfo

func (m *WriteRequest) GetEvent() *Event {
	if m != nil {
		return m.Event
	}
	return nil
}

func (m *WriteRequest) GetTtl() int64 {
	if m != nil {
		return m.Ttl
	}
	return 0
}

type WriteResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *WriteResponse) Reset()         { *m = WriteResponse{} }
func (m *WriteResponse) String() string { return proto.CompactTextString(m) }
func (*WriteResponse) ProtoMessage()    {}
func (*WriteResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_8ec31f2d2a3db598, []int{7}
}

func (m *WriteResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_WriteResponse.Unmarshal(m, b)
}
func (m *WriteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_WriteResponse.Marshal(b, m, deterministic)
}
func (m *WriteResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WriteResponse.Merge(m, src)
}
func (m *WriteResponse) XXX_Size() int {
	return xxx_messageInfo_WriteResponse.Size(m)
}
func (m *WriteResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_WriteResponse.DiscardUnknown(m)
}

var xxx_messageInfo_WriteResponse proto.InternalMessageInfo

type AckRequest struct {
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Success              bool     `protobuf:"varint,2,opt,name=success,proto3" json:"success,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AckRequest) Reset()         { *m = AckRequest{} }
func (m *AckRequest) String() string { return proto.CompactTextString(m) }
func (*AckRequest) ProtoMessage()    {}
func (*AckRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_8ec31f2d2a3db598, []int{8}
}

func (m *AckRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AckRequest.Unmarshal(m, b)
}
func (m *AckRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AckRequest.Marshal(b, m, deterministic)
}
func (m *AckRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AckRequest.Merge(m, src)
}
func (m *AckRequest) XXX_Size() int {
	return xxx_messageInfo_AckRequest.Size(m)
}
func (m *AckRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AckRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AckRequest proto.InternalMessageInfo

func (m *AckRequest) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *AckRequest) GetSuccess() bool {
	if m != nil {
		return m.Success
	}
	return false
}

func init() {
	proto.RegisterType((*PublishRequest)(nil), "events.PublishRequest")
	proto.RegisterMapType((map[string]string)(nil), "events.PublishRequest.MetadataEntry")
	proto.RegisterType((*PublishResponse)(nil), "events.PublishResponse")
	proto.RegisterType((*ConsumeRequest)(nil), "events.ConsumeRequest")
	proto.RegisterType((*Event)(nil), "events.Event")
	proto.RegisterMapType((map[string]string)(nil), "events.Event.MetadataEntry")
	proto.RegisterType((*ReadRequest)(nil), "events.ReadRequest")
	proto.RegisterType((*ReadResponse)(nil), "events.ReadResponse")
	proto.RegisterType((*WriteRequest)(nil), "events.WriteRequest")
	proto.RegisterType((*WriteResponse)(nil), "events.WriteResponse")
	proto.RegisterType((*AckRequest)(nil), "events.AckRequest")
}

func init() { proto.RegisterFile("events/events.proto", fileDescriptor_8ec31f2d2a3db598) }

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

// StreamClient is the client API for Stream service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type StreamClient interface {
	Publish(ctx context.Context, in *PublishRequest, opts ...grpc.CallOption) (*PublishResponse, error)
	Consume(ctx context.Context, in *ConsumeRequest, opts ...grpc.CallOption) (Stream_ConsumeClient, error)
}

type streamClient struct {
	cc *grpc.ClientConn
}

func NewStreamClient(cc *grpc.ClientConn) StreamClient {
	return &streamClient{cc}
}

func (c *streamClient) Publish(ctx context.Context, in *PublishRequest, opts ...grpc.CallOption) (*PublishResponse, error) {
	out := new(PublishResponse)
	err := c.cc.Invoke(ctx, "/events.Stream/Publish", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *streamClient) Consume(ctx context.Context, in *ConsumeRequest, opts ...grpc.CallOption) (Stream_ConsumeClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Stream_serviceDesc.Streams[0], "/events.Stream/Consume", opts...)
	if err != nil {
		return nil, err
	}
	x := &streamConsumeClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Stream_ConsumeClient interface {
	Recv() (*Event, error)
	grpc.ClientStream
}

type streamConsumeClient struct {
	grpc.ClientStream
}

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

// StreamServer is the server API for Stream service.
type StreamServer interface {
	Publish(context.Context, *PublishRequest) (*PublishResponse, error)
	Consume(*ConsumeRequest, Stream_ConsumeServer) error
}

func RegisterStreamServer(s *grpc.Server, srv StreamServer) {
	s.RegisterService(&_Stream_serviceDesc, srv)
}

func _Stream_Publish_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PublishRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StreamServer).Publish(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/events.Stream/Publish",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StreamServer).Publish(ctx, req.(*PublishRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Stream_Consume_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ConsumeRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(StreamServer).Consume(m, &streamConsumeServer{stream})
}

type Stream_ConsumeServer interface {
	Send(*Event) error
	grpc.ServerStream
}

type streamConsumeServer struct {
	grpc.ServerStream
}

func (x *streamConsumeServer) Send(m *Event) error {
	return x.ServerStream.SendMsg(m)
}

var _Stream_serviceDesc = grpc.ServiceDesc{
	ServiceName: "events.Stream",
	HandlerType: (*StreamServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Publish",
			Handler:    _Stream_Publish_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Consume",
			Handler:       _Stream_Consume_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "events/events.proto",
}

// StoreClient is the client API for Store service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type StoreClient interface {
	Read(ctx context.Context, in *ReadRequest, opts ...grpc.CallOption) (*ReadResponse, error)
	Write(ctx context.Context, in *WriteRequest, opts ...grpc.CallOption) (*WriteResponse, error)
}

type storeClient struct {
	cc *grpc.ClientConn
}

func NewStoreClient(cc *grpc.ClientConn) StoreClient {
	return &storeClient{cc}
}

func (c *storeClient) Read(ctx context.Context, in *ReadRequest, opts ...grpc.CallOption) (*ReadResponse, error) {
	out := new(ReadResponse)
	err := c.cc.Invoke(ctx, "/events.Store/Read", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *storeClient) Write(ctx context.Context, in *WriteRequest, opts ...grpc.CallOption) (*WriteResponse, error) {
	out := new(WriteResponse)
	err := c.cc.Invoke(ctx, "/events.Store/Write", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// StoreServer is the server API for Store service.
type StoreServer interface {
	Read(context.Context, *ReadRequest) (*ReadResponse, error)
	Write(context.Context, *WriteRequest) (*WriteResponse, error)
}

func RegisterStoreServer(s *grpc.Server, srv StoreServer) {
	s.RegisterService(&_Store_serviceDesc, srv)
}

func _Store_Read_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReadRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StoreServer).Read(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/events.Store/Read",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StoreServer).Read(ctx, req.(*ReadRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Store_Write_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WriteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(StoreServer).Write(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/events.Store/Write",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(StoreServer).Write(ctx, req.(*WriteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Store_serviceDesc = grpc.ServiceDesc{
	ServiceName: "events.Store",
	HandlerType: (*StoreServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Read",
			Handler:    _Store_Read_Handler,
		},
		{
			MethodName: "Write",
			Handler:    _Store_Write_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "events/events.proto",
}