// SPDX-License-Identifier: MIT

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.12
// 	protoc        (unknown)
// source: ermite/event.proto

package ermite

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// WatchRequest selects the events to receive.
type WatchRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Topics are the subjects to follow: "home" for every repository visible to
	// the caller, or "repo:<name>" for one repository. Empty means "home".
	// Unknown topics are invalid_argument. A "repo:<name>" topic for a repository
	// that does not exist or is not visible is not_found.
	Topics []string `protobuf:"bytes,1,rep,name=topics,proto3" json:"topics,omitempty"`
	// ResumeAfter is the Event.id of the last event the client has seen. Empty
	// to receive only new events.
	ResumeAfter   string `protobuf:"bytes,2,opt,name=resume_after,json=resumeAfter,proto3" json:"resume_after,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *WatchRequest) Reset() {
	*x = WatchRequest{}
	mi := &file_ermite_event_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *WatchRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*WatchRequest) ProtoMessage() {}

func (x *WatchRequest) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_event_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use WatchRequest.ProtoReflect.Descriptor instead.
func (*WatchRequest) Descriptor() ([]byte, []int) {
	return file_ermite_event_proto_rawDescGZIP(), []int{0}
}

func (x *WatchRequest) GetTopics() []string {
	if x != nil {
		return x.Topics
	}
	return nil
}

func (x *WatchRequest) GetResumeAfter() string {
	if x != nil {
		return x.ResumeAfter
	}
	return ""
}

// WatchResponse carries one event of the stream.
type WatchResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Event is the event.
	Event         *Event `protobuf:"bytes,1,opt,name=event,proto3" json:"event,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *WatchResponse) Reset() {
	*x = WatchResponse{}
	mi := &file_ermite_event_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *WatchResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*WatchResponse) ProtoMessage() {}

func (x *WatchResponse) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_event_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use WatchResponse.ProtoReflect.Descriptor instead.
func (*WatchResponse) Descriptor() ([]byte, []int) {
	return file_ermite_event_proto_rawDescGZIP(), []int{1}
}

func (x *WatchResponse) GetEvent() *Event {
	if x != nil {
		return x.Event
	}
	return nil
}

// Event is something that happened on the forge.
type Event struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Id identifies the event and is passed as resume_after to resume a stream.
	// It is opaque and only comparable for equality; clients must not parse it.
	// Empty on a Gap event.
	Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	// Time is when the event happened.
	Time *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=time,proto3" json:"time,omitempty"`
	// Kind is the type and payload of the event. New kinds may be added; clients
	// must ignore kinds they do not know.
	//
	// Types that are valid to be assigned to Kind:
	//
	//	*Event_RepoCreated
	//	*Event_RepoUpdated
	//	*Event_RepoDeleted
	//	*Event_Pushed
	//	*Event_Gap
	//	*Event_MergeRequestOpened
	//	*Event_MergeRequestMerged
	//	*Event_MergeRequestClosed
	//	*Event_CommentAdded
	//	*Event_RunUpdated
	//	*Event_JobUpdated
	Kind          isEvent_Kind `protobuf_oneof:"kind"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Event) Reset() {
	*x = Event{}
	mi := &file_ermite_event_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Event) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Event) ProtoMessage() {}

func (x *Event) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_event_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Event.ProtoReflect.Descriptor instead.
func (*Event) Descriptor() ([]byte, []int) {
	return file_ermite_event_proto_rawDescGZIP(), []int{2}
}

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

func (x *Event) GetTime() *timestamppb.Timestamp {
	if x != nil {
		return x.Time
	}
	return nil
}

func (x *Event) GetKind() isEvent_Kind {
	if x != nil {
		return x.Kind
	}
	return nil
}

func (x *Event) GetRepoCreated() *RepoCreated {
	if x != nil {
		if x, ok := x.Kind.(*Event_RepoCreated); ok {
			return x.RepoCreated
		}
	}
	return nil
}

func (x *Event) GetRepoUpdated() *RepoUpdated {
	if x != nil {
		if x, ok := x.Kind.(*Event_RepoUpdated); ok {
			return x.RepoUpdated
		}
	}
	return nil
}

func (x *Event) GetRepoDeleted() *RepoDeleted {
	if x != nil {
		if x, ok := x.Kind.(*Event_RepoDeleted); ok {
			return x.RepoDeleted
		}
	}
	return nil
}

func (x *Event) GetPushed() *Pushed {
	if x != nil {
		if x, ok := x.Kind.(*Event_Pushed); ok {
			return x.Pushed
		}
	}
	return nil
}

func (x *Event) GetGap() *Gap {
	if x != nil {
		if x, ok := x.Kind.(*Event_Gap); ok {
			return x.Gap
		}
	}
	return nil
}

func (x *Event) GetMergeRequestOpened() *MergeRequestOpened {
	if x != nil {
		if x, ok := x.Kind.(*Event_MergeRequestOpened); ok {
			return x.MergeRequestOpened
		}
	}
	return nil
}

func (x *Event) GetMergeRequestMerged() *MergeRequestMerged {
	if x != nil {
		if x, ok := x.Kind.(*Event_MergeRequestMerged); ok {
			return x.MergeRequestMerged
		}
	}
	return nil
}

func (x *Event) GetMergeRequestClosed() *MergeRequestClosed {
	if x != nil {
		if x, ok := x.Kind.(*Event_MergeRequestClosed); ok {
			return x.MergeRequestClosed
		}
	}
	return nil
}

func (x *Event) GetCommentAdded() *CommentAdded {
	if x != nil {
		if x, ok := x.Kind.(*Event_CommentAdded); ok {
			return x.CommentAdded
		}
	}
	return nil
}

func (x *Event) GetRunUpdated() *RunUpdated {
	if x != nil {
		if x, ok := x.Kind.(*Event_RunUpdated); ok {
			return x.RunUpdated
		}
	}
	return nil
}

func (x *Event) GetJobUpdated() *JobUpdated {
	if x != nil {
		if x, ok := x.Kind.(*Event_JobUpdated); ok {
			return x.JobUpdated
		}
	}
	return nil
}

type isEvent_Kind interface {
	isEvent_Kind()
}

type Event_RepoCreated struct {
	// RepoCreated: a repository was created.
	RepoCreated *RepoCreated `protobuf:"bytes,3,opt,name=repo_created,json=repoCreated,proto3,oneof"`
}

type Event_RepoUpdated struct {
	// RepoUpdated: repository metadata changed.
	RepoUpdated *RepoUpdated `protobuf:"bytes,4,opt,name=repo_updated,json=repoUpdated,proto3,oneof"`
}

type Event_RepoDeleted struct {
	// RepoDeleted: a repository was deleted.
	RepoDeleted *RepoDeleted `protobuf:"bytes,5,opt,name=repo_deleted,json=repoDeleted,proto3,oneof"`
}

type Event_Pushed struct {
	// Pushed: refs of a repository were updated by a push.
	Pushed *Pushed `protobuf:"bytes,6,opt,name=pushed,proto3,oneof"`
}

type Event_Gap struct {
	// Gap: events were lost, reload state.
	Gap *Gap `protobuf:"bytes,7,opt,name=gap,proto3,oneof"`
}

type Event_MergeRequestOpened struct {
	// MergeRequestOpened: a merge request was opened.
	MergeRequestOpened *MergeRequestOpened `protobuf:"bytes,8,opt,name=merge_request_opened,json=mergeRequestOpened,proto3,oneof"`
}

type Event_MergeRequestMerged struct {
	// MergeRequestMerged: a merge request was merged.
	MergeRequestMerged *MergeRequestMerged `protobuf:"bytes,9,opt,name=merge_request_merged,json=mergeRequestMerged,proto3,oneof"`
}

type Event_MergeRequestClosed struct {
	// MergeRequestClosed: a merge request was closed without merging.
	MergeRequestClosed *MergeRequestClosed `protobuf:"bytes,10,opt,name=merge_request_closed,json=mergeRequestClosed,proto3,oneof"`
}

type Event_CommentAdded struct {
	// CommentAdded: a comment was added to a merge request.
	CommentAdded *CommentAdded `protobuf:"bytes,11,opt,name=comment_added,json=commentAdded,proto3,oneof"`
}

type Event_RunUpdated struct {
	// RunUpdated: a CI run was created or changed.
	RunUpdated *RunUpdated `protobuf:"bytes,12,opt,name=run_updated,json=runUpdated,proto3,oneof"`
}

type Event_JobUpdated struct {
	// JobUpdated: a CI job was created or changed.
	JobUpdated *JobUpdated `protobuf:"bytes,13,opt,name=job_updated,json=jobUpdated,proto3,oneof"`
}

func (*Event_RepoCreated) isEvent_Kind() {}

func (*Event_RepoUpdated) isEvent_Kind() {}

func (*Event_RepoDeleted) isEvent_Kind() {}

func (*Event_Pushed) isEvent_Kind() {}

func (*Event_Gap) isEvent_Kind() {}

func (*Event_MergeRequestOpened) isEvent_Kind() {}

func (*Event_MergeRequestMerged) isEvent_Kind() {}

func (*Event_MergeRequestClosed) isEvent_Kind() {}

func (*Event_CommentAdded) isEvent_Kind() {}

func (*Event_RunUpdated) isEvent_Kind() {}

func (*Event_JobUpdated) isEvent_Kind() {}

// RepoCreated reports a new repository.
type RepoCreated struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Repo is the new repository.
	Repo          *Repo `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RepoCreated) Reset() {
	*x = RepoCreated{}
	mi := &file_ermite_event_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RepoCreated) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RepoCreated) ProtoMessage() {}

func (x *RepoCreated) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_event_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RepoCreated.ProtoReflect.Descriptor instead.
func (*RepoCreated) Descriptor() ([]byte, []int) {
	return file_ermite_event_proto_rawDescGZIP(), []int{3}
}

func (x *RepoCreated) GetRepo() *Repo {
	if x != nil {
		return x.Repo
	}
	return nil
}

// RepoUpdated reports a metadata change.
type RepoUpdated struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Repo is the repository after the change.
	Repo          *Repo `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RepoUpdated) Reset() {
	*x = RepoUpdated{}
	mi := &file_ermite_event_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RepoUpdated) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RepoUpdated) ProtoMessage() {}

func (x *RepoUpdated) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_event_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RepoUpdated.ProtoReflect.Descriptor instead.
func (*RepoUpdated) Descriptor() ([]byte, []int) {
	return file_ermite_event_proto_rawDescGZIP(), []int{4}
}

func (x *RepoUpdated) GetRepo() *Repo {
	if x != nil {
		return x.Repo
	}
	return nil
}

// RepoDeleted reports a deleted repository.
type RepoDeleted struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Repo is the name of the deleted repository.
	Repo          string `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RepoDeleted) Reset() {
	*x = RepoDeleted{}
	mi := &file_ermite_event_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RepoDeleted) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RepoDeleted) ProtoMessage() {}

func (x *RepoDeleted) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_event_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RepoDeleted.ProtoReflect.Descriptor instead.
func (*RepoDeleted) Descriptor() ([]byte, []int) {
	return file_ermite_event_proto_rawDescGZIP(), []int{5}
}

func (x *RepoDeleted) GetRepo() string {
	if x != nil {
		return x.Repo
	}
	return ""
}

// Pushed reports the ref updates of one push.
type Pushed struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Repo is the name of the repository.
	Repo string `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"`
	// RefUpdates are the refs changed by the push.
	RefUpdates    []*RefUpdate `protobuf:"bytes,2,rep,name=ref_updates,json=refUpdates,proto3" json:"ref_updates,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Pushed) Reset() {
	*x = Pushed{}
	mi := &file_ermite_event_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Pushed) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Pushed) ProtoMessage() {}

func (x *Pushed) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_event_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Pushed.ProtoReflect.Descriptor instead.
func (*Pushed) Descriptor() ([]byte, []int) {
	return file_ermite_event_proto_rawDescGZIP(), []int{6}
}

func (x *Pushed) GetRepo() string {
	if x != nil {
		return x.Repo
	}
	return ""
}

func (x *Pushed) GetRefUpdates() []*RefUpdate {
	if x != nil {
		return x.RefUpdates
	}
	return nil
}

// RefUpdate is the change of one ref.
type RefUpdate struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Ref is the full ref name, for example "refs/heads/main".
	Ref string `protobuf:"bytes,1,opt,name=ref,proto3" json:"ref,omitempty"`
	// OldId is the object id before the update. Empty when the ref was created.
	OldId string `protobuf:"bytes,2,opt,name=old_id,json=oldId,proto3" json:"old_id,omitempty"`
	// NewId is the object id after the update. Empty when the ref was deleted.
	NewId         string `protobuf:"bytes,3,opt,name=new_id,json=newId,proto3" json:"new_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RefUpdate) Reset() {
	*x = RefUpdate{}
	mi := &file_ermite_event_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RefUpdate) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RefUpdate) ProtoMessage() {}

func (x *RefUpdate) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_event_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RefUpdate.ProtoReflect.Descriptor instead.
func (*RefUpdate) Descriptor() ([]byte, []int) {
	return file_ermite_event_proto_rawDescGZIP(), []int{7}
}

func (x *RefUpdate) GetRef() string {
	if x != nil {
		return x.Ref
	}
	return ""
}

func (x *RefUpdate) GetOldId() string {
	if x != nil {
		return x.OldId
	}
	return ""
}

func (x *RefUpdate) GetNewId() string {
	if x != nil {
		return x.NewId
	}
	return ""
}

// MergeRequestOpened reports a new merge request.
type MergeRequestOpened struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// MergeRequest is the new merge request.
	MergeRequest  *MergeRequest `protobuf:"bytes,1,opt,name=merge_request,json=mergeRequest,proto3" json:"merge_request,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MergeRequestOpened) Reset() {
	*x = MergeRequestOpened{}
	mi := &file_ermite_event_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *MergeRequestOpened) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*MergeRequestOpened) ProtoMessage() {}

func (x *MergeRequestOpened) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_event_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use MergeRequestOpened.ProtoReflect.Descriptor instead.
func (*MergeRequestOpened) Descriptor() ([]byte, []int) {
	return file_ermite_event_proto_rawDescGZIP(), []int{8}
}

func (x *MergeRequestOpened) GetMergeRequest() *MergeRequest {
	if x != nil {
		return x.MergeRequest
	}
	return nil
}

// MergeRequestMerged reports a merged merge request. It is published before
// the Pushed event of the target branch.
type MergeRequestMerged struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// MergeRequest is the merge request after the merge.
	MergeRequest  *MergeRequest `protobuf:"bytes,1,opt,name=merge_request,json=mergeRequest,proto3" json:"merge_request,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MergeRequestMerged) Reset() {
	*x = MergeRequestMerged{}
	mi := &file_ermite_event_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *MergeRequestMerged) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*MergeRequestMerged) ProtoMessage() {}

func (x *MergeRequestMerged) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_event_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use MergeRequestMerged.ProtoReflect.Descriptor instead.
func (*MergeRequestMerged) Descriptor() ([]byte, []int) {
	return file_ermite_event_proto_rawDescGZIP(), []int{9}
}

func (x *MergeRequestMerged) GetMergeRequest() *MergeRequest {
	if x != nil {
		return x.MergeRequest
	}
	return nil
}

// MergeRequestClosed reports a merge request closed without merging.
type MergeRequestClosed struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// MergeRequest is the merge request after closing.
	MergeRequest  *MergeRequest `protobuf:"bytes,1,opt,name=merge_request,json=mergeRequest,proto3" json:"merge_request,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MergeRequestClosed) Reset() {
	*x = MergeRequestClosed{}
	mi := &file_ermite_event_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *MergeRequestClosed) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*MergeRequestClosed) ProtoMessage() {}

func (x *MergeRequestClosed) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_event_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use MergeRequestClosed.ProtoReflect.Descriptor instead.
func (*MergeRequestClosed) Descriptor() ([]byte, []int) {
	return file_ermite_event_proto_rawDescGZIP(), []int{10}
}

func (x *MergeRequestClosed) GetMergeRequest() *MergeRequest {
	if x != nil {
		return x.MergeRequest
	}
	return nil
}

// CommentAdded reports a new comment on a merge request.
type CommentAdded struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Repo is the name of the repository.
	Repo string `protobuf:"bytes,1,opt,name=repo,proto3" json:"repo,omitempty"`
	// Number is the number of the merge request.
	Number int64 `protobuf:"varint,2,opt,name=number,proto3" json:"number,omitempty"`
	// Comment is the new comment.
	Comment       *Comment `protobuf:"bytes,3,opt,name=comment,proto3" json:"comment,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *CommentAdded) Reset() {
	*x = CommentAdded{}
	mi := &file_ermite_event_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *CommentAdded) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*CommentAdded) ProtoMessage() {}

func (x *CommentAdded) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_event_proto_msgTypes[11]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use CommentAdded.ProtoReflect.Descriptor instead.
func (*CommentAdded) Descriptor() ([]byte, []int) {
	return file_ermite_event_proto_rawDescGZIP(), []int{11}
}

func (x *CommentAdded) GetRepo() string {
	if x != nil {
		return x.Repo
	}
	return ""
}

func (x *CommentAdded) GetNumber() int64 {
	if x != nil {
		return x.Number
	}
	return 0
}

func (x *CommentAdded) GetComment() *Comment {
	if x != nil {
		return x.Comment
	}
	return nil
}

// Gap tells the client that events were lost: the requested resume point is
// older than the server's buffer. It has no fields. The client should reload
// the state it displays (repositories, refs, merge requests and their
// comments, CI runs and their jobs) and carry on with the next events.
type Gap struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Gap) Reset() {
	*x = Gap{}
	mi := &file_ermite_event_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Gap) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Gap) ProtoMessage() {}

func (x *Gap) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_event_proto_msgTypes[12]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Gap.ProtoReflect.Descriptor instead.
func (*Gap) Descriptor() ([]byte, []int) {
	return file_ermite_event_proto_rawDescGZIP(), []int{12}
}

// RunUpdated reports a CI run that was created or whose status, conclusion or
// timestamps changed. It is delivered on the "repo:<name>" topic only.
type RunUpdated struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Run is the run after the change, as of its latest attempt, without jobs.
	Run           *Run `protobuf:"bytes,1,opt,name=run,proto3" json:"run,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RunUpdated) Reset() {
	*x = RunUpdated{}
	mi := &file_ermite_event_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RunUpdated) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RunUpdated) ProtoMessage() {}

func (x *RunUpdated) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_event_proto_msgTypes[13]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RunUpdated.ProtoReflect.Descriptor instead.
func (*RunUpdated) Descriptor() ([]byte, []int) {
	return file_ermite_event_proto_rawDescGZIP(), []int{13}
}

func (x *RunUpdated) GetRun() *Run {
	if x != nil {
		return x.Run
	}
	return nil
}

// JobUpdated reports a CI job that was created or whose status, conclusion,
// runner or steps changed. It is delivered on the "repo:<name>" topic only.
type JobUpdated struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Job is the job after the change, with its steps.
	Job           *RunJob `protobuf:"bytes,1,opt,name=job,proto3" json:"job,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *JobUpdated) Reset() {
	*x = JobUpdated{}
	mi := &file_ermite_event_proto_msgTypes[14]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *JobUpdated) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*JobUpdated) ProtoMessage() {}

func (x *JobUpdated) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_event_proto_msgTypes[14]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use JobUpdated.ProtoReflect.Descriptor instead.
func (*JobUpdated) Descriptor() ([]byte, []int) {
	return file_ermite_event_proto_rawDescGZIP(), []int{14}
}

func (x *JobUpdated) GetJob() *RunJob {
	if x != nil {
		return x.Job
	}
	return nil
}

var File_ermite_event_proto protoreflect.FileDescriptor

const file_ermite_event_proto_rawDesc = "" +
	"\n" +
	"\x12ermite/event.proto\x12\x06ermite\x1a\x1aermite/merge_request.proto\x1a\x11ermite/repo.proto\x1a\x10ermite/run.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"I\n" +
	"\fWatchRequest\x12\x16\n" +
	"\x06topics\x18\x01 \x03(\tR\x06topics\x12!\n" +
	"\fresume_after\x18\x02 \x01(\tR\vresumeAfter\"4\n" +
	"\rWatchResponse\x12#\n" +
	"\x05event\x18\x01 \x01(\v2\r.ermite.EventR\x05event\"\xe3\x05\n" +
	"\x05Event\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\x12.\n" +
	"\x04time\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\x04time\x128\n" +
	"\frepo_created\x18\x03 \x01(\v2\x13.ermite.RepoCreatedH\x00R\vrepoCreated\x128\n" +
	"\frepo_updated\x18\x04 \x01(\v2\x13.ermite.RepoUpdatedH\x00R\vrepoUpdated\x128\n" +
	"\frepo_deleted\x18\x05 \x01(\v2\x13.ermite.RepoDeletedH\x00R\vrepoDeleted\x12(\n" +
	"\x06pushed\x18\x06 \x01(\v2\x0e.ermite.PushedH\x00R\x06pushed\x12\x1f\n" +
	"\x03gap\x18\a \x01(\v2\v.ermite.GapH\x00R\x03gap\x12N\n" +
	"\x14merge_request_opened\x18\b \x01(\v2\x1a.ermite.MergeRequestOpenedH\x00R\x12mergeRequestOpened\x12N\n" +
	"\x14merge_request_merged\x18\t \x01(\v2\x1a.ermite.MergeRequestMergedH\x00R\x12mergeRequestMerged\x12N\n" +
	"\x14merge_request_closed\x18\n" +
	" \x01(\v2\x1a.ermite.MergeRequestClosedH\x00R\x12mergeRequestClosed\x12;\n" +
	"\rcomment_added\x18\v \x01(\v2\x14.ermite.CommentAddedH\x00R\fcommentAdded\x125\n" +
	"\vrun_updated\x18\f \x01(\v2\x12.ermite.RunUpdatedH\x00R\n" +
	"runUpdated\x125\n" +
	"\vjob_updated\x18\r \x01(\v2\x12.ermite.JobUpdatedH\x00R\n" +
	"jobUpdatedB\x06\n" +
	"\x04kind\"/\n" +
	"\vRepoCreated\x12 \n" +
	"\x04repo\x18\x01 \x01(\v2\f.ermite.RepoR\x04repo\"/\n" +
	"\vRepoUpdated\x12 \n" +
	"\x04repo\x18\x01 \x01(\v2\f.ermite.RepoR\x04repo\"!\n" +
	"\vRepoDeleted\x12\x12\n" +
	"\x04repo\x18\x01 \x01(\tR\x04repo\"P\n" +
	"\x06Pushed\x12\x12\n" +
	"\x04repo\x18\x01 \x01(\tR\x04repo\x122\n" +
	"\vref_updates\x18\x02 \x03(\v2\x11.ermite.RefUpdateR\n" +
	"refUpdates\"K\n" +
	"\tRefUpdate\x12\x10\n" +
	"\x03ref\x18\x01 \x01(\tR\x03ref\x12\x15\n" +
	"\x06old_id\x18\x02 \x01(\tR\x05oldId\x12\x15\n" +
	"\x06new_id\x18\x03 \x01(\tR\x05newId\"O\n" +
	"\x12MergeRequestOpened\x129\n" +
	"\rmerge_request\x18\x01 \x01(\v2\x14.ermite.MergeRequestR\fmergeRequest\"O\n" +
	"\x12MergeRequestMerged\x129\n" +
	"\rmerge_request\x18\x01 \x01(\v2\x14.ermite.MergeRequestR\fmergeRequest\"O\n" +
	"\x12MergeRequestClosed\x129\n" +
	"\rmerge_request\x18\x01 \x01(\v2\x14.ermite.MergeRequestR\fmergeRequest\"e\n" +
	"\fCommentAdded\x12\x12\n" +
	"\x04repo\x18\x01 \x01(\tR\x04repo\x12\x16\n" +
	"\x06number\x18\x02 \x01(\x03R\x06number\x12)\n" +
	"\acomment\x18\x03 \x01(\v2\x0f.ermite.CommentR\acomment\"\x05\n" +
	"\x03Gap\"+\n" +
	"\n" +
	"RunUpdated\x12\x1d\n" +
	"\x03run\x18\x01 \x01(\v2\v.ermite.RunR\x03run\".\n" +
	"\n" +
	"JobUpdated\x12 \n" +
	"\x03job\x18\x01 \x01(\v2\x0e.ermite.RunJobR\x03job2F\n" +
	"\fEventService\x126\n" +
	"\x05Watch\x12\x14.ermite.WatchRequest\x1a\x15.ermite.WatchResponse0\x01Bq\n" +
	"\n" +
	"com.ermiteB\n" +
	"EventProtoP\x01Z\x1fbnema.dev/ermite-api/gen/ermite\xa2\x02\x03EXX\xaa\x02\x06Ermite\xca\x02\x06Ermite\xe2\x02\x12Ermite\\GPBMetadata\xea\x02\x06Ermiteb\x06proto3"

var (
	file_ermite_event_proto_rawDescOnce sync.Once
	file_ermite_event_proto_rawDescData []byte
)

func file_ermite_event_proto_rawDescGZIP() []byte {
	file_ermite_event_proto_rawDescOnce.Do(func() {
		file_ermite_event_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_ermite_event_proto_rawDesc), len(file_ermite_event_proto_rawDesc)))
	})
	return file_ermite_event_proto_rawDescData
}

var file_ermite_event_proto_msgTypes = make([]protoimpl.MessageInfo, 15)
var file_ermite_event_proto_goTypes = []any{
	(*WatchRequest)(nil),          // 0: ermite.WatchRequest
	(*WatchResponse)(nil),         // 1: ermite.WatchResponse
	(*Event)(nil),                 // 2: ermite.Event
	(*RepoCreated)(nil),           // 3: ermite.RepoCreated
	(*RepoUpdated)(nil),           // 4: ermite.RepoUpdated
	(*RepoDeleted)(nil),           // 5: ermite.RepoDeleted
	(*Pushed)(nil),                // 6: ermite.Pushed
	(*RefUpdate)(nil),             // 7: ermite.RefUpdate
	(*MergeRequestOpened)(nil),    // 8: ermite.MergeRequestOpened
	(*MergeRequestMerged)(nil),    // 9: ermite.MergeRequestMerged
	(*MergeRequestClosed)(nil),    // 10: ermite.MergeRequestClosed
	(*CommentAdded)(nil),          // 11: ermite.CommentAdded
	(*Gap)(nil),                   // 12: ermite.Gap
	(*RunUpdated)(nil),            // 13: ermite.RunUpdated
	(*JobUpdated)(nil),            // 14: ermite.JobUpdated
	(*timestamppb.Timestamp)(nil), // 15: google.protobuf.Timestamp
	(*Repo)(nil),                  // 16: ermite.Repo
	(*MergeRequest)(nil),          // 17: ermite.MergeRequest
	(*Comment)(nil),               // 18: ermite.Comment
	(*Run)(nil),                   // 19: ermite.Run
	(*RunJob)(nil),                // 20: ermite.RunJob
}
var file_ermite_event_proto_depIdxs = []int32{
	2,  // 0: ermite.WatchResponse.event:type_name -> ermite.Event
	15, // 1: ermite.Event.time:type_name -> google.protobuf.Timestamp
	3,  // 2: ermite.Event.repo_created:type_name -> ermite.RepoCreated
	4,  // 3: ermite.Event.repo_updated:type_name -> ermite.RepoUpdated
	5,  // 4: ermite.Event.repo_deleted:type_name -> ermite.RepoDeleted
	6,  // 5: ermite.Event.pushed:type_name -> ermite.Pushed
	12, // 6: ermite.Event.gap:type_name -> ermite.Gap
	8,  // 7: ermite.Event.merge_request_opened:type_name -> ermite.MergeRequestOpened
	9,  // 8: ermite.Event.merge_request_merged:type_name -> ermite.MergeRequestMerged
	10, // 9: ermite.Event.merge_request_closed:type_name -> ermite.MergeRequestClosed
	11, // 10: ermite.Event.comment_added:type_name -> ermite.CommentAdded
	13, // 11: ermite.Event.run_updated:type_name -> ermite.RunUpdated
	14, // 12: ermite.Event.job_updated:type_name -> ermite.JobUpdated
	16, // 13: ermite.RepoCreated.repo:type_name -> ermite.Repo
	16, // 14: ermite.RepoUpdated.repo:type_name -> ermite.Repo
	7,  // 15: ermite.Pushed.ref_updates:type_name -> ermite.RefUpdate
	17, // 16: ermite.MergeRequestOpened.merge_request:type_name -> ermite.MergeRequest
	17, // 17: ermite.MergeRequestMerged.merge_request:type_name -> ermite.MergeRequest
	17, // 18: ermite.MergeRequestClosed.merge_request:type_name -> ermite.MergeRequest
	18, // 19: ermite.CommentAdded.comment:type_name -> ermite.Comment
	19, // 20: ermite.RunUpdated.run:type_name -> ermite.Run
	20, // 21: ermite.JobUpdated.job:type_name -> ermite.RunJob
	0,  // 22: ermite.EventService.Watch:input_type -> ermite.WatchRequest
	1,  // 23: ermite.EventService.Watch:output_type -> ermite.WatchResponse
	23, // [23:24] is the sub-list for method output_type
	22, // [22:23] is the sub-list for method input_type
	22, // [22:22] is the sub-list for extension type_name
	22, // [22:22] is the sub-list for extension extendee
	0,  // [0:22] is the sub-list for field type_name
}

func init() { file_ermite_event_proto_init() }
func file_ermite_event_proto_init() {
	if File_ermite_event_proto != nil {
		return
	}
	file_ermite_merge_request_proto_init()
	file_ermite_repo_proto_init()
	file_ermite_run_proto_init()
	file_ermite_event_proto_msgTypes[2].OneofWrappers = []any{
		(*Event_RepoCreated)(nil),
		(*Event_RepoUpdated)(nil),
		(*Event_RepoDeleted)(nil),
		(*Event_Pushed)(nil),
		(*Event_Gap)(nil),
		(*Event_MergeRequestOpened)(nil),
		(*Event_MergeRequestMerged)(nil),
		(*Event_MergeRequestClosed)(nil),
		(*Event_CommentAdded)(nil),
		(*Event_RunUpdated)(nil),
		(*Event_JobUpdated)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_ermite_event_proto_rawDesc), len(file_ermite_event_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   15,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_ermite_event_proto_goTypes,
		DependencyIndexes: file_ermite_event_proto_depIdxs,
		MessageInfos:      file_ermite_event_proto_msgTypes,
	}.Build()
	File_ermite_event_proto = out.File
	file_ermite_event_proto_goTypes = nil
	file_ermite_event_proto_depIdxs = nil
}