// Code generated by protoc-gen-go. DO NOT EDIT.
// source: lab/dut_state.proto

package lab

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	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

// Next Tag: 5
type PeripheralState int32

const (
	// keep for all unknown states except working & not_connected.
	PeripheralState_UNKNOWN       PeripheralState = 0
	PeripheralState_WORKING       PeripheralState = 1
	PeripheralState_NOT_CONNECTED PeripheralState = 2
	PeripheralState_BROKEN        PeripheralState = 3
	PeripheralState_WRONG_CONFIG  PeripheralState = 4
)

var PeripheralState_name = map[int32]string{
	0: "UNKNOWN",
	1: "WORKING",
	2: "NOT_CONNECTED",
	3: "BROKEN",
	4: "WRONG_CONFIG",
}

var PeripheralState_value = map[string]int32{
	"UNKNOWN":       0,
	"WORKING":       1,
	"NOT_CONNECTED": 2,
	"BROKEN":        3,
	"WRONG_CONFIG":  4,
}

func (x PeripheralState) String() string {
	return proto.EnumName(PeripheralState_name, int32(x))
}

func (PeripheralState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_bfe5ddd3f74c848d, []int{0}
}

// Next Tag: 4
type HardwareState int32

const (
	// keep for all unknown state by default.
	HardwareState_HARDWARE_UNKNOWN          HardwareState = 0
	HardwareState_HARDWARE_NORMAL           HardwareState = 1
	HardwareState_HARDWARE_ACCEPTABLE       HardwareState = 2
	HardwareState_HARDWARE_NEED_REPLACEMENT HardwareState = 3
)

var HardwareState_name = map[int32]string{
	0: "HARDWARE_UNKNOWN",
	1: "HARDWARE_NORMAL",
	2: "HARDWARE_ACCEPTABLE",
	3: "HARDWARE_NEED_REPLACEMENT",
}

var HardwareState_value = map[string]int32{
	"HARDWARE_UNKNOWN":          0,
	"HARDWARE_NORMAL":           1,
	"HARDWARE_ACCEPTABLE":       2,
	"HARDWARE_NEED_REPLACEMENT": 3,
}

func (x HardwareState) String() string {
	return proto.EnumName(HardwareState_name, int32(x))
}

func (HardwareState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_bfe5ddd3f74c848d, []int{1}
}

// CR50-related configs by definition shouldn't be a state config, but a build config.
// However, we don't have a way to source it from any external configuration system,
// and it's changed frequently enough to handle cr50 tests, which makes
// it basically impossible for manual updatings: See crbug.com/1057145 for the
// troubles it causes.
//
// So we temporarily set it in state config so that repair job can update it.
// For further changes of it, please see tracking bug crbug.com/1057719.
//
// phases for cr50 module. Next Tag: 3
type DutState_CR50Phase int32

const (
	DutState_CR50_PHASE_INVALID DutState_CR50Phase = 0
	DutState_CR50_PHASE_PREPVT  DutState_CR50Phase = 1
	DutState_CR50_PHASE_PVT     DutState_CR50Phase = 2
)

var DutState_CR50Phase_name = map[int32]string{
	0: "CR50_PHASE_INVALID",
	1: "CR50_PHASE_PREPVT",
	2: "CR50_PHASE_PVT",
}

var DutState_CR50Phase_value = map[string]int32{
	"CR50_PHASE_INVALID": 0,
	"CR50_PHASE_PREPVT":  1,
	"CR50_PHASE_PVT":     2,
}

func (x DutState_CR50Phase) String() string {
	return proto.EnumName(DutState_CR50Phase_name, int32(x))
}

func (DutState_CR50Phase) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_bfe5ddd3f74c848d, []int{0, 0}
}

// key env for cr50 RW version. Next Tag: 3
type DutState_CR50KeyEnv int32

const (
	DutState_CR50_KEYENV_INVALID DutState_CR50KeyEnv = 0
	DutState_CR50_KEYENV_PROD    DutState_CR50KeyEnv = 1
	DutState_CR50_KEYENV_DEV     DutState_CR50KeyEnv = 2
)

var DutState_CR50KeyEnv_name = map[int32]string{
	0: "CR50_KEYENV_INVALID",
	1: "CR50_KEYENV_PROD",
	2: "CR50_KEYENV_DEV",
}

var DutState_CR50KeyEnv_value = map[string]int32{
	"CR50_KEYENV_INVALID": 0,
	"CR50_KEYENV_PROD":    1,
	"CR50_KEYENV_DEV":     2,
}

func (x DutState_CR50KeyEnv) String() string {
	return proto.EnumName(DutState_CR50KeyEnv_name, int32(x))
}

func (DutState_CR50KeyEnv) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_bfe5ddd3f74c848d, []int{0, 1}
}

// Next Tag: 10
type DutState struct {
	Id                  *ChromeOSDeviceID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Servo               PeripheralState   `protobuf:"varint,2,opt,name=servo,proto3,enum=lab.PeripheralState" json:"servo,omitempty"`
	Chameleon           PeripheralState   `protobuf:"varint,3,opt,name=chameleon,proto3,enum=lab.PeripheralState" json:"chameleon,omitempty"`
	AudioLoopbackDongle PeripheralState   `protobuf:"varint,4,opt,name=audio_loopback_dongle,json=audioLoopbackDongle,proto3,enum=lab.PeripheralState" json:"audio_loopback_dongle,omitempty"`
	// Indicate how many working bluetooth btpeer for a device.
	WorkingBluetoothBtpeer int32              `protobuf:"varint,5,opt,name=working_bluetooth_btpeer,json=workingBluetoothBtpeer,proto3" json:"working_bluetooth_btpeer,omitempty"`
	Cr50Phase              DutState_CR50Phase `protobuf:"varint,6,opt,name=cr50_phase,json=cr50Phase,proto3,enum=lab.DutState_CR50Phase" json:"cr50_phase,omitempty"`
	// Detected based on the cr50 RW version that the DUT is running on.
	Cr50KeyEnv DutState_CR50KeyEnv `protobuf:"varint,7,opt,name=cr50_key_env,json=cr50KeyEnv,proto3,enum=lab.DutState_CR50KeyEnv" json:"cr50_key_env,omitempty"`
	// Detected during running admin_audit task.
	StorageState         HardwareState `protobuf:"varint,8,opt,name=storage_state,json=storageState,proto3,enum=lab.HardwareState" json:"storage_state,omitempty"`
	ServoUsbState        HardwareState `protobuf:"varint,9,opt,name=servo_usb_state,json=servoUsbState,proto3,enum=lab.HardwareState" json:"servo_usb_state,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

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

var xxx_messageInfo_DutState proto.InternalMessageInfo

func (m *DutState) GetId() *ChromeOSDeviceID {
	if m != nil {
		return m.Id
	}
	return nil
}

func (m *DutState) GetServo() PeripheralState {
	if m != nil {
		return m.Servo
	}
	return PeripheralState_UNKNOWN
}

func (m *DutState) GetChameleon() PeripheralState {
	if m != nil {
		return m.Chameleon
	}
	return PeripheralState_UNKNOWN
}

func (m *DutState) GetAudioLoopbackDongle() PeripheralState {
	if m != nil {
		return m.AudioLoopbackDongle
	}
	return PeripheralState_UNKNOWN
}

func (m *DutState) GetWorkingBluetoothBtpeer() int32 {
	if m != nil {
		return m.WorkingBluetoothBtpeer
	}
	return 0
}

func (m *DutState) GetCr50Phase() DutState_CR50Phase {
	if m != nil {
		return m.Cr50Phase
	}
	return DutState_CR50_PHASE_INVALID
}

func (m *DutState) GetCr50KeyEnv() DutState_CR50KeyEnv {
	if m != nil {
		return m.Cr50KeyEnv
	}
	return DutState_CR50_KEYENV_INVALID
}

func (m *DutState) GetStorageState() HardwareState {
	if m != nil {
		return m.StorageState
	}
	return HardwareState_HARDWARE_UNKNOWN
}

func (m *DutState) GetServoUsbState() HardwareState {
	if m != nil {
		return m.ServoUsbState
	}
	return HardwareState_HARDWARE_UNKNOWN
}

func init() {
	proto.RegisterEnum("lab.PeripheralState", PeripheralState_name, PeripheralState_value)
	proto.RegisterEnum("lab.HardwareState", HardwareState_name, HardwareState_value)
	proto.RegisterEnum("lab.DutState_CR50Phase", DutState_CR50Phase_name, DutState_CR50Phase_value)
	proto.RegisterEnum("lab.DutState_CR50KeyEnv", DutState_CR50KeyEnv_name, DutState_CR50KeyEnv_value)
	proto.RegisterType((*DutState)(nil), "lab.DutState")
}

func init() { proto.RegisterFile("lab/dut_state.proto", fileDescriptor_bfe5ddd3f74c848d) }

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