swarming/proto/api/swarming.pb.go

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

package apipb

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

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	duration "github.com/golang/protobuf/ptypes/duration"
	_struct "github.com/golang/protobuf/ptypes/struct"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

// 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
	// 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
	// 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
	// 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
	// Bot is healthy and waiting for tasks.
	//
	// Bot.status_msg shall not be set.
	BotStatusType_IDLE BotStatusType = 9
)

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",
}

var 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) String() string {
	return proto.EnumName(BotStatusType_name, int32(x))
}

func (BotStatusType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_d3887eaa0fa60818, []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
	// Bot had an internal failure to report to the server outside of a task
	// context. This shall send a report to the administrator of the instance and
	// service author.
	//
	// BotEvent.event_msg shall contain the error message.
	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
	// Knowledge of the bot by the server was deleted.
	//
	// In this case, the bot's historical data is still kept in the Swarming
	// server's DB for a year, but the bot is not shown anywhere.
	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.
	//
	// 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
)

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",
}

var 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) String() string {
	return proto.EnumName(BotEventType_name, int32(x))
}

func (BotEventType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_d3887eaa0fa60818, []int{1}
}

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

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",
}

var 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) String() string {
	return proto.EnumName(TaskStateCategory_name, int32(x))
}

func (TaskStateCategory) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_d3887eaa0fa60818, []int{2}
}

// 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
	// 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
	// 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
	// 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
	// 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
	// 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
	// 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
	// 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
	// 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
	// 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
	// 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
	// The task is valid but was denied due to insufficient quota.
	TaskState_RESOURCE_EXHAUSTED TaskState = 85
	// 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
)

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",
}

var 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,
}

func (x TaskState) String() string {
	return proto.EnumName(TaskState_name, int32(x))
}

func (TaskState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_d3887eaa0fa60818, []int{3}
}

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
)

var Containment_ContainmentType_name = map[int32]string{
	0: "NOT_SPECIFIED",
	1: "NONE",
	2: "AUTO",
	3: "JOB_OBJECT",
}

var Containment_ContainmentType_value = map[string]int32{
	"NOT_SPECIFIED": 0,
	"NONE":          1,
	"AUTO":          2,
	"JOB_OBJECT":    3,
}

func (x Containment_ContainmentType) String() string {
	return proto.EnumName(Containment_ContainmentType_name, int32(x))
}

func (Containment_ContainmentType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_d3887eaa0fa60818, []int{14, 0}
}

// Request for BotAPI.Events.
type BotEventsRequest struct {
	// 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 *timestamp.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              *timestamp.Timestamp `protobuf:"bytes,5,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

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

var xxx_messageInfo_BotEventsRequest proto.InternalMessageInfo

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

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

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

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

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

// Response of BotAPI.Events.
type BotEventsResponse struct {
	// 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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_BotEventsResponse proto.InternalMessageInfo

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

func (m *BotEventsResponse) GetNextPageToken() string {
	if m != nil {
		return m.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 {
	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value                string   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_StringPair proto.InternalMessageInfo

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

func (m *StringPair) GetValue() string {
	if m != nil {
		return m.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 {
	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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_StringListPair proto.InternalMessageInfo

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

func (m *StringListPair) GetValues() []string {
	if m != nil {
		return m.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 {
	// 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"`
	// 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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Bot proto.InternalMessageInfo

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

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

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

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

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

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

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

func (m *Bot) GetInfo() *BotInfo {
	if m != nil {
		return m.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 {
	// 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 *_struct.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           *timestamp.Timestamp `protobuf:"bytes,10,opt,name=last_seen_ts,json=lastSeenTs,proto3" json:"last_seen_ts,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

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

var xxx_messageInfo_BotInfo proto.InternalMessageInfo

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

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

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

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

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

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

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

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

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

func (m *BotInfo) GetLastSeenTs() *timestamp.Timestamp {
	if m != nil {
		return m.LastSeenTs
	}
	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 {
	// 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 *_struct.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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_PhysicalEntity proto.InternalMessageInfo

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

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

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

// Bot local content addressed cache information.
type CASStats struct {
	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           *timestamp.Timestamp `protobuf:"bytes,3,opt,name=oldest_time,json=oldestTime,proto3" json:"oldest_time,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

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

var xxx_messageInfo_CASStats proto.InternalMessageInfo

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

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

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

// Bot local named cache information.
type NamedCacheStats struct {
	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          *timestamp.Timestamp `protobuf:"bytes,3,opt,name=last_use_time,json=lastUseTime,proto3" json:"last_use_time,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

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

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

var xxx_messageInfo_NamedCacheStats proto.InternalMessageInfo

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

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

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

// Bot local CIPD package cache information.
type CIPDPackageCacheStats struct {
	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          *timestamp.Timestamp `protobuf:"bytes,4,opt,name=last_use_time,json=lastUseTime,proto3" json:"last_use_time,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *CIPDPackageCacheStats) Reset()         { *m = CIPDPackageCacheStats{} }
func (m *CIPDPackageCacheStats) String() string { return proto.CompactTextString(m) }
func (*CIPDPackageCacheStats) ProtoMessage()    {}
func (*CIPDPackageCacheStats) Descriptor() ([]byte, []int) {
	return fileDescriptor_d3887eaa0fa60818, []int{9}
}

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

var xxx_messageInfo_CIPDPackageCacheStats proto.InternalMessageInfo

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

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

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

func (m *CIPDPackageCacheStats) GetLastUseTime() *timestamp.Timestamp {
	if m != nil {
		return m.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 {
	EventTime *timestamp.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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *BotEvent) Reset()         { *m = BotEvent{} }
func (m *BotEvent) String() string { return proto.CompactTextString(m) }
func (*BotEvent) ProtoMessage()    {}
func (*BotEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_d3887eaa0fa60818, []int{10}
}

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

var xxx_messageInfo_BotEvent proto.InternalMessageInfo

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

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

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

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

// Defines a Content Addressed Storage (a cache in practice) data tree
// reference, normally a reference to a .isolated file.
//
// 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 {
	// 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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CASTree) Reset()         { *m = CASTree{} }
func (m *CASTree) String() string { return proto.CompactTextString(m) }
func (*CASTree) ProtoMessage()    {}
func (*CASTree) Descriptor() ([]byte, []int) {
	return fileDescriptor_d3887eaa0fa60818, []int{11}
}

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

var xxx_messageInfo_CASTree proto.InternalMessageInfo

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

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

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

// 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 {
	// 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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CIPDPackage) Reset()         { *m = CIPDPackage{} }
func (m *CIPDPackage) String() string { return proto.CompactTextString(m) }
func (*CIPDPackage) ProtoMessage()    {}
func (*CIPDPackage) Descriptor() ([]byte, []int) {
	return fileDescriptor_d3887eaa0fa60818, []int{12}
}

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

var xxx_messageInfo_CIPDPackage proto.InternalMessageInfo

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

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

func (m *CIPDPackage) GetDestPath() string {
	if m != nil {
		return m.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 {
	// 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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *NamedCacheEntry) Reset()         { *m = NamedCacheEntry{} }
func (m *NamedCacheEntry) String() string { return proto.CompactTextString(m) }
func (*NamedCacheEntry) ProtoMessage()    {}
func (*NamedCacheEntry) Descriptor() ([]byte, []int) {
	return fileDescriptor_d3887eaa0fa60818, []int{13}
}

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

var xxx_messageInfo_NamedCacheEntry proto.InternalMessageInfo

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

func (m *NamedCacheEntry) GetDestPath() string {
	if m != nil {
		return m.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 {
	// 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"`
	XXX_NoUnkeyedLiteral      struct{} `json:"-"`
	XXX_unrecognized          []byte   `json:"-"`
	XXX_sizecache             int32    `json:"-"`
}

func (m *Containment) Reset()         { *m = Containment{} }
func (m *Containment) String() string { return proto.CompactTextString(m) }
func (*Containment) ProtoMessage()    {}
func (*Containment) Descriptor() ([]byte, []int) {
	return fileDescriptor_d3887eaa0fa60818, []int{14}
}

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

var xxx_messageInfo_Containment proto.InternalMessageInfo

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

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

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

func (m *Containment) GetLimitTotalCommittedMemory() int64 {
	if m != nil {
		return m.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.
type TaskProperties struct {
	// Isolated inputs to map in the working directory.
	//
	// 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"`
	// 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. Only one of 'command' or 'extra_args' can be specified.
	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. Only one
	// of 'command' or 'extra_args' can be specified.
	//
	// 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"`
	// Maximum number of seconds the task can run before its process is forcibly
	// terminated and the task results in TIMED_OUT.
	ExecutionTimeout *duration.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 *duration.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 *duration.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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskProperties) Reset()         { *m = TaskProperties{} }
func (m *TaskProperties) String() string { return proto.CompactTextString(m) }
func (*TaskProperties) ProtoMessage()    {}
func (*TaskProperties) Descriptor() ([]byte, []int) {
	return fileDescriptor_d3887eaa0fa60818, []int{15}
}

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

var xxx_messageInfo_TaskProperties proto.InternalMessageInfo

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// 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 {
	// 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 *duration.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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskSlice) Reset()         { *m = TaskSlice{} }
func (m *TaskSlice) String() string { return proto.CompactTextString(m) }
func (*TaskSlice) ProtoMessage()    {}
func (*TaskSlice) Descriptor() ([]byte, []int) {
	return fileDescriptor_d3887eaa0fa60818, []int{16}
}

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

var xxx_messageInfo_TaskSlice proto.InternalMessageInfo

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

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

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

func (m *TaskSlice) GetPropertiesHash() string {
	if m != nil {
		return m.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 {
	// 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 task service accounts at all, this is default.
	//   - 'bot': use bot's own account, works only if bots authenticate with
	//       OAuth2.
	//   - 'email': use this account (if token server's service_accounts.cfg rules
	//       allow it). Not implemented yet.
	//
	// 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.
	//
	// TODO(vadimsh): Link to a doc that describes Swarming Service Accounts, when
	// it exists.
	ServiceAccount string `protobuf:"bytes,3,opt,name=service_account,json=serviceAccount,proto3" json:"service_account,omitempty"`
	// When the task was created.
	CreateTime *timestamp.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"`
	// 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"`
	// 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     *duration.Duration `protobuf:"bytes,12,opt,name=bot_ping_tolerance,json=botPingTolerance,proto3" json:"bot_ping_tolerance,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *TaskRequest) Reset()         { *m = TaskRequest{} }
func (m *TaskRequest) String() string { return proto.CompactTextString(m) }
func (*TaskRequest) ProtoMessage()    {}
func (*TaskRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_d3887eaa0fa60818, []int{17}
}

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

var xxx_messageInfo_TaskRequest proto.InternalMessageInfo

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

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

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

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

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

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

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

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

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

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

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

func (m *TaskRequest) GetBotPingTolerance() *duration.Duration {
	if m != nil {
		return m.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 {
	// 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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PubSub) Reset()         { *m = PubSub{} }
func (m *PubSub) String() string { return proto.CompactTextString(m) }
func (*PubSub) ProtoMessage()    {}
func (*PubSub) Descriptor() ([]byte, []int) {
	return fileDescriptor_d3887eaa0fa60818, []int{18}
}

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

var xxx_messageInfo_PubSub proto.InternalMessageInfo

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

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

func (m *PubSub) GetUserdata() string {
	if m != nil {
		return m.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.
type TaskResult struct {
	Request *TaskRequest `protobuf:"bytes,1,opt,name=request,proto3" json:"request,omitempty"`
	// Time the task was requested.
	CreateTime *timestamp.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 *timestamp.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 *timestamp.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 *timestamp.Timestamp `protobuf:"bytes,5,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
	// Duration of the task. This excludes overheads.
	Duration *duration.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 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 int32 `protobuf:"zigzag32,19,opt,name=exit_code,json=exitCode,proto3" json:"exit_code,omitempty"`
	// Isolated outputs, if any.
	Outputs              *CASTree `protobuf:"bytes,20,opt,name=outputs,proto3" json:"outputs,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskResult) Reset()         { *m = TaskResult{} }
func (m *TaskResult) String() string { return proto.CompactTextString(m) }
func (*TaskResult) ProtoMessage()    {}
func (*TaskResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_d3887eaa0fa60818, []int{19}
}

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

var xxx_messageInfo_TaskResult proto.InternalMessageInfo

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

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

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

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

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

func (m *TaskResult) GetDuration() *duration.Duration {
	if m != nil {
		return m.Duration
	}
	return nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Defines pinned CIPD packages that were installed during the task.
type CIPDPins struct {
	// 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"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *CIPDPins) Reset()         { *m = CIPDPins{} }
func (m *CIPDPins) String() string { return proto.CompactTextString(m) }
func (*CIPDPins) ProtoMessage()    {}
func (*CIPDPins) Descriptor() ([]byte, []int) {
	return fileDescriptor_d3887eaa0fa60818, []int{20}
}

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

var xxx_messageInfo_CIPDPins proto.InternalMessageInfo

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

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

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

// Information about the task's performance.
type TaskPerformance struct {
	// 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"`
	// Overhead that is caused by the bot server that is not accounted for by the
	// other overheads.
	OtherOverhead *duration.Duration `protobuf:"bytes,2,opt,name=other_overhead,json=otherOverhead,proto3" json:"other_overhead,omitempty"`
	// Task environment setup overhead. This is the task state
	// RUNNING_OVERHEAD_SETUP.
	Setup *TaskOverheadStats `protobuf:"bytes,3,opt,name=setup,proto3" json:"setup,omitempty"`
	// Task environment teardown overhead. This is the task state
	// RUNNING_OVERHEAD_TEARDOWN.
	Teardown             *TaskOverheadStats `protobuf:"bytes,4,opt,name=teardown,proto3" json:"teardown,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *TaskPerformance) Reset()         { *m = TaskPerformance{} }
func (m *TaskPerformance) String() string { return proto.CompactTextString(m) }
func (*TaskPerformance) ProtoMessage()    {}
func (*TaskPerformance) Descriptor() ([]byte, []int) {
	return fileDescriptor_d3887eaa0fa60818, []int{21}
}

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

var xxx_messageInfo_TaskPerformance proto.InternalMessageInfo

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

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

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

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

// Information about setup or teardown.
type TaskOverheadStats struct {
	// Duration of this overhead.
	Duration *duration.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"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *TaskOverheadStats) Reset()         { *m = TaskOverheadStats{} }
func (m *TaskOverheadStats) String() string { return proto.CompactTextString(m) }
func (*TaskOverheadStats) ProtoMessage()    {}
func (*TaskOverheadStats) Descriptor() ([]byte, []int) {
	return fileDescriptor_d3887eaa0fa60818, []int{22}
}

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

var xxx_messageInfo_TaskOverheadStats proto.InternalMessageInfo

func (m *TaskOverheadStats) GetDuration() *duration.Duration {
	if m != nil {
		return m.Duration
	}
	return nil
}

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

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

// Statistics for differential CAS entries in the context of I/O for a task.
type CASEntriesStats struct {
	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"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CASEntriesStats) Reset()         { *m = CASEntriesStats{} }
func (m *CASEntriesStats) String() string { return proto.CompactTextString(m) }
func (*CASEntriesStats) ProtoMessage()    {}
func (*CASEntriesStats) Descriptor() ([]byte, []int) {
	return fileDescriptor_d3887eaa0fa60818, []int{23}
}

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

var xxx_messageInfo_CASEntriesStats proto.InternalMessageInfo

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

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

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

func init() {
	proto.RegisterEnum("swarming.v1.BotStatusType", BotStatusType_name, BotStatusType_value)
	proto.RegisterEnum("swarming.v1.BotEventType", BotEventType_name, BotEventType_value)
	proto.RegisterEnum("swarming.v1.TaskStateCategory", TaskStateCategory_name, TaskStateCategory_value)
	proto.RegisterEnum("swarming.v1.TaskState", TaskState_name, TaskState_value)
	proto.RegisterEnum("swarming.v1.Containment_ContainmentType", Containment_ContainmentType_name, Containment_ContainmentType_value)
	proto.RegisterType((*BotEventsRequest)(nil), "swarming.v1.BotEventsRequest")
	proto.RegisterType((*BotEventsResponse)(nil), "swarming.v1.BotEventsResponse")
	proto.RegisterType((*StringPair)(nil), "swarming.v1.StringPair")
	proto.RegisterType((*StringListPair)(nil), "swarming.v1.StringListPair")
	proto.RegisterType((*Bot)(nil), "swarming.v1.Bot")
	proto.RegisterType((*BotInfo)(nil), "swarming.v1.BotInfo")
	proto.RegisterType((*PhysicalEntity)(nil), "swarming.v1.PhysicalEntity")
	proto.RegisterType((*CASStats)(nil), "swarming.v1.CASStats")
	proto.RegisterType((*NamedCacheStats)(nil), "swarming.v1.NamedCacheStats")
	proto.RegisterType((*CIPDPackageCacheStats)(nil), "swarming.v1.CIPDPackageCacheStats")
	proto.RegisterType((*BotEvent)(nil), "swarming.v1.BotEvent")
	proto.RegisterType((*CASTree)(nil), "swarming.v1.CASTree")
	proto.RegisterType((*CIPDPackage)(nil), "swarming.v1.CIPDPackage")
	proto.RegisterType((*NamedCacheEntry)(nil), "swarming.v1.NamedCacheEntry")
	proto.RegisterType((*Containment)(nil), "swarming.v1.Containment")
	proto.RegisterType((*TaskProperties)(nil), "swarming.v1.TaskProperties")
	proto.RegisterType((*TaskSlice)(nil), "swarming.v1.TaskSlice")
	proto.RegisterType((*TaskRequest)(nil), "swarming.v1.TaskRequest")
	proto.RegisterType((*PubSub)(nil), "swarming.v1.PubSub")
	proto.RegisterType((*TaskResult)(nil), "swarming.v1.TaskResult")
	proto.RegisterType((*CIPDPins)(nil), "swarming.v1.CIPDPins")
	proto.RegisterType((*TaskPerformance)(nil), "swarming.v1.TaskPerformance")
	proto.RegisterType((*TaskOverheadStats)(nil), "swarming.v1.TaskOverheadStats")
	proto.RegisterType((*CASEntriesStats)(nil), "swarming.v1.CASEntriesStats")
}

func init() {
	proto.RegisterFile("go.chromium.org/luci/swarming/proto/api/swarming.proto", fileDescriptor_d3887eaa0fa60818)
}

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

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConnInterface

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6

// BotAPIClient is the client API for BotAPI service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type BotAPIClient interface {
	// Events returns events relating to one bot.
	Events(ctx context.Context, in *BotEventsRequest, opts ...grpc.CallOption) (*BotEventsResponse, error)
}
type botAPIPRPCClient struct {
	client *prpc.Client
}

func NewBotAPIPRPCClient(client *prpc.Client) BotAPIClient {
	return &botAPIPRPCClient{client}
}

func (c *botAPIPRPCClient) Events(ctx context.Context, in *BotEventsRequest, opts ...grpc.CallOption) (*BotEventsResponse, error) {
	out := new(BotEventsResponse)
	err := c.client.Call(ctx, "swarming.v1.BotAPI", "Events", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

type botAPIClient struct {
	cc grpc.ClientConnInterface
}

func NewBotAPIClient(cc grpc.ClientConnInterface) BotAPIClient {
	return &botAPIClient{cc}
}

func (c *botAPIClient) Events(ctx context.Context, in *BotEventsRequest, opts ...grpc.CallOption) (*BotEventsResponse, error) {
	out := new(BotEventsResponse)
	err := c.cc.Invoke(ctx, "/swarming.v1.BotAPI/Events", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// BotAPIServer is the server API for BotAPI service.
type BotAPIServer interface {
	// Events returns events relating to one bot.
	Events(context.Context, *BotEventsRequest) (*BotEventsResponse, error)
}

// UnimplementedBotAPIServer can be embedded to have forward compatible implementations.
type UnimplementedBotAPIServer struct {
}

func (*UnimplementedBotAPIServer) Events(ctx context.Context, req *BotEventsRequest) (*BotEventsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Events not implemented")
}

func RegisterBotAPIServer(s prpc.Registrar, srv BotAPIServer) {
	s.RegisterService(&_BotAPI_serviceDesc, srv)
}

func _BotAPI_Events_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BotEventsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BotAPIServer).Events(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/swarming.v1.BotAPI/Events",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BotAPIServer).Events(ctx, req.(*BotEventsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _BotAPI_serviceDesc = grpc.ServiceDesc{
	ServiceName: "swarming.v1.BotAPI",
	HandlerType: (*BotAPIServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Events",
			Handler:    _BotAPI_Events_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "go.chromium.org/luci/swarming/proto/api/swarming.proto",
}