vendor/go.chromium.org/luci/swarming/proto/api/swarming.pb.go

// Copyright 2018 The LUCI Authors. All rights reserved.
// Use of this source code is governed under the Apache License, Version 2.0
// that can be found in the LICENSE file.

// This proto tries to converge with
// https://github.com/googleapis/googleapis/blob/master/google/devtools/remoteworkers/v1test2/
// as much as it is sensible to (not much). It has several inherent divergences
// as Swarming has a much wider use case and has a different fundamental model
// for bot state. Swarming has the limitation of not supporting children
// devices: as a single bot is a single execution unit, unlike RBE.

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.28.1
// 	protoc        v3.21.7
// source: go.chromium.org/luci/swarming/proto/api/swarming.proto

package apipb

import prpc "go.chromium.org/luci/grpc/prpc"

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	structpb "google.golang.org/protobuf/types/known/structpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	reflect "reflect"
	sync "sync"
)

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)
)

// BotStatusType is one of the states the bot can be in.
//
// A bot status implies being in this status for a certain amount of time, for
// example a hook running for N seconds, contrary to BotEventType which is about
// an event that doesn't have an inherent duration.
//
// Some values are more important than others. For example if a bot is now
// MISSING but used to be QUARANTINED, the value is still MISSING.
type BotStatusType int32

const (
	// Invalid bot status, do not use.
	BotStatusType_BOT_STATUS_UNSPECIFIED BotStatusType = 0
	// The server detected that the bot is not pinging the server anymore. Unlike
	// other statuses, this value is set after a timeout.
	//
	// Bot.status_msg shall not be set.
	BotStatusType_MISSING BotStatusType = 1
	// Bot was quarantined by the server.
	//
	// Bot.status_msg shall include the server provided rationale.
	BotStatusType_QUARANTINED_BY_SERVER BotStatusType = 2 // Not used yet. https://crbug.com/757931
	// Bot self-reported as unhealthy.
	//
	// What is currently called as 'quarantined' in the old API.
	//
	// Bot.status_msg shall include the bot provided rationale.
	BotStatusType_QUARANTINED_BY_BOT BotStatusType = 3
	// Bot self-reported as unable to run tasks due to externally induced
	// overhead.
	//
	// Examples include:
	//   - The temperature of the DUT (Device Under Test) is too high, and the bot
	//     is waiting for cool down
	//   - host is doing self-cleaning work out of the bot's control (puppet is
	//     running), etc.
	//
	// Bot.status_msg shall include the bot provided rationale.
	BotStatusType_OVERHEAD_MAINTENANCE_EXTERNAL BotStatusType = 4
	// Bot self-reported as unable to run tasks due to doing internal overhead.
	//
	// Examples include:
	// - Running hooks
	// - Cleaning up or verifying its local cache
	// - Bot is starting for a version upgrade
	//
	// Bot.status_msg shall disambiguate the type of work item done.
	BotStatusType_OVERHEAD_BOT_INTERNAL BotStatusType = 5 // Not used yet. https://crbug.com/870723
	// Bot is down as its host is rebooting and contact was lost.
	//
	// If the bot doesn't contact back soon enough, it will be considered MISSING.
	//
	// Bot.status_msg shall not be set.
	BotStatusType_HOST_REBOOTING BotStatusType = 6 // Not used yet. https://crbug.com/870723
	// Running a task.
	//
	// Bot.status_msg shall not be set.
	BotStatusType_BUSY BotStatusType = 7
	// Bot is 'reserved' for operations outside of normal operations. This can be
	// relevant for SUT (System Under Test).
	//
	// Bot.status_msg shall not be set.
	BotStatusType_RESERVED BotStatusType = 8 // Not used yet. https://crbug.com/913978
	// Bot is healthy and waiting for tasks.
	//
	// Bot.status_msg shall not be set.
	BotStatusType_IDLE BotStatusType = 9
)

// Enum value maps for BotStatusType.
var (
	BotStatusType_name = map[int32]string{
		0: "BOT_STATUS_UNSPECIFIED",
		1: "MISSING",
		2: "QUARANTINED_BY_SERVER",
		3: "QUARANTINED_BY_BOT",
		4: "OVERHEAD_MAINTENANCE_EXTERNAL",
		5: "OVERHEAD_BOT_INTERNAL",
		6: "HOST_REBOOTING",
		7: "BUSY",
		8: "RESERVED",
		9: "IDLE",
	}
	BotStatusType_value = map[string]int32{
		"BOT_STATUS_UNSPECIFIED":        0,
		"MISSING":                       1,
		"QUARANTINED_BY_SERVER":         2,
		"QUARANTINED_BY_BOT":            3,
		"OVERHEAD_MAINTENANCE_EXTERNAL": 4,
		"OVERHEAD_BOT_INTERNAL":         5,
		"HOST_REBOOTING":                6,
		"BUSY":                          7,
		"RESERVED":                      8,
		"IDLE":                          9,
	}
)

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

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

func (BotStatusType) Descriptor() protoreflect.EnumDescriptor {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_enumTypes[0].Descriptor()
}

func (BotStatusType) Type() protoreflect.EnumType {
	return &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_enumTypes[0]
}

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

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

// BotEventType defines the reason why BotEvent was created.
type BotEventType int32

const (
	// Invalid bot event type, do not use.
	BotEventType_BOT_EVENT_TYPE_UNSPECIFIED BotEventType = 0
	// Bot connected and started a new session.
	//
	// BotEvent.event_msg shall not be set.
	BotEventType_BOT_NEW_SESSION BotEventType = 1
	// Currently unused.
	BotEventType_BOT_INTERNAL_FAILURE BotEventType = 2
	// Bot had an hook error to report to the server. This shall send a report to
	// the administrator of the instance.
	//
	// BotEvent.event_msg shall contain the error message.
	BotEventType_BOT_HOOK_ERROR BotEventType = 3
	// Bot hook logged information. The bot hooks can log locally to the local log
	// file, which itself can be streamed out of band. For special notifications
	// that are worth notifying the administrator, this event can be used to raise
	// these. Due to the cost of doing an RPC just for this, this should be used
	// sparingly; vs local logging.
	//
	// BotEvent.event_msg shall contain the log entry.
	BotEventType_BOT_HOOK_LOG BotEventType = 4
	// Bot initiated a host reboot. An example is a bot hook requesting to reboot
	// the host after a task failure.
	//
	// BotEvent.event_msg shall contain the reason for rebooting the host, if any.
	BotEventType_BOT_REBOOTING_HOST BotEventType = 5
	// Bot is shutting down. It may be restarting for an update.
	//
	// BotEvent.event_msg shall contain the reason.
	BotEventType_BOT_SHUTDOWN BotEventType = 6
	// Currently unused.
	BotEventType_BOT_DELETED BotEventType = 7
	// Bot is missing. There have been no communication from the bot for longer
	// than deadline configured on server side.
	BotEventType_BOT_MISSING BotEventType = 8
	// The server instructs the bot to stay idle. This is when there is no task
	// pending for this bot. Will only be stored when there are other state
	// changes.
	//
	// BotEvent.event_msg shall not be set.
	BotEventType_INSTRUCT_IDLE BotEventType = 10
	// The server instructs the bot to start a task.
	//
	// BotEvent.event_msg shall not be set. BotEvent.bot.current_task_id shall
	// contain the task ID.
	BotEventType_INSTRUCT_START_TASK BotEventType = 11
	// The server instructs the bot to restart without self-updating. This is to
	// initiate a new bot session, with potentially new bot hooks.
	//
	// BotEvent.event_msg can be set to the rationale, if any.
	BotEventType_INSTRUCT_RESTART_BOT BotEventType = 12
	// The server instructs the bot to self-update.
	//
	// BotEvent.event_msg shall be set to the version to update to.
	// BotEvent.bot.info.version contains the bot's previous version.
	BotEventType_INSTRUCT_UPDATE_BOT_CODE BotEventType = 13
	// The server instructs the bot to stop its process.
	//
	// BotEvent.event_msg shall not be set. BotEvent.bot.current_task_id shall
	// contain the task ID.
	BotEventType_INSTRUCT_TERMINATE_BOT BotEventType = 14
	// Bot completed a task.
	//
	// BotEvent.event_msg shall not be set. BotEvent.bot.current_task_id shall
	// contain the task ID.
	BotEventType_TASK_COMPLETED BotEventType = 20
	// Bot had an internal failure (RAN_INTERNAL_FAILURE) to report to the server
	// while processing a task. This shall send a report to the administrator of
	// the instance and service author.
	//
	// This event shall not be filed in case of a MISSING_INPUTS.
	//
	// BotEvent.event_msg shall contain the error message.
	// BotEvent.bot.current_task_id shall contain the task ID.
	BotEventType_TASK_INTERNAL_FAILURE BotEventType = 21
	// Bot is forcibly killing the task.
	//
	// This can be induced by a server side request (KILLED, PREEMPTED) or by a
	// bot side decision (TIMED_OUT, TIMED_OUT_SILENCE).
	//
	// BotEvent.event_msg shall not be set. BotEvent.bot.current_task_id shall
	// contain the task ID.
	BotEventType_TASK_KILLED BotEventType = 22
)

// Enum value maps for BotEventType.
var (
	BotEventType_name = map[int32]string{
		0:  "BOT_EVENT_TYPE_UNSPECIFIED",
		1:  "BOT_NEW_SESSION",
		2:  "BOT_INTERNAL_FAILURE",
		3:  "BOT_HOOK_ERROR",
		4:  "BOT_HOOK_LOG",
		5:  "BOT_REBOOTING_HOST",
		6:  "BOT_SHUTDOWN",
		7:  "BOT_DELETED",
		8:  "BOT_MISSING",
		10: "INSTRUCT_IDLE",
		11: "INSTRUCT_START_TASK",
		12: "INSTRUCT_RESTART_BOT",
		13: "INSTRUCT_UPDATE_BOT_CODE",
		14: "INSTRUCT_TERMINATE_BOT",
		20: "TASK_COMPLETED",
		21: "TASK_INTERNAL_FAILURE",
		22: "TASK_KILLED",
	}
	BotEventType_value = map[string]int32{
		"BOT_EVENT_TYPE_UNSPECIFIED": 0,
		"BOT_NEW_SESSION":            1,
		"BOT_INTERNAL_FAILURE":       2,
		"BOT_HOOK_ERROR":             3,
		"BOT_HOOK_LOG":               4,
		"BOT_REBOOTING_HOST":         5,
		"BOT_SHUTDOWN":               6,
		"BOT_DELETED":                7,
		"BOT_MISSING":                8,
		"INSTRUCT_IDLE":              10,
		"INSTRUCT_START_TASK":        11,
		"INSTRUCT_RESTART_BOT":       12,
		"INSTRUCT_UPDATE_BOT_CODE":   13,
		"INSTRUCT_TERMINATE_BOT":     14,
		"TASK_COMPLETED":             20,
		"TASK_INTERNAL_FAILURE":      21,
		"TASK_KILLED":                22,
	}
)

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

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

func (BotEventType) Descriptor() protoreflect.EnumDescriptor {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_enumTypes[1].Descriptor()
}

func (BotEventType) Type() protoreflect.EnumType {
	return &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_enumTypes[1]
}

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

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

// The user to run the task.
type User int32

const (
	// Unspecified; will default to pool-level defaults.
	User_USER_UNSPECIFIED User = 0
	// Historical value; tasks currently run as the same user that Swarming ran
	// as.
	User_USER_SWARMING User = 1
	// Using the new, unprivileged user to run the task.
	User_USER_TEMPORARY User = 2
)

// Enum value maps for User.
var (
	User_name = map[int32]string{
		0: "USER_UNSPECIFIED",
		1: "USER_SWARMING",
		2: "USER_TEMPORARY",
	}
	User_value = map[string]int32{
		"USER_UNSPECIFIED": 0,
		"USER_SWARMING":    1,
		"USER_TEMPORARY":   2,
	}
)

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

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

func (User) Descriptor() protoreflect.EnumDescriptor {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_enumTypes[2].Descriptor()
}

func (User) Type() protoreflect.EnumType {
	return &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_enumTypes[2]
}

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

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

// TaskStateCategory represents the 5 different categories of task state.
//
// For active state categories (RUNNING_MASK and TRANSIENT_DONE_MASK), it is
// possible to go 'back' to PENDING_MASK category; for example, a task has an
// internal error, and the server reenqueues the task for a second try.
type TaskStateCategory int32

const (
	// Invalid value.
	TaskStateCategory_TASK_STATE_CATEGORY_UNSPECIFIED TaskStateCategory = 0
	// Bit mask for the TaskState inside each category.
	TaskStateCategory_TASK_STATE_MASK TaskStateCategory = 15
	// The task is enqueued and pending bot availability.
	TaskStateCategory_CATEGORY_PENDING TaskStateCategory = 16
	// The task is running.
	TaskStateCategory_CATEGORY_RUNNING TaskStateCategory = 32
	// Transient done states are uncertain states; something ran but the result
	// was inconclusive.
	//
	// They can trigger the Swarming internal retry mechanism. In this case, the
	// "task try" will have this state, but the task summary will become PENDING.
	// In case the task cannot be retried, when idempotent is false, then this
	// becomes a final state.
	TaskStateCategory_CATEGORY_TRANSIENT_DONE TaskStateCategory = 48
	// The task ran, and it is done.
	TaskStateCategory_CATEGORY_EXECUTION_DONE TaskStateCategory = 64
	// The task did not run, and won't.
	TaskStateCategory_CATEGORY_NEVER_RAN_DONE TaskStateCategory = 80
)

// Enum value maps for TaskStateCategory.
var (
	TaskStateCategory_name = map[int32]string{
		0:  "TASK_STATE_CATEGORY_UNSPECIFIED",
		15: "TASK_STATE_MASK",
		16: "CATEGORY_PENDING",
		32: "CATEGORY_RUNNING",
		48: "CATEGORY_TRANSIENT_DONE",
		64: "CATEGORY_EXECUTION_DONE",
		80: "CATEGORY_NEVER_RAN_DONE",
	}
	TaskStateCategory_value = map[string]int32{
		"TASK_STATE_CATEGORY_UNSPECIFIED": 0,
		"TASK_STATE_MASK":                 15,
		"CATEGORY_PENDING":                16,
		"CATEGORY_RUNNING":                32,
		"CATEGORY_TRANSIENT_DONE":         48,
		"CATEGORY_EXECUTION_DONE":         64,
		"CATEGORY_NEVER_RAN_DONE":         80,
	}
)

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

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

func (TaskStateCategory) Descriptor() protoreflect.EnumDescriptor {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_enumTypes[3].Descriptor()
}

func (TaskStateCategory) Type() protoreflect.EnumType {
	return &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_enumTypes[3]
}

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

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

// TaskState represents the different possible states for a Task.
//
// Each state is in one of the bitmask in TaskStateCategory.
type TaskState int32

const (
	// Invalid task state.
	TaskState_TASK_STATE_INVALID TaskState = 0
	// The task is currently pending.
	//
	// This means that no bot reaped the task yet. It will stay in this state
	// until either a bot reaps the task, or the expiration elapsed or all bots
	// become MISSING, leading to a NO_RESOURCE. The task pending expiration is
	// specified as TaskSlice.expiration, one per task slice.
	//
	// The task may go through multiple pending TaskSlice as they expire or are
	// skipped due to NO_RESOURCE (see definition below). In this situation the
	// task state still stays in PENDING state as long as there's a chance for a
	// bot to reap the task.
	TaskState_PENDING TaskState = 16
	// The task is currently pending, but another previously scheduled task was
	// identified to be deduped against, but the previously scheduled task hasn't
	// completed yet.
	//
	// In this case, the task may go back into PENDING if the previous identical
	// task failed, or immediately into DEDUPED if it succeeded.
	TaskState_PENDING_DEDUPING TaskState = 17 // Not used yet, https://crbug.com/915342
	// The task is currently running.
	//
	// For new tasks, this is only the actual tasks runtime. For old tasks, this
	// includes RUNNING_OVERHEAD_START and RUNNING_OVERHEAD_END.
	TaskState_RUNNING TaskState = 32
	// The task is assigned to a bot. The bot is fetching input files and setting
	// up the runtime environment.
	TaskState_RUNNING_OVERHEAD_SETUP TaskState = 33 // Not used yet, https://crbug.com/796757
	// Task completed and result metadata is available. Outputs and other
	// associated logs are still being uploaded and the environment is being
	// teared down.
	//
	// A client that only needs the exit code may chose to stop waiting for the
	// task, as the task will end with COMPLETED, unless there's a failure during
	// outputs upload, which would result in INTERNAL_FAILURE.
	TaskState_RUNNING_OVERHEAD_TEARDOWN TaskState = 34 // Not used yet, https://crbug.com/813412
	// The task is being forcibly terminated. This can be due to either a kill
	// request, preemption or time out.
	//
	// See
	// https://chromium.googlesource.com/infra/luci/luci-py.git/+/master/appengine/swarming/doc/Bot.md#graceful-termination_aka-the-sigterm-and-sigkill-dance
	TaskState_TERMINATING TaskState = 35 // Not used yet. https://crbug.com/916560
	// Task completed, result metadata and task outputs are available. There's
	// still some overhead being finished like attaching relevant bot logs to the
	// task.
	//
	// The client can return right away unless infrastructure issue debugging is
	// needed.
	TaskState_COMPLETING TaskState = 47 // Not used yet, https://crbug.com/813412
	// The task ran but the bot had an internal failure, unrelated to the task
	// itself. It can be due to disk or network I/O issues.
	TaskState_RAN_INTERNAL_FAILURE TaskState = 48
	// The task ran and completed normally, but returned an exit code that was
	// provided in the TaskProperties as signaling an hardware failure of the DUT
	// (Device Under Test).
	//
	// As such, the task may need to be retried.
	TaskState_DUT_FAILURE TaskState = 49 // Not used yet, https://crbug.com/902807
	// The task started but the bot failed to keep the connection to the server
	// alive. This can be due to the bot's host crashing, or network connectivity
	// issues.
	TaskState_BOT_DISAPPEARED TaskState = 50 // Not used yet. https://crbug.com/916553
	// The task ran but was killed by the client or an external scheduler in a way
	// that it should still be retried as another task try.
	//
	// This can happen via the external scheduler or an API yet to be defined. The
	// rationale is to kill slow running low priority task, without disrupting the
	// client and simply postponing the task for later.
	TaskState_PREEMPTED TaskState = 51 // Not used yet. https://crbug.com/916559
	// The task ran and completed normally. The task process exit code may be 0 or
	// another value.
	//
	// This value is also used when the task is deduped against a previous task.
	TaskState_COMPLETED TaskState = 64
	// The task ran for longer than the allowed time in
	// TaskProperties.execution_timeout.
	//
	// This means the bot forcefully killed the task process as described in the
	// graceful termination dance in the documentation.
	TaskState_TIMED_OUT TaskState = 65
	// The task timed out due to not sending updates to stdout or stderr within
	// the period specified in TaskProperties.io_timeout.
	//
	// This means the bot forcefully killed the task process as described in the
	// graceful termination dance in the documentation.
	TaskState_TIMED_OUT_SILENCE TaskState = 66 // Not used yet. https://crbug.com/916556
	// The task ran but was manually killed via the 'cancel' API.
	//
	// This means the bot forcefully killed the task process as described in the
	// graceful termination dance in the documentation.
	TaskState_KILLED TaskState = 67
	// The task had specified invalid inputs. This is found out by the bot while
	// RUNNING_OVERHEAD_SETUP.
	//
	// For example, the cas_inputs or cipd_inputs refers to missing items,
	// or the requested containment cannot be achieved.
	TaskState_MISSING_INPUTS TaskState = 68 // Not used yet. https://crbug.com/916553
	// The task didn't have to run, because a previous task had results. It is
	// functionally equivalent to COMPLETED, except that previous results were
	// returned as-is.
	TaskState_DEDUPED TaskState = 80
	// The task is not pending anymore; it never ran due to lack of capacity.
	//
	// This means that other higher priority tasks ran instead and that not enough
	// bots were available to run this task for TaskSlice.expiration.
	TaskState_EXPIRED TaskState = 81
	// The task never ran, and was manually cancelled via the 'cancel' API before
	// it was reaped.
	TaskState_CANCELED TaskState = 82
	// The task was never set to PENDING and was immediately refused, as the
	// server determined that there is no bot capacity to run this task. This
	// happens because no bot exposes a superset of the requested task dimensions.
	//
	// There can be a situation where a task goes from PENDING to NO_RESOURCE if
	// capacity (bots) is removed.
	//
	// Set TaskSlice.wait_for_capacity to True to force the server to keep the
	// task slice pending even in this case. Generally speaking, the task will
	// eventually switch to EXPIRED, as there's no bot to run it. That said, there
	// are situations where it is known that in some not-too-distant future a wild
	// bot will appear that will be able to run this task.
	TaskState_NO_RESOURCE TaskState = 83
	// The task was valid but was denied due to a temporary capacity surcharge.
	// The user should try again after a delay, or surface the lack of capacity to
	// the user.
	TaskState_LOAD_SHED TaskState = 84 // Not used yet. https://crbug.com/916562
	// The task is valid but was denied due to insufficient quota.
	TaskState_RESOURCE_EXHAUSTED TaskState = 85 // Not used yet. https://crbug.com/916557
	// The task never ran, the server had an internal failure, unrelated to the
	// task itself. It can be due to a server bug or network I/O issues.
	TaskState_SKIPPED_INTERNAL_FAILURE TaskState = 86 // Not used yet. https://crbug.com/916553
	// The task encounted an error caused by the client. This means that
	// rerunning the task with the same parameters will not change the result
	TaskState_CLIENT_ERROR TaskState = 87
)

// Enum value maps for TaskState.
var (
	TaskState_name = map[int32]string{
		0:  "TASK_STATE_INVALID",
		16: "PENDING",
		17: "PENDING_DEDUPING",
		32: "RUNNING",
		33: "RUNNING_OVERHEAD_SETUP",
		34: "RUNNING_OVERHEAD_TEARDOWN",
		35: "TERMINATING",
		47: "COMPLETING",
		48: "RAN_INTERNAL_FAILURE",
		49: "DUT_FAILURE",
		50: "BOT_DISAPPEARED",
		51: "PREEMPTED",
		64: "COMPLETED",
		65: "TIMED_OUT",
		66: "TIMED_OUT_SILENCE",
		67: "KILLED",
		68: "MISSING_INPUTS",
		80: "DEDUPED",
		81: "EXPIRED",
		82: "CANCELED",
		83: "NO_RESOURCE",
		84: "LOAD_SHED",
		85: "RESOURCE_EXHAUSTED",
		86: "SKIPPED_INTERNAL_FAILURE",
		87: "CLIENT_ERROR",
	}
	TaskState_value = map[string]int32{
		"TASK_STATE_INVALID":        0,
		"PENDING":                   16,
		"PENDING_DEDUPING":          17,
		"RUNNING":                   32,
		"RUNNING_OVERHEAD_SETUP":    33,
		"RUNNING_OVERHEAD_TEARDOWN": 34,
		"TERMINATING":               35,
		"COMPLETING":                47,
		"RAN_INTERNAL_FAILURE":      48,
		"DUT_FAILURE":               49,
		"BOT_DISAPPEARED":           50,
		"PREEMPTED":                 51,
		"COMPLETED":                 64,
		"TIMED_OUT":                 65,
		"TIMED_OUT_SILENCE":         66,
		"KILLED":                    67,
		"MISSING_INPUTS":            68,
		"DEDUPED":                   80,
		"EXPIRED":                   81,
		"CANCELED":                  82,
		"NO_RESOURCE":               83,
		"LOAD_SHED":                 84,
		"RESOURCE_EXHAUSTED":        85,
		"SKIPPED_INTERNAL_FAILURE":  86,
		"CLIENT_ERROR":              87,
	}
)

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

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

func (TaskState) Descriptor() protoreflect.EnumDescriptor {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_enumTypes[4].Descriptor()
}

func (TaskState) Type() protoreflect.EnumType {
	return &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_enumTypes[4]
}

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

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

type Containment_ContainmentType int32

const (
	// Historical value, not specified. Containment may or may not be used.
	Containment_NOT_SPECIFIED Containment_ContainmentType = 0
	// No containment, the default for now.
	Containment_NONE Containment_ContainmentType = 1
	// Use the containment appropriate on the platform.
	Containment_AUTO Containment_ContainmentType = 2
	// Use Job Object on Windows. Will fail if used on other platforms.
	Containment_JOB_OBJECT Containment_ContainmentType = 3
)

// Enum value maps for Containment_ContainmentType.
var (
	Containment_ContainmentType_name = map[int32]string{
		0: "NOT_SPECIFIED",
		1: "NONE",
		2: "AUTO",
		3: "JOB_OBJECT",
	}
	Containment_ContainmentType_value = map[string]int32{
		"NOT_SPECIFIED": 0,
		"NONE":          1,
		"AUTO":          2,
		"JOB_OBJECT":    3,
	}
)

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

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

func (Containment_ContainmentType) Descriptor() protoreflect.EnumDescriptor {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_enumTypes[5].Descriptor()
}

func (Containment_ContainmentType) Type() protoreflect.EnumType {
	return &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_enumTypes[5]
}

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

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

// Request for BotAPI.Events.
type BotEventsRequest struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Required. Bot ID to retrieve results from.
	BotId string `protobuf:"bytes,1,opt,name=bot_id,json=botId,proto3" json:"bot_id,omitempty"`
	// Optional. Use this field to specify the maximum number of results to be
	// returned by the server.
	//
	// The server may further constrain the maximum number of results returned in
	// a single page. If the page_size is 0, the server will decide the number of
	// results to be returned.
	PageSize int32 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
	// Optional. Use this field to request a specific page of the list results,
	// following a previous call.
	//
	// When specified, page_size, start_time and end_time must match exactly the
	// previous call's argument.
	PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
	// Optional. Earliest time to return bot event. Inclusive.
	//
	// If not specified, pagination is done until all events are returned.
	StartTime *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
	// Optional. Most recent time to return bot event. Exclusive.
	//
	// If not specified, defaults to the current time.
	EndTime *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
}

func (x *BotEventsRequest) Reset() {
	*x = BotEventsRequest{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[0]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*BotEventsRequest) ProtoMessage() {}

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

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

func (x *BotEventsRequest) GetBotId() string {
	if x != nil {
		return x.BotId
	}
	return ""
}

func (x *BotEventsRequest) GetPageSize() int32 {
	if x != nil {
		return x.PageSize
	}
	return 0
}

func (x *BotEventsRequest) GetPageToken() string {
	if x != nil {
		return x.PageToken
	}
	return ""
}

func (x *BotEventsRequest) GetStartTime() *timestamppb.Timestamp {
	if x != nil {
		return x.StartTime
	}
	return nil
}

func (x *BotEventsRequest) GetEndTime() *timestamppb.Timestamp {
	if x != nil {
		return x.EndTime
	}
	return nil
}

// Response of BotAPI.Events.
type BotEventsResponse struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Events are in reverse chronological order, most recents first and going
	// down to older events.
	Events []*BotEvent `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"`
	// This field represents the pagination token to retrieve the next page of
	// results. If the value is "", it means no further results for the request.
	NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
}

func (x *BotEventsResponse) Reset() {
	*x = BotEventsResponse{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[1]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*BotEventsResponse) ProtoMessage() {}

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

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

func (x *BotEventsResponse) GetEvents() []*BotEvent {
	if x != nil {
		return x.Events
	}
	return nil
}

func (x *BotEventsResponse) GetNextPageToken() string {
	if x != nil {
		return x.NextPageToken
	}
	return ""
}

// Represents a mapping of string to a string.
//
// The same as a map<key, value>, except that the encoding is deterministic.
//
// If the StringPair is itself repeated inside another message, the list
// must be sorted by key and the keys must be unique.
type StringPair struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Key   string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

func (x *StringPair) Reset() {
	*x = StringPair{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[2]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*StringPair) ProtoMessage() {}

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

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

func (x *StringPair) GetKey() string {
	if x != nil {
		return x.Key
	}
	return ""
}

func (x *StringPair) GetValue() string {
	if x != nil {
		return x.Value
	}
	return ""
}

// Represents a mapping of string to a list of strings.
//
// The same as a map<key, repeated values>, except that the encoding is
// deterministic.
//
// If the StringListPair is itself repeated inside another message, the list
// must be sorted by key and the keys must be unique.
type StringListPair struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// All the values for this key. values must be sorted. Human readable.
	//
	// This string should make sense to a user in the context of 'key'.
	Values []string `protobuf:"bytes,2,rep,name=values,proto3" json:"values,omitempty"`
}

func (x *StringListPair) Reset() {
	*x = StringListPair{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[3]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*StringListPair) ProtoMessage() {}

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

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

func (x *StringListPair) GetKey() string {
	if x != nil {
		return x.Key
	}
	return ""
}

func (x *StringListPair) GetValues() []string {
	if x != nil {
		return x.Values
	}
	return nil
}

// Bot describes a Swarming bot.
//
// Because a Swarming bot is a single execution unit unlike RBE, it doesn't have
// a concept of owned device at the moment. This may change later.
type Bot struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Bot ID. It must be unique across the Swarming fleet. Generally based on the
	// hostname where the bot runs, but that's not a requirement. Must be
	// predefined in bots.cfg.
	//
	// This value is also included in dimensions for the key 'id'.
	BotId string `protobuf:"bytes,1,opt,name=bot_id,json=botId,proto3" json:"bot_id,omitempty"`
	// Bot session ID. An opaque value.
	//
	// There is one bot session ID per bot process ID on the host. When the bot
	// self-upgrades, it creates a new bot session ID.
	SessionId string `protobuf:"bytes,2,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"` // Not used yet. https://crbug.com/786735
	// Pools that this bot belongs to. Normally assigned via bots.cfg. The
	// pools must be defined in pools.cfg.
	//
	// Normally a bot shall belong to a single pool, but belonging to multiple
	// pool is allowed. This is generally helpful for transitioning bots.
	//
	// This value is also included in dimensions for the key 'pool'.
	Pools []string `protobuf:"bytes,3,rep,name=pools,proto3" json:"pools,omitempty"`
	// Current bot status. A bot status is a state in which the bot is for a
	// certain amount of time.
	Status BotStatusType `protobuf:"varint,4,opt,name=status,proto3,enum=swarming.v1.BotStatusType" json:"status,omitempty"`
	// Supplemental information to describe the bot status. Human readable.
	//
	// See BotStatusType for the meaning of this string for each status.
	StatusMsg string `protobuf:"bytes,5,opt,name=status_msg,json=statusMsg,proto3" json:"status_msg,omitempty"`
	// Current task being handled by the bot, if there is one.
	//
	// In Swarming, only a single task can be assigned to a bot at any given time.
	CurrentTaskId string `protobuf:"bytes,6,opt,name=current_task_id,json=currentTaskId,proto3" json:"current_task_id,omitempty"`
	// Bot reported dimensions. dimensions is a {key: [values]} dictionary. This
	// can be used to declare the properties of the host or for the DUT (Device
	// Under Test) under control. This is used for task selection.
	//
	// In RBE, this is called Property. The difference is that RBE's Property is a
	// string:string flat dictionary, it doesn't allow repeated values.
	//
	// https://chromium.googlesource.com/infra/luci/luci-py.git/+/master/appengine/swarming/doc/Detailed-Design.md#bot-dimensions
	//
	// dimensions MUST be sorted by keys, and each values list must be sorted.
	// Each dimension key must be unique.
	//
	// The values are effectively an OR, a task may match any of the value.
	//
	// Human readable.
	Dimensions []*StringListPair `protobuf:"bytes,7,rep,name=dimensions,proto3" json:"dimensions,omitempty"`
	// Bot reported informational state. This can be used to describe the host,
	// the bot itself and the DUT (Device Under Test) under control as applicable.
	//
	// This is NOT used for task selection.
	Info *BotInfo `protobuf:"bytes,8,opt,name=info,proto3" json:"info,omitempty"`
}

func (x *Bot) Reset() {
	*x = Bot{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[4]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*Bot) ProtoMessage() {}

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

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

func (x *Bot) GetBotId() string {
	if x != nil {
		return x.BotId
	}
	return ""
}

func (x *Bot) GetSessionId() string {
	if x != nil {
		return x.SessionId
	}
	return ""
}

func (x *Bot) GetPools() []string {
	if x != nil {
		return x.Pools
	}
	return nil
}

func (x *Bot) GetStatus() BotStatusType {
	if x != nil {
		return x.Status
	}
	return BotStatusType_BOT_STATUS_UNSPECIFIED
}

func (x *Bot) GetStatusMsg() string {
	if x != nil {
		return x.StatusMsg
	}
	return ""
}

func (x *Bot) GetCurrentTaskId() string {
	if x != nil {
		return x.CurrentTaskId
	}
	return ""
}

func (x *Bot) GetDimensions() []*StringListPair {
	if x != nil {
		return x.Dimensions
	}
	return nil
}

func (x *Bot) GetInfo() *BotInfo {
	if x != nil {
		return x.Info
	}
	return nil
}

// Bot reported informational state. This can be used to describe the host,
// the bot itself and the DUT (Device Under Test) under control as applicable.
//
// This is NOT used for task selection.
type BotInfo struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// supplemental contains the free form JSON data that includes interesting
	// information about the bot that doesn't fit in any of the fields below.
	//
	// Anything that is usable by multiple customers should eventually be moved to
	// a new field below.
	Supplemental *structpb.Struct `protobuf:"bytes,1,opt,name=supplemental,proto3" json:"supplemental,omitempty"`
	// Bot's version. An opaque value.
	//
	// This value is Swarming instance and configuration dependent. Bot are
	// updated through the process described at
	// https://chromium.googlesource.com/infra/luci/luci-py.git/+/master/appengine/swarming/doc/Bot.md#update
	Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
	// External IP address as visible by the server.
	//
	// This could be a NAT'ing router external IP.
	//
	// Can be either IPv4 or IPv6.
	ExternalIp string `protobuf:"bytes,3,opt,name=external_ip,json=externalIp,proto3" json:"external_ip,omitempty"`
	// Authentication identity that the bot identified as. An opaque value.
	AuthenticatedAs string `protobuf:"bytes,4,opt,name=authenticated_as,json=authenticatedAs,proto3" json:"authenticated_as,omitempty"`
	// State of the content addressed cache on the bot. This is used for inputs
	// files.
	CasStats *CASStats `protobuf:"bytes,5,opt,name=cas_stats,json=casStats,proto3" json:"cas_stats,omitempty"`
	// State of the named caches (used by incremental tasks) on the bot. This is
	// used for task that benefits from incrementality, like builds.
	//
	// Should be sorted by name.
	NamedCachesStats []*NamedCacheStats `protobuf:"bytes,6,rep,name=named_caches_stats,json=namedCachesStats,proto3" json:"named_caches_stats,omitempty"`
	// State of the CIPD packages cache on the bot. This is use for installable,
	// versioned packages.
	//
	// Should be sorted by package name, then version.
	CipdPackagesCacheStats []*CIPDPackageCacheStats `protobuf:"bytes,7,rep,name=cipd_packages_cache_stats,json=cipdPackagesCacheStats,proto3" json:"cipd_packages_cache_stats,omitempty"`
	// Information about the host.
	Host *PhysicalEntity `protobuf:"bytes,8,opt,name=host,proto3" json:"host,omitempty"`
	// Information about the devices connected to the host.
	//
	// This can be the DUT (Device Under Test) or other peripherals.
	Devices []*PhysicalEntity `protobuf:"bytes,9,rep,name=devices,proto3" json:"devices,omitempty"`
	// This field is used in BOT_MISSING event to know the timestamp of the last activity.
	LastSeenTs *timestamppb.Timestamp `protobuf:"bytes,10,opt,name=last_seen_ts,json=lastSeenTs,proto3" json:"last_seen_ts,omitempty"`
	// The time when the bot became idle.
	IdleSinceTs *timestamppb.Timestamp `protobuf:"bytes,11,opt,name=idle_since_ts,json=idleSinceTs,proto3" json:"idle_since_ts,omitempty"`
}

func (x *BotInfo) Reset() {
	*x = BotInfo{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[5]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*BotInfo) ProtoMessage() {}

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

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

func (x *BotInfo) GetSupplemental() *structpb.Struct {
	if x != nil {
		return x.Supplemental
	}
	return nil
}

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

func (x *BotInfo) GetExternalIp() string {
	if x != nil {
		return x.ExternalIp
	}
	return ""
}

func (x *BotInfo) GetAuthenticatedAs() string {
	if x != nil {
		return x.AuthenticatedAs
	}
	return ""
}

func (x *BotInfo) GetCasStats() *CASStats {
	if x != nil {
		return x.CasStats
	}
	return nil
}

func (x *BotInfo) GetNamedCachesStats() []*NamedCacheStats {
	if x != nil {
		return x.NamedCachesStats
	}
	return nil
}

func (x *BotInfo) GetCipdPackagesCacheStats() []*CIPDPackageCacheStats {
	if x != nil {
		return x.CipdPackagesCacheStats
	}
	return nil
}

func (x *BotInfo) GetHost() *PhysicalEntity {
	if x != nil {
		return x.Host
	}
	return nil
}

func (x *BotInfo) GetDevices() []*PhysicalEntity {
	if x != nil {
		return x.Devices
	}
	return nil
}

func (x *BotInfo) GetLastSeenTs() *timestamppb.Timestamp {
	if x != nil {
		return x.LastSeenTs
	}
	return nil
}

func (x *BotInfo) GetIdleSinceTs() *timestamppb.Timestamp {
	if x != nil {
		return x.IdleSinceTs
	}
	return nil
}

// PhysicalEntity includes information about an host or device.
//
// This can be the host where the bot runs, or a device under control of the
// bot.
//
// If the bot runs inside a docker container, this information is about the
// container, or whatever the bot can observe from its vantage point.
type PhysicalEntity struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Name that represents this physical entity.
	//
	// For a host, it shall be the hostname. For a device, it should be the device
	// hostname, if any. Failing that, something that makes sense to the users.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// supplemental contains the free form JSON data that includes interesting
	// information about the device that doesn't fit in any of the fields below.
	//
	// Anything that is usable by multiple customers should eventually be moved to
	// a new field below.
	Supplemental *structpb.Struct `protobuf:"bytes,2,opt,name=supplemental,proto3" json:"supplemental,omitempty"`
	// IP address as visible by the bot process (bot_main) itself.
	//
	// In the case of the host, it will be one of the IP addresses assigned to it.
	// In the case of the host where the bot is running inside docker, it will be
	// the IP address assigned to the docker container.
	// In the case of a device, it is the IP address of the device, if any.
	//
	// Can be either IPv4 or IPv6.
	Ip string `protobuf:"bytes,3,opt,name=ip,proto3" json:"ip,omitempty"`
}

func (x *PhysicalEntity) Reset() {
	*x = PhysicalEntity{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[6]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*PhysicalEntity) ProtoMessage() {}

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

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

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

func (x *PhysicalEntity) GetSupplemental() *structpb.Struct {
	if x != nil {
		return x.Supplemental
	}
	return nil
}

func (x *PhysicalEntity) GetIp() string {
	if x != nil {
		return x.Ip
	}
	return ""
}

// Bot local content addressed cache information.
type CASStats struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	NumberItems int64                  `protobuf:"varint,1,opt,name=number_items,json=numberItems,proto3" json:"number_items,omitempty"`
	Size        int64                  `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"`
	OldestTime  *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=oldest_time,json=oldestTime,proto3" json:"oldest_time,omitempty"`
}

func (x *CASStats) Reset() {
	*x = CASStats{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[7]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*CASStats) ProtoMessage() {}

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

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

func (x *CASStats) GetNumberItems() int64 {
	if x != nil {
		return x.NumberItems
	}
	return 0
}

func (x *CASStats) GetSize() int64 {
	if x != nil {
		return x.Size
	}
	return 0
}

func (x *CASStats) GetOldestTime() *timestamppb.Timestamp {
	if x != nil {
		return x.OldestTime
	}
	return nil
}

// Bot local named cache information.
type NamedCacheStats struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Name        string                 `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Size        int64                  `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"`
	LastUseTime *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=last_use_time,json=lastUseTime,proto3" json:"last_use_time,omitempty"`
}

func (x *NamedCacheStats) Reset() {
	*x = NamedCacheStats{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[8]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*NamedCacheStats) ProtoMessage() {}

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

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

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

func (x *NamedCacheStats) GetSize() int64 {
	if x != nil {
		return x.Size
	}
	return 0
}

func (x *NamedCacheStats) GetLastUseTime() *timestamppb.Timestamp {
	if x != nil {
		return x.LastUseTime
	}
	return nil
}

// Bot local CIPD package cache information.
type CIPDPackageCacheStats struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Name        string                 `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Version     string                 `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
	Size        int64                  `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"`
	LastUseTime *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=last_use_time,json=lastUseTime,proto3" json:"last_use_time,omitempty"`
}

func (x *CIPDPackageCacheStats) Reset() {
	*x = CIPDPackageCacheStats{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[9]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*CIPDPackageCacheStats) ProtoMessage() {}

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

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

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

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

func (x *CIPDPackageCacheStats) GetSize() int64 {
	if x != nil {
		return x.Size
	}
	return 0
}

func (x *CIPDPackageCacheStats) GetLastUseTime() *timestamppb.Timestamp {
	if x != nil {
		return x.LastUseTime
	}
	return nil
}

// BotEvent represents an event on the bot.
//
// This message is used both in the API and as a BigQuery table description for
// the table 'bot_events' in dataset 'swarming'.
type BotEvent struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	EventTime *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=event_time,json=eventTime,proto3" json:"event_time,omitempty"`
	// Snapshot of the Bot that had this event.
	//
	// Eventually we'd want to only snapshot the difference from the previous
	// event, but this would make the SQL queries much more complicated.
	Bot *Bot `protobuf:"bytes,2,opt,name=bot,proto3" json:"bot,omitempty"`
	// Type of state change (event) that trigger this message.
	Event BotEventType `protobuf:"varint,3,opt,name=event,proto3,enum=swarming.v1.BotEventType" json:"event,omitempty"`
	// Supplementation information to describe the bot event. Human readable.
	//
	// See BotEventType for the meaning of this string for each status.
	EventMsg string `protobuf:"bytes,4,opt,name=event_msg,json=eventMsg,proto3" json:"event_msg,omitempty"`
}

func (x *BotEvent) Reset() {
	*x = BotEvent{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[10]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*BotEvent) ProtoMessage() {}

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

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

func (x *BotEvent) GetEventTime() *timestamppb.Timestamp {
	if x != nil {
		return x.EventTime
	}
	return nil
}

func (x *BotEvent) GetBot() *Bot {
	if x != nil {
		return x.Bot
	}
	return nil
}

func (x *BotEvent) GetEvent() BotEventType {
	if x != nil {
		return x.Event
	}
	return BotEventType_BOT_EVENT_TYPE_UNSPECIFIED
}

func (x *BotEvent) GetEventMsg() string {
	if x != nil {
		return x.EventMsg
	}
	return ""
}

// Defines a Content Addressed Storage (a cache in practice) data tree
// reference, normally a reference to a .isolated file.
//
// Deprecated: Isoalte server is being migrated to RBE-CAS. Use `CASReference`
// for the digest on RBE-CAS.
//
// This can be used to refer to either a task's inputs or a task's outputs.
//
// The .isolated file format is defined at
// https://chromium.googlesource.com/infra/luci/luci-py.git/+/master/appengine/isolate/doc/Design.md#file-format
// It is a JSON file listing all the inputs.
//
// It is very different RBE's CAS format, which uses a merkel tree of protobuf
// files.
type CASTree struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// server is one of:
	//   - The isolated server to fetch (or push) content from. Must contain
	//     "https://" or "http://" prefix.
	//   - The Google Cloud Project name hosting the RBE CAS.
	Server string `protobuf:"bytes,1,opt,name=server,proto3" json:"server,omitempty"`
	// The hex encoded hash of an isolated archive. It is expected to be a SHA-1
	// (40 characters) or SHA-256 (64 characters), based on the namespace value
	// below.
	Digest string `protobuf:"bytes,2,opt,name=digest,proto3" json:"digest,omitempty"`
	// Namespace on the isolate server. This currently defines the hashing
	// algorithm and compression algorithm but is currently loosely defined.
	//
	// A prefix "sha256-" defines a SHA-256 hashing. Defaults to SHA-1.
	// A suffix "-deflate" or "-gzip" defines a deflate algorithm.
	//
	// When referring to a RBE CAS instance, the namespace must be set to
	// "sha256-GCP". The GCP RBE CAS requires SHA-256 and doesn't support
	// precompressed data.
	Namespace string `protobuf:"bytes,3,opt,name=namespace,proto3" json:"namespace,omitempty"`
}

func (x *CASTree) Reset() {
	*x = CASTree{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[11]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*CASTree) ProtoMessage() {}

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

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

func (x *CASTree) GetServer() string {
	if x != nil {
		return x.Server
	}
	return ""
}

func (x *CASTree) GetDigest() string {
	if x != nil {
		return x.Digest
	}
	return ""
}

func (x *CASTree) GetNamespace() string {
	if x != nil {
		return x.Namespace
	}
	return ""
}

type Digest struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// This is a [Digest][build.bazel.remote.execution.v2.Digest] of a blob on
	// RBE-CAS. See the explanations at the original definition.
	// https://github.com/bazelbuild/remote-apis/blob/77cfb44a88577a7ade5dd2400425f6d50469ec6d/build/bazel/remote/execution/v2/remote_execution.proto#L753-L791
	Hash      string `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	SizeBytes int64  `protobuf:"varint,2,opt,name=size_bytes,json=sizeBytes,proto3" json:"size_bytes,omitempty"`
}

func (x *Digest) Reset() {
	*x = Digest{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[12]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*Digest) ProtoMessage() {}

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

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

func (x *Digest) GetHash() string {
	if x != nil {
		return x.Hash
	}
	return ""
}

func (x *Digest) GetSizeBytes() int64 {
	if x != nil {
		return x.SizeBytes
	}
	return 0
}

type CASReference struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Full name of RBE-CAS instance. `projects/{project_id}/instances/{instance}`.
	// e.g. projects/chromium-swarm/instances/default_instance
	CasInstance string `protobuf:"bytes,1,opt,name=cas_instance,json=casInstance,proto3" json:"cas_instance,omitempty"`
	// CAS Digest consists of hash and size bytes.
	Digest *Digest `protobuf:"bytes,2,opt,name=digest,proto3" json:"digest,omitempty"`
}

func (x *CASReference) Reset() {
	*x = CASReference{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[13]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*CASReference) ProtoMessage() {}

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

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

func (x *CASReference) GetCasInstance() string {
	if x != nil {
		return x.CasInstance
	}
	return ""
}

func (x *CASReference) GetDigest() *Digest {
	if x != nil {
		return x.Digest
	}
	return nil
}

// Defines one CIPD package to install prior to running the task.
//
// CIPD packages are versioned and ACL'ed packages that are meant for tools that
// are kept for a long time.
type CIPDPackage struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// The template for the CIPD package name that will have its variables
	// evaluated, e.g. "infra/tools/authutil/${platform}".
	//
	// TODO(vadimsh): Link to documentation of the variable usable.
	PackageName string `protobuf:"bytes,1,opt,name=package_name,json=packageName,proto3" json:"package_name,omitempty"`
	// Valid package version for the requested package.
	Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
	// Path to directory relative to the task's root dir, where the package is to
	// be installed.
	//
	// If empty, the package will be installed at the root of the mapped
	// directory. If file names in the package and in the isolate clash, it will
	// cause a failure.
	DestPath string `protobuf:"bytes,3,opt,name=dest_path,json=destPath,proto3" json:"dest_path,omitempty"`
}

func (x *CIPDPackage) Reset() {
	*x = CIPDPackage{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[14]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*CIPDPackage) ProtoMessage() {}

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

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

func (x *CIPDPackage) GetPackageName() string {
	if x != nil {
		return x.PackageName
	}
	return ""
}

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

func (x *CIPDPackage) GetDestPath() string {
	if x != nil {
		return x.DestPath
	}
	return ""
}

// Describes a named cache that should be reused on the bot.
//
// A NamedCacheEntry in a task specifies that the task wants a directory to be
// persisted on the bot across tasks.
//
// The cache directory is created at <run_dir>/|path|. If the cache was not
// present on the bot prior the task's execution, the directory is empty when
// the task starts. Any change done in the directory by the task is persisted on
// the bot after the task completes.
//
// If another task runs on the same bot and requests the same named cache, even
// if mapped to a different path, it will get the updated content.
type NamedCacheEntry struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Unique name of the cache. Required. Length is limited to 4096.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Path to directory relative to the task's root dir, where the named cache is
	// to be installed.
	//
	// A path cannot be shared among multiple caches or CIPD installations.
	// A task will fail if a file/dir with the same name already exists.
	DestPath string `protobuf:"bytes,2,opt,name=dest_path,json=destPath,proto3" json:"dest_path,omitempty"`
}

func (x *NamedCacheEntry) Reset() {
	*x = NamedCacheEntry{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[15]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*NamedCacheEntry) ProtoMessage() {}

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

// Deprecated: Use NamedCacheEntry.ProtoReflect.Descriptor instead.
func (*NamedCacheEntry) Descriptor() ([]byte, []int) {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_rawDescGZIP(), []int{15}
}

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

func (x *NamedCacheEntry) GetDestPath() string {
	if x != nil {
		return x.DestPath
	}
	return ""
}

// Defines the type of containment to use to put the task primary process
// inside.
//
// TODO(maruel): https://crbug.com/808836
//
// This is highly OS specific:
//   - Lower the integrity level on Windows. https://crbug.com/916586
//   - Job Object on Windows. https://crbug.com/732818
//   - Docker on Linux or Windows. https://crbug.com/916584
//   - cgroup on Linux. https://crbug.com/764493
//   - Creating a temporary user on Windows and macOS. https://crbug.com/916585
//   - Lightweight home directory override on Windows, Linux and macOS.
//     https://crbug.com/811411
type Containment struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Lowers the priority of the task process when started. Doesn't require
	// containment. This gives the bot a chance to survive when the task starts an
	// overwhelming number of children processes.
	LowerPriority bool `protobuf:"varint,1,opt,name=lower_priority,json=lowerPriority,proto3" json:"lower_priority,omitempty"`
	// Defines the type of containment used.
	ContainmentType Containment_ContainmentType `protobuf:"varint,2,opt,name=containment_type,json=containmentType,proto3,enum=swarming.v1.Containment_ContainmentType" json:"containment_type,omitempty"`
	// Limits the number of concurrent active processes.
	LimitProcesses int64 `protobuf:"varint,3,opt,name=limit_processes,json=limitProcesses,proto3" json:"limit_processes,omitempty"`
	// Limits the total amount of memory allocated by processes.
	LimitTotalCommittedMemory int64 `protobuf:"varint,4,opt,name=limit_total_committed_memory,json=limitTotalCommittedMemory,proto3" json:"limit_total_committed_memory,omitempty"`
}

func (x *Containment) Reset() {
	*x = Containment{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[16]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*Containment) ProtoMessage() {}

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

// Deprecated: Use Containment.ProtoReflect.Descriptor instead.
func (*Containment) Descriptor() ([]byte, []int) {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_rawDescGZIP(), []int{16}
}

func (x *Containment) GetLowerPriority() bool {
	if x != nil {
		return x.LowerPriority
	}
	return false
}

func (x *Containment) GetContainmentType() Containment_ContainmentType {
	if x != nil {
		return x.ContainmentType
	}
	return Containment_NOT_SPECIFIED
}

func (x *Containment) GetLimitProcesses() int64 {
	if x != nil {
		return x.LimitProcesses
	}
	return 0
}

func (x *Containment) GetLimitTotalCommittedMemory() int64 {
	if x != nil {
		return x.LimitTotalCommittedMemory
	}
	return 0
}

// Defines the 'what' to run.
//
// A serialization of this message is hashed and this hash is what is used for
// task deduping.
// NEXT_ID: 20
type TaskProperties struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Isolated inputs to map in the working directory.
	//
	// Deprecated: Isolate server is being migrated to RBE-CAS. `cas_input_root`
	// will be used to reference to the input root on RBE-CAS.
	// Deprecated: the isolated file may optionally specify a command to run.
	// Otherwise, 'command' must be specified.
	CasInputs *CASTree `protobuf:"bytes,1,opt,name=cas_inputs,json=casInputs,proto3" json:"cas_inputs,omitempty"`
	// Digest of the input root on RBE-CAS.
	// cas_input_root.digest MUST be digest of [build.bazel.remote.execution.v2.Directory].
	CasInputRoot *CASReference `protobuf:"bytes,18,opt,name=cas_input_root,json=casInputRoot,proto3" json:"cas_input_root,omitempty"`
	// Defines the set of CIPD packages to install prior to running the task.
	//
	// These packages are meant to be software that is needed (a dependency) by
	// the task being run. Unlike isolated files from cas_inputs, the CIPD
	// packages do not expire from the server.
	//
	// Items must be sorted per the CIPD package name.
	CipdInputs []*CIPDPackage `protobuf:"bytes,2,rep,name=cipd_inputs,json=cipdInputs,proto3" json:"cipd_inputs,omitempty"`
	// Specifies named caches to map into the working directory. These caches
	// outlive the task, which can then be reused by tasks later used on this bot
	// that request the same named cache.
	//
	// Items must be sorted per the named cache name.
	NamedCaches []*NamedCacheEntry `protobuf:"bytes,3,rep,name=named_caches,json=namedCaches,proto3" json:"named_caches,omitempty"`
	// Command to run. This has priority over a command specified in the isolated
	// files.
	Command []string `protobuf:"bytes,4,rep,name=command,proto3" json:"command,omitempty"`
	// Relative working directory to start the 'command' in, defaults to the root
	// mapped directory or what is provided in the isolated file, if any.
	RelativeCwd string `protobuf:"bytes,5,opt,name=relative_cwd,json=relativeCwd,proto3" json:"relative_cwd,omitempty"`
	// Extraneous arguments to append to the command specified in the isolated
	// file. Can only be used when an isolated file specifies a command.
	//
	// Deprecated.
	ExtraArgs []string `protobuf:"bytes,6,rep,name=extra_args,json=extraArgs,proto3" json:"extra_args,omitempty"`
	// Secret bytes to provide to the task. Write only, cannot be retrieved back.
	SecretBytes []byte `protobuf:"bytes,7,opt,name=secret_bytes,json=secretBytes,proto3" json:"secret_bytes,omitempty"`
	// When retrieved back, has_secret_bytes is set to true.
	HasSecretBytes bool `protobuf:"varint,8,opt,name=has_secret_bytes,json=hasSecretBytes,proto3" json:"has_secret_bytes,omitempty"`
	// Dimensions are what is used to determine which bot can run the task.
	//
	// The values are effectively an AND, a bot must match all dimensions to be
	// selected to run the task.
	//
	// Items must be sorted.
	Dimensions []*StringListPair `protobuf:"bytes,9,rep,name=dimensions,proto3" json:"dimensions,omitempty"`
	// Environment variables to set when running the task.
	//
	// Items must be sorted.
	Env []*StringPair `protobuf:"bytes,10,rep,name=env,proto3" json:"env,omitempty"`
	// Task root relative paths to prepend to a given environment variable.
	//
	// This allows one to safely modify variables like PATH, PYTHONPATH, or other
	// PATH-like environment variables. The order of operations is:
	//   - Turn slashes into native-platform slashes
	//   - Make the path absolute
	//   - Prepend it to the current value of the envvar using the os-native list
	//     separator (`;` on Windows, `:` on POSIX)
	//
	// Each key can have multiple paths to prepend. They will be prepended in
	// the order seen here.
	//
	// For example, if env_paths is:
	//
	//	[ (key="PATH", values=["foo", "bar"]),
	//	  (key="CUSTOMPATH", values=["custom"]), ]
	//
	// The task would see:
	//
	//	PATH=/path/to/swarming/rundir/foo:/path/to/swarming/rundir/bar:$PATH
	//	CUSTOMPATH=/path/to/swarming/rundir/custom
	//
	// Paths must always be specified here with forward-slashes, and must not
	// attempt to escape the task's root (i.e. must not contain `..`).
	//
	// This is applied AFTER evaluating `env`.
	//
	// Items must be sorted by key, but exceptionally not by values.
	EnvPaths []*StringListPair `protobuf:"bytes,11,rep,name=env_paths,json=envPaths,proto3" json:"env_paths,omitempty"`
	// Declare what kind of containment shall be used to run the task process
	// in.
	Containment *Containment `protobuf:"bytes,12,opt,name=containment,proto3" json:"containment,omitempty"` // Not used yet. https://crbug.com/808836
	// Maximum number of seconds the task can run before its process is forcibly
	// terminated and the task results in TIMED_OUT.
	ExecutionTimeout *durationpb.Duration `protobuf:"bytes,13,opt,name=execution_timeout,json=executionTimeout,proto3" json:"execution_timeout,omitempty"`
	// Maximum number of seconds the task may be silent (no output to stdout nor
	// stderr) before it is considered hung and it forcibly terminated early and
	// the task results in TIMED_OUT_SILENCE.
	IoTimeout *durationpb.Duration `protobuf:"bytes,14,opt,name=io_timeout,json=ioTimeout,proto3" json:"io_timeout,omitempty"`
	// Number of second to give the child process after a SIGTERM before sending a
	// SIGKILL. See ../../doc/Bot.md#timeout-handling
	GracePeriod *durationpb.Duration `protobuf:"bytes,15,opt,name=grace_period,json=gracePeriod,proto3" json:"grace_period,omitempty"`
	// True if the task does not access any service through the network and is
	// believed to be certain to produce the same output given the same input. In
	// the case of a successful task, previous results will be reused if possible,
	// leading to DEDUPED task result for the tasks that could reuse previous
	// task's outcome.
	Idempotent bool `protobuf:"varint,16,opt,name=idempotent,proto3" json:"idempotent,omitempty"`
	// Paths in the working directory to archive back and store as
	// TaskResult.outputs.
	//
	// Items must be sorted.
	Outputs []string `protobuf:"bytes,17,rep,name=outputs,proto3" json:"outputs,omitempty"`
	// User to run the task as.
	User User `protobuf:"varint,19,opt,name=user,proto3,enum=swarming.v1.User" json:"user,omitempty"`
}

func (x *TaskProperties) Reset() {
	*x = TaskProperties{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[17]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*TaskProperties) ProtoMessage() {}

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

// Deprecated: Use TaskProperties.ProtoReflect.Descriptor instead.
func (*TaskProperties) Descriptor() ([]byte, []int) {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_rawDescGZIP(), []int{17}
}

func (x *TaskProperties) GetCasInputs() *CASTree {
	if x != nil {
		return x.CasInputs
	}
	return nil
}

func (x *TaskProperties) GetCasInputRoot() *CASReference {
	if x != nil {
		return x.CasInputRoot
	}
	return nil
}

func (x *TaskProperties) GetCipdInputs() []*CIPDPackage {
	if x != nil {
		return x.CipdInputs
	}
	return nil
}

func (x *TaskProperties) GetNamedCaches() []*NamedCacheEntry {
	if x != nil {
		return x.NamedCaches
	}
	return nil
}

func (x *TaskProperties) GetCommand() []string {
	if x != nil {
		return x.Command
	}
	return nil
}

func (x *TaskProperties) GetRelativeCwd() string {
	if x != nil {
		return x.RelativeCwd
	}
	return ""
}

func (x *TaskProperties) GetExtraArgs() []string {
	if x != nil {
		return x.ExtraArgs
	}
	return nil
}

func (x *TaskProperties) GetSecretBytes() []byte {
	if x != nil {
		return x.SecretBytes
	}
	return nil
}

func (x *TaskProperties) GetHasSecretBytes() bool {
	if x != nil {
		return x.HasSecretBytes
	}
	return false
}

func (x *TaskProperties) GetDimensions() []*StringListPair {
	if x != nil {
		return x.Dimensions
	}
	return nil
}

func (x *TaskProperties) GetEnv() []*StringPair {
	if x != nil {
		return x.Env
	}
	return nil
}

func (x *TaskProperties) GetEnvPaths() []*StringListPair {
	if x != nil {
		return x.EnvPaths
	}
	return nil
}

func (x *TaskProperties) GetContainment() *Containment {
	if x != nil {
		return x.Containment
	}
	return nil
}

func (x *TaskProperties) GetExecutionTimeout() *durationpb.Duration {
	if x != nil {
		return x.ExecutionTimeout
	}
	return nil
}

func (x *TaskProperties) GetIoTimeout() *durationpb.Duration {
	if x != nil {
		return x.IoTimeout
	}
	return nil
}

func (x *TaskProperties) GetGracePeriod() *durationpb.Duration {
	if x != nil {
		return x.GracePeriod
	}
	return nil
}

func (x *TaskProperties) GetIdempotent() bool {
	if x != nil {
		return x.Idempotent
	}
	return false
}

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

func (x *TaskProperties) GetUser() User {
	if x != nil {
		return x.User
	}
	return User_USER_UNSPECIFIED
}

// Defines a possible task execution for a task request to be run on the
// Swarming infrastructure.
//
// When there is more than TaskSlice specified in TaskRequest, the second
// TaskSlice onwards represent possible fallbacks.
type TaskSlice struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// The property of the task to try to run.
	//
	// If there is no bot that can serve this properties.dimensions when this task
	// slice is enqueued, it is immediately denied. This can trigger if:
	// - There is no bot with these dimensions currently known (NO_RESOURCE).
	// - Bots that could run this task are either all missing or quarantined.
	Properties *TaskProperties `protobuf:"bytes,1,opt,name=properties,proto3" json:"properties,omitempty"`
	// If this task slice is not scheduled after waiting this long, the next one
	// will be processed.
	Expiration *durationpb.Duration `protobuf:"bytes,2,opt,name=expiration,proto3" json:"expiration,omitempty"`
	// When a task is scheduled and there are currently no bots available to run
	// the task, the TaskSlice can either be PENDING, or be denied immediately.
	// When denied, the next TaskSlice is enqueued, and if there's no following
	// TaskSlice, the task state is set to NO_RESOURCE. This should normally be
	// set to False to avoid unnecessary waiting.
	WaitForCapacity bool `protobuf:"varint,3,opt,name=wait_for_capacity,json=waitForCapacity,proto3" json:"wait_for_capacity,omitempty"`
	// Digest of a serialized form of TaskProperties.
	//
	// This is used for DEDUPED and PENDING_DEDUPING when idempotent is true.
	// Consider this value as opaque string, only use to check equality.
	//
	// It is set even if idempotent is false.
	PropertiesHash string `protobuf:"bytes,4,opt,name=properties_hash,json=propertiesHash,proto3" json:"properties_hash,omitempty"`
}

func (x *TaskSlice) Reset() {
	*x = TaskSlice{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[18]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*TaskSlice) ProtoMessage() {}

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

// Deprecated: Use TaskSlice.ProtoReflect.Descriptor instead.
func (*TaskSlice) Descriptor() ([]byte, []int) {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_rawDescGZIP(), []int{18}
}

func (x *TaskSlice) GetProperties() *TaskProperties {
	if x != nil {
		return x.Properties
	}
	return nil
}

func (x *TaskSlice) GetExpiration() *durationpb.Duration {
	if x != nil {
		return x.Expiration
	}
	return nil
}

func (x *TaskSlice) GetWaitForCapacity() bool {
	if x != nil {
		return x.WaitForCapacity
	}
	return false
}

func (x *TaskSlice) GetPropertiesHash() string {
	if x != nil {
		return x.PropertiesHash
	}
	return ""
}

// This message is used to create a new task and can be retrieved back, except
// for a few write-only fields.
//
// A TaskRequest is immutable, it cannot be updated once created.
type TaskRequest struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// List of TaskSlice, along with their scheduling parameters.
	//
	// This defines all the various possible task execution for a task request to
	// be run on the Swarming infrastructure. They are processed in order, and it
	// is guaranteed that at most one of these will be processed.
	//
	// At least one must be specified, and a maximum number of 8 can be included.
	TaskSlices []*TaskSlice `protobuf:"bytes,1,rep,name=task_slices,json=taskSlices,proto3" json:"task_slices,omitempty"`
	// Task priority, the lower the more important.
	//
	// Valid values are between 1 and 255.
	Priority int32 `protobuf:"varint,2,opt,name=priority,proto3" json:"priority,omitempty"`
	// Defines what OAuth2 credentials the task uses when calling other services.
	//
	// Possible values are:
	//   - 'none': do not use a task service account at all, this is the default.
	//   - 'bot': use bot's own account, works only if bots authenticate with
	//     OAuth2.
	//   - <some email>: use this specific service account if it is allowed in the
	//     pool (via 'allowed_service_account' pools.cfg setting) and configured
	//     in the token server's service_accounts.cfg.
	//
	// Note that the service account name is specified outside of task properties,
	// and thus it is possible to have two tasks with different service accounts,
	// but identical properties hash (so one can be deduped). If this is
	// unsuitable use 'idempotent=False' or include a service account name in
	// properties separately.
	ServiceAccount string `protobuf:"bytes,3,opt,name=service_account,json=serviceAccount,proto3" json:"service_account,omitempty"`
	// When the task was created.
	CreateTime *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=create_time,json=createTime,proto3" json:"create_time,omitempty"`
	// Task name for display purpose.
	//
	// Note: this value is not indexed. If you want to be able to query for tasks
	// based on names, use tags below.
	Name string `protobuf:"bytes,5,opt,name=name,proto3" json:"name,omitempty"`
	// Tags are 'key:value' strings that describes what the task is about (it's
	// semantic meaning).
	//
	// It is fine to reuse the same 'key' multiple times. It is not fine to use a
	// key that is also used as a dimension.
	//
	// The tags are indexed, thus can be used for search with exact matches.
	//
	// Items must be sorted.
	Tags []string `protobuf:"bytes,6,rep,name=tags,proto3" json:"tags,omitempty"`
	// User for this task is run, if relevant. Not validated.
	User string `protobuf:"bytes,7,opt,name=user,proto3" json:"user,omitempty"`
	// Authenticated client that triggered this task.
	Authenticated string `protobuf:"bytes,13,opt,name=authenticated,proto3" json:"authenticated,omitempty"`
	// Task realm is used to control who can interact with the task e.g. get,
	// cancel etc, and which task service accounts can be used in the realm.
	Realm string `protobuf:"bytes,14,opt,name=realm,proto3" json:"realm,omitempty"`
	// Swarming:ResultDB integration configuration for a task.
	Resultdb *ResultDBCfg `protobuf:"bytes,15,opt,name=resultdb,proto3" json:"resultdb,omitempty"`
	// The task request ID.
	//
	// The request wasn't "run" so it is the same ID as the summary (ending with
	// '0').
	TaskId string `protobuf:"bytes,8,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
	// Parent Swarming task summary ID of the process requesting this task.
	//
	// This points to the TaskResult.task_id (ending with '0'). Note that an
	// idempotent task can be automatically retried by Swarming, which may result
	// in two TaskResult with the same task_id but different run_id.
	//
	// This field is read-only and derived from parent_run_id. It cannot be
	// specified at task creation.
	ParentTaskId string `protobuf:"bytes,9,opt,name=parent_task_id,json=parentTaskId,proto3" json:"parent_task_id,omitempty"`
	// Parent Swarming task run ID of the process requesting this task.
	//
	// This field is set on the children tasks when a Swarming task creates
	// children Swarming tasks.
	//
	// This points to the TaskResult.run_id (ending with '1', '2' or more).
	ParentRunId string `protobuf:"bytes,11,opt,name=parent_run_id,json=parentRunId,proto3" json:"parent_run_id,omitempty"`
	// Root task id, independent of the depth of recursive tasks.
	RootTaskId string `protobuf:"bytes,16,opt,name=root_task_id,json=rootTaskId,proto3" json:"root_task_id,omitempty"`
	// Root task run id, independent of the depth of recursive tasks.
	RootRunId string `protobuf:"bytes,17,opt,name=root_run_id,json=rootRunId,proto3" json:"root_run_id,omitempty"`
	// Send notification to this pubsub topic for updates of this task.
	PubsubNotification *PubSub `protobuf:"bytes,10,opt,name=pubsub_notification,json=pubsubNotification,proto3" json:"pubsub_notification,omitempty"`
	// Maximum delay between bot pings before the bot is considered dead
	// while running a task.
	//
	// When a task is running, the bot sends update to the server every
	// few seconds. In some cases, like when the system is overloaded,
	// the bot may be preempted and delayed in sending its updates.
	// After the delay specified here, the server will claim the bot to
	// be dead and will forcibly abort the task as BOT_DIED. This is to
	// catch system wide issues like a BSOD.
	BotPingTolerance *durationpb.Duration `protobuf:"bytes,12,opt,name=bot_ping_tolerance,json=botPingTolerance,proto3" json:"bot_ping_tolerance,omitempty"`
}

func (x *TaskRequest) Reset() {
	*x = TaskRequest{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[19]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*TaskRequest) ProtoMessage() {}

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

// Deprecated: Use TaskRequest.ProtoReflect.Descriptor instead.
func (*TaskRequest) Descriptor() ([]byte, []int) {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_rawDescGZIP(), []int{19}
}

func (x *TaskRequest) GetTaskSlices() []*TaskSlice {
	if x != nil {
		return x.TaskSlices
	}
	return nil
}

func (x *TaskRequest) GetPriority() int32 {
	if x != nil {
		return x.Priority
	}
	return 0
}

func (x *TaskRequest) GetServiceAccount() string {
	if x != nil {
		return x.ServiceAccount
	}
	return ""
}

func (x *TaskRequest) GetCreateTime() *timestamppb.Timestamp {
	if x != nil {
		return x.CreateTime
	}
	return nil
}

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

func (x *TaskRequest) GetTags() []string {
	if x != nil {
		return x.Tags
	}
	return nil
}

func (x *TaskRequest) GetUser() string {
	if x != nil {
		return x.User
	}
	return ""
}

func (x *TaskRequest) GetAuthenticated() string {
	if x != nil {
		return x.Authenticated
	}
	return ""
}

func (x *TaskRequest) GetRealm() string {
	if x != nil {
		return x.Realm
	}
	return ""
}

func (x *TaskRequest) GetResultdb() *ResultDBCfg {
	if x != nil {
		return x.Resultdb
	}
	return nil
}

func (x *TaskRequest) GetTaskId() string {
	if x != nil {
		return x.TaskId
	}
	return ""
}

func (x *TaskRequest) GetParentTaskId() string {
	if x != nil {
		return x.ParentTaskId
	}
	return ""
}

func (x *TaskRequest) GetParentRunId() string {
	if x != nil {
		return x.ParentRunId
	}
	return ""
}

func (x *TaskRequest) GetRootTaskId() string {
	if x != nil {
		return x.RootTaskId
	}
	return ""
}

func (x *TaskRequest) GetRootRunId() string {
	if x != nil {
		return x.RootRunId
	}
	return ""
}

func (x *TaskRequest) GetPubsubNotification() *PubSub {
	if x != nil {
		return x.PubsubNotification
	}
	return nil
}

func (x *TaskRequest) GetBotPingTolerance() *durationpb.Duration {
	if x != nil {
		return x.BotPingTolerance
	}
	return nil
}

// PubSub is a Cloud Pub/Sub topic to send task updates to.
//
// For this to work, the Swarming's AppEngine service account must have
// roles/pubsub.publisher role on the Cloud Pub/Sub topic.
//
// For a Swarming instance "FOOBAR.appspot.com", the service account to grant
// publisher right is "FOOBAR@@appspot.gserviceaccount.com".
//
// This is described at https://cloud.google.com/pubsub/docs/access-control.
//
// To grant Swarming instance FOOBAR.appspot.com publisher rights to topic
// projects/PROJ/topics/TOP, use:
//
//	gcloud beta pubsub topics add-iam-policy-binding \
//	    TOP \
//	    --project PROJ \
//	    --member serviceAccount:FOOBAR@appspot.gserviceaccount.com \
//	    --role roles/pubsub.publisher
//
// See https://cloud.google.com/pubsub/docs/authentication for more
// information.
type PubSub struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Full topic name to post task state updates to, e.g.
	// "projects/<id>/topics/<id>".
	Topic string `protobuf:"bytes,1,opt,name=topic,proto3" json:"topic,omitempty"`
	// Secret string to put into "auth_token" attribute of PubSub messages.
	//
	// This value is write only, it cannot be retrieved back.
	AuthToken string `protobuf:"bytes,2,opt,name=auth_token,json=authToken,proto3" json:"auth_token,omitempty"`
	// String to put into "userdata" attribute of PubSub messages.
	Userdata string `protobuf:"bytes,3,opt,name=userdata,proto3" json:"userdata,omitempty"`
}

func (x *PubSub) Reset() {
	*x = PubSub{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[20]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*PubSub) ProtoMessage() {}

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

// Deprecated: Use PubSub.ProtoReflect.Descriptor instead.
func (*PubSub) Descriptor() ([]byte, []int) {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_rawDescGZIP(), []int{20}
}

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

func (x *PubSub) GetAuthToken() string {
	if x != nil {
		return x.AuthToken
	}
	return ""
}

func (x *PubSub) GetUserdata() string {
	if x != nil {
		return x.Userdata
	}
	return ""
}

// TaskResult is the result of a TaskRequest as it is processed by Swarming.
//
// The TaskResult represents one attempt (run on a bot) and/or the final result
// (summary). When the task never ran (for example EXPIRED), there's one summary
// but no run.
//
// An idempotent task can be automatically retried by Swarming, which may result
// in two TaskResult with the same task_id but different run_id; two runs, one
// summary.
//
// A retry is done when a task fails with a retriable error (for example with
// RAN_INTERNAL_FAILURE). For the client's perspective when looking at the
// summary (ID ending with '0'), the task went from PENDING to RUNNING and then
// back to PENDING.
//
// When stored in BigQuery in table task_result_run and task_results_summary,
// on-going tasks are in the __NULL__ partition since end_time is unset.
//
// There's a risk of duplicate rows because BigQuery is eventually consistent
// with regards to duplicate rows. Set your filter to ignore the __NULL__
// partition to enforce strong consistency and ignore on-going tasks. See
// https://cloud.google.com/bigquery/streaming-data-into-bigquery#dataconsistency
// for more information.
// NEXT_ID: 23
type TaskResult struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Request *TaskRequest `protobuf:"bytes,1,opt,name=request,proto3" json:"request,omitempty"`
	// Time the task was requested.
	CreateTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=create_time,json=createTime,proto3" json:"create_time,omitempty"`
	// Time the task started being run by a bot, before RUNNING_OVERHEAD_SETUP.
	//
	// Doing "start_time - create_time" gives the task pending time.
	StartTime *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
	// Time when the task was abandoned instead of normal completion.
	//
	// This happens for example when a task was KILLED, this then represents the
	// time a client requested the task to be killed, which is before end_time.
	// Same for TIMED_OUT state, this then represents the time when the bot
	// decided to abort the task.
	AbandonTime *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=abandon_time,json=abandonTime,proto3" json:"abandon_time,omitempty"`
	// Time the task completed and teared down, after RUNNING_OVERHEAD_TEARDOWN.
	//
	// Doing "end_time - start_time" will not lead to the exact task duration,
	// since this time frame includes overheads.
	EndTime *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
	// Duration of the task. This excludes overheads.
	Duration *durationpb.Duration `protobuf:"bytes,6,opt,name=duration,proto3" json:"duration,omitempty"`
	// Current state of the task (e.g. PENDING, RUNNING, COMPLETED, EXPIRED, etc).
	State TaskState `protobuf:"varint,7,opt,name=state,proto3,enum=swarming.v1.TaskState" json:"state,omitempty"`
	// The category of the current task state. This is primarily useful to
	// simplify BigQuery queries. This can be used to determine if a task is done
	// or if still considered for execution.
	StateCategory TaskStateCategory `protobuf:"varint,8,opt,name=state_category,json=stateCategory,proto3,enum=swarming.v1.TaskStateCategory" json:"state_category,omitempty"`
	// The task try number.
	//
	// It is 0 for a deduped task, since nothing ran. It is 0 if the task is still
	// PENDING.
	//
	// It is normally 1 for a task that started running and runs a normal flow.
	//
	// A number above 1 means that the task was tried multiple times. It can
	// be due to a previous try resulting in a task state in the category
	// CATEGORY_TRANSIENT_DONE.
	TryNumber int32 `protobuf:"varint,9,opt,name=try_number,json=tryNumber,proto3" json:"try_number,omitempty"`
	// Index in the TaskRequest.task_slices (TaskSlice instance) that this result
	// represents. This is updated when a TaskSlice is enqueued to run. It can be
	// updated until the task state is in either category CATEGORY_EXECUTION_DONE
	// or CATEGORY_NEVER_RAN_DONE.
	//
	// The TaskSlice contains a TaskProperties, which defines what is run.
	CurrentTaskSlice int32 `protobuf:"varint,10,opt,name=current_task_slice,json=currentTaskSlice,proto3" json:"current_task_slice,omitempty"`
	// Snapshot of the bot that was assigned to this task at the start of the
	// task. This includes bot local cache information.
	Bot *Bot `protobuf:"bytes,11,opt,name=bot,proto3" json:"bot,omitempty"`
	// Server versions that touched this task.
	//
	// A different version of the server may get the request and hand it to the
	// bot. This is primarily useful to detect if a new server version introduced
	// a bug and for canarying purpose.
	ServerVersions []string `protobuf:"bytes,12,rep,name=server_versions,json=serverVersions,proto3" json:"server_versions,omitempty"`
	// List of children task IDs that this task triggered, if any.
	//
	// This happens only in the case of reentrant tasks, a Swarming task that
	// itself triggers more Swarming task. Each of these task will have 'run_id'
	// set as their 'TaskRequest.parent_task_id'.
	ChildrenTaskIds []string `protobuf:"bytes,13,rep,name=children_task_ids,json=childrenTaskIds,proto3" json:"children_task_ids,omitempty"`
	// Task ID which results was reused for state DEDUPED.
	//
	// This is the run_id (ending with '1', '2' or more).
	DedupedFrom string `protobuf:"bytes,14,opt,name=deduped_from,json=dedupedFrom,proto3" json:"deduped_from,omitempty"`
	// Summary task ID (ending with '0') when creating a new task.
	TaskId string `protobuf:"bytes,15,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
	// Actual executed task id that this task represents.
	//
	// This value is only set if it ran, that is, the task went through one of the
	// state in CATEGORY_RUNNING.
	//
	// A task_id can have multiple run_id associated to it, they will have the
	// corresponding try_number incremented starting at 1.
	RunId string `protobuf:"bytes,16,opt,name=run_id,json=runId,proto3" json:"run_id,omitempty"`
	// Listing of the actual pinned CIPDPackages that the task used.
	//
	// These can vary from the input packages if the inputs included non-identity
	// versions (e.g. a ref like "latest"). This can be available once task setup
	// is completed.
	CipdPins *CIPDPins `protobuf:"bytes,17,opt,name=cipd_pins,json=cipdPins,proto3" json:"cipd_pins,omitempty"`
	// Statistics about overhead for an isolated task. This is populated as the
	// task goes through setup, execution and teardown.
	Performance *TaskPerformance `protobuf:"bytes,18,opt,name=performance,proto3" json:"performance,omitempty"`
	// Process exit code if relevant. May be forcibly set to -1 in exceptional
	// cases.
	ExitCode int64 `protobuf:"zigzag64,19,opt,name=exit_code,json=exitCode,proto3" json:"exit_code,omitempty"`
	// Isolated outputs, if any.
	// Deprecated: `cas_output_root` will be used.
	Outputs *CASTree `protobuf:"bytes,20,opt,name=outputs,proto3" json:"outputs,omitempty"`
	// RBE-CAS output, if any.
	CasOutputRoot *CASReference `protobuf:"bytes,21,opt,name=cas_output_root,json=casOutputRoot,proto3" json:"cas_output_root,omitempty"`
	// ResultDB related properties for this task.
	ResultdbInfo *ResultDBInfo `protobuf:"bytes,22,opt,name=resultdb_info,json=resultdbInfo,proto3" json:"resultdb_info,omitempty"`
}

func (x *TaskResult) Reset() {
	*x = TaskResult{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[21]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*TaskResult) ProtoMessage() {}

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

// Deprecated: Use TaskResult.ProtoReflect.Descriptor instead.
func (*TaskResult) Descriptor() ([]byte, []int) {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_rawDescGZIP(), []int{21}
}

func (x *TaskResult) GetRequest() *TaskRequest {
	if x != nil {
		return x.Request
	}
	return nil
}

func (x *TaskResult) GetCreateTime() *timestamppb.Timestamp {
	if x != nil {
		return x.CreateTime
	}
	return nil
}

func (x *TaskResult) GetStartTime() *timestamppb.Timestamp {
	if x != nil {
		return x.StartTime
	}
	return nil
}

func (x *TaskResult) GetAbandonTime() *timestamppb.Timestamp {
	if x != nil {
		return x.AbandonTime
	}
	return nil
}

func (x *TaskResult) GetEndTime() *timestamppb.Timestamp {
	if x != nil {
		return x.EndTime
	}
	return nil
}

func (x *TaskResult) GetDuration() *durationpb.Duration {
	if x != nil {
		return x.Duration
	}
	return nil
}

func (x *TaskResult) GetState() TaskState {
	if x != nil {
		return x.State
	}
	return TaskState_TASK_STATE_INVALID
}

func (x *TaskResult) GetStateCategory() TaskStateCategory {
	if x != nil {
		return x.StateCategory
	}
	return TaskStateCategory_TASK_STATE_CATEGORY_UNSPECIFIED
}

func (x *TaskResult) GetTryNumber() int32 {
	if x != nil {
		return x.TryNumber
	}
	return 0
}

func (x *TaskResult) GetCurrentTaskSlice() int32 {
	if x != nil {
		return x.CurrentTaskSlice
	}
	return 0
}

func (x *TaskResult) GetBot() *Bot {
	if x != nil {
		return x.Bot
	}
	return nil
}

func (x *TaskResult) GetServerVersions() []string {
	if x != nil {
		return x.ServerVersions
	}
	return nil
}

func (x *TaskResult) GetChildrenTaskIds() []string {
	if x != nil {
		return x.ChildrenTaskIds
	}
	return nil
}

func (x *TaskResult) GetDedupedFrom() string {
	if x != nil {
		return x.DedupedFrom
	}
	return ""
}

func (x *TaskResult) GetTaskId() string {
	if x != nil {
		return x.TaskId
	}
	return ""
}

func (x *TaskResult) GetRunId() string {
	if x != nil {
		return x.RunId
	}
	return ""
}

func (x *TaskResult) GetCipdPins() *CIPDPins {
	if x != nil {
		return x.CipdPins
	}
	return nil
}

func (x *TaskResult) GetPerformance() *TaskPerformance {
	if x != nil {
		return x.Performance
	}
	return nil
}

func (x *TaskResult) GetExitCode() int64 {
	if x != nil {
		return x.ExitCode
	}
	return 0
}

func (x *TaskResult) GetOutputs() *CASTree {
	if x != nil {
		return x.Outputs
	}
	return nil
}

func (x *TaskResult) GetCasOutputRoot() *CASReference {
	if x != nil {
		return x.CasOutputRoot
	}
	return nil
}

func (x *TaskResult) GetResultdbInfo() *ResultDBInfo {
	if x != nil {
		return x.ResultdbInfo
	}
	return nil
}

// Defines pinned CIPD packages that were installed during the task.
type CIPDPins struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// The CIPD server where the CIPD packages were fetched from. Must contain
	// "https://" or "http://" prefix.
	//
	// This field or its subfields are optional if default CIPD client is defined
	// in the server config.
	Server string `protobuf:"bytes,1,opt,name=server,proto3" json:"server,omitempty"`
	// The pinned package + version of the CIPD client that was actually used.
	ClientPackage *CIPDPackage `protobuf:"bytes,2,opt,name=client_package,json=clientPackage,proto3" json:"client_package,omitempty"`
	// List of CIPD packages that were installed in the task with fully resolved
	// package names and versions.
	Packages []*CIPDPackage `protobuf:"bytes,3,rep,name=packages,proto3" json:"packages,omitempty"`
}

func (x *CIPDPins) Reset() {
	*x = CIPDPins{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[22]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*CIPDPins) ProtoMessage() {}

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

// Deprecated: Use CIPDPins.ProtoReflect.Descriptor instead.
func (*CIPDPins) Descriptor() ([]byte, []int) {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_rawDescGZIP(), []int{22}
}

func (x *CIPDPins) GetServer() string {
	if x != nil {
		return x.Server
	}
	return ""
}

func (x *CIPDPins) GetClientPackage() *CIPDPackage {
	if x != nil {
		return x.ClientPackage
	}
	return nil
}

func (x *CIPDPins) GetPackages() []*CIPDPackage {
	if x != nil {
		return x.Packages
	}
	return nil
}

// Information about the task's performance.
type TaskPerformance struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Total cost of running this task in $USD. In the case of DEDUPED task, this
	// represents the amount saved.
	CostUsd float32 `protobuf:"fixed32,1,opt,name=cost_usd,json=costUsd,proto3" json:"cost_usd,omitempty"`
	// Total overhead caused by the bot.
	// This is calculated by subtracting the command duration measured in
	// run_isolated.py from the total duration in task_runner.run_command().
	// https://source.chromium.org/chromium/infra/infra/+/master:luci/appengine/swarming/swarming_bot/bot_code/task_runner.py;l=811;drc=dfa14c6863d14a5969bb4fea08846985d89aed76
	TotalOverhead *durationpb.Duration `protobuf:"bytes,5,opt,name=total_overhead,json=totalOverhead,proto3" json:"total_overhead,omitempty"`
	// Overhead that is caused by the bot server that is not accounted for by the
	// other overheads.
	OtherOverhead *durationpb.Duration `protobuf:"bytes,2,opt,name=other_overhead,json=otherOverhead,proto3" json:"other_overhead,omitempty"`
	// Deprecated: use setup_overhead instead.
	// Task environment setup overhead. This is the task state
	// RUNNING_OVERHEAD_SETUP.
	Setup *TaskOverheadStats `protobuf:"bytes,3,opt,name=setup,proto3" json:"setup,omitempty"`
	// Deprecated: use teardown_overhead instead.
	// Task environment teardown overhead. This is the task state
	// RUNNING_OVERHEAD_TEARDOWN.
	Teardown *TaskOverheadStats `protobuf:"bytes,4,opt,name=teardown,proto3" json:"teardown,omitempty"`
	// Task environment setup overhead. This is the task state
	// RUNNING_OVERHEAD_SETUP.
	SetupOverhead *TaskSetupOverhead `protobuf:"bytes,6,opt,name=setup_overhead,json=setupOverhead,proto3" json:"setup_overhead,omitempty"`
	// Task environment teardown overhead. This is the task state
	// RUNNING_OVERHEAD_TEARDOWN.
	TeardownOverhead *TaskTeardownOverhead `protobuf:"bytes,7,opt,name=teardown_overhead,json=teardownOverhead,proto3" json:"teardown_overhead,omitempty"`
}

func (x *TaskPerformance) Reset() {
	*x = TaskPerformance{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[23]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*TaskPerformance) ProtoMessage() {}

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

// Deprecated: Use TaskPerformance.ProtoReflect.Descriptor instead.
func (*TaskPerformance) Descriptor() ([]byte, []int) {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_rawDescGZIP(), []int{23}
}

func (x *TaskPerformance) GetCostUsd() float32 {
	if x != nil {
		return x.CostUsd
	}
	return 0
}

func (x *TaskPerformance) GetTotalOverhead() *durationpb.Duration {
	if x != nil {
		return x.TotalOverhead
	}
	return nil
}

func (x *TaskPerformance) GetOtherOverhead() *durationpb.Duration {
	if x != nil {
		return x.OtherOverhead
	}
	return nil
}

func (x *TaskPerformance) GetSetup() *TaskOverheadStats {
	if x != nil {
		return x.Setup
	}
	return nil
}

func (x *TaskPerformance) GetTeardown() *TaskOverheadStats {
	if x != nil {
		return x.Teardown
	}
	return nil
}

func (x *TaskPerformance) GetSetupOverhead() *TaskSetupOverhead {
	if x != nil {
		return x.SetupOverhead
	}
	return nil
}

func (x *TaskPerformance) GetTeardownOverhead() *TaskTeardownOverhead {
	if x != nil {
		return x.TeardownOverhead
	}
	return nil
}

// Overhead information about setup.
type TaskSetupOverhead struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Duration of this overhead.
	Duration *durationpb.Duration `protobuf:"bytes,1,opt,name=duration,proto3" json:"duration,omitempty"`
	// Cache trimming overhead.
	CacheTrim *CacheTrimOverhead `protobuf:"bytes,2,opt,name=cache_trim,json=cacheTrim,proto3" json:"cache_trim,omitempty"`
	// CIPD packge installation overhead.
	Cipd *CIPDOverhead `protobuf:"bytes,3,opt,name=cipd,proto3" json:"cipd,omitempty"`
	// Named cache install overhead.
	NamedCache *NamedCacheOverhead `protobuf:"bytes,4,opt,name=named_cache,json=namedCache,proto3" json:"named_cache,omitempty"`
	// CAS download overhead.
	Cas *CASOverhead `protobuf:"bytes,5,opt,name=cas,proto3" json:"cas,omitempty"`
}

func (x *TaskSetupOverhead) Reset() {
	*x = TaskSetupOverhead{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[24]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*TaskSetupOverhead) ProtoMessage() {}

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

// Deprecated: Use TaskSetupOverhead.ProtoReflect.Descriptor instead.
func (*TaskSetupOverhead) Descriptor() ([]byte, []int) {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_rawDescGZIP(), []int{24}
}

func (x *TaskSetupOverhead) GetDuration() *durationpb.Duration {
	if x != nil {
		return x.Duration
	}
	return nil
}

func (x *TaskSetupOverhead) GetCacheTrim() *CacheTrimOverhead {
	if x != nil {
		return x.CacheTrim
	}
	return nil
}

func (x *TaskSetupOverhead) GetCipd() *CIPDOverhead {
	if x != nil {
		return x.Cipd
	}
	return nil
}

func (x *TaskSetupOverhead) GetNamedCache() *NamedCacheOverhead {
	if x != nil {
		return x.NamedCache
	}
	return nil
}

func (x *TaskSetupOverhead) GetCas() *CASOverhead {
	if x != nil {
		return x.Cas
	}
	return nil
}

// Overhead information about teardown.
type TaskTeardownOverhead struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Duration of this overhead.
	Duration *durationpb.Duration `protobuf:"bytes,1,opt,name=duration,proto3" json:"duration,omitempty"`
	// CAS upload overhead.
	Cas *CASOverhead `protobuf:"bytes,2,opt,name=cas,proto3" json:"cas,omitempty"`
	// Named cache uninstall overhead.
	NamedCache *NamedCacheOverhead `protobuf:"bytes,3,opt,name=named_cache,json=namedCache,proto3" json:"named_cache,omitempty"`
	// Directory cleanup overhead.
	Cleanup *CleanupOverhead `protobuf:"bytes,4,opt,name=cleanup,proto3" json:"cleanup,omitempty"`
}

func (x *TaskTeardownOverhead) Reset() {
	*x = TaskTeardownOverhead{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[25]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*TaskTeardownOverhead) ProtoMessage() {}

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

// Deprecated: Use TaskTeardownOverhead.ProtoReflect.Descriptor instead.
func (*TaskTeardownOverhead) Descriptor() ([]byte, []int) {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_rawDescGZIP(), []int{25}
}

func (x *TaskTeardownOverhead) GetDuration() *durationpb.Duration {
	if x != nil {
		return x.Duration
	}
	return nil
}

func (x *TaskTeardownOverhead) GetCas() *CASOverhead {
	if x != nil {
		return x.Cas
	}
	return nil
}

func (x *TaskTeardownOverhead) GetNamedCache() *NamedCacheOverhead {
	if x != nil {
		return x.NamedCache
	}
	return nil
}

func (x *TaskTeardownOverhead) GetCleanup() *CleanupOverhead {
	if x != nil {
		return x.Cleanup
	}
	return nil
}

// Overhead information about cache trimming.
type CacheTrimOverhead struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Duration *durationpb.Duration `protobuf:"bytes,1,opt,name=duration,proto3" json:"duration,omitempty"`
}

func (x *CacheTrimOverhead) Reset() {
	*x = CacheTrimOverhead{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[26]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*CacheTrimOverhead) ProtoMessage() {}

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

// Deprecated: Use CacheTrimOverhead.ProtoReflect.Descriptor instead.
func (*CacheTrimOverhead) Descriptor() ([]byte, []int) {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_rawDescGZIP(), []int{26}
}

func (x *CacheTrimOverhead) GetDuration() *durationpb.Duration {
	if x != nil {
		return x.Duration
	}
	return nil
}

// Overhead information about CIPD packge installation.
type CIPDOverhead struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Duration of this overhead.
	Duration *durationpb.Duration `protobuf:"bytes,1,opt,name=duration,proto3" json:"duration,omitempty"`
}

func (x *CIPDOverhead) Reset() {
	*x = CIPDOverhead{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[27]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*CIPDOverhead) ProtoMessage() {}

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

// Deprecated: Use CIPDOverhead.ProtoReflect.Descriptor instead.
func (*CIPDOverhead) Descriptor() ([]byte, []int) {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_rawDescGZIP(), []int{27}
}

func (x *CIPDOverhead) GetDuration() *durationpb.Duration {
	if x != nil {
		return x.Duration
	}
	return nil
}

// Overhead information about Named Caches install or uninstall.
type NamedCacheOverhead struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Duration of this overhead.
	Duration *durationpb.Duration `protobuf:"bytes,1,opt,name=duration,proto3" json:"duration,omitempty"`
}

func (x *NamedCacheOverhead) Reset() {
	*x = NamedCacheOverhead{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[28]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*NamedCacheOverhead) ProtoMessage() {}

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

// Deprecated: Use NamedCacheOverhead.ProtoReflect.Descriptor instead.
func (*NamedCacheOverhead) Descriptor() ([]byte, []int) {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_rawDescGZIP(), []int{28}
}

func (x *NamedCacheOverhead) GetDuration() *durationpb.Duration {
	if x != nil {
		return x.Duration
	}
	return nil
}

// Overhead information about CAS download or upload.
type CASOverhead struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Duration of this overhead.
	Duration *durationpb.Duration `protobuf:"bytes,1,opt,name=duration,proto3" json:"duration,omitempty"`
	// CAS entries that were not present in the local or remote cache and had to
	// be sent across the network.
	Cold *CASEntriesStats `protobuf:"bytes,2,opt,name=cold,proto3" json:"cold,omitempty"`
	// CAS entries that were in the cache and thus didn't have to be transferred.
	Hot *CASEntriesStats `protobuf:"bytes,3,opt,name=hot,proto3" json:"hot,omitempty"`
}

func (x *CASOverhead) Reset() {
	*x = CASOverhead{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[29]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*CASOverhead) ProtoMessage() {}

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

// Deprecated: Use CASOverhead.ProtoReflect.Descriptor instead.
func (*CASOverhead) Descriptor() ([]byte, []int) {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_rawDescGZIP(), []int{29}
}

func (x *CASOverhead) GetDuration() *durationpb.Duration {
	if x != nil {
		return x.Duration
	}
	return nil
}

func (x *CASOverhead) GetCold() *CASEntriesStats {
	if x != nil {
		return x.Cold
	}
	return nil
}

func (x *CASOverhead) GetHot() *CASEntriesStats {
	if x != nil {
		return x.Hot
	}
	return nil
}

// Overhead information about cleanup step.
type CleanupOverhead struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Duration of this overhead.
	Duration *durationpb.Duration `protobuf:"bytes,1,opt,name=duration,proto3" json:"duration,omitempty"`
}

func (x *CleanupOverhead) Reset() {
	*x = CleanupOverhead{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[30]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*CleanupOverhead) ProtoMessage() {}

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

// Deprecated: Use CleanupOverhead.ProtoReflect.Descriptor instead.
func (*CleanupOverhead) Descriptor() ([]byte, []int) {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_rawDescGZIP(), []int{30}
}

func (x *CleanupOverhead) GetDuration() *durationpb.Duration {
	if x != nil {
		return x.Duration
	}
	return nil
}

// Deprecated: Use TaskSetupOverheadStats or TaskTeardownOverheadStats instead.
// Information about setup or teardown.
type TaskOverheadStats struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Duration of this overhead.
	Duration *durationpb.Duration `protobuf:"bytes,1,opt,name=duration,proto3" json:"duration,omitempty"`
	// CAS entries that were not present in the local or remote cache and had to
	// be sent across the network.
	Cold *CASEntriesStats `protobuf:"bytes,2,opt,name=cold,proto3" json:"cold,omitempty"`
	// CAS entries that were in the cache and thus didn't have to be transferred.
	Hot *CASEntriesStats `protobuf:"bytes,3,opt,name=hot,proto3" json:"hot,omitempty"`
}

func (x *TaskOverheadStats) Reset() {
	*x = TaskOverheadStats{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[31]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*TaskOverheadStats) ProtoMessage() {}

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

// Deprecated: Use TaskOverheadStats.ProtoReflect.Descriptor instead.
func (*TaskOverheadStats) Descriptor() ([]byte, []int) {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_rawDescGZIP(), []int{31}
}

func (x *TaskOverheadStats) GetDuration() *durationpb.Duration {
	if x != nil {
		return x.Duration
	}
	return nil
}

func (x *TaskOverheadStats) GetCold() *CASEntriesStats {
	if x != nil {
		return x.Cold
	}
	return nil
}

func (x *TaskOverheadStats) GetHot() *CASEntriesStats {
	if x != nil {
		return x.Hot
	}
	return nil
}

// Statistics for differential CAS entries in the context of I/O for a task.
type CASEntriesStats struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	NumItems        int64 `protobuf:"varint,1,opt,name=num_items,json=numItems,proto3" json:"num_items,omitempty"`
	TotalBytesItems int64 `protobuf:"varint,2,opt,name=total_bytes_items,json=totalBytesItems,proto3" json:"total_bytes_items,omitempty"`
	// This buffer is compressed as deflate'd delta-encoded varints. This is the
	// list of all the item size for an I/O operation, which can scale in the 100k
	// range. So this can be large! See //client/utils/large.py for the code to
	// handle these.
	Items []byte `protobuf:"bytes,6,opt,name=items,proto3" json:"items,omitempty"`
}

func (x *CASEntriesStats) Reset() {
	*x = CASEntriesStats{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[32]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*CASEntriesStats) ProtoMessage() {}

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

// Deprecated: Use CASEntriesStats.ProtoReflect.Descriptor instead.
func (*CASEntriesStats) Descriptor() ([]byte, []int) {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_rawDescGZIP(), []int{32}
}

func (x *CASEntriesStats) GetNumItems() int64 {
	if x != nil {
		return x.NumItems
	}
	return 0
}

func (x *CASEntriesStats) GetTotalBytesItems() int64 {
	if x != nil {
		return x.TotalBytesItems
	}
	return 0
}

func (x *CASEntriesStats) GetItems() []byte {
	if x != nil {
		return x.Items
	}
	return nil
}

// Swarming:ResultDB integration configuration for a task.
// This is a copy of SwarmingRpcsResultDBCfg.
type ResultDBCfg struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// Flag to indicates the integration is enabled.
	Enable bool `protobuf:"varint,1,opt,name=enable,proto3" json:"enable,omitempty"`
}

func (x *ResultDBCfg) Reset() {
	*x = ResultDBCfg{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[33]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*ResultDBCfg) ProtoMessage() {}

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

// Deprecated: Use ResultDBCfg.ProtoReflect.Descriptor instead.
func (*ResultDBCfg) Descriptor() ([]byte, []int) {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_rawDescGZIP(), []int{33}
}

func (x *ResultDBCfg) GetEnable() bool {
	if x != nil {
		return x.Enable
	}
	return false
}

// ResultDB Related properties.
type ResultDBInfo struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	// ResultDB hostname, e.g. "results.api.cr.dev"
	Hostname string `protobuf:"bytes,1,opt,name=hostname,proto3" json:"hostname,omitempty"`
	// Name of the task's ResultDB invocation.
	//
	// e.g. "invocations/task-chromium-swarm.appspot.com-deadbeef1"
	// None if Swarming:ResultDB integration was not enabled for this task.
	//
	// If the task was deduplicated, this equals invocation name of the original
	// task.
	Invocation string `protobuf:"bytes,2,opt,name=invocation,proto3" json:"invocation,omitempty"`
}

func (x *ResultDBInfo) Reset() {
	*x = ResultDBInfo{}
	if protoimpl.UnsafeEnabled {
		mi := &file_go_chromium_org_luci_swarming_proto_api_swarming_proto_msgTypes[34]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

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

func (*ResultDBInfo) ProtoMessage() {}

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

// Deprecated: Use ResultDBInfo.ProtoReflect.Descriptor instead.
func (*ResultDBInfo) Descriptor() ([]byte, []int) {
	return file_go_chromium_org_luci_swarming_proto_api_swarming_proto_rawDescGZIP(), []int{34}
}

func (x *ResultDBInfo) GetHostname() string {
	if x != nil {
		return x.Hostname
	}
	return ""
}

func (x *ResultDBInfo) GetInvocation() string {
	if x != nil {
		return x.Invocation
	}
	return ""
}

var File_go_chromium_org_luci_swarming_proto_api_swarming_proto protoreflect.FileDescriptor

var file_go_chromium_org_luci_swarming_proto_api_swarming_proto_rawDesc = []byte{
	0x0a, 0x36, 0x67, 0x6f, 0x2e, 0x63, 0x68, 0x72, 0x6f, 0x6d, 0x69, 0x75, 0x6d, 0x2e, 0x6f, 0x72,
	0x67, 0x2f, 0x6c, 0x75, 0x63, 0x69, 0x2f, 0x73, 0x77, 0x61, 0x72, 0x6d, 0x69, 0x6e, 0x67, 0x2f,
	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x73, 0x77, 0x61, 0x72, 0x6d, 0x69,
	0x6e, 0x67, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0b, 0x73, 0x77, 0x61, 0x72, 0x6d, 0x69,
	0x6e, 0x67, 0x2e, 0x76, 0x31, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72,
	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72,
	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2e, 0x70, 0x72,
	0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74,
	0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70,
	0x72, 0x6f, 0x74, 0x6f, 0x22, 0xd7, 0x01, 0x0a, 0x10, 0x42, 0x6f, 0x74, 0x45, 0x76, 0x65, 0x6e,
	0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x15, 0x0a, 0x06, 0x62, 0x6f, 0x74,
	0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x62, 0x6f, 0x74, 0x49, 0x64,
	0x12, 0x1b, 0x0a, 0x09, 0x70, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x02, 0x20,
	0x01, 0x28, 0x05, 0x52, 0x08, 0x70, 0x61, 0x67, 0x65, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x1d, 0x0a,
	0x0a, 0x70, 0x61, 0x67, 0x65, 0x5f, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28,
	0x09, 0x52, 0x09, 0x70, 0x61, 0x67, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x39, 0x0a, 0x0a,
	0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b,
	0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
	0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x73, 0x74,
	0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x35, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f, 0x74,
	0x69, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65,
	0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x6a,
	0x0a, 0x11, 0x42, 0x6f, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f,
	0x6e, 0x73, 0x65, 0x12, 0x2d, 0x0a, 0x06, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20,
	0x03, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x73, 0x77, 0x61, 0x72, 0x6d, 0x69, 0x6e, 0x67, 0x2e, 0x76,
	0x31, 0x2e, 0x42, 0x6f, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x06, 0x65, 0x76, 0x65, 0x6e,
	0x74, 0x73, 0x12, 0x26, 0x0a, 0x0f, 0x6e, 0x65, 0x78, 0x74, 0x5f, 0x70, 0x61, 0x67, 0x65, 0x5f,
	0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x6e, 0x65, 0x78,
	0x74, 0x50, 0x61, 0x67, 0x65, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x22, 0x34, 0x0a, 0x0a, 0x53, 0x74,
	0x72, 0x69, 0x6e, 0x67, 0x50, 0x61, 0x69, 0x72, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18,
	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61,
	0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
	0x22, 0x3a, 0x0a, 0x0e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x61,
	0x69, 0x72, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
	0x03, 0x6b, 0x65, 0x79, 0x12, 0x16, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x02,
	0x20, 0x03, 0x28, 0x09, 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x22, 0xb3, 0x02, 0x0a,
	0x03, 0x42, 0x6f, 0x74, 0x12, 0x15, 0x0a, 0x06, 0x62, 0x6f, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x01,
	0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x62, 0x6f, 0x74, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x73,
	0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
	0x09, 0x73, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x6f,
	0x6f, 0x6c, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x05, 0x70, 0x6f, 0x6f, 0x6c, 0x73,
	0x12, 0x32, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e,
	0x32, 0x1a, 0x2e, 0x73, 0x77, 0x61, 0x72, 0x6d, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x2e, 0x42,
	0x6f, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x54, 0x79, 0x70, 0x65, 0x52, 0x06, 0x73, 0x74,
	0x61, 0x74, 0x75, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x5f, 0x6d,
	0x73, 0x67, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73,
	0x4d, 0x73, 0x67, 0x12, 0x26, 0x0a, 0x0f, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x74,
	0x61, 0x73, 0x6b, 0x5f, 0x69, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x75,
	0x72, 0x72, 0x65, 0x6e, 0x74, 0x54, 0x61, 0x73, 0x6b, 0x49, 0x64, 0x12, 0x3b, 0x0a, 0x0a, 0x64,
	0x69, 0x6d, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32,
	0x1b, 0x2e, 0x73, 0x77, 0x61, 0x72, 0x6d, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74,
	0x72, 0x69, 0x6e, 0x67, 0x4c, 0x69, 0x73, 0x74, 0x50, 0x61, 0x69, 0x72, 0x52, 0x0a, 0x64, 0x69,
	0x6d, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x28, 0x0a, 0x04, 0x69, 0x6e, 0x66, 0x6f,
	0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x73, 0x77, 0x61, 0x72, 0x6d, 0x69, 0x6e,
	0x67, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6f, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x04, 0x69, 0x6e,
	0x66, 0x6f, 0x22, 0xf1, 0x04, 0x0a, 0x07, 0x42, 0x6f, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x3b,
	0x0a, 0x0c, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x18, 0x01,
	0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, 0x0c, 0x73,
	0x75, 0x70, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x12, 0x18, 0x0a, 0x07, 0x76,
	0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65,
	0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61,
	0x6c, 0x5f, 0x69, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x65, 0x78, 0x74, 0x65,
	0x72, 0x6e, 0x61, 0x6c, 0x49, 0x70, 0x12, 0x29, 0x0a, 0x10, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e,
	0x74, 0x69, 0x63, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x61, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09,
	0x52, 0x0f, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, 0x69, 0x63, 0x61, 0x74, 0x65, 0x64, 0x41,
	0x73, 0x12, 0x32, 0x0a, 0x09, 0x63, 0x61, 0x73, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x05,
	0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x73, 0x77, 0x61, 0x72, 0x6d, 0x69, 0x6e, 0x67, 0x2e,
	0x76, 0x31, 0x2e, 0x43, 0x41, 0x53, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x08, 0x63, 0x61, 0x73,
	0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x4a, 0x0a, 0x12, 0x6e, 0x61, 0x6d, 0x65, 0x64, 0x5f, 0x63,
	0x61, 0x63, 0x68, 0x65, 0x73, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28,
	0x0b, 0x32, 0x1c, 0x2e, 0x73, 0x77, 0x61, 0x72, 0x6d, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x2e,
	0x4e, 0x61, 0x6d, 0x65, 0x64, 0x43, 0x61, 0x63, 0x68, 0x65, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52,
	0x10, 0x6e, 0x61, 0x6d, 0x65, 0x64, 0x43, 0x61, 0x63, 0x68, 0x65, 0x73, 0x53, 0x74, 0x61, 0x74,
	0x73, 0x12, 0x5d, 0x0a, 0x19, 0x63, 0x69, 0x70, 0x64, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67,
	0x65, 0x73, 0x5f, 0x63, 0x61, 0x63, 0x68, 0x65, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x07,
	0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x73, 0x77, 0x61, 0x72, 0x6d, 0x69, 0x6e, 0x67, 0x2e,
	0x76, 0x31, 0x2e, 0x43, 0x49, 0x50, 0x44, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x43, 0x61,
	0x63, 0x68, 0x65, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x16, 0x63, 0x69, 0x70, 0x64, 0x50, 0x61,
	0x63, 0x6b, 0x61, 0x67, 0x65, 0x73, 0x43, 0x61, 0x63, 0x68, 0x65, 0x53, 0x74, 0x61, 0x74, 0x73,
	0x12, 0x2f, 0x0a, 0x04, 0x68, 0x6f, 0x73, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b,
	0x2e, 0x73, 0x77, 0x61, 0x72, 0x6d, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x68, 0x79,
	0x73, 0x69, 0x63, 0x61, 0x6c, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x04, 0x68, 0x6f, 0x73,
	0x74, 0x12, 0x35, 0x0a, 0x07, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x18, 0x09, 0x20, 0x03,
	0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x73, 0x77, 0x61, 0x72, 0x6d, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31,
	0x2e, 0x50, 0x68, 0x79, 0x73, 0x69, 0x63, 0x61, 0x6c, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52,
	0x07, 0x64, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x12, 0x3c, 0x0a, 0x0c, 0x6c, 0x61, 0x73, 0x74,
	0x5f, 0x73, 0x65, 0x65, 0x6e, 0x5f, 0x74, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a,
	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
	0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0a, 0x6c, 0x61, 0x73, 0x74,
	0x53, 0x65, 0x65, 0x6e, 0x54, 0x73, 0x12, 0x3e, 0x0a, 0x0d, 0x69, 0x64, 0x6c, 0x65, 0x5f, 0x73,
	0x69, 0x6e, 0x63, 0x65, 0x5f, 0x74, 0x73, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e,
	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
	0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0b, 0x69, 0x64, 0x6c, 0x65, 0x53,
	0x69, 0x6e, 0x63, 0x65, 0x54, 0x73, 0x22, 0x71, 0x0a, 0x0e, 0x50, 0x68, 0x79, 0x73, 0x69, 0x63,
	0x61, 0x6c, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65,
	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x3b, 0x0a, 0x0c,
	0x73, 0x75, 0x70, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x18, 0x02, 0x20, 0x01,
	0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74,
	0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, 0x0c, 0x73, 0x75, 0x70,
	0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x70, 0x18,
	0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x70, 0x22, 0x7e, 0x0a, 0x08, 0x43, 0x41, 0x53,
	0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x5f,
	0x69, 0x74, 0x65, 0x6d, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x6e, 0x75, 0x6d,
	0x62, 0x65, 0x72, 0x49, 0x74, 0x65, 0x6d, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x69, 0x7a, 0x65,
	0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x12, 0x3b, 0x0a, 0x0b,
	0x6f, 0x6c, 0x64, 0x65, 0x73, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28,
	0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
	0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0a, 0x6f,
	0x6c, 0x64, 0x65, 0x73, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x22, 0x79, 0x0a, 0x0f, 0x4e, 0x61, 0x6d,
	0x65, 0x64, 0x43, 0x61, 0x63, 0x68, 0x65, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x12, 0x0a, 0x04,
	0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65,
	0x12, 0x12, 0x0a, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04,
	0x73, 0x69, 0x7a, 0x65, 0x12, 0x3e, 0x0a, 0x0d, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x75, 0x73, 0x65,
	0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f,
	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69,
	0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x0b, 0x6c, 0x61, 0x73, 0x74, 0x55, 0x73, 0x65,
	0x54, 0x69, 0x6d, 0x65, 0x22, 0x99, 0x01, 0x0a, 0x15, 0x43, 0x49, 0x50, 0x44, 0x50, 0x61, 0x63,
	0x6b, 0x61, 0x67, 0x65, 0x43, 0x61, 0x63, 0x68, 0x65, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x12,
	0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61,
	0x6d, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20,
	0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04,
	0x73, 0x69, 0x7a, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x73, 0x69, 0x7a, 0x65,
	0x12, 0x3e, 0x0a, 0x0d, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x75, 0x73, 0x65, 0x5f, 0x74, 0x69, 0x6d,
	0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74,
	0x61, 0x6d, 0x70, 0x52, 0x0b, 0x6c, 0x61, 0x73, 0x74, 0x55, 0x73, 0x65, 0x54, 0x69, 0x6d, 0x65,
	0x22, 0xb7, 0x01, 0x0a, 0x08, 0x42, 0x6f, 0x74, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x39, 0x0a,
	0x0a, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
	0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
	0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x65,
	0x76, 0x65, 0x6e, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x22, 0x0a, 0x03, 0x62, 0x6f, 0x74, 0x18,
	0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x73, 0x77, 0x61, 0x72, 0x6d, 0x69, 0x6e, 0x67,
	0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6f, 0x74, 0x52, 0x03, 0x62, 0x6f, 0x74, 0x12, 0x2f, 0x0a, 0x05,
	0x65, 0x76, 0x65, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x19, 0x2e, 0x73, 0x77,
	0x61, 0x72, 0x6d, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6f, 0x74, 0x45, 0x76, 0x65,
	0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x05, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x1b, 0x0a,
	0x09, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x5f, 0x6d, 0x73, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09,
	0x52, 0x08, 0x65, 0x76, 0x65, 0x6e, 0x74, 0x4d, 0x73, 0x67, 0x22, 0x57, 0x0a, 0x07, 0x43, 0x41,
	0x53, 0x54, 0x72, 0x65, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x18,
	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x12, 0x16, 0x0a,
	0x06, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x64,
	0x69, 0x67, 0x65, 0x73, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61,
	0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70,
	0x61, 0x63, 0x65, 0x22, 0x3b, 0x0a, 0x06, 0x44, 0x69, 0x67, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a,
	0x04, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x68, 0x61, 0x73,
	0x68, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x69, 0x7a, 0x65, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18,
	0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x73, 0x69, 0x7a, 0x65, 0x42, 0x79, 0x74, 0x65, 0x73,
	0x22, 0x5e, 0x0a, 0x0c, 0x43, 0x41, 0x53, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65,
	0x12, 0x21, 0x0a, 0x0c, 0x63, 0x61, 0x73, 0x5f, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65,
	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x61, 0x73, 0x49, 0x6e, 0x73, 0x74, 0x61,
	0x6e, 0x63, 0x65, 0x12, 0x2b, 0x0a, 0x06, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74, 0x18, 0x02, 0x20,
	0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x73, 0x77, 0x61, 0x72, 0x6d, 0x69, 0x6e, 0x67, 0x2e, 0x76,
	0x31, 0x2e, 0x44, 0x69, 0x67, 0x65, 0x73, 0x74, 0x52, 0x06, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74,
	0x22, 0x67, 0x0a, 0x0b, 0x43, 0x49, 0x50, 0x44, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x12,
	0x21, 0x0a, 0x0c, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18,
	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x4e, 0x61,
	0x6d, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20,
	0x01, 0x28, 0x09, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1b, 0x0a, 0x09,
	0x64, 0x65, 0x73, 0x74, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52,
	0x08, 0x64, 0x65, 0x73, 0x74, 0x50, 0x61, 0x74, 0x68, 0x22, 0x42, 0x0a, 0x0f, 0x4e, 0x61, 0x6d,
	0x65, 0x64, 0x43, 0x61, 0x63, 0x68, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x12, 0x0a, 0x04,
	0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65,
	0x12, 0x1b, 0x0a, 0x09, 0x64, 0x65, 0x73, 0x74, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x18, 0x02, 0x20,
	0x01, 0x28, 0x09, 0x52, 0x08, 0x64, 0x65, 0x73, 0x74, 0x50, 0x61, 0x74, 0x68, 0x22, 0xbd, 0x02,
	0x0a, 0x0b, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x25, 0x0a,
	0x0e, 0x6c, 0x6f, 0x77, 0x65, 0x72, 0x5f, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18,
	0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0d, 0x6c, 0x6f, 0x77, 0x65, 0x72, 0x50, 0x72, 0x69, 0x6f,
	0x72, 0x69, 0x74, 0x79, 0x12, 0x53, 0x0a, 0x10, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x6d,
	0x65, 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x28,
	0x2e, 0x73, 0x77, 0x61, 0x72, 0x6d, 0x69, 0x6e, 0x67, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6e,
	0x74, 0x61, 0x69, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e,
	0x6d, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0f, 0x63, 0x6f, 0x6e, 0x74, 0x61, 0x69,
	0x6e, 0x6d, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x6c, 0x69, 0x6d,
	0x69, 0x74, 0x5f, 0x70, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01,
	0x28, 0x03, 0x52, 0x0e, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73,
	0x65, 0x73, 0x12, 0x3f, 0x0a, 0x1c, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x5f, 0x74, 0x6f, 0x74, 0x61,
	0x6c, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x64, 0x5f, 0x6d, 0x65, 0x6d, 0x6f,
	0x72, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x19, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x54,
	0x6f, 0x74, 0x61, 0x6c, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x64, 0x4d, 0x65, 0x6d,
	0x6f, 0x72, 0x79, 0x22, 0x48, 0x0a, 0x0f, 0x43, 0x6f, 0x6e, 0x74, 0x61, 0x69, 0x6e, 0x6d, 0x65,
	0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x11, 0x0a, 0x0d, 0x4e, 0x4f, 0x54, 0x5f, 0x53, 0x50,
	0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x4e, 0x4f, 0x4e,
	0x45, 0x10, 0x01, 0x12, 0x08, 0x0a, 0x04, 0x41, 0x55, 0x54, 0x4f, 0x10, 0x02, 0x12, 0x0e, 0x0a,
	0x0a, 0x4a, 0x4f, 0x42, 0x5f, 0x4f, 0x42, 0x4a, 0x45, 0x43, 0x54, 0x10, 0x03, 0x22, 0xaa, 0x07,
	0x0a, 0x0e, 0x54, 0x61, 0x73, 0x6b, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x6