// SPDX-License-Identifier: MIT

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

package ermite

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	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)
)

// CiStatus is where a run, a job or a check is in its life. It is the same
// as GitHub's status, without the rarely used values.
type CiStatus int32

const (
	// Not set. In a filter it means every status. Never returned by the server.
	CiStatus_CI_STATUS_UNSPECIFIED CiStatus = 0
	// Waiting: for a runner, for the jobs it needs, or for its turn
	// (max-parallel).
	CiStatus_CI_STATUS_QUEUED CiStatus = 1
	// At least one job has been given to a runner and has not ended.
	CiStatus_CI_STATUS_IN_PROGRESS CiStatus = 2
	// Over. The conclusion says how it ended.
	CiStatus_CI_STATUS_COMPLETED CiStatus = 3
	// Held back by a concurrency group: another run or job of the group is
	// running, or a newer one is waiting (see RunJob.concurrency_group). Only for
	// jobs and checks, and only from servers with the feature "ci.concurrency";
	// a client that does not know the value shows it as queued.
	CiStatus_CI_STATUS_PENDING CiStatus = 4
)

// Enum value maps for CiStatus.
var (
	CiStatus_name = map[int32]string{
		0: "CI_STATUS_UNSPECIFIED",
		1: "CI_STATUS_QUEUED",
		2: "CI_STATUS_IN_PROGRESS",
		3: "CI_STATUS_COMPLETED",
		4: "CI_STATUS_PENDING",
	}
	CiStatus_value = map[string]int32{
		"CI_STATUS_UNSPECIFIED": 0,
		"CI_STATUS_QUEUED":      1,
		"CI_STATUS_IN_PROGRESS": 2,
		"CI_STATUS_COMPLETED":   3,
		"CI_STATUS_PENDING":     4,
	}
)

func (x CiStatus) Enum() *CiStatus {
	p := new(CiStatus)
	*p = x
	return p
}

func (x CiStatus) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (CiStatus) Descriptor() protoreflect.EnumDescriptor {
	return file_ermite_runner_proto_enumTypes[0].Descriptor()
}

func (CiStatus) Type() protoreflect.EnumType {
	return &file_ermite_runner_proto_enumTypes[0]
}

func (x CiStatus) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use CiStatus.Descriptor instead.
func (CiStatus) EnumDescriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{0}
}

// CiConclusion is how a run, a job, a step or a check ended, with GitHub's
// values and meaning. It is unset (CI_CONCLUSION_UNSPECIFIED) until the status is
// COMPLETED.
type CiConclusion int32

const (
	// Not completed yet. Never returned by the server for a completed item.
	CiConclusion_CI_CONCLUSION_UNSPECIFIED CiConclusion = 0
	// Everything it ran succeeded.
	CiConclusion_CI_CONCLUSION_SUCCESS CiConclusion = 1
	// A step failed, or the job failed for another reason described in
	// RunJob.error (runner lost, queue timeout, log limit, feature not
	// supported yet, invalid workflow file).
	CiConclusion_CI_CONCLUSION_FAILURE CiConclusion = 2
	// Cancelled by the owner, or by fail-fast, or because the runner shut down.
	CiConclusion_CI_CONCLUSION_CANCELLED CiConclusion = 3
	// Never ran: its "if" was false, or a job it needs did not succeed, or it was
	// not selected. Never reported by a runner.
	CiConclusion_CI_CONCLUSION_SKIPPED CiConclusion = 4
	// Exceeded its timeout.
	CiConclusion_CI_CONCLUSION_TIMED_OUT CiConclusion = 5
	// Neither a success nor a failure. Defined for parity with GitHub; no
	// workflow job ends this way yet. For merging it counts as a success.
	CiConclusion_CI_CONCLUSION_NEUTRAL CiConclusion = 6
	// Waits for a human action (for example the approval of an environment).
	// Defined for parity with GitHub; the server does not produce it before
	// environments exist. For merging it counts as a failure.
	CiConclusion_CI_CONCLUSION_ACTION_REQUIRED CiConclusion = 7
)

// Enum value maps for CiConclusion.
var (
	CiConclusion_name = map[int32]string{
		0: "CI_CONCLUSION_UNSPECIFIED",
		1: "CI_CONCLUSION_SUCCESS",
		2: "CI_CONCLUSION_FAILURE",
		3: "CI_CONCLUSION_CANCELLED",
		4: "CI_CONCLUSION_SKIPPED",
		5: "CI_CONCLUSION_TIMED_OUT",
		6: "CI_CONCLUSION_NEUTRAL",
		7: "CI_CONCLUSION_ACTION_REQUIRED",
	}
	CiConclusion_value = map[string]int32{
		"CI_CONCLUSION_UNSPECIFIED":     0,
		"CI_CONCLUSION_SUCCESS":         1,
		"CI_CONCLUSION_FAILURE":         2,
		"CI_CONCLUSION_CANCELLED":       3,
		"CI_CONCLUSION_SKIPPED":         4,
		"CI_CONCLUSION_TIMED_OUT":       5,
		"CI_CONCLUSION_NEUTRAL":         6,
		"CI_CONCLUSION_ACTION_REQUIRED": 7,
	}
)

func (x CiConclusion) Enum() *CiConclusion {
	p := new(CiConclusion)
	*p = x
	return p
}

func (x CiConclusion) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (CiConclusion) Descriptor() protoreflect.EnumDescriptor {
	return file_ermite_runner_proto_enumTypes[1].Descriptor()
}

func (CiConclusion) Type() protoreflect.EnumType {
	return &file_ermite_runner_proto_enumTypes[1]
}

func (x CiConclusion) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use CiConclusion.Descriptor instead.
func (CiConclusion) EnumDescriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{1}
}

// StepState is where a step is in its life.
type StepState int32

const (
	// Not set. Rejected in requests, never returned by the server.
	StepState_STEP_STATE_UNSPECIFIED StepState = 0
	// Known but not started.
	StepState_STEP_STATE_PENDING StepState = 1
	// Running.
	StepState_STEP_STATE_IN_PROGRESS StepState = 2
	// Over. The conclusion says how it ended. A step that did not run because
	// of its "if" or an earlier failure is COMPLETED with CI_CONCLUSION_SKIPPED.
	StepState_STEP_STATE_COMPLETED StepState = 3
)

// Enum value maps for StepState.
var (
	StepState_name = map[int32]string{
		0: "STEP_STATE_UNSPECIFIED",
		1: "STEP_STATE_PENDING",
		2: "STEP_STATE_IN_PROGRESS",
		3: "STEP_STATE_COMPLETED",
	}
	StepState_value = map[string]int32{
		"STEP_STATE_UNSPECIFIED": 0,
		"STEP_STATE_PENDING":     1,
		"STEP_STATE_IN_PROGRESS": 2,
		"STEP_STATE_COMPLETED":   3,
	}
)

func (x StepState) Enum() *StepState {
	p := new(StepState)
	*p = x
	return p
}

func (x StepState) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (StepState) Descriptor() protoreflect.EnumDescriptor {
	return file_ermite_runner_proto_enumTypes[2].Descriptor()
}

func (StepState) Type() protoreflect.EnumType {
	return &file_ermite_runner_proto_enumTypes[2]
}

func (x StepState) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use StepState.Descriptor instead.
func (StepState) EnumDescriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{2}
}

// RunnerIsolation is how a runner isolates each job from the host and from
// other jobs. The runner chooses it (auto-detection included) and reports it
// at registration; the job page shows it.
type RunnerIsolation int32

const (
	// Not set. Rejected at registration, never returned by the server.
	RunnerIsolation_RUNNER_ISOLATION_UNSPECIFIED RunnerIsolation = 0
	// One micro-VM per job, destroyed at the end.
	RunnerIsolation_RUNNER_ISOLATION_VM RunnerIsolation = 1
	// One container per job with its own Docker daemon, run by the sysbox
	// runtime. Shares the host kernel.
	RunnerIsolation_RUNNER_ISOLATION_CONTAINER_SYSBOX RunnerIsolation = 2
	// One privileged container per job with its own Docker daemon. Shares the
	// host kernel and is equivalent to root on the host: the weakest mode.
	RunnerIsolation_RUNNER_ISOLATION_CONTAINER_PRIVILEGED RunnerIsolation = 3
)

// Enum value maps for RunnerIsolation.
var (
	RunnerIsolation_name = map[int32]string{
		0: "RUNNER_ISOLATION_UNSPECIFIED",
		1: "RUNNER_ISOLATION_VM",
		2: "RUNNER_ISOLATION_CONTAINER_SYSBOX",
		3: "RUNNER_ISOLATION_CONTAINER_PRIVILEGED",
	}
	RunnerIsolation_value = map[string]int32{
		"RUNNER_ISOLATION_UNSPECIFIED":          0,
		"RUNNER_ISOLATION_VM":                   1,
		"RUNNER_ISOLATION_CONTAINER_SYSBOX":     2,
		"RUNNER_ISOLATION_CONTAINER_PRIVILEGED": 3,
	}
)

func (x RunnerIsolation) Enum() *RunnerIsolation {
	p := new(RunnerIsolation)
	*p = x
	return p
}

func (x RunnerIsolation) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (RunnerIsolation) Descriptor() protoreflect.EnumDescriptor {
	return file_ermite_runner_proto_enumTypes[3].Descriptor()
}

func (RunnerIsolation) Type() protoreflect.EnumType {
	return &file_ermite_runner_proto_enumTypes[3]
}

func (x RunnerIsolation) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use RunnerIsolation.Descriptor instead.
func (RunnerIsolation) EnumDescriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{3}
}

// CancelReason says why the server asks a runner to stop a job.
type CancelReason int32

const (
	// Not set. Never sent in a CancelRequest.
	CancelReason_CANCEL_REASON_UNSPECIFIED CancelReason = 0
	// The owner cancelled the run (RunService.CancelRun, web or CLI). The job
	// ends CI_CONCLUSION_CANCELLED.
	CancelReason_CANCEL_REASON_USER CancelReason = 1
	// Another job of the same matrix failed and the strategy has fail-fast. The
	// job ends CI_CONCLUSION_CANCELLED.
	CancelReason_CANCEL_REASON_FAIL_FAST CancelReason = 2
	// The job exceeded its time budget (see Job.timeout_minutes). The job ends
	// CI_CONCLUSION_TIMED_OUT.
	CancelReason_CANCEL_REASON_TIMEOUT CancelReason = 3
)

// Enum value maps for CancelReason.
var (
	CancelReason_name = map[int32]string{
		0: "CANCEL_REASON_UNSPECIFIED",
		1: "CANCEL_REASON_USER",
		2: "CANCEL_REASON_FAIL_FAST",
		3: "CANCEL_REASON_TIMEOUT",
	}
	CancelReason_value = map[string]int32{
		"CANCEL_REASON_UNSPECIFIED": 0,
		"CANCEL_REASON_USER":        1,
		"CANCEL_REASON_FAIL_FAST":   2,
		"CANCEL_REASON_TIMEOUT":     3,
	}
)

func (x CancelReason) Enum() *CancelReason {
	p := new(CancelReason)
	*p = x
	return p
}

func (x CancelReason) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (CancelReason) Descriptor() protoreflect.EnumDescriptor {
	return file_ermite_runner_proto_enumTypes[4].Descriptor()
}

func (CancelReason) Type() protoreflect.EnumType {
	return &file_ermite_runner_proto_enumTypes[4]
}

func (x CancelReason) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use CancelReason.Descriptor instead.
func (CancelReason) EnumDescriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{4}
}

// AnnotationLevel is the severity of an annotation, with the values of
// GitHub's check run annotation levels ("notice", "warning", "failure"). The
// workflow commands ::notice, ::warning and ::error produce NOTICE, WARNING and
// FAILURE.
type AnnotationLevel int32

const (
	// Not set. Rejected in requests, never returned by the server.
	AnnotationLevel_ANNOTATION_LEVEL_UNSPECIFIED AnnotationLevel = 0
	// Information: ::notice.
	AnnotationLevel_ANNOTATION_LEVEL_NOTICE AnnotationLevel = 1
	// A problem that does not fail the job by itself: ::warning.
	AnnotationLevel_ANNOTATION_LEVEL_WARNING AnnotationLevel = 2
	// An error: ::error.
	AnnotationLevel_ANNOTATION_LEVEL_FAILURE AnnotationLevel = 3
)

// Enum value maps for AnnotationLevel.
var (
	AnnotationLevel_name = map[int32]string{
		0: "ANNOTATION_LEVEL_UNSPECIFIED",
		1: "ANNOTATION_LEVEL_NOTICE",
		2: "ANNOTATION_LEVEL_WARNING",
		3: "ANNOTATION_LEVEL_FAILURE",
	}
	AnnotationLevel_value = map[string]int32{
		"ANNOTATION_LEVEL_UNSPECIFIED": 0,
		"ANNOTATION_LEVEL_NOTICE":      1,
		"ANNOTATION_LEVEL_WARNING":     2,
		"ANNOTATION_LEVEL_FAILURE":     3,
	}
)

func (x AnnotationLevel) Enum() *AnnotationLevel {
	p := new(AnnotationLevel)
	*p = x
	return p
}

func (x AnnotationLevel) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (AnnotationLevel) Descriptor() protoreflect.EnumDescriptor {
	return file_ermite_runner_proto_enumTypes[5].Descriptor()
}

func (AnnotationLevel) Type() protoreflect.EnumType {
	return &file_ermite_runner_proto_enumTypes[5]
}

func (x AnnotationLevel) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use AnnotationLevel.Descriptor instead.
func (AnnotationLevel) EnumDescriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{5}
}

// ActionSource says where the server found an action.
type ActionSource int32

const (
	// Not set. Only in a ResolvedAction that carries an error.
	ActionSource_ACTION_SOURCE_UNSPECIFIED ActionSource = 0
	// github.com: the archive is downloaded from GitHub, without a token.
	ActionSource_ACTION_SOURCE_GITHUB ActionSource = 1
	// A repository of this server, which wins over a github.com repository of
	// the same name (as GitHub Enterprise Server's own actions do).
	ActionSource_ACTION_SOURCE_ERMITE ActionSource = 2
)

// Enum value maps for ActionSource.
var (
	ActionSource_name = map[int32]string{
		0: "ACTION_SOURCE_UNSPECIFIED",
		1: "ACTION_SOURCE_GITHUB",
		2: "ACTION_SOURCE_ERMITE",
	}
	ActionSource_value = map[string]int32{
		"ACTION_SOURCE_UNSPECIFIED": 0,
		"ACTION_SOURCE_GITHUB":      1,
		"ACTION_SOURCE_ERMITE":      2,
	}
)

func (x ActionSource) Enum() *ActionSource {
	p := new(ActionSource)
	*p = x
	return p
}

func (x ActionSource) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (ActionSource) Descriptor() protoreflect.EnumDescriptor {
	return file_ermite_runner_proto_enumTypes[6].Descriptor()
}

func (ActionSource) Type() protoreflect.EnumType {
	return &file_ermite_runner_proto_enumTypes[6]
}

func (x ActionSource) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use ActionSource.Descriptor instead.
func (ActionSource) EnumDescriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{6}
}

// RegisterRunnerRequest describes the runner to register.
type RegisterRunnerRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Name identifies the runner for people (job page, logs, ListRunners) and is
	// unique: 1 to 64 characters among letters, digits, ".", "_" and "-". It is
	// not a label and never matches runs-on.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Labels are the labels the runner adds to its implicit ones: at most 64,
	// each 1 to 64 characters among letters, digits, ".", "_" and "-", for
	// example "ubuntu-latest". Comparison is case-insensitive and duplicates
	// are removed. The server adds the implicit labels "self-hosted", the os
	// and the arch ("linux", "x64" or "arm64"); the runner name is not a label.
	Labels []string `protobuf:"bytes,2,rep,name=labels,proto3" json:"labels,omitempty"`
	// Version is the release of the runner, for example "v0.1.0", or "devel".
	// Informational, at most 64 characters.
	Version string `protobuf:"bytes,3,opt,name=version,proto3" json:"version,omitempty"`
	// Isolation is how the runner isolates jobs. Required.
	Isolation RunnerIsolation `protobuf:"varint,4,opt,name=isolation,proto3,enum=ermite.RunnerIsolation" json:"isolation,omitempty"`
	// Arch is the CPU architecture, in GitHub's names: "x64" or "arm64". Other
	// values are invalid_argument (the set may grow with compatible additions).
	Arch string `protobuf:"bytes,5,opt,name=arch,proto3" json:"arch,omitempty"`
	// Os is the operating system: "linux". Other values are invalid_argument
	// (the set may grow with compatible additions).
	Os string `protobuf:"bytes,6,opt,name=os,proto3" json:"os,omitempty"`
	// Replace removes the runner that already has this name, if any, before
	// registering this one: its runner token is revoked at once, as in
	// RunService.RemoveRunner, and a job it is running is not affected. The new
	// runner gets a new runner_id. Needs the same scope as registering. Without
	// replace, a name in use is already_exists. It is how a runner re-registers
	// after losing its state.
	Replace       bool `protobuf:"varint,7,opt,name=replace,proto3" json:"replace,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RegisterRunnerRequest) ProtoMessage() {}

func (x *RegisterRunnerRequest) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_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 RegisterRunnerRequest.ProtoReflect.Descriptor instead.
func (*RegisterRunnerRequest) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{0}
}

func (x *RegisterRunnerRequest) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *RegisterRunnerRequest) GetLabels() []string {
	if x != nil {
		return x.Labels
	}
	return nil
}

func (x *RegisterRunnerRequest) GetVersion() string {
	if x != nil {
		return x.Version
	}
	return ""
}

func (x *RegisterRunnerRequest) GetIsolation() RunnerIsolation {
	if x != nil {
		return x.Isolation
	}
	return RunnerIsolation_RUNNER_ISOLATION_UNSPECIFIED
}

func (x *RegisterRunnerRequest) GetArch() string {
	if x != nil {
		return x.Arch
	}
	return ""
}

func (x *RegisterRunnerRequest) GetOs() string {
	if x != nil {
		return x.Os
	}
	return ""
}

func (x *RegisterRunnerRequest) GetReplace() bool {
	if x != nil {
		return x.Replace
	}
	return false
}

// RegisterRunnerResponse holds the new runner and its secret.
type RegisterRunnerResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// RunnerId identifies the runner in ListRunners and RemoveRunner. It is not
	// a secret.
	RunnerId string `protobuf:"bytes,1,opt,name=runner_id,json=runnerId,proto3" json:"runner_id,omitempty"`
	// RunnerToken is the secret of the runner, to present as "Authorization:
	// Bearer <runner_token>" to FetchJob: "ermiterun_" and 43 base64url
	// characters (32 random bytes, no padding). It is returned once: the server
	// keeps only its SHA-256, the runner must store it (mode 0600). It stops
	// working when the runner is removed or replaced.
	RunnerToken   string `protobuf:"bytes,2,opt,name=runner_token,json=runnerToken,proto3" json:"runner_token,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RegisterRunnerResponse) ProtoMessage() {}

func (x *RegisterRunnerResponse) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_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 RegisterRunnerResponse.ProtoReflect.Descriptor instead.
func (*RegisterRunnerResponse) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{1}
}

func (x *RegisterRunnerResponse) GetRunnerId() string {
	if x != nil {
		return x.RunnerId
	}
	return ""
}

func (x *RegisterRunnerResponse) GetRunnerToken() string {
	if x != nil {
		return x.RunnerToken
	}
	return ""
}

// FetchJobRequest asks for a job.
type FetchJobRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Labels narrows the labels offered for this call. Empty means all the
	// labels of the runner, which is the normal case. Otherwise each one must be
	// a label of the runner (invalid_argument if not) and only jobs whose runs-on
	// labels are all among them are offered.
	Labels []string `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels,omitempty"`
	// PollId identifies this poll, chosen by the client (for example 16 random
	// bytes in base64url), 1 to 64 characters among letters, digits, "_" and
	// "-". A client that retries a call whose response it did not get sends the
	// same poll_id, and gets the assignment the first call made, if it made one
	// (see FetchJob). A new poll uses a new id. Empty means no retry protection:
	// a lost assignment is then recovered by the acknowledgement timeout alone.
	PollId string `protobuf:"bytes,2,opt,name=poll_id,json=pollId,proto3" json:"poll_id,omitempty"`
	// Version is the release of the running runner software, for example
	// "v0.1.0", or "devel", at most 64 characters. Optional: the server stores it
	// as the runner's version (Runner.version in ListRunners), replacing the one
	// given at registration, so that the list shows what runs now. Empty, from
	// an older runner, leaves the stored version unchanged.
	Version       string `protobuf:"bytes,3,opt,name=version,proto3" json:"version,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FetchJobRequest) ProtoMessage() {}

func (x *FetchJobRequest) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_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 FetchJobRequest.ProtoReflect.Descriptor instead.
func (*FetchJobRequest) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{2}
}

func (x *FetchJobRequest) GetLabels() []string {
	if x != nil {
		return x.Labels
	}
	return nil
}

func (x *FetchJobRequest) GetPollId() string {
	if x != nil {
		return x.PollId
	}
	return ""
}

func (x *FetchJobRequest) GetVersion() string {
	if x != nil {
		return x.Version
	}
	return ""
}

// FetchJobResponse holds the job given to the runner, if any.
type FetchJobResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Job is the job to run. Unset when no job was available before the end of
	// the poll.
	Job *Job `protobuf:"bytes,1,opt,name=job,proto3" json:"job,omitempty"`
	// RetryAfter is how long the client waits before its next FetchJob. Unset or
	// zero means call again at once. The server sets it when it has no job for
	// the runner and wants to slow polling down (load, shutdown in progress);
	// clients obey it and may wait longer, never less. Unset when job is set.
	RetryAfter    *durationpb.Duration `protobuf:"bytes,2,opt,name=retry_after,json=retryAfter,proto3" json:"retry_after,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FetchJobResponse) ProtoMessage() {}

func (x *FetchJobResponse) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_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 FetchJobResponse.ProtoReflect.Descriptor instead.
func (*FetchJobResponse) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{3}
}

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

func (x *FetchJobResponse) GetRetryAfter() *durationpb.Duration {
	if x != nil {
		return x.RetryAfter
	}
	return nil
}

// Job is a job given to a runner: everything needed to run it, nothing more.
// The runner parses workflow_yaml itself; the protocol does not carry the
// workflow model, so it does not change when the model grows.
type Job struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// JobId identifies the job on the server. It is opaque, unique across
	// repositories and runs, and the same for every attempt of the job. With
	// attempt it names one execution.
	JobId string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
	// RunId is the run the job belongs to, the "github.run_id". It is global to
	// the server.
	RunId int64 `protobuf:"varint,2,opt,name=run_id,json=runId,proto3" json:"run_id,omitempty"`
	// Attempt is the attempt of the run this job executes: 1 for the first, and
	// one more after each RunService.RerunRun. It is the "github.run_attempt".
	Attempt int32 `protobuf:"varint,3,opt,name=attempt,proto3" json:"attempt,omitempty"`
	// JobToken is the secret that authenticates this job's UpdateJob,
	// AppendLog, Heartbeat, WatchJob and CompleteJob calls ("Authorization:
	// Bearer <job_token>"): "ermitejob_" and 43 base64url characters (32 random
	// bytes, no padding). It is random, valid from the assignment until the job
	// ends (and for CompleteJob 24 hours more), survives a server restart and
	// is shown only in this response, or in a repeat of the same poll_id. It
	// must stay in the runner host process and never reach the job's code. A new
	// assignment of the same job has a new token.
	JobToken string `protobuf:"bytes,4,opt,name=job_token,json=jobToken,proto3" json:"job_token,omitempty"`
	// WorkflowPath is the path of the workflow file in the repository, for
	// example ".github/workflows/ci.yml".
	WorkflowPath string `protobuf:"bytes,5,opt,name=workflow_path,json=workflowPath,proto3" json:"workflow_path,omitempty"`
	// WorkflowYaml is the content of that file at sha, as is, at most 1 MiB
	// (larger files fail at planning).
	WorkflowYaml string `protobuf:"bytes,6,opt,name=workflow_yaml,json=workflowYaml,proto3" json:"workflow_yaml,omitempty"`
	// JobKey is the key of the job under "jobs:" in the workflow, the
	// "github.job".
	JobKey string `protobuf:"bytes,7,opt,name=job_key,json=jobKey,proto3" json:"job_key,omitempty"`
	// Matrix is the JSON object of the matrix values of this instance of the
	// job, for example {"os":"linux","go":"1.27"}. "{}" when the job has no
	// matrix. It is the "matrix" context.
	Matrix string `protobuf:"bytes,8,opt,name=matrix,proto3" json:"matrix,omitempty"`
	// Contexts is a JSON object with the contexts that the server computed for
	// this job: "github", "needs", "strategy", "matrix", "inputs" and "vars", in
	// the shape GitHub gives them. The contexts "job", "runner", "steps" and
	// "env" belong to the runner and are not in it. Other keys may be added
	// later; clients ignore those they do not know.
	Contexts string `protobuf:"bytes,9,opt,name=contexts,proto3" json:"contexts,omitempty"`
	// Labels are the runs-on labels of the job, evaluated.
	Labels []string `protobuf:"bytes,10,rep,name=labels,proto3" json:"labels,omitempty"`
	// TimeoutMinutes is the timeout of the job in minutes: the value of the
	// workflow's timeout-minutes, or 360 when it has none. At least 1. The
	// runner enforces it from the moment it receives the job. The server counts
	// from the moment of the assignment and adds 60 seconds of slack, so the
	// runner's own timeout always comes first: when the server's deadline
	// passes it announces CANCEL_REASON_TIMEOUT, and ends the job itself after
	// 60 more seconds without a conclusion (see WatchJob).
	TimeoutMinutes int32 `protobuf:"varint,11,opt,name=timeout_minutes,json=timeoutMinutes,proto3" json:"timeout_minutes,omitempty"`
	// Repo is the name of the repository.
	Repo string `protobuf:"bytes,12,opt,name=repo,proto3" json:"repo,omitempty"`
	// Sha is the full id of the commit the run is for, 40 lowercase
	// hexadecimal characters for SHA-1. The runner reads the code at it.
	Sha string `protobuf:"bytes,13,opt,name=sha,proto3" json:"sha,omitempty"`
	// Ref is the full ref name that triggered the run, for example
	// "refs/heads/main" or "refs/tags/v1.0.0".
	Ref string `protobuf:"bytes,14,opt,name=ref,proto3" json:"ref,omitempty"`
	// GithubToken is the job repository token, the "github.token" and
	// "secrets.GITHUB_TOKEN" of the job: "ermitegh_" and 43 base64url characters
	// (32 random bytes, no padding). Unlike job_token it is meant for the code of
	// the job: the runner gives it to the sandbox (actions/checkout clones with
	// it). It can only act on the repository of the run: read-only from servers
	// without the feature "ci.secrets", whatever "permissions:" says, and with
	// the rights of permissions from those that have it (never more than read
	// when trusted is false). It is valid from the assignment until the job ends
	// (it is revoked then, on cancellation and when the job is lost). It is a
	// secret: the runner registers it in its masker before anything runs, and
	// neither the runner nor the server logs it. It is shown only in this
	// response, or in a repeat of the same poll_id; a new assignment of the same
	// job has a new one. Empty from servers without the feature "ci.actions".
	GithubToken string `protobuf:"bytes,15,opt,name=github_token,json=githubToken,proto3" json:"github_token,omitempty"`
	// Secrets are the secrets of the job by name (upper case), in plain text:
	// the ones the job's workflow refers to, from the instance, the repository
	// and the environment, with the environment overriding the repository and
	// the repository the instance. The server picks them; the runner uses them
	// as they are. They are empty when the job is not trusted, when the job
	// refers to none, and from servers without the feature "ci.secrets"; the
	// "GITHUB_TOKEN" secret is github_token, not an entry here. They travel only
	// over the runner's authenticated channel. The runner never logs them, never
	// writes them to disk or to its recovery state, and registers them in its
	// log masker before the first step runs, as GitHub's runner does: each value
	// trimmed, each non-empty trimmed line of it (split on CR and LF), and the
	// encoded forms of each. The server never stores them in the run record nor
	// logs them. Treat the whole map as a secret.
	Secrets map[string]string `protobuf:"bytes,16,rep,name=secrets,proto3" json:"secrets,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// Vars are the configuration variables of the job by name (upper case),
	// already merged by the server with environment over repository over
	// instance. They are not secret. The same values are in the "vars" context
	// of contexts, which the runner may use instead. Empty from servers without
	// the feature "ci.secrets".
	Vars map[string]string `protobuf:"bytes,17,rep,name=vars,proto3" json:"vars,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// Environment is the name of the environment the job deploys to (the
	// evaluated "environment:" of the job). Empty when the job has none. It is
	// environment that secrets and vars were resolved for.
	Environment string `protobuf:"bytes,18,opt,name=environment,proto3" json:"environment,omitempty"`
	// Permissions are the effective permissions of github_token. Unset from
	// servers without the feature "ci.secrets"; the token is then read-only.
	Permissions *JobPermissions `protobuf:"bytes,19,opt,name=permissions,proto3" json:"permissions,omitempty"`
	// Cache tells the runner which cache entries the job may read and write.
	// Unset when the server gives the job no cache (the runner then serves no
	// cache) and from servers without the feature "ci.cache".
	Cache *JobCache `protobuf:"bytes,20,opt,name=cache,proto3" json:"cache,omitempty"`
	// Trusted is true when the run's actor is the owner (or a re-run of a
	// trusted run by the owner): only then are secrets sent and a write
	// permission granted. It is false when the actor is a token limited to
	// branches (an automated agent could otherwise print any secret by pushing a
	// workflow) and for a re-run of such a run, and then secrets is empty and
	// github_token is read-only whatever "permissions:" says. The runner states
	// this in the log of "Set up job". False from servers that do not send it:
	// the safe reading.
	Trusted bool `protobuf:"varint,21,opt,name=trusted,proto3" json:"trusted,omitempty"`
	// IdTokenUrl is the URL the job's code fetches OIDC ID tokens from, the
	// ACTIONS_ID_TOKEN_REQUEST_URL of GitHub's runner: the server's
	// "/-/oidc/token?api-version=2.0". It already has a query, so clients append
	// "&audience=<url-encoded audience>" as @actions/core does. A GET with
	// "Authorization: Bearer <id_token_request_token>" answers
	// {"value":"<jwt>"}: an RS256 JWT with GitHub's claims, signed by the key
	// the server publishes at "/-/oidc/.well-known/jwks". The runner sets
	// ACTIONS_ID_TOKEN_REQUEST_URL to it for run steps, JavaScript actions and
	// Docker actions, with the origin rewritten as for the other server URLs
	// the sandbox reaches. Empty when the job may not have ID tokens: when it is
	// not trusted, when its effective permissions do not include
	// "id-token: write", when the server has no key to sign with, and from
	// servers without the feature "ci.oidc". Both fields are set or neither.
	IdTokenUrl string `protobuf:"bytes,22,opt,name=id_token_url,json=idTokenUrl,proto3" json:"id_token_url,omitempty"`
	// IdTokenRequestToken is the bearer for id_token_url, the
	// ACTIONS_ID_TOKEN_REQUEST_TOKEN of GitHub's runner: "ermiteoidc_" and 43
	// base64url characters (32 random bytes, no padding). It is valid only for
	// id_token_url, only while the job is assigned or running (it is revoked
	// when the job ends, on cancellation and when the job is lost), and is
	// shown only in this response, or in a repeat of the same poll_id. It is a
	// secret: the runner registers it in its masker before anything runs, and
	// gives it to the sandbox only with id_token_url. Empty when id_token_url
	// is.
	IdTokenRequestToken string `protobuf:"bytes,23,opt,name=id_token_request_token,json=idTokenRequestToken,proto3" json:"id_token_request_token,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

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

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

func (*Job) ProtoMessage() {}

func (x *Job) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_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 Job.ProtoReflect.Descriptor instead.
func (*Job) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{4}
}

func (x *Job) GetJobId() string {
	if x != nil {
		return x.JobId
	}
	return ""
}

func (x *Job) GetRunId() int64 {
	if x != nil {
		return x.RunId
	}
	return 0
}

func (x *Job) GetAttempt() int32 {
	if x != nil {
		return x.Attempt
	}
	return 0
}

func (x *Job) GetJobToken() string {
	if x != nil {
		return x.JobToken
	}
	return ""
}

func (x *Job) GetWorkflowPath() string {
	if x != nil {
		return x.WorkflowPath
	}
	return ""
}

func (x *Job) GetWorkflowYaml() string {
	if x != nil {
		return x.WorkflowYaml
	}
	return ""
}

func (x *Job) GetJobKey() string {
	if x != nil {
		return x.JobKey
	}
	return ""
}

func (x *Job) GetMatrix() string {
	if x != nil {
		return x.Matrix
	}
	return ""
}

func (x *Job) GetContexts() string {
	if x != nil {
		return x.Contexts
	}
	return ""
}

func (x *Job) GetLabels() []string {
	if x != nil {
		return x.Labels
	}
	return nil
}

func (x *Job) GetTimeoutMinutes() int32 {
	if x != nil {
		return x.TimeoutMinutes
	}
	return 0
}

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

func (x *Job) GetSha() string {
	if x != nil {
		return x.Sha
	}
	return ""
}

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

func (x *Job) GetGithubToken() string {
	if x != nil {
		return x.GithubToken
	}
	return ""
}

func (x *Job) GetSecrets() map[string]string {
	if x != nil {
		return x.Secrets
	}
	return nil
}

func (x *Job) GetVars() map[string]string {
	if x != nil {
		return x.Vars
	}
	return nil
}

func (x *Job) GetEnvironment() string {
	if x != nil {
		return x.Environment
	}
	return ""
}

func (x *Job) GetPermissions() *JobPermissions {
	if x != nil {
		return x.Permissions
	}
	return nil
}

func (x *Job) GetCache() *JobCache {
	if x != nil {
		return x.Cache
	}
	return nil
}

func (x *Job) GetTrusted() bool {
	if x != nil {
		return x.Trusted
	}
	return false
}

func (x *Job) GetIdTokenUrl() string {
	if x != nil {
		return x.IdTokenUrl
	}
	return ""
}

func (x *Job) GetIdTokenRequestToken() string {
	if x != nil {
		return x.IdTokenRequestToken
	}
	return ""
}

// JobPermissions are the permissions of the job repository token, with the
// keys and values of the "permissions:" of a GitHub workflow.
type JobPermissions struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Levels maps a permission key ("contents", "pull-requests", "id-token",
	// "actions", ...) to "read", "write" or "none". They are the permissions in
	// effect after the server merged the workflow's and the job's "permissions:"
	// (and the caller's, for a reusable workflow) and applied the trust rule of
	// Job.trusted; a key absent from the map is "none". Keys are lowercase as in
	// the workflow. The runner prints them in "Set up job" and does not
	// enforce them: the server checks the token.
	Levels        map[string]string `protobuf:"bytes,1,rep,name=levels,proto3" json:"levels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*JobPermissions) ProtoMessage() {}

func (x *JobPermissions) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_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 JobPermissions.ProtoReflect.Descriptor instead.
func (*JobPermissions) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{5}
}

func (x *JobPermissions) GetLevels() map[string]string {
	if x != nil {
		return x.Levels
	}
	return nil
}

// JobCache is the scope of the cache of one job. The cache is served by the
// runner and shared by the jobs of a repository, as GitHub scopes it.
type JobCache struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Repository is the name of the repository whose cache the job uses. Entries
	// of another repository are never visible to it.
	Repository string `protobuf:"bytes,1,opt,name=repository,proto3" json:"repository,omitempty"`
	// WriteRef is the only ref the job may save entries under, for example
	// "refs/heads/main" or "refs/pull/7/merge".
	WriteRef string `protobuf:"bytes,2,opt,name=write_ref,json=writeRef,proto3" json:"write_ref,omitempty"`
	// ReadRefs are the refs the job may restore entries from, most specific
	// first: the ref of the run, then the base branch for a pull request, then
	// the default branch. Entries under other refs are never restored.
	ReadRefs      []string `protobuf:"bytes,3,rep,name=read_refs,json=readRefs,proto3" json:"read_refs,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*JobCache) ProtoMessage() {}

func (x *JobCache) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_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 JobCache.ProtoReflect.Descriptor instead.
func (*JobCache) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{6}
}

func (x *JobCache) GetRepository() string {
	if x != nil {
		return x.Repository
	}
	return ""
}

func (x *JobCache) GetWriteRef() string {
	if x != nil {
		return x.WriteRef
	}
	return ""
}

func (x *JobCache) GetReadRefs() []string {
	if x != nil {
		return x.ReadRefs
	}
	return nil
}

// UpdateJobRequest reports the steps of a running job.
type UpdateJobRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// JobId is the Job.job_id. It must be the job of the token.
	JobId string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
	// Steps are the steps whose state changed or that are new. Each one is a
	// full snapshot of its step, applied by number. At most 1,000 steps per job
	// (invalid_argument beyond). Steps are numbered like GitHub's log: the
	// implicit "Set up job" is 1, the steps of the workflow follow in order, and
	// the implicit "Complete job" is last.
	Steps []*StepUpdate `protobuf:"bytes,2,rep,name=steps,proto3" json:"steps,omitempty"`
	// Annotations are the annotations of the steps that the call names: for
	// each step_number present, all the annotations of that step known so far,
	// not only the new ones (see the rules on UpdateJob). At most 10 per level
	// and per step, and each one within the limits of Annotation; otherwise the
	// whole call is invalid_argument. The server ignores them without the
	// feature "ci.annotations".
	Annotations   []*Annotation `protobuf:"bytes,3,rep,name=annotations,proto3" json:"annotations,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UpdateJobRequest) ProtoMessage() {}

func (x *UpdateJobRequest) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_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 UpdateJobRequest.ProtoReflect.Descriptor instead.
func (*UpdateJobRequest) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{7}
}

func (x *UpdateJobRequest) GetJobId() string {
	if x != nil {
		return x.JobId
	}
	return ""
}

func (x *UpdateJobRequest) GetSteps() []*StepUpdate {
	if x != nil {
		return x.Steps
	}
	return nil
}

func (x *UpdateJobRequest) GetAnnotations() []*Annotation {
	if x != nil {
		return x.Annotations
	}
	return nil
}

// StepUpdate is the state of one step as the runner knows it.
type StepUpdate struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Number is the 1-based number of the step in the job. It is the number
	// used by AppendLog.
	Number int32 `protobuf:"varint,1,opt,name=number,proto3" json:"number,omitempty"`
	// Name is the display name of the step, evaluated: the "name" of the
	// workflow step, or "Run <first line of the script>", as GitHub shows it.
	// At most 1,024 characters; the server cuts longer names.
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// State is where the step is.
	State StepState `protobuf:"varint,3,opt,name=state,proto3,enum=ermite.StepState" json:"state,omitempty"`
	// Conclusion is how the step ended. Required (not UNSPECIFIED) when state is
	// COMPLETED, must be UNSPECIFIED otherwise. Allowed values: success,
	// failure, cancelled, skipped.
	Conclusion CiConclusion `protobuf:"varint,4,opt,name=conclusion,proto3,enum=ermite.CiConclusion" json:"conclusion,omitempty"`
	// StartedAt is when the step started, by the clock of the runner. Required
	// from IN_PROGRESS on.
	StartedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=started_at,json=startedAt,proto3" json:"started_at,omitempty"`
	// CompletedAt is when the step ended, by the clock of the runner. Required
	// when state is COMPLETED.
	CompletedAt *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=completed_at,json=completedAt,proto3" json:"completed_at,omitempty"`
	// Outcome is how the step ended before continue-on-error was applied, GitHub's
	// "steps.<id>.outcome", whereas conclusion is the result after it
	// ("steps.<id>.conclusion"). Same values as conclusion. They differ only for
	// a step with continue-on-error that failed: outcome FAILURE, conclusion
	// SUCCESS. Set by the runner when state is COMPLETED and UNSPECIFIED
	// otherwise; UNSPECIFIED in a COMPLETED step means the same as conclusion
	// (a runner that does not know the field).
	Outcome       CiConclusion `protobuf:"varint,7,opt,name=outcome,proto3,enum=ermite.CiConclusion" json:"outcome,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*StepUpdate) ProtoMessage() {}

func (x *StepUpdate) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_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 StepUpdate.ProtoReflect.Descriptor instead.
func (*StepUpdate) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{8}
}

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

func (x *StepUpdate) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *StepUpdate) GetState() StepState {
	if x != nil {
		return x.State
	}
	return StepState_STEP_STATE_UNSPECIFIED
}

func (x *StepUpdate) GetConclusion() CiConclusion {
	if x != nil {
		return x.Conclusion
	}
	return CiConclusion_CI_CONCLUSION_UNSPECIFIED
}

func (x *StepUpdate) GetStartedAt() *timestamppb.Timestamp {
	if x != nil {
		return x.StartedAt
	}
	return nil
}

func (x *StepUpdate) GetCompletedAt() *timestamppb.Timestamp {
	if x != nil {
		return x.CompletedAt
	}
	return nil
}

func (x *StepUpdate) GetOutcome() CiConclusion {
	if x != nil {
		return x.Outcome
	}
	return CiConclusion_CI_CONCLUSION_UNSPECIFIED
}

// UpdateJobResponse is empty.
type UpdateJobResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UpdateJobResponse) ProtoMessage() {}

func (x *UpdateJobResponse) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_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 UpdateJobResponse.ProtoReflect.Descriptor instead.
func (*UpdateJobResponse) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{9}
}

// CompleteJobRequest ends a job.
type CompleteJobRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// JobId is the Job.job_id. It must be the job of the token.
	JobId string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
	// Conclusion is how the job ended. Required: a runner reports
	// CI_CONCLUSION_SUCCESS, CI_CONCLUSION_FAILURE, CI_CONCLUSION_CANCELLED or
	// CI_CONCLUSION_TIMED_OUT; any other value is invalid_argument. Skipped is
	// decided by the server and never reported by a runner.
	Conclusion CiConclusion `protobuf:"varint,2,opt,name=conclusion,proto3,enum=ermite.CiConclusion" json:"conclusion,omitempty"`
	// Outputs are the outputs of the job, evaluated by the runner. Names are 1
	// to 255 characters among letters, digits, "_" and "-" and begin with a
	// letter or "_" and are case-insensitive: two names that differ only by case
	// are invalid_argument. Each value is at most 1 MiB, and all names and
	// values together at most 1 MiB (1,048,576 bytes); beyond that the whole call
	// is rejected with invalid_argument and the runner reports the failure of
	// the job without outputs, with a line in the log. The runner leaves out an
	// output whose value its masker would change, with the warning "Skip output
	// '<name>' since it may contain secret." (as GitHub's runner), so no secret
	// reaches the server through outputs.
	Outputs map[string]string `protobuf:"bytes,3,rep,name=outputs,proto3" json:"outputs,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// RunnerShutdown is true when the runner ends the job because it was told to
	// stop (service stopped, signal). Only allowed with CI_CONCLUSION_CANCELLED.
	// The server then annotates the job with GitHub's message "The runner has
	// received a shutdown signal. This can happen when the runner service is
	// stopped, or a manually started runner is canceled." The conclusion
	// CANCELLED for this case is to be verified against a recording of GitHub.
	RunnerShutdown bool `protobuf:"varint,4,opt,name=runner_shutdown,json=runnerShutdown,proto3" json:"runner_shutdown,omitempty"`
	// Steps are the final steps, with the same meaning as UpdateJobRequest.steps,
	// applied in the same atomic step as the conclusion.
	Steps []*StepUpdate `protobuf:"bytes,5,rep,name=steps,proto3" json:"steps,omitempty"`
	// Annotations are those of the steps that changed since the last call, with
	// the rules of UpdateJobRequest.annotations (all the annotations of each
	// step named). The server ignores them without the feature
	// "ci.annotations".
	Annotations   []*Annotation `protobuf:"bytes,6,rep,name=annotations,proto3" json:"annotations,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CompleteJobRequest) ProtoMessage() {}

func (x *CompleteJobRequest) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_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 CompleteJobRequest.ProtoReflect.Descriptor instead.
func (*CompleteJobRequest) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{10}
}

func (x *CompleteJobRequest) GetJobId() string {
	if x != nil {
		return x.JobId
	}
	return ""
}

func (x *CompleteJobRequest) GetConclusion() CiConclusion {
	if x != nil {
		return x.Conclusion
	}
	return CiConclusion_CI_CONCLUSION_UNSPECIFIED
}

func (x *CompleteJobRequest) GetOutputs() map[string]string {
	if x != nil {
		return x.Outputs
	}
	return nil
}

func (x *CompleteJobRequest) GetRunnerShutdown() bool {
	if x != nil {
		return x.RunnerShutdown
	}
	return false
}

func (x *CompleteJobRequest) GetSteps() []*StepUpdate {
	if x != nil {
		return x.Steps
	}
	return nil
}

func (x *CompleteJobRequest) GetAnnotations() []*Annotation {
	if x != nil {
		return x.Annotations
	}
	return nil
}

// CompleteJobResponse is the stored result of a job.
type CompleteJobResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Conclusion is the conclusion of the job as the server stored it. It is the
	// one of the request when applied is true.
	Conclusion CiConclusion `protobuf:"varint,1,opt,name=conclusion,proto3,enum=ermite.CiConclusion" json:"conclusion,omitempty"`
	// Error is the error text stored with the job, as RunJob.error. Empty when
	// there is none.
	Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	// Applied is true when this call ended the job, false when the job had
	// already ended (a retry, or the server ended it first) and nothing changed.
	Applied       bool `protobuf:"varint,3,opt,name=applied,proto3" json:"applied,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CompleteJobResponse) ProtoMessage() {}

func (x *CompleteJobResponse) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_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 CompleteJobResponse.ProtoReflect.Descriptor instead.
func (*CompleteJobResponse) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{11}
}

func (x *CompleteJobResponse) GetConclusion() CiConclusion {
	if x != nil {
		return x.Conclusion
	}
	return CiConclusion_CI_CONCLUSION_UNSPECIFIED
}

func (x *CompleteJobResponse) GetError() string {
	if x != nil {
		return x.Error
	}
	return ""
}

func (x *CompleteJobResponse) GetApplied() bool {
	if x != nil {
		return x.Applied
	}
	return false
}

// JobEnded says that a job has ended. It is sent in WatchJob and attached, as
// an error detail, to the failed_precondition errors that RunnerService returns
// for a job that has ended.
type JobEnded struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Conclusion is how the job ended.
	Conclusion CiConclusion `protobuf:"varint,1,opt,name=conclusion,proto3,enum=ermite.CiConclusion" json:"conclusion,omitempty"`
	// Error is the error text stored with the job, as RunJob.error. Empty when
	// there is none.
	Error         string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*JobEnded) ProtoMessage() {}

func (x *JobEnded) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_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 JobEnded.ProtoReflect.Descriptor instead.
func (*JobEnded) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{12}
}

func (x *JobEnded) GetConclusion() CiConclusion {
	if x != nil {
		return x.Conclusion
	}
	return CiConclusion_CI_CONCLUSION_UNSPECIFIED
}

func (x *JobEnded) GetError() string {
	if x != nil {
		return x.Error
	}
	return ""
}

// AppendLogRequest carries log lines of one step.
type AppendLogRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// JobId is the Job.job_id. It must be the job of the token.
	JobId string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
	// Step is the number of the step the lines belong to (see
	// UpdateJobRequest.steps), at least 1, and at least the step of the last
	// stored line. A step that UpdateJob has not announced yet is created by the
	// first lines. See the rules on AppendLog.
	Step int32 `protobuf:"varint,2,opt,name=step,proto3" json:"step,omitempty"`
	// Offset is the number of the first line of the request in the log of the
	// job, counted from 0 across all steps. See the rules on AppendLog.
	Offset int64 `protobuf:"varint,3,opt,name=offset,proto3" json:"offset,omitempty"`
	// Lines are the lines to append, in order: at most 1,000, at most 64 KiB of
	// text in total.
	Lines         []*LogLine `protobuf:"bytes,4,rep,name=lines,proto3" json:"lines,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AppendLogRequest) ProtoMessage() {}

func (x *AppendLogRequest) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_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 AppendLogRequest.ProtoReflect.Descriptor instead.
func (*AppendLogRequest) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{13}
}

func (x *AppendLogRequest) GetJobId() string {
	if x != nil {
		return x.JobId
	}
	return ""
}

func (x *AppendLogRequest) GetStep() int32 {
	if x != nil {
		return x.Step
	}
	return 0
}

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

func (x *AppendLogRequest) GetLines() []*LogLine {
	if x != nil {
		return x.Lines
	}
	return nil
}

// LogLine is one line of a job log.
type LogLine struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Time is when the line was produced, by the clock of the runner. The server
	// keeps it with nanosecond precision (RFC 3339) and does not reorder lines.
	Time *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=time,proto3" json:"time,omitempty"`
	// Text is the line without its line terminator, valid UTF-8 (the client
	// replaces invalid bytes with U+FFFD). It must not contain a line feed; a
	// carriage return is kept. It is the line as GitHub's raw log has it,
	// including "##[group]" and "##[endgroup]" markers and "##[error]" lines.
	Text string `protobuf:"bytes,2,opt,name=text,proto3" json:"text,omitempty"`
	// Continued is true when this line is the continuation of the line before
	// it, which was too long to send whole. A runner cuts a line of more than
	// 64 KiB into pieces at UTF-8 character boundaries, each piece of at most
	// 64 KiB, and sets continued on every piece but the first. Each piece is one
	// line for numbering and offsets; the server and the raw log join the
	// pieces back, so the original line is rebuilt exactly. The first line of a
	// job cannot be continued (invalid_argument) and a continued line is in
	// the same step as the line before it (failed_precondition otherwise).
	Continued     bool `protobuf:"varint,3,opt,name=continued,proto3" json:"continued,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LogLine) ProtoMessage() {}

func (x *LogLine) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_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 LogLine.ProtoReflect.Descriptor instead.
func (*LogLine) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{14}
}

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

func (x *LogLine) GetText() string {
	if x != nil {
		return x.Text
	}
	return ""
}

func (x *LogLine) GetContinued() bool {
	if x != nil {
		return x.Continued
	}
	return false
}

// AppendLogResponse tells how much of the log the server holds.
type AppendLogResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// NextOffset is the number of lines of the job log after the call, which is
	// the offset of the next request.
	NextOffset    int64 `protobuf:"varint,1,opt,name=next_offset,json=nextOffset,proto3" json:"next_offset,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AppendLogResponse) Reset() {
	*x = AppendLogResponse{}
	mi := &file_ermite_runner_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*AppendLogResponse) ProtoMessage() {}

func (x *AppendLogResponse) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_proto_msgTypes[15]
	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 AppendLogResponse.ProtoReflect.Descriptor instead.
func (*AppendLogResponse) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{15}
}

func (x *AppendLogResponse) GetNextOffset() int64 {
	if x != nil {
		return x.NextOffset
	}
	return 0
}

// HeartbeatRequest names the job that is alive.
type HeartbeatRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// JobId is the Job.job_id. It must be the job of the token.
	JobId         string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *HeartbeatRequest) Reset() {
	*x = HeartbeatRequest{}
	mi := &file_ermite_runner_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*HeartbeatRequest) ProtoMessage() {}

func (x *HeartbeatRequest) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_proto_msgTypes[16]
	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 HeartbeatRequest.ProtoReflect.Descriptor instead.
func (*HeartbeatRequest) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{16}
}

func (x *HeartbeatRequest) GetJobId() string {
	if x != nil {
		return x.JobId
	}
	return ""
}

// HeartbeatResponse is empty.
type HeartbeatResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *HeartbeatResponse) Reset() {
	*x = HeartbeatResponse{}
	mi := &file_ermite_runner_proto_msgTypes[17]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*HeartbeatResponse) ProtoMessage() {}

func (x *HeartbeatResponse) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_proto_msgTypes[17]
	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 HeartbeatResponse.ProtoReflect.Descriptor instead.
func (*HeartbeatResponse) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{17}
}

// WatchJobRequest names the job to watch.
type WatchJobRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// JobId is the Job.job_id. It must be the job of the token.
	JobId         string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *WatchJobRequest) Reset() {
	*x = WatchJobRequest{}
	mi := &file_ermite_runner_proto_msgTypes[18]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*WatchJobRequest) ProtoMessage() {}

func (x *WatchJobRequest) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_proto_msgTypes[18]
	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 WatchJobRequest.ProtoReflect.Descriptor instead.
func (*WatchJobRequest) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{18}
}

func (x *WatchJobRequest) GetJobId() string {
	if x != nil {
		return x.JobId
	}
	return ""
}

// WatchJobResponse is one message of the stream.
type WatchJobResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Msg is what the message carries. New kinds may be added: a client ignores
	// the ones it does not know.
	//
	// Types that are valid to be assigned to Msg:
	//
	//	*WatchJobResponse_Keepalive
	//	*WatchJobResponse_Cancel
	//	*WatchJobResponse_Ended
	Msg           isWatchJobResponse_Msg `protobuf_oneof:"msg"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *WatchJobResponse) Reset() {
	*x = WatchJobResponse{}
	mi := &file_ermite_runner_proto_msgTypes[19]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*WatchJobResponse) ProtoMessage() {}

func (x *WatchJobResponse) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_proto_msgTypes[19]
	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 WatchJobResponse.ProtoReflect.Descriptor instead.
func (*WatchJobResponse) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{19}
}

func (x *WatchJobResponse) GetMsg() isWatchJobResponse_Msg {
	if x != nil {
		return x.Msg
	}
	return nil
}

func (x *WatchJobResponse) GetKeepalive() *Keepalive {
	if x != nil {
		if x, ok := x.Msg.(*WatchJobResponse_Keepalive); ok {
			return x.Keepalive
		}
	}
	return nil
}

func (x *WatchJobResponse) GetCancel() *CancelRequest {
	if x != nil {
		if x, ok := x.Msg.(*WatchJobResponse_Cancel); ok {
			return x.Cancel
		}
	}
	return nil
}

func (x *WatchJobResponse) GetEnded() *JobEnded {
	if x != nil {
		if x, ok := x.Msg.(*WatchJobResponse_Ended); ok {
			return x.Ended
		}
	}
	return nil
}

type isWatchJobResponse_Msg interface {
	isWatchJobResponse_Msg()
}

type WatchJobResponse_Keepalive struct {
	// Keepalive: nothing to do, the stream is alive.
	Keepalive *Keepalive `protobuf:"bytes,1,opt,name=keepalive,proto3,oneof"`
}

type WatchJobResponse_Cancel struct {
	// Cancel: the job must stop.
	Cancel *CancelRequest `protobuf:"bytes,2,opt,name=cancel,proto3,oneof"`
}

type WatchJobResponse_Ended struct {
	// Ended: the job has ended. The last message of a stream: a close without
	// it means the client reconnects.
	Ended *JobEnded `protobuf:"bytes,3,opt,name=ended,proto3,oneof"`
}

func (*WatchJobResponse_Keepalive) isWatchJobResponse_Msg() {}

func (*WatchJobResponse_Cancel) isWatchJobResponse_Msg() {}

func (*WatchJobResponse_Ended) isWatchJobResponse_Msg() {}

// Keepalive has no fields.
type Keepalive struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Keepalive) Reset() {
	*x = Keepalive{}
	mi := &file_ermite_runner_proto_msgTypes[20]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Keepalive) ProtoMessage() {}

func (x *Keepalive) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_proto_msgTypes[20]
	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 Keepalive.ProtoReflect.Descriptor instead.
func (*Keepalive) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{20}
}

// CancelRequest asks the runner to stop a job.
type CancelRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Reason is why the job must stop. New reasons may be added; a runner that
	// does not know one cancels the job and reports CI_CONCLUSION_CANCELLED.
	Reason CancelReason `protobuf:"varint,1,opt,name=reason,proto3,enum=ermite.CancelReason" json:"reason,omitempty"`
	// Message is a short human-readable explanation, for the job log, for
	// example "Canceled by the owner". At most 1,024 characters.
	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	// RequestedAt is when the cancellation was requested, by the clock of the
	// server.
	RequestedAt   *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=requested_at,json=requestedAt,proto3" json:"requested_at,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *CancelRequest) Reset() {
	*x = CancelRequest{}
	mi := &file_ermite_runner_proto_msgTypes[21]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*CancelRequest) ProtoMessage() {}

func (x *CancelRequest) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_proto_msgTypes[21]
	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 CancelRequest.ProtoReflect.Descriptor instead.
func (*CancelRequest) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{21}
}

func (x *CancelRequest) GetReason() CancelReason {
	if x != nil {
		return x.Reason
	}
	return CancelReason_CANCEL_REASON_UNSPECIFIED
}

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

func (x *CancelRequest) GetRequestedAt() *timestamppb.Timestamp {
	if x != nil {
		return x.RequestedAt
	}
	return nil
}

// Annotation is a message attached to a step, and optionally to a place in a
// file of the repository, like an annotation of a GitHub check run. The runner
// produces them from the workflow commands ::notice, ::warning and ::error and
// from problem matchers, after masking.
//
// Limits, checked by the server: at most 10 annotations of each level per step
// (the runner sends no more: the ones beyond only reach the log, as with
// GitHub). A call that breaks a limit below is rejected whole with
// invalid_argument. Lengths count characters (Unicode code points), not bytes.
type Annotation struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Level is the severity. Required.
	Level AnnotationLevel `protobuf:"varint,1,opt,name=level,proto3,enum=ermite.AnnotationLevel" json:"level,omitempty"`
	// Title is the optional title, at most 4,096 characters like the message; a
	// longer one is invalid_argument. Empty when not given.
	Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`
	// Message is the text. Required, not empty, at most 4,096 characters; a
	// longer one is invalid_argument. The runner never sends a longer one: like
	// GitHub, it only logs such an annotation.
	Message string `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
	// File is the path the annotation is about, relative to the repository when
	// the runner can tell, else as given. At most 1,024 characters. Empty when
	// the annotation is not about a file.
	File string `protobuf:"bytes,4,opt,name=file,proto3" json:"file,omitempty"`
	// StartLine is the first line, counted from 1. 0 when not given.
	StartLine int32 `protobuf:"varint,5,opt,name=start_line,json=startLine,proto3" json:"start_line,omitempty"`
	// EndLine is the last line, counted from 1, not before start_line. 0 when
	// not given.
	EndLine int32 `protobuf:"varint,6,opt,name=end_line,json=endLine,proto3" json:"end_line,omitempty"`
	// StartColumn is the first column, counted from 1. 0 when not given.
	StartColumn int32 `protobuf:"varint,7,opt,name=start_column,json=startColumn,proto3" json:"start_column,omitempty"`
	// EndColumn is the last column, counted from 1. 0 when not given.
	EndColumn int32 `protobuf:"varint,8,opt,name=end_column,json=endColumn,proto3" json:"end_column,omitempty"`
	// StepNumber is the number of the step that produced it (see
	// StepUpdate.number), from 1 to 1,000. An annotation of a step inside a
	// composite action belongs to the step of the workflow that uses the action.
	StepNumber    int32 `protobuf:"varint,9,opt,name=step_number,json=stepNumber,proto3" json:"step_number,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Annotation) Reset() {
	*x = Annotation{}
	mi := &file_ermite_runner_proto_msgTypes[22]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*Annotation) ProtoMessage() {}

func (x *Annotation) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_proto_msgTypes[22]
	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 Annotation.ProtoReflect.Descriptor instead.
func (*Annotation) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{22}
}

func (x *Annotation) GetLevel() AnnotationLevel {
	if x != nil {
		return x.Level
	}
	return AnnotationLevel_ANNOTATION_LEVEL_UNSPECIFIED
}

func (x *Annotation) GetTitle() string {
	if x != nil {
		return x.Title
	}
	return ""
}

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

func (x *Annotation) GetFile() string {
	if x != nil {
		return x.File
	}
	return ""
}

func (x *Annotation) GetStartLine() int32 {
	if x != nil {
		return x.StartLine
	}
	return 0
}

func (x *Annotation) GetEndLine() int32 {
	if x != nil {
		return x.EndLine
	}
	return 0
}

func (x *Annotation) GetStartColumn() int32 {
	if x != nil {
		return x.StartColumn
	}
	return 0
}

func (x *Annotation) GetEndColumn() int32 {
	if x != nil {
		return x.EndColumn
	}
	return 0
}

func (x *Annotation) GetStepNumber() int32 {
	if x != nil {
		return x.StepNumber
	}
	return 0
}

// ActionRef is an action to resolve.
type ActionRef struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Uses is the value of "uses" as written, after expression evaluation, for
	// example "actions/checkout@v4" or "owner/repo/path/to/action@ref". Required.
	Uses          string `protobuf:"bytes,1,opt,name=uses,proto3" json:"uses,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ActionRef) Reset() {
	*x = ActionRef{}
	mi := &file_ermite_runner_proto_msgTypes[23]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ActionRef) ProtoMessage() {}

func (x *ActionRef) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_proto_msgTypes[23]
	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 ActionRef.ProtoReflect.Descriptor instead.
func (*ActionRef) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{23}
}

func (x *ActionRef) GetUses() string {
	if x != nil {
		return x.Uses
	}
	return ""
}

// ResolveActionsRequest lists the actions to resolve.
type ResolveActionsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// JobId is the Job.job_id. It must be the job of the token.
	JobId string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
	// Refs are the actions to resolve, at most 100. Duplicates are allowed and
	// answered one by one.
	Refs          []*ActionRef `protobuf:"bytes,2,rep,name=refs,proto3" json:"refs,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ResolveActionsRequest) Reset() {
	*x = ResolveActionsRequest{}
	mi := &file_ermite_runner_proto_msgTypes[24]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ResolveActionsRequest) ProtoMessage() {}

func (x *ResolveActionsRequest) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_proto_msgTypes[24]
	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 ResolveActionsRequest.ProtoReflect.Descriptor instead.
func (*ResolveActionsRequest) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{24}
}

func (x *ResolveActionsRequest) GetJobId() string {
	if x != nil {
		return x.JobId
	}
	return ""
}

func (x *ResolveActionsRequest) GetRefs() []*ActionRef {
	if x != nil {
		return x.Refs
	}
	return nil
}

// ResolveActionsResponse holds the resolution of each action.
type ResolveActionsResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Actions has one entry per ActionRef of the request, in the same order.
	Actions       []*ResolvedAction `protobuf:"bytes,1,rep,name=actions,proto3" json:"actions,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ResolveActionsResponse) Reset() {
	*x = ResolveActionsResponse{}
	mi := &file_ermite_runner_proto_msgTypes[25]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ResolveActionsResponse) ProtoMessage() {}

func (x *ResolveActionsResponse) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_proto_msgTypes[25]
	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 ResolveActionsResponse.ProtoReflect.Descriptor instead.
func (*ResolveActionsResponse) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{25}
}

func (x *ResolveActionsResponse) GetActions() []*ResolvedAction {
	if x != nil {
		return x.Actions
	}
	return nil
}

// ResolvedAction is where to download one action, or why it cannot be.
type ResolvedAction struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Ref is the ActionRef.uses of the request, unchanged.
	Ref string `protobuf:"bytes,1,opt,name=ref,proto3" json:"ref,omitempty"`
	// NameWithOwner is the repository of the action, "owner/repo", with the
	// case of the repository as the source gives it. Empty when error is set.
	NameWithOwner string `protobuf:"bytes,2,opt,name=name_with_owner,json=nameWithOwner,proto3" json:"name_with_owner,omitempty"`
	// Path is the sub-path of the action inside the repository, a clean
	// relative path: "path/to/action" for "owner/repo/path/to/action@ref", with
	// "/" separators, no leading or trailing slash, no empty, "." or ".."
	// element, never absolute. Empty for an action at the root of the
	// repository.
	Path string `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"`
	// ResolvedSha is the full id of the commit the ref points to, 40 lowercase
	// hexadecimal characters for SHA-1 (the commit that an annotated tag points
	// to, not the tag object). Stable for a run attempt: every job and every
	// call of the attempt gets the same value for the same ref. Empty when error
	// is set.
	ResolvedSha string `protobuf:"bytes,4,opt,name=resolved_sha,json=resolvedSha,proto3" json:"resolved_sha,omitempty"`
	// TarballUrl is where to download the archive of the repository at
	// resolved_sha, a gzip-compressed tar with one top-level directory. The
	// runner downloads it from the sandbox. Empty when error is set.
	TarballUrl string `protobuf:"bytes,5,opt,name=tarball_url,json=tarballUrl,proto3" json:"tarball_url,omitempty"`
	// Token authenticates the download: the runner sends it as "Authorization:
	// Basic" with the user "x-access-token". Empty for ACTION_SOURCE_GITHUB.
	// For ACTION_SOURCE_ERMITE it is a read token for that one repository,
	// valid until the job ends, so a job can use an action of another private
	// repository of the server that its own repository token cannot read. It is
	// issued per job and never shared across jobs (two jobs resolving the same
	// action get different tokens). It is a secret: the runner masks it, and neither the runner nor the server logs
	// it.
	Token string `protobuf:"bytes,6,opt,name=token,proto3" json:"token,omitempty"`
	// Source is where the action was found. UNSPECIFIED when error is set.
	Source ActionSource `protobuf:"varint,7,opt,name=source,proto3,enum=ermite.ActionSource" json:"source,omitempty"`
	// Error is why the reference could not be resolved, in the words of GitHub
	// for the same failure. Empty when the action was resolved, in which case
	// the other fields describe it.
	Error         string `protobuf:"bytes,8,opt,name=error,proto3" json:"error,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ResolvedAction) Reset() {
	*x = ResolvedAction{}
	mi := &file_ermite_runner_proto_msgTypes[26]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ResolvedAction) ProtoMessage() {}

func (x *ResolvedAction) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_proto_msgTypes[26]
	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 ResolvedAction.ProtoReflect.Descriptor instead.
func (*ResolvedAction) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{26}
}

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

func (x *ResolvedAction) GetNameWithOwner() string {
	if x != nil {
		return x.NameWithOwner
	}
	return ""
}

func (x *ResolvedAction) GetPath() string {
	if x != nil {
		return x.Path
	}
	return ""
}

func (x *ResolvedAction) GetResolvedSha() string {
	if x != nil {
		return x.ResolvedSha
	}
	return ""
}

func (x *ResolvedAction) GetTarballUrl() string {
	if x != nil {
		return x.TarballUrl
	}
	return ""
}

func (x *ResolvedAction) GetToken() string {
	if x != nil {
		return x.Token
	}
	return ""
}

func (x *ResolvedAction) GetSource() ActionSource {
	if x != nil {
		return x.Source
	}
	return ActionSource_ACTION_SOURCE_UNSPECIFIED
}

func (x *ResolvedAction) GetError() string {
	if x != nil {
		return x.Error
	}
	return ""
}

// UploadSummaryRequest carries the job summary of one step.
type UploadSummaryRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// JobId is the Job.job_id. It must be the job of the token.
	JobId string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
	// StepNumber is the number of the step that wrote the summary (see
	// StepUpdate.number), from 1 to 1,000.
	StepNumber int32 `protobuf:"varint,2,opt,name=step_number,json=stepNumber,proto3" json:"step_number,omitempty"`
	// Markdown is the summary, masked, valid UTF-8, at most 1 MiB (1,048,576
	// bytes). Empty removes the summary of the step.
	Markdown      string `protobuf:"bytes,3,opt,name=markdown,proto3" json:"markdown,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *UploadSummaryRequest) Reset() {
	*x = UploadSummaryRequest{}
	mi := &file_ermite_runner_proto_msgTypes[27]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UploadSummaryRequest) ProtoMessage() {}

func (x *UploadSummaryRequest) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_proto_msgTypes[27]
	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 UploadSummaryRequest.ProtoReflect.Descriptor instead.
func (*UploadSummaryRequest) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{27}
}

func (x *UploadSummaryRequest) GetJobId() string {
	if x != nil {
		return x.JobId
	}
	return ""
}

func (x *UploadSummaryRequest) GetStepNumber() int32 {
	if x != nil {
		return x.StepNumber
	}
	return 0
}

func (x *UploadSummaryRequest) GetMarkdown() string {
	if x != nil {
		return x.Markdown
	}
	return ""
}

// UploadSummaryResponse is empty.
type UploadSummaryResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *UploadSummaryResponse) Reset() {
	*x = UploadSummaryResponse{}
	mi := &file_ermite_runner_proto_msgTypes[28]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*UploadSummaryResponse) ProtoMessage() {}

func (x *UploadSummaryResponse) ProtoReflect() protoreflect.Message {
	mi := &file_ermite_runner_proto_msgTypes[28]
	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 UploadSummaryResponse.ProtoReflect.Descriptor instead.
func (*UploadSummaryResponse) Descriptor() ([]byte, []int) {
	return file_ermite_runner_proto_rawDescGZIP(), []int{28}
}

var File_ermite_runner_proto protoreflect.FileDescriptor

const file_ermite_runner_proto_rawDesc = "" +
	"\n" +
	"\x13ermite/runner.proto\x12\x06ermite\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\xd2\x01\n" +
	"\x15RegisterRunnerRequest\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12\x16\n" +
	"\x06labels\x18\x02 \x03(\tR\x06labels\x12\x18\n" +
	"\aversion\x18\x03 \x01(\tR\aversion\x125\n" +
	"\tisolation\x18\x04 \x01(\x0e2\x17.ermite.RunnerIsolationR\tisolation\x12\x12\n" +
	"\x04arch\x18\x05 \x01(\tR\x04arch\x12\x0e\n" +
	"\x02os\x18\x06 \x01(\tR\x02os\x12\x18\n" +
	"\areplace\x18\a \x01(\bR\areplace\"X\n" +
	"\x16RegisterRunnerResponse\x12\x1b\n" +
	"\trunner_id\x18\x01 \x01(\tR\brunnerId\x12!\n" +
	"\frunner_token\x18\x02 \x01(\tR\vrunnerToken\"\\\n" +
	"\x0fFetchJobRequest\x12\x16\n" +
	"\x06labels\x18\x01 \x03(\tR\x06labels\x12\x17\n" +
	"\apoll_id\x18\x02 \x01(\tR\x06pollId\x12\x18\n" +
	"\aversion\x18\x03 \x01(\tR\aversion\"m\n" +
	"\x10FetchJobResponse\x12\x1d\n" +
	"\x03job\x18\x01 \x01(\v2\v.ermite.JobR\x03job\x12:\n" +
	"\vretry_after\x18\x02 \x01(\v2\x19.google.protobuf.DurationR\n" +
	"retryAfter\"\xe6\x06\n" +
	"\x03Job\x12\x15\n" +
	"\x06job_id\x18\x01 \x01(\tR\x05jobId\x12\x15\n" +
	"\x06run_id\x18\x02 \x01(\x03R\x05runId\x12\x18\n" +
	"\aattempt\x18\x03 \x01(\x05R\aattempt\x12\x1b\n" +
	"\tjob_token\x18\x04 \x01(\tR\bjobToken\x12#\n" +
	"\rworkflow_path\x18\x05 \x01(\tR\fworkflowPath\x12#\n" +
	"\rworkflow_yaml\x18\x06 \x01(\tR\fworkflowYaml\x12\x17\n" +
	"\ajob_key\x18\a \x01(\tR\x06jobKey\x12\x16\n" +
	"\x06matrix\x18\b \x01(\tR\x06matrix\x12\x1a\n" +
	"\bcontexts\x18\t \x01(\tR\bcontexts\x12\x16\n" +
	"\x06labels\x18\n" +
	" \x03(\tR\x06labels\x12'\n" +
	"\x0ftimeout_minutes\x18\v \x01(\x05R\x0etimeoutMinutes\x12\x12\n" +
	"\x04repo\x18\f \x01(\tR\x04repo\x12\x10\n" +
	"\x03sha\x18\r \x01(\tR\x03sha\x12\x10\n" +
	"\x03ref\x18\x0e \x01(\tR\x03ref\x12!\n" +
	"\fgithub_token\x18\x0f \x01(\tR\vgithubToken\x122\n" +
	"\asecrets\x18\x10 \x03(\v2\x18.ermite.Job.SecretsEntryR\asecrets\x12)\n" +
	"\x04vars\x18\x11 \x03(\v2\x15.ermite.Job.VarsEntryR\x04vars\x12 \n" +
	"\venvironment\x18\x12 \x01(\tR\venvironment\x128\n" +
	"\vpermissions\x18\x13 \x01(\v2\x16.ermite.JobPermissionsR\vpermissions\x12&\n" +
	"\x05cache\x18\x14 \x01(\v2\x10.ermite.JobCacheR\x05cache\x12\x18\n" +
	"\atrusted\x18\x15 \x01(\bR\atrusted\x12 \n" +
	"\fid_token_url\x18\x16 \x01(\tR\n" +
	"idTokenUrl\x123\n" +
	"\x16id_token_request_token\x18\x17 \x01(\tR\x13idTokenRequestToken\x1a:\n" +
	"\fSecretsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\x1a7\n" +
	"\tVarsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\x87\x01\n" +
	"\x0eJobPermissions\x12:\n" +
	"\x06levels\x18\x01 \x03(\v2\".ermite.JobPermissions.LevelsEntryR\x06levels\x1a9\n" +
	"\vLevelsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"d\n" +
	"\bJobCache\x12\x1e\n" +
	"\n" +
	"repository\x18\x01 \x01(\tR\n" +
	"repository\x12\x1b\n" +
	"\twrite_ref\x18\x02 \x01(\tR\bwriteRef\x12\x1b\n" +
	"\tread_refs\x18\x03 \x03(\tR\breadRefs\"\x89\x01\n" +
	"\x10UpdateJobRequest\x12\x15\n" +
	"\x06job_id\x18\x01 \x01(\tR\x05jobId\x12(\n" +
	"\x05steps\x18\x02 \x03(\v2\x12.ermite.StepUpdateR\x05steps\x124\n" +
	"\vannotations\x18\x03 \x03(\v2\x12.ermite.AnnotationR\vannotations\"\xc1\x02\n" +
	"\n" +
	"StepUpdate\x12\x16\n" +
	"\x06number\x18\x01 \x01(\x05R\x06number\x12\x12\n" +
	"\x04name\x18\x02 \x01(\tR\x04name\x12'\n" +
	"\x05state\x18\x03 \x01(\x0e2\x11.ermite.StepStateR\x05state\x124\n" +
	"\n" +
	"conclusion\x18\x04 \x01(\x0e2\x14.ermite.CiConclusionR\n" +
	"conclusion\x129\n" +
	"\n" +
	"started_at\x18\x05 \x01(\v2\x1a.google.protobuf.TimestampR\tstartedAt\x12=\n" +
	"\fcompleted_at\x18\x06 \x01(\v2\x1a.google.protobuf.TimestampR\vcompletedAt\x12.\n" +
	"\aoutcome\x18\a \x01(\x0e2\x14.ermite.CiConclusionR\aoutcome\"\x13\n" +
	"\x11UpdateJobResponse\"\xe9\x02\n" +
	"\x12CompleteJobRequest\x12\x15\n" +
	"\x06job_id\x18\x01 \x01(\tR\x05jobId\x124\n" +
	"\n" +
	"conclusion\x18\x02 \x01(\x0e2\x14.ermite.CiConclusionR\n" +
	"conclusion\x12A\n" +
	"\aoutputs\x18\x03 \x03(\v2'.ermite.CompleteJobRequest.OutputsEntryR\aoutputs\x12'\n" +
	"\x0frunner_shutdown\x18\x04 \x01(\bR\x0erunnerShutdown\x12(\n" +
	"\x05steps\x18\x05 \x03(\v2\x12.ermite.StepUpdateR\x05steps\x124\n" +
	"\vannotations\x18\x06 \x03(\v2\x12.ermite.AnnotationR\vannotations\x1a:\n" +
	"\fOutputsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"{\n" +
	"\x13CompleteJobResponse\x124\n" +
	"\n" +
	"conclusion\x18\x01 \x01(\x0e2\x14.ermite.CiConclusionR\n" +
	"conclusion\x12\x14\n" +
	"\x05error\x18\x02 \x01(\tR\x05error\x12\x18\n" +
	"\aapplied\x18\x03 \x01(\bR\aapplied\"V\n" +
	"\bJobEnded\x124\n" +
	"\n" +
	"conclusion\x18\x01 \x01(\x0e2\x14.ermite.CiConclusionR\n" +
	"conclusion\x12\x14\n" +
	"\x05error\x18\x02 \x01(\tR\x05error\"|\n" +
	"\x10AppendLogRequest\x12\x15\n" +
	"\x06job_id\x18\x01 \x01(\tR\x05jobId\x12\x12\n" +
	"\x04step\x18\x02 \x01(\x05R\x04step\x12\x16\n" +
	"\x06offset\x18\x03 \x01(\x03R\x06offset\x12%\n" +
	"\x05lines\x18\x04 \x03(\v2\x0f.ermite.LogLineR\x05lines\"k\n" +
	"\aLogLine\x12.\n" +
	"\x04time\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\x04time\x12\x12\n" +
	"\x04text\x18\x02 \x01(\tR\x04text\x12\x1c\n" +
	"\tcontinued\x18\x03 \x01(\bR\tcontinued\"4\n" +
	"\x11AppendLogResponse\x12\x1f\n" +
	"\vnext_offset\x18\x01 \x01(\x03R\n" +
	"nextOffset\")\n" +
	"\x10HeartbeatRequest\x12\x15\n" +
	"\x06job_id\x18\x01 \x01(\tR\x05jobId\"\x13\n" +
	"\x11HeartbeatResponse\"(\n" +
	"\x0fWatchJobRequest\x12\x15\n" +
	"\x06job_id\x18\x01 \x01(\tR\x05jobId\"\xa7\x01\n" +
	"\x10WatchJobResponse\x121\n" +
	"\tkeepalive\x18\x01 \x01(\v2\x11.ermite.KeepaliveH\x00R\tkeepalive\x12/\n" +
	"\x06cancel\x18\x02 \x01(\v2\x15.ermite.CancelRequestH\x00R\x06cancel\x12(\n" +
	"\x05ended\x18\x03 \x01(\v2\x10.ermite.JobEndedH\x00R\x05endedB\x05\n" +
	"\x03msg\"\v\n" +
	"\tKeepalive\"\x96\x01\n" +
	"\rCancelRequest\x12,\n" +
	"\x06reason\x18\x01 \x01(\x0e2\x14.ermite.CancelReasonR\x06reason\x12\x18\n" +
	"\amessage\x18\x02 \x01(\tR\amessage\x12=\n" +
	"\frequested_at\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\vrequestedAt\"\x9c\x02\n" +
	"\n" +
	"Annotation\x12-\n" +
	"\x05level\x18\x01 \x01(\x0e2\x17.ermite.AnnotationLevelR\x05level\x12\x14\n" +
	"\x05title\x18\x02 \x01(\tR\x05title\x12\x18\n" +
	"\amessage\x18\x03 \x01(\tR\amessage\x12\x12\n" +
	"\x04file\x18\x04 \x01(\tR\x04file\x12\x1d\n" +
	"\n" +
	"start_line\x18\x05 \x01(\x05R\tstartLine\x12\x19\n" +
	"\bend_line\x18\x06 \x01(\x05R\aendLine\x12!\n" +
	"\fstart_column\x18\a \x01(\x05R\vstartColumn\x12\x1d\n" +
	"\n" +
	"end_column\x18\b \x01(\x05R\tendColumn\x12\x1f\n" +
	"\vstep_number\x18\t \x01(\x05R\n" +
	"stepNumber\"\x1f\n" +
	"\tActionRef\x12\x12\n" +
	"\x04uses\x18\x01 \x01(\tR\x04uses\"U\n" +
	"\x15ResolveActionsRequest\x12\x15\n" +
	"\x06job_id\x18\x01 \x01(\tR\x05jobId\x12%\n" +
	"\x04refs\x18\x02 \x03(\v2\x11.ermite.ActionRefR\x04refs\"J\n" +
	"\x16ResolveActionsResponse\x120\n" +
	"\aactions\x18\x01 \x03(\v2\x16.ermite.ResolvedActionR\aactions\"\xfc\x01\n" +
	"\x0eResolvedAction\x12\x10\n" +
	"\x03ref\x18\x01 \x01(\tR\x03ref\x12&\n" +
	"\x0fname_with_owner\x18\x02 \x01(\tR\rnameWithOwner\x12\x12\n" +
	"\x04path\x18\x03 \x01(\tR\x04path\x12!\n" +
	"\fresolved_sha\x18\x04 \x01(\tR\vresolvedSha\x12\x1f\n" +
	"\vtarball_url\x18\x05 \x01(\tR\n" +
	"tarballUrl\x12\x14\n" +
	"\x05token\x18\x06 \x01(\tR\x05token\x12,\n" +
	"\x06source\x18\a \x01(\x0e2\x14.ermite.ActionSourceR\x06source\x12\x14\n" +
	"\x05error\x18\b \x01(\tR\x05error\"j\n" +
	"\x14UploadSummaryRequest\x12\x15\n" +
	"\x06job_id\x18\x01 \x01(\tR\x05jobId\x12\x1f\n" +
	"\vstep_number\x18\x02 \x01(\x05R\n" +
	"stepNumber\x12\x1a\n" +
	"\bmarkdown\x18\x03 \x01(\tR\bmarkdown\"\x17\n" +
	"\x15UploadSummaryResponse*\x86\x01\n" +
	"\bCiStatus\x12\x19\n" +
	"\x15CI_STATUS_UNSPECIFIED\x10\x00\x12\x14\n" +
	"\x10CI_STATUS_QUEUED\x10\x01\x12\x19\n" +
	"\x15CI_STATUS_IN_PROGRESS\x10\x02\x12\x17\n" +
	"\x13CI_STATUS_COMPLETED\x10\x03\x12\x15\n" +
	"\x11CI_STATUS_PENDING\x10\x04*\xf6\x01\n" +
	"\fCiConclusion\x12\x1d\n" +
	"\x19CI_CONCLUSION_UNSPECIFIED\x10\x00\x12\x19\n" +
	"\x15CI_CONCLUSION_SUCCESS\x10\x01\x12\x19\n" +
	"\x15CI_CONCLUSION_FAILURE\x10\x02\x12\x1b\n" +
	"\x17CI_CONCLUSION_CANCELLED\x10\x03\x12\x19\n" +
	"\x15CI_CONCLUSION_SKIPPED\x10\x04\x12\x1b\n" +
	"\x17CI_CONCLUSION_TIMED_OUT\x10\x05\x12\x19\n" +
	"\x15CI_CONCLUSION_NEUTRAL\x10\x06\x12!\n" +
	"\x1dCI_CONCLUSION_ACTION_REQUIRED\x10\a*u\n" +
	"\tStepState\x12\x1a\n" +
	"\x16STEP_STATE_UNSPECIFIED\x10\x00\x12\x16\n" +
	"\x12STEP_STATE_PENDING\x10\x01\x12\x1a\n" +
	"\x16STEP_STATE_IN_PROGRESS\x10\x02\x12\x18\n" +
	"\x14STEP_STATE_COMPLETED\x10\x03*\x9e\x01\n" +
	"\x0fRunnerIsolation\x12 \n" +
	"\x1cRUNNER_ISOLATION_UNSPECIFIED\x10\x00\x12\x17\n" +
	"\x13RUNNER_ISOLATION_VM\x10\x01\x12%\n" +
	"!RUNNER_ISOLATION_CONTAINER_SYSBOX\x10\x02\x12)\n" +
	"%RUNNER_ISOLATION_CONTAINER_PRIVILEGED\x10\x03*}\n" +
	"\fCancelReason\x12\x1d\n" +
	"\x19CANCEL_REASON_UNSPECIFIED\x10\x00\x12\x16\n" +
	"\x12CANCEL_REASON_USER\x10\x01\x12\x1b\n" +
	"\x17CANCEL_REASON_FAIL_FAST\x10\x02\x12\x19\n" +
	"\x15CANCEL_REASON_TIMEOUT\x10\x03*\x8c\x01\n" +
	"\x0fAnnotationLevel\x12 \n" +
	"\x1cANNOTATION_LEVEL_UNSPECIFIED\x10\x00\x12\x1b\n" +
	"\x17ANNOTATION_LEVEL_NOTICE\x10\x01\x12\x1c\n" +
	"\x18ANNOTATION_LEVEL_WARNING\x10\x02\x12\x1c\n" +
	"\x18ANNOTATION_LEVEL_FAILURE\x10\x03*a\n" +
	"\fActionSource\x12\x1d\n" +
	"\x19ACTION_SOURCE_UNSPECIFIED\x10\x00\x12\x18\n" +
	"\x14ACTION_SOURCE_GITHUB\x10\x01\x12\x18\n" +
	"\x14ACTION_SOURCE_ERMITE\x10\x022\x8d\x05\n" +
	"\rRunnerService\x12O\n" +
	"\x0eRegisterRunner\x12\x1d.ermite.RegisterRunnerRequest\x1a\x1e.ermite.RegisterRunnerResponse\x12=\n" +
	"\bFetchJob\x12\x17.ermite.FetchJobRequest\x1a\x18.ermite.FetchJobResponse\x12@\n" +
	"\tUpdateJob\x12\x18.ermite.UpdateJobRequest\x1a\x19.ermite.UpdateJobResponse\x12@\n" +
	"\tAppendLog\x12\x18.ermite.AppendLogRequest\x1a\x19.ermite.AppendLogResponse\x12@\n" +
	"\tHeartbeat\x12\x18.ermite.HeartbeatRequest\x1a\x19.ermite.HeartbeatResponse\x12?\n" +
	"\bWatchJob\x12\x17.ermite.WatchJobRequest\x1a\x18.ermite.WatchJobResponse0\x01\x12F\n" +
	"\vCompleteJob\x12\x1a.ermite.CompleteJobRequest\x1a\x1b.ermite.CompleteJobResponse\x12O\n" +
	"\x0eResolveActions\x12\x1d.ermite.ResolveActionsRequest\x1a\x1e.ermite.ResolveActionsResponse\x12L\n" +
	"\rUploadSummary\x12\x1c.ermite.UploadSummaryRequest\x1a\x1d.ermite.UploadSummaryResponseBr\n" +
	"\n" +
	"com.ermiteB\vRunnerProtoP\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_runner_proto_rawDescOnce sync.Once
	file_ermite_runner_proto_rawDescData []byte
)

func file_ermite_runner_proto_rawDescGZIP() []byte {
	file_ermite_runner_proto_rawDescOnce.Do(func() {
		file_ermite_runner_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_ermite_runner_proto_rawDesc), len(file_ermite_runner_proto_rawDesc)))
	})
	return file_ermite_runner_proto_rawDescData
}

var file_ermite_runner_proto_enumTypes = make([]protoimpl.EnumInfo, 7)
var file_ermite_runner_proto_msgTypes = make([]protoimpl.MessageInfo, 33)
var file_ermite_runner_proto_goTypes = []any{
	(CiStatus)(0),                  // 0: ermite.CiStatus
	(CiConclusion)(0),              // 1: ermite.CiConclusion
	(StepState)(0),                 // 2: ermite.StepState
	(RunnerIsolation)(0),           // 3: ermite.RunnerIsolation
	(CancelReason)(0),              // 4: ermite.CancelReason
	(AnnotationLevel)(0),           // 5: ermite.AnnotationLevel
	(ActionSource)(0),              // 6: ermite.ActionSource
	(*RegisterRunnerRequest)(nil),  // 7: ermite.RegisterRunnerRequest
	(*RegisterRunnerResponse)(nil), // 8: ermite.RegisterRunnerResponse
	(*FetchJobRequest)(nil),        // 9: ermite.FetchJobRequest
	(*FetchJobResponse)(nil),       // 10: ermite.FetchJobResponse
	(*Job)(nil),                    // 11: ermite.Job
	(*JobPermissions)(nil),         // 12: ermite.JobPermissions
	(*JobCache)(nil),               // 13: ermite.JobCache
	(*UpdateJobRequest)(nil),       // 14: ermite.UpdateJobRequest
	(*StepUpdate)(nil),             // 15: ermite.StepUpdate
	(*UpdateJobResponse)(nil),      // 16: ermite.UpdateJobResponse
	(*CompleteJobRequest)(nil),     // 17: ermite.CompleteJobRequest
	(*CompleteJobResponse)(nil),    // 18: ermite.CompleteJobResponse
	(*JobEnded)(nil),               // 19: ermite.JobEnded
	(*AppendLogRequest)(nil),       // 20: ermite.AppendLogRequest
	(*LogLine)(nil),                // 21: ermite.LogLine
	(*AppendLogResponse)(nil),      // 22: ermite.AppendLogResponse
	(*HeartbeatRequest)(nil),       // 23: ermite.HeartbeatRequest
	(*HeartbeatResponse)(nil),      // 24: ermite.HeartbeatResponse
	(*WatchJobRequest)(nil),        // 25: ermite.WatchJobRequest
	(*WatchJobResponse)(nil),       // 26: ermite.WatchJobResponse
	(*Keepalive)(nil),              // 27: ermite.Keepalive
	(*CancelRequest)(nil),          // 28: ermite.CancelRequest
	(*Annotation)(nil),             // 29: ermite.Annotation
	(*ActionRef)(nil),              // 30: ermite.ActionRef
	(*ResolveActionsRequest)(nil),  // 31: ermite.ResolveActionsRequest
	(*ResolveActionsResponse)(nil), // 32: ermite.ResolveActionsResponse
	(*ResolvedAction)(nil),         // 33: ermite.ResolvedAction
	(*UploadSummaryRequest)(nil),   // 34: ermite.UploadSummaryRequest
	(*UploadSummaryResponse)(nil),  // 35: ermite.UploadSummaryResponse
	nil,                            // 36: ermite.Job.SecretsEntry
	nil,                            // 37: ermite.Job.VarsEntry
	nil,                            // 38: ermite.JobPermissions.LevelsEntry
	nil,                            // 39: ermite.CompleteJobRequest.OutputsEntry
	(*durationpb.Duration)(nil),    // 40: google.protobuf.Duration
	(*timestamppb.Timestamp)(nil),  // 41: google.protobuf.Timestamp
}
var file_ermite_runner_proto_depIdxs = []int32{
	3,  // 0: ermite.RegisterRunnerRequest.isolation:type_name -> ermite.RunnerIsolation
	11, // 1: ermite.FetchJobResponse.job:type_name -> ermite.Job
	40, // 2: ermite.FetchJobResponse.retry_after:type_name -> google.protobuf.Duration
	36, // 3: ermite.Job.secrets:type_name -> ermite.Job.SecretsEntry
	37, // 4: ermite.Job.vars:type_name -> ermite.Job.VarsEntry
	12, // 5: ermite.Job.permissions:type_name -> ermite.JobPermissions
	13, // 6: ermite.Job.cache:type_name -> ermite.JobCache
	38, // 7: ermite.JobPermissions.levels:type_name -> ermite.JobPermissions.LevelsEntry
	15, // 8: ermite.UpdateJobRequest.steps:type_name -> ermite.StepUpdate
	29, // 9: ermite.UpdateJobRequest.annotations:type_name -> ermite.Annotation
	2,  // 10: ermite.StepUpdate.state:type_name -> ermite.StepState
	1,  // 11: ermite.StepUpdate.conclusion:type_name -> ermite.CiConclusion
	41, // 12: ermite.StepUpdate.started_at:type_name -> google.protobuf.Timestamp
	41, // 13: ermite.StepUpdate.completed_at:type_name -> google.protobuf.Timestamp
	1,  // 14: ermite.StepUpdate.outcome:type_name -> ermite.CiConclusion
	1,  // 15: ermite.CompleteJobRequest.conclusion:type_name -> ermite.CiConclusion
	39, // 16: ermite.CompleteJobRequest.outputs:type_name -> ermite.CompleteJobRequest.OutputsEntry
	15, // 17: ermite.CompleteJobRequest.steps:type_name -> ermite.StepUpdate
	29, // 18: ermite.CompleteJobRequest.annotations:type_name -> ermite.Annotation
	1,  // 19: ermite.CompleteJobResponse.conclusion:type_name -> ermite.CiConclusion
	1,  // 20: ermite.JobEnded.conclusion:type_name -> ermite.CiConclusion
	21, // 21: ermite.AppendLogRequest.lines:type_name -> ermite.LogLine
	41, // 22: ermite.LogLine.time:type_name -> google.protobuf.Timestamp
	27, // 23: ermite.WatchJobResponse.keepalive:type_name -> ermite.Keepalive
	28, // 24: ermite.WatchJobResponse.cancel:type_name -> ermite.CancelRequest
	19, // 25: ermite.WatchJobResponse.ended:type_name -> ermite.JobEnded
	4,  // 26: ermite.CancelRequest.reason:type_name -> ermite.CancelReason
	41, // 27: ermite.CancelRequest.requested_at:type_name -> google.protobuf.Timestamp
	5,  // 28: ermite.Annotation.level:type_name -> ermite.AnnotationLevel
	30, // 29: ermite.ResolveActionsRequest.refs:type_name -> ermite.ActionRef
	33, // 30: ermite.ResolveActionsResponse.actions:type_name -> ermite.ResolvedAction
	6,  // 31: ermite.ResolvedAction.source:type_name -> ermite.ActionSource
	7,  // 32: ermite.RunnerService.RegisterRunner:input_type -> ermite.RegisterRunnerRequest
	9,  // 33: ermite.RunnerService.FetchJob:input_type -> ermite.FetchJobRequest
	14, // 34: ermite.RunnerService.UpdateJob:input_type -> ermite.UpdateJobRequest
	20, // 35: ermite.RunnerService.AppendLog:input_type -> ermite.AppendLogRequest
	23, // 36: ermite.RunnerService.Heartbeat:input_type -> ermite.HeartbeatRequest
	25, // 37: ermite.RunnerService.WatchJob:input_type -> ermite.WatchJobRequest
	17, // 38: ermite.RunnerService.CompleteJob:input_type -> ermite.CompleteJobRequest
	31, // 39: ermite.RunnerService.ResolveActions:input_type -> ermite.ResolveActionsRequest
	34, // 40: ermite.RunnerService.UploadSummary:input_type -> ermite.UploadSummaryRequest
	8,  // 41: ermite.RunnerService.RegisterRunner:output_type -> ermite.RegisterRunnerResponse
	10, // 42: ermite.RunnerService.FetchJob:output_type -> ermite.FetchJobResponse
	16, // 43: ermite.RunnerService.UpdateJob:output_type -> ermite.UpdateJobResponse
	22, // 44: ermite.RunnerService.AppendLog:output_type -> ermite.AppendLogResponse
	24, // 45: ermite.RunnerService.Heartbeat:output_type -> ermite.HeartbeatResponse
	26, // 46: ermite.RunnerService.WatchJob:output_type -> ermite.WatchJobResponse
	18, // 47: ermite.RunnerService.CompleteJob:output_type -> ermite.CompleteJobResponse
	32, // 48: ermite.RunnerService.ResolveActions:output_type -> ermite.ResolveActionsResponse
	35, // 49: ermite.RunnerService.UploadSummary:output_type -> ermite.UploadSummaryResponse
	41, // [41:50] is the sub-list for method output_type
	32, // [32:41] is the sub-list for method input_type
	32, // [32:32] is the sub-list for extension type_name
	32, // [32:32] is the sub-list for extension extendee
	0,  // [0:32] is the sub-list for field type_name
}

func init() { file_ermite_runner_proto_init() }
func file_ermite_runner_proto_init() {
	if File_ermite_runner_proto != nil {
		return
	}
	file_ermite_runner_proto_msgTypes[19].OneofWrappers = []any{
		(*WatchJobResponse_Keepalive)(nil),
		(*WatchJobResponse_Cancel)(nil),
		(*WatchJobResponse_Ended)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_ermite_runner_proto_rawDesc), len(file_ermite_runner_proto_rawDesc)),
			NumEnums:      7,
			NumMessages:   33,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_ermite_runner_proto_goTypes,
		DependencyIndexes: file_ermite_runner_proto_depIdxs,
		EnumInfos:         file_ermite_runner_proto_enumTypes,
		MessageInfos:      file_ermite_runner_proto_msgTypes,
	}.Build()
	File_ermite_runner_proto = out.File
	file_ermite_runner_proto_goTypes = nil
	file_ermite_runner_proto_depIdxs = nil
}