func (*HashOrigin) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*HashOrigin_Request)(nil),
	}
}
XXX_OneofWrappers is for the internal use of the proto package.
package eventpb
import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	isspb "github.com/hyperledger-labs/mirbft/pkg/pb/isspb"
	messagepb "github.com/hyperledger-labs/mirbft/pkg/pb/messagepb"
	requestpb "github.com/hyperledger-labs/mirbft/pkg/pb/requestpb"
	math "math"
)
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
const _ = proto.ProtoPackageIsVersion3  
type Event struct {
	Type isEvent_Type `protobuf_oneof:"type"`
	Next                 []*Event `protobuf:"bytes,100,rep,name=next,proto3" json:"next,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_e1d62373b81ab9ca, []int{0}
}
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
type isEvent_Type interface {
	isEvent_Type()
}
type Event_Tick struct {
	Tick *Tick `protobuf:"bytes,1,opt,name=tick,proto3,oneof"`
}
type Event_WalAppend struct {
	WalAppend *WALAppend `protobuf:"bytes,2,opt,name=wal_append,json=walAppend,proto3,oneof"`
}
type Event_WalEntry struct {
	WalEntry *WALEntry `protobuf:"bytes,3,opt,name=wal_entry,json=walEntry,proto3,oneof"`
}
type Event_Request struct {
	Request *requestpb.Request `protobuf:"bytes,4,opt,name=request,proto3,oneof"`
}
type Event_HashRequest struct {
	HashRequest *HashRequest `protobuf:"bytes,5,opt,name=hash_request,json=hashRequest,proto3,oneof"`
}
type Event_HashResult struct {
	HashResult *HashResult `protobuf:"bytes,6,opt,name=hash_result,json=hashResult,proto3,oneof"`
}
type Event_RequestReady struct {
	RequestReady *RequestReady `protobuf:"bytes,7,opt,name=request_ready,json=requestReady,proto3,oneof"`
}
type Event_SendMessage struct {
	SendMessage *SendMessage `protobuf:"bytes,8,opt,name=send_message,json=sendMessage,proto3,oneof"`
}
type Event_MessageReceived struct {
	MessageReceived *MessageReceived `protobuf:"bytes,9,opt,name=message_received,json=messageReceived,proto3,oneof"`
}
type Event_Deliver struct {
	Deliver *Deliver `protobuf:"bytes,10,opt,name=deliver,proto3,oneof"`
}
type Event_Iss struct {
	Iss *isspb.ISSEvent `protobuf:"bytes,11,opt,name=iss,proto3,oneof"`
}
type Event_PersistDummyBatch struct {
	PersistDummyBatch *PersistDummyBatch `protobuf:"bytes,101,opt,name=persist_dummy_batch,json=persistDummyBatch,proto3,oneof"`
}
type Event_AnnounceDummyBatch struct {
	AnnounceDummyBatch *AnnounceDummyBatch `protobuf:"bytes,102,opt,name=announce_dummy_batch,json=announceDummyBatch,proto3,oneof"`
}
type Event_StoreDummyRequest struct {
	StoreDummyRequest *StoreDummyRequest `protobuf:"bytes,103,opt,name=store_dummy_request,json=storeDummyRequest,proto3,oneof"`
}
func (*Event_Tick) isEvent_Type() {}
func (*Event_WalAppend) isEvent_Type() {}
func (*Event_WalEntry) isEvent_Type() {}
func (*Event_Request) isEvent_Type() {}
func (*Event_HashRequest) isEvent_Type() {}
func (*Event_HashResult) isEvent_Type() {}
func (*Event_RequestReady) isEvent_Type() {}
func (*Event_SendMessage) isEvent_Type() {}
func (*Event_MessageReceived) isEvent_Type() {}
func (*Event_Deliver) isEvent_Type() {}
func (*Event_Iss) isEvent_Type() {}
func (*Event_PersistDummyBatch) isEvent_Type() {}
func (*Event_AnnounceDummyBatch) isEvent_Type() {}
func (*Event_StoreDummyRequest) isEvent_Type() {}
func (m *Event) GetType() isEvent_Type {
	if m != nil {
		return m.Type
	}
	return nil
}
func (m *Event) GetTick() *Tick {
	if x, ok := m.GetType().(*Event_Tick); ok {
		return x.Tick
	}
	return nil
}
func (m *Event) GetWalAppend() *WALAppend {
	if x, ok := m.GetType().(*Event_WalAppend); ok {
		return x.WalAppend
	}
	return nil
}
func (m *Event) GetWalEntry() *WALEntry {
	if x, ok := m.GetType().(*Event_WalEntry); ok {
		return x.WalEntry
	}
	return nil
}
func (m *Event) GetRequest() *requestpb.Request {
	if x, ok := m.GetType().(*Event_Request); ok {
		return x.Request
	}
	return nil
}
func (m *Event) GetHashRequest() *HashRequest {
	if x, ok := m.GetType().(*Event_HashRequest); ok {
		return x.HashRequest
	}
	return nil
}
func (m *Event) GetHashResult() *HashResult {
	if x, ok := m.GetType().(*Event_HashResult); ok {
		return x.HashResult
	}
	return nil
}
func (m *Event) GetRequestReady() *RequestReady {
	if x, ok := m.GetType().(*Event_RequestReady); ok {
		return x.RequestReady
	}
	return nil
}
func (m *Event) GetSendMessage() *SendMessage {
	if x, ok := m.GetType().(*Event_SendMessage); ok {
		return x.SendMessage
	}
	return nil
}
func (m *Event) GetMessageReceived() *MessageReceived {
	if x, ok := m.GetType().(*Event_MessageReceived); ok {
		return x.MessageReceived
	}
	return nil
}
func (m *Event) GetDeliver() *Deliver {
	if x, ok := m.GetType().(*Event_Deliver); ok {
		return x.Deliver
	}
	return nil
}
func (m *Event) GetIss() *isspb.ISSEvent {
	if x, ok := m.GetType().(*Event_Iss); ok {
		return x.Iss
	}
	return nil
}
func (m *Event) GetPersistDummyBatch() *PersistDummyBatch {
	if x, ok := m.GetType().(*Event_PersistDummyBatch); ok {
		return x.PersistDummyBatch
	}
	return nil
}
func (m *Event) GetAnnounceDummyBatch() *AnnounceDummyBatch {
	if x, ok := m.GetType().(*Event_AnnounceDummyBatch); ok {
		return x.AnnounceDummyBatch
	}
	return nil
}
func (m *Event) GetStoreDummyRequest() *StoreDummyRequest {
	if x, ok := m.GetType().(*Event_StoreDummyRequest); ok {
		return x.StoreDummyRequest
	}
	return nil
}
func (m *Event) GetNext() []*Event {
	if m != nil {
		return m.Next
	}
	return nil
}
func (*Event) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Event_Tick)(nil),
		(*Event_WalAppend)(nil),
		(*Event_WalEntry)(nil),
		(*Event_Request)(nil),
		(*Event_HashRequest)(nil),
		(*Event_HashResult)(nil),
		(*Event_RequestReady)(nil),
		(*Event_SendMessage)(nil),
		(*Event_MessageReceived)(nil),
		(*Event_Deliver)(nil),
		(*Event_Iss)(nil),
		(*Event_PersistDummyBatch)(nil),
		(*Event_AnnounceDummyBatch)(nil),
		(*Event_StoreDummyRequest)(nil),
	}
}
type Tick struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}
func (m *Tick) Reset()         { *m = Tick{} }
func (m *Tick) String() string { return proto.CompactTextString(m) }
func (*Tick) ProtoMessage()    {}
func (*Tick) Descriptor() ([]byte, []int) {
	return fileDescriptor_e1d62373b81ab9ca, []int{1}
}
func (m *Tick) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Tick.Unmarshal(m, b)
}
func (m *Tick) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Tick.Marshal(b, m, deterministic)
}
func (m *Tick) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Tick.Merge(m, src)
}
func (m *Tick) XXX_Size() int {
	return xxx_messageInfo_Tick.Size(m)
}
func (m *Tick) XXX_DiscardUnknown() {
	xxx_messageInfo_Tick.DiscardUnknown(m)
}
var xxx_messageInfo_Tick proto.InternalMessageInfo
type HashRequest struct {
	Data                 [][]byte    `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"`
	Origin               *HashOrigin `protobuf:"bytes,2,opt,name=origin,proto3" json:"origin,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}
func (m *HashRequest) Reset()         { *m = HashRequest{} }
func (m *HashRequest) String() string { return proto.CompactTextString(m) }
func (*HashRequest) ProtoMessage()    {}
func (*HashRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e1d62373b81ab9ca, []int{2}
}
func (m *HashRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_HashRequest.Unmarshal(m, b)
}
func (m *HashRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_HashRequest.Marshal(b, m, deterministic)
}
func (m *HashRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HashRequest.Merge(m, src)
}
func (m *HashRequest) XXX_Size() int {
	return xxx_messageInfo_HashRequest.Size(m)
}
func (m *HashRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_HashRequest.DiscardUnknown(m)
}
var xxx_messageInfo_HashRequest proto.InternalMessageInfo
func (m *HashRequest) GetData() [][]byte {
	if m != nil {
		return m.Data
	}
	return nil
}
func (m *HashRequest) GetOrigin() *HashOrigin {
	if m != nil {
		return m.Origin
	}
	return nil
}
type HashResult struct {
	Digest               []byte      `protobuf:"bytes,1,opt,name=digest,proto3" json:"digest,omitempty"`
	Origin               *HashOrigin `protobuf:"bytes,2,opt,name=origin,proto3" json:"origin,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}
func (m *HashResult) Reset()         { *m = HashResult{} }
func (m *HashResult) String() string { return proto.CompactTextString(m) }
func (*HashResult) ProtoMessage()    {}
func (*HashResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_e1d62373b81ab9ca, []int{3}
}
func (m *HashResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_HashResult.Unmarshal(m, b)
}
func (m *HashResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_HashResult.Marshal(b, m, deterministic)
}
func (m *HashResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HashResult.Merge(m, src)
}
func (m *HashResult) XXX_Size() int {
	return xxx_messageInfo_HashResult.Size(m)
}
func (m *HashResult) XXX_DiscardUnknown() {
	xxx_messageInfo_HashResult.DiscardUnknown(m)
}
var xxx_messageInfo_HashResult proto.InternalMessageInfo
func (m *HashResult) GetDigest() []byte {
	if m != nil {
		return m.Digest
	}
	return nil
}
func (m *HashResult) GetOrigin() *HashOrigin {
	if m != nil {
		return m.Origin
	}
	return nil
}
type HashOrigin struct {
	Type                 isHashOrigin_Type `protobuf_oneof:"type"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}
func (m *HashOrigin) Reset()         { *m = HashOrigin{} }
func (m *HashOrigin) String() string { return proto.CompactTextString(m) }
func (*HashOrigin) ProtoMessage()    {}
func (*HashOrigin) Descriptor() ([]byte, []int) {
	return fileDescriptor_e1d62373b81ab9ca, []int{4}
}
func (m *HashOrigin) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_HashOrigin.Unmarshal(m, b)
}
func (m *HashOrigin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_HashOrigin.Marshal(b, m, deterministic)
}
func (m *HashOrigin) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HashOrigin.Merge(m, src)
}
func (m *HashOrigin) XXX_Size() int {
	return xxx_messageInfo_HashOrigin.Size(m)
}
func (m *HashOrigin) XXX_DiscardUnknown() {
	xxx_messageInfo_HashOrigin.DiscardUnknown(m)
}
var xxx_messageInfo_HashOrigin proto.InternalMessageInfo
type isHashOrigin_Type interface {
	isHashOrigin_Type()
}
type HashOrigin_Request struct {
	Request *requestpb.Request `protobuf:"bytes,1,opt,name=request,proto3,oneof"`
}
func (*HashOrigin_Request) isHashOrigin_Type() {}
func (m *HashOrigin) GetType() isHashOrigin_Type {
	if m != nil {
		return m.Type
	}
	return nil
}
func (m *HashOrigin) GetRequest() *requestpb.Request {
	if x, ok := m.GetType().(*HashOrigin_Request); ok {
		return x.Request
	}
	return nil
}