var CallServoXmlRpcResponse_Status_name = map[int32]string{
    0:  "STATUS_UNKNOWN",
    1:  "STATUS_OK",
    2:  "STATUS_BAD_DUT",
    3:  "STATUS_NO_METHOD",
    4:  "STATUS_NO_SERVO",
    5:  "STATUS_SERVO_ERROR",
}

var CallServoXmlRpcResponse_Status_value = map[string]int32{
    "STATUS_UNKNOWN":     0,
    "STATUS_OK":          1,
    "STATUS_BAD_DUT":     2,
    "STATUS_NO_METHOD":   3,
    "STATUS_NO_SERVO":    4,
    "STATUS_SERVO_ERROR": 5,
}

var Output_name = map[int32]string{
    0:  "OUTPUT_PIPE",
    1:  "OUTPUT_STDOUT",
}

var Output_value = map[string]int32{
    "OUTPUT_PIPE":   0,
    "OUTPUT_STDOUT": 1,
}

var ProvisionResponse_Reason_name = map[int32]string{
    0:  "REASON_INVALID_REQUEST",
    1:  "REASON_DUT_UNREACHABLE_PRE_PROVISION",
    2:  "REASON_DOWNLOADING_IMAGE_FAILED",
    3:  "REASON_PROVISIONING_TIMEDOUT",
    4:  "REASON_PROVISIONING_FAILED",
    5:  "REASON_DUT_UNREACHABLE_POST_PROVISION",
}

var ProvisionResponse_Reason_value = map[string]int32{
    "REASON_INVALID_REQUEST":                0,
    "REASON_DUT_UNREACHABLE_PRE_PROVISION":  1,
    "REASON_DOWNLOADING_IMAGE_FAILED":       2,
    "REASON_PROVISIONING_TIMEDOUT":          3,
    "REASON_PROVISIONING_FAILED":            4,
    "REASON_DUT_UNREACHABLE_POST_PROVISION": 5,
}

var SetDutPowerSupplyRequest_State_name = map[int32]string{
    0:  "STATE_UNKNOWN",
    1:  "STATE_ON",
    2:  "STATE_OFF",
}

var SetDutPowerSupplyRequest_State_value = map[string]int32{
    "STATE_UNKNOWN": 0,
    "STATE_ON":      1,
    "STATE_OFF":     2,
}

var SetDutPowerSupplyResponse_Status_name = map[int32]string{
    0:  "STATUS_UNKNOWN",
    1:  "STATUS_OK",
    2:  "STATUS_BAD_DUT",
    3:  "STATUS_BAD_REQUEST",
    4:  "STATUS_NO_RPM",
    5:  "STATUS_RPM_ERROR",
}

var SetDutPowerSupplyResponse_Status_value = map[string]int32{
    "STATUS_UNKNOWN":     0,
    "STATUS_OK":          1,
    "STATUS_BAD_DUT":     2,
    "STATUS_BAD_REQUEST": 3,
    "STATUS_NO_RPM":      4,
    "STATUS_RPM_ERROR":   5,
}

type CacheForDutMetadata struct {
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

type CacheForDutRequest struct {
    // url identifies the resource to cache.
    // Only http, https, and gs schemes are supported. The resource to cache MUST
    // be accessible from the service. The implementation MAY use
    // implementation-specific credentials to attempt to access resources.
    Url string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
    // dut_name is the resource name for the DUT.
    // The DUT name is passed to the RTD when the RTD is started.
    // It is not specified whether the name is the DUT hostname.
    DutName              string   `protobuf:"bytes,2,opt,name=dut_name,json=dutName,proto3" json:"dut_name,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

type CacheForDutResponse struct {
    // url is where the resource is cached at.
    // This MUST be accessible to the DUT.
    // If the host part of the url is a name, it MUST be resolvable by the DUT
    // via standard name resolution facilities.
    Url                  string   `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

type CallServoXmlRpcRequest struct {
    Dut                  string          `protobuf:"bytes,1,opt,name=dut,proto3" json:"dut,omitempty"`
    Method               string          `protobuf:"bytes,2,opt,name=method,proto3" json:"method,omitempty"`
    Args                 []*xmlrpc.Value `protobuf:"bytes,3,rep,name=args,proto3" json:"args,omitempty"`
    XXX_NoUnkeyedLiteral struct{}        `json:"-"`
    XXX_unrecognized     []byte          `json:"-"`
    XXX_sizecache        int32           `json:"-"`
}

type CallServoXmlRpcResponse struct {
    Status CallServoXmlRpcResponse_Status `protobuf:"varint,1,opt,name=status,proto3,enum=chromiumos.config.api.test.tls.CallServoXmlRpcResponse_Status" json:"status,omitempty"`
    Value  *xmlrpc.Value                  `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
    // fault indicates that the servo XML-RPC returned a fault.
    // The fault value is stored in the value field.
    Fault                bool     `protobuf:"varint,3,opt,name=fault,proto3" json:"fault,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

type CallServoXmlRpcResponse_Status int32

const (
    CallServoXmlRpcResponse_STATUS_UNKNOWN CallServoXmlRpcResponse_Status = 0
    CallServoXmlRpcResponse_STATUS_OK      CallServoXmlRpcResponse_Status = 1
    // STATUS_BAD_DUT indicates that the DUT is not known,
    // or the caller does not have access to it.
    CallServoXmlRpcResponse_STATUS_BAD_DUT CallServoXmlRpcResponse_Status = 2
    // STATUS_NO_METHOD indicates that the requested method does not
    // exist.
    CallServoXmlRpcResponse_STATUS_NO_METHOD   CallServoXmlRpcResponse_Status = 3
    CallServoXmlRpcResponse_STATUS_NO_SERVO    CallServoXmlRpcResponse_Status = 4
    CallServoXmlRpcResponse_STATUS_SERVO_ERROR CallServoXmlRpcResponse_Status = 5
)

type CommonClient interface {
    // ExecDutCommand runs a command on a DUT.
    //
    // The working directory is /.
    // A tty is not spawned for the command.
    // The user and group is root.
    // All signals have their default dispositions and are not masked.
    // The umask is set to 0.
    //
    // The environment contains:
    //
    //   TERM=dumb
    //   PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/opt/bin
    //   LANG=en_US.UTF-8
    //   USER=root
    //   HOME=/root
    //
    // The environment MAY also contain SSH client variables.
    // The environment SHALL NOT contain variables not mentioned above.
    //
    // If the stream is interrupted, the implementation MAY attempt to
    // stop the command by sending SIGINT, SIGHUP, SIGTERM, or SIGKILL.
    ExecDutCommand(ctx context.Context, in *ExecDutCommandRequest, opts ...grpc.CallOption) (Common_ExecDutCommandClient, error)
    // Provision installs a specified version of Chrome OS on the DUT, along with
    // any specified DLCs.
    //
    // If the DUT is already on the specified version of Chrome OS, the OS will
    // not be provisioned.
    //
    // If the DUT already has the specified list of DLCs, only the missing DLCs
    // will be provisioned.
    Provision(ctx context.Context, in *ProvisionRequest, opts ...grpc.CallOption) (*longrunning.Operation, error)
    // FetchCrashes gets a stream of all crash reports currently on the DUT.
    //
    // The stream returned may split up a crash over multiple
    // `FetchCrashesResponse` protos. See the definition of that proto for
    // details.
    //
    // This call is read-only: it doesn't delete the crashes that it reads.
    FetchCrashes(ctx context.Context, in *FetchCrashesRequest, opts ...grpc.CallOption) (Common_FetchCrashesClient, error)
}

type CommonServer interface {
    // ExecDutCommand runs a command on a DUT.
    //
    // The working directory is /.
    // A tty is not spawned for the command.
    // The user and group is root.
    // All signals have their default dispositions and are not masked.
    // The umask is set to 0.
    //
    // The environment contains:
    //
    //   TERM=dumb
    //   PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/opt/bin
    //   LANG=en_US.UTF-8
    //   USER=root
    //   HOME=/root
    //
    // The environment MAY also contain SSH client variables.
    // The environment SHALL NOT contain variables not mentioned above.
    //
    // If the stream is interrupted, the implementation MAY attempt to
    // stop the command by sending SIGINT, SIGHUP, SIGTERM, or SIGKILL.
    ExecDutCommand(*ExecDutCommandRequest, Common_ExecDutCommandServer) error
    // Provision installs a specified version of Chrome OS on the DUT, along with
    // any specified DLCs.
    //
    // If the DUT is already on the specified version of Chrome OS, the OS will
    // not be provisioned.
    //
    // If the DUT already has the specified list of DLCs, only the missing DLCs
    // will be provisioned.
    Provision(context.Context, *ProvisionRequest) (*longrunning.Operation, error)
    // FetchCrashes gets a stream of all crash reports currently on the DUT.
    //
    // The stream returned may split up a crash over multiple
    // `FetchCrashesResponse` protos. See the definition of that proto for
    // details.
    //
    // This call is read-only: it doesn't delete the crashes that it reads.
    FetchCrashes(*FetchCrashesRequest, Common_FetchCrashesServer) error
}

type Common_ExecDutCommandClient interface {
    Recv() (*ExecDutCommandResponse, error)
    grpc.ClientStream
}

type Common_ExecDutCommandServer interface {
    Send(*ExecDutCommandResponse) error
    grpc.ServerStream
}

type Common_FetchCrashesClient interface {
    Recv() (*FetchCrashesResponse, error)
    grpc.ClientStream
}

type Common_FetchCrashesServer interface {
    Send(*FetchCrashesResponse) error
    grpc.ServerStream
}

type CrashBlob struct {
    // This value is a UTF8, human-readable, description of the data.
    Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
    // The value is a blob (e.g. a file from sysfs or a minidump), which need
    // not be valid UTF-8, and may be large.
    Blob                 []byte   `protobuf:"bytes,2,opt,name=blob,proto3" json:"blob,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

type CrashInfo struct {
    // Name of executable that crashed (e.g. "chrome")
    ExecName string `protobuf:"bytes,1,opt,name=exec_name,json=execName,proto3" json:"exec_name,omitempty"`
    // Product name (e.g. "Chrome_ChromeOS" or "ChromeOS")
    Prod string `protobuf:"bytes,2,opt,name=prod,proto3" json:"prod,omitempty"`
    // Product version (e.g. "12345.0.0")
    Ver string `protobuf:"bytes,3,opt,name=ver,proto3" json:"ver,omitempty"`
    // Crash signature (may not be populated for all crashes)
    Sig string `protobuf:"bytes,4,opt,name=sig,proto3" json:"sig,omitempty"`
    // The name of the integration test that was running when this crash
    // happened, if any.
    InProgressIntegrationTest string `protobuf:"bytes,5,opt,name=in_progress_integration_test,json=inProgressIntegrationTest,proto3" json:"in_progress_integration_test,omitempty"`
    // The name of the collector (e.g. chrome_collector, arc_collector)
    Collector string `protobuf:"bytes,6,opt,name=collector,proto3" json:"collector,omitempty"`
    // Additional key-value pairs of metadata (e.g. "crash_loop_mode = true").
    // These should be included in any POSTs to the crash server in a standard
    // POST form, as seen in CreateCrashFormData.
    // (despite the fact that this message is a subfield, it should be a flat
    // structure in any POSTs).
    Fields               []*CrashMetadata `protobuf:"bytes,7,rep,name=fields,proto3" json:"fields,omitempty"`
    XXX_NoUnkeyedLiteral struct{}         `json:"-"`
    XXX_unrecognized     []byte           `json:"-"`
    XXX_sizecache        int32            `json:"-"`
}

type CrashMetadata struct {
    // This value is a UTF8, human-readable, description of the data.
    Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
    // The value will be a human-readable string (e.g. "12345.0.0"), which must
    // be valid UTF-8.
    Text                 string   `protobuf:"bytes,2,opt,name=text,proto3" json:"text,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

type ExecDutCommandRequest struct {
    // name is the resource name for the DUT.
    // The DUT name is passed to the RTD when the RTD is started.
    // It is not specified whether the name is the DUT hostname.
    Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
    // command is the command to run.
    // If this contains no slashes, it is resolved using PATH.
    // If this starts with /, it is used as an absolute path to the
    // program to run.
    // Otherwise, this is treated as a path relative to the working
    // directory.
    Command string `protobuf:"bytes,2,opt,name=command,proto3" json:"command,omitempty"`
    // args are the arguments to pass to the command.
    Args []string `protobuf:"bytes,3,rep,name=args,proto3" json:"args,omitempty"`
    // stdin is passed to the command as the program's stdin.
    // The stream does not support seeking.
    // An empty bytes is not treated specially; if the command reads
    // from stdin, it will receive zero bytes.
    Stdin []byte `protobuf:"bytes,4,opt,name=stdin,proto3" json:"stdin,omitempty"`
    // stdout indicates how to handle the command's stdout.
    Stdout Output `protobuf:"varint,5,opt,name=stdout,proto3,enum=chromiumos.config.api.test.tls.Output" json:"stdout,omitempty"`
    // stderr indicates how to handle the command's stderr.
    Stderr               Output   `protobuf:"varint,6,opt,name=stderr,proto3,enum=chromiumos.config.api.test.tls.Output" json:"stderr,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

type ExecDutCommandResponse struct {
    // exit_info contains exit information.
    // This is set when the command has exited or failed to start.
    // This is set on the last message in the response stream.
    ExitInfo *ExecDutCommandResponse_ExitInfo `protobuf:"bytes,1,opt,name=exit_info,json=exitInfo,proto3" json:"exit_info,omitempty"`
    // stdout contains the shell command's stdout output since the last
    // response in the stream.
    // The implementation MAY batch or delay output to later
    // responses in the stream.
    Stdout []byte `protobuf:"bytes,2,opt,name=stdout,proto3" json:"stdout,omitempty"`
    // stderr contains the shell command's stderr output since the last
    // response in the stream.
    // The implementation MAY batch or delay output to later
    // responses in the stream.
    Stderr               []byte   `protobuf:"bytes,3,opt,name=stderr,proto3" json:"stderr,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

type ExecDutCommandResponse_ExitInfo struct {
    // status provides information about how the command process
    // terminated.
    //
    // If the command failed to start, status is set to an arbitrary
    // non-zero value.
    //
    // If signaled is set, status is set to the signal that caused
    // the command to terminate.
    //
    // Otherwise, status is set to the exit status of the process.
    // Exit statuses outside of 0 to 255 inclusive are not supported;
    // they will be mapped to an arbitrary non-zero value.
    //
    // status is zero if and only if the process was successfully
    // started and exited with a zero status.
    Status int32 `protobuf:"varint,1,opt,name=status,proto3" json:"status,omitempty"`
    // signaled indicates whether the command exited due to a signal.
    // If set, status contains the signal.
    Signaled bool `protobuf:"varint,2,opt,name=signaled,proto3" json:"signaled,omitempty"`
    // started indicates whether the command was started.
    Started bool `protobuf:"varint,3,opt,name=started,proto3" json:"started,omitempty"`
    // error_message provides a human readable explanation for some errors.
    // This MUST NOT be inspected by programs.
    ErrorMessage         string   `protobuf:"bytes,4,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

type ExposePortToDutRequest struct {
    // dut_name is the resource name for the DUT.
    // The DUT name is passed to the RTD when the RTD is started.
    // It is not specified whether the name is the DUT hostname.
    DutName string `protobuf:"bytes,1,opt,name=dut_name,json=dutName,proto3" json:"dut_name,omitempty"`
    // local_port is the port of a service running inside the RTD container to
    // expose. It MUST be in the range of [1, 65535] as defined in RFC 1700
    // (http://https://tools.ietf.org/html/rfc1700).
    // A client MAY bind to the special port number "0" from inside an RTD to get
    // an OS assigned free port number without race condition. Then the client
    // MUST get the real port number assigned and pass it to "local_port" here.
    LocalPort int32 `protobuf:"varint,2,opt,name=local_port,json=localPort,proto3" json:"local_port,omitempty"`
    // require_remote_proxy indicates if the implementation SHOULD use a DUT
    // reachable server as a proxy and return the address and port of the proxy
    // server.
    // If require_remote_proxy is set, the exposed port SHOULD persist across DUT
    // reboots.
    // If require_remote_proxy is set but an implementation cannot provide a
    // remote proxy, the implementation SHOULD return FAILED_PRECONDITION.
    // If require_remote_proxy is not set, the implementation MAY expose a port
    // that cannot persist across DUT reboots.
    // If require_remote_proxy is not set, the implementation MAY use 'localhost'
    // as the exposed address.
    RequireRemoteProxy   bool     `protobuf:"varint,3,opt,name=require_remote_proxy,json=requireRemoteProxy,proto3" json:"require_remote_proxy,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

type ExposePortToDutResponse struct {
    // exposed_address is the address reachable by the requesting DUT.
    // TLEs SHOULD return an IPv4 or IPv6 address to avoid name resolution
    // issues.
    // IPv4 addresses MUST be in standard dotted decimal notation.
    // IPv6 addresses MUST be formatted according to RFC4291, Section 2.2. The
    // mixed IPv4 and IPv6 form MUST NOT be used.
    // If TLEs return a hostname, they SHOULD ensure that the hostname can be
    // resolved by the DUT via standard name resolution facilities.
    ExposedAddress string `protobuf:"bytes,1,opt,name=exposed_address,json=exposedAddress,proto3" json:"exposed_address,omitempty"`
    // exposed_port is the port on the exposed_address which is reachable from
    // the DUT.
    ExposedPort          int32    `protobuf:"varint,2,opt,name=exposed_port,json=exposedPort,proto3" json:"exposed_port,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

type FetchCrashesRequest struct {
    // dut is the resource name for the DUT from which to fetch crashes.
    // The DUT name is passed to the RTD when the RTD is started.
    // It is not specified whether the name is the DUT hostname.
    Dut string `protobuf:"bytes,1,opt,name=dut,proto3" json:"dut,omitempty"`
    // If true, fetch the core file.
    // For uploads to the crash server, that should generally be false.
    // If the crash file is likely to be used for manual debugging (e.g. on
    // a manually-invoked test suite run), this might be true.
    // Coredumps can be extremely large (even gigabytes), so if resource usage
    // is a concern, this should probably be false.
    FetchCore            bool     `protobuf:"varint,2,opt,name=fetch_core,json=fetchCore,proto3" json:"fetch_core,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

type FetchCrashesResponse struct {
    // Crash id. unique only within responses to a single FetchCrashes request.
    // Used to assemble multiple streamed |FetchCrashesResponse| protos into a
    // single crash report.
    CrashId int64 `protobuf:"varint,1,opt,name=crash_id,json=crashId,proto3" json:"crash_id,omitempty"`
    // Types that are valid to be assigned to Data:
    //	*FetchCrashesResponse_Crash
    //	*FetchCrashesResponse_Blob
    //	*FetchCrashesResponse_Core
    Data                 isFetchCrashesResponse_Data `protobuf_oneof:"data"`
    XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
    XXX_unrecognized     []byte                      `json:"-"`
    XXX_sizecache        int32                       `json:"-"`
}

type FetchCrashesResponse_Blob struct {
    Blob *CrashBlob `protobuf:"bytes,3,opt,name=blob,proto3,oneof"`
}

type FetchCrashesResponse_Core struct {
    Core []byte `protobuf:"bytes,4,opt,name=core,proto3,oneof"`
}

type FetchCrashesResponse_Crash struct {
    Crash *CrashInfo `protobuf:"bytes,2,opt,name=crash,proto3,oneof"`
}

type OpenDutPortRequest struct {
    // name is the resource name for the DUT.
    // The DUT name is passed to the RTD when the RTD is started.
    // It is not specified whether the name is the DUT hostname.
    Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
    // port is the port to open on the DUT.
    Port                 int32    `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

type OpenDutPortResponse struct {
    // address for which a port is forwarded to the DUT.
    // TLEs SHOULD return an IPv4 or IPv6 address to avoid name
    // resolution issues.
    // IPv4 addresses MUST be in standard dotted decimal notation.
    // IPv6 addresses MUST be formatted according to RFC4291, Section
    // 2.2.  The mixed IPv4 and IPv6 form MUST NOT be used.
    // If TLEs return a hostname, they SHOULD ensure that the hostname
    // can be resolved by the RTD via standard name resolution
    // facilities.
    Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
    // port on the address which is forwarded to the DUT.
    Port                 int32    `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

type Output int32

const (
    // OUTPUT_PIPE means to collect output and return it.
    Output_OUTPUT_PIPE Output = 0
    // OUTPUT_STDOUT is a special value for stderr which means to merge stderr
    // into stdout.
    Output_OUTPUT_STDOUT Output = 1
)

type ProvisionMetadata struct {
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

type ProvisionRequest struct {
    // name is the resource name for the DUT.
    // The DUT name is passed to the RTD when the RTD is started.
    // It is not specified whether the name is the DUT hostname.
    Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
    // image specifies the Chrome OS image with which to provision the DUT.
    Image *ProvisionRequest_ChromeOSImage `protobuf:"bytes,2,opt,name=image,proto3" json:"image,omitempty"`
    // dlc_specs specifies which DLCs to install on the DUT after provisioning.
    DlcSpecs             []*ProvisionRequest_DLCSpec `protobuf:"bytes,3,rep,name=dlc_specs,json=dlcSpecs,proto3" json:"dlc_specs,omitempty"`
    XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
    XXX_unrecognized     []byte                      `json:"-"`
    XXX_sizecache        int32                       `json:"-"`
}

type ProvisionRequest_ChromeOSImage struct {
    // Types that are valid to be assigned to PathOneof:
    //	*ProvisionRequest_ChromeOSImage_GsPathPrefix
    PathOneof            isProvisionRequest_ChromeOSImage_PathOneof `protobuf_oneof:"path_oneof"`
    XXX_NoUnkeyedLiteral struct{}                                   `json:"-"`
    XXX_unrecognized     []byte                                     `json:"-"`
    XXX_sizecache        int32                                      `json:"-"`
}

type ProvisionRequest_ChromeOSImage_GsPathPrefix struct {
    GsPathPrefix string `protobuf:"bytes,1,opt,name=gs_path_prefix,json=gsPathPrefix,proto3,oneof"`
}

type ProvisionRequest_DLCSpec struct {
    // id is the DLC ID which is a unique identifier.
    // The DLC ID must follow a specific format that can be found in the DLC
    // developer doc below.
    Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

type ProvisionResponse struct {
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

type ProvisionResponse_Reason int32

const (
    // status code: INVALID_ARGUMENT
    ProvisionResponse_REASON_INVALID_REQUEST ProvisionResponse_Reason = 0
    // status code: FAILED_PRECONDITION
    ProvisionResponse_REASON_DUT_UNREACHABLE_PRE_PROVISION ProvisionResponse_Reason = 1
    // status code: FAILED_PRECONDITION
    ProvisionResponse_REASON_DOWNLOADING_IMAGE_FAILED ProvisionResponse_Reason = 2
    // status code: DEADLINE_EXCEEDED
    ProvisionResponse_REASON_PROVISIONING_TIMEDOUT ProvisionResponse_Reason = 3
    // status code: ABORTED
    ProvisionResponse_REASON_PROVISIONING_FAILED ProvisionResponse_Reason = 4
    // status code: ABORTED
    ProvisionResponse_REASON_DUT_UNREACHABLE_POST_PROVISION ProvisionResponse_Reason = 5
)

type SetDutPowerSupplyRequest struct {
    Dut                  string                         `protobuf:"bytes,1,opt,name=dut,proto3" json:"dut,omitempty"`
    State                SetDutPowerSupplyRequest_State `protobuf:"varint,2,opt,name=state,proto3,enum=chromiumos.config.api.test.tls.SetDutPowerSupplyRequest_State" json:"state,omitempty"`
    XXX_NoUnkeyedLiteral struct{}                       `json:"-"`
    XXX_unrecognized     []byte                         `json:"-"`
    XXX_sizecache        int32                          `json:"-"`
}

type SetDutPowerSupplyRequest_State int32

const (
    SetDutPowerSupplyRequest_STATE_UNKNOWN SetDutPowerSupplyRequest_State = 0
    SetDutPowerSupplyRequest_STATE_ON      SetDutPowerSupplyRequest_State = 1
    SetDutPowerSupplyRequest_STATE_OFF     SetDutPowerSupplyRequest_State = 2
)

type SetDutPowerSupplyResponse struct {
    Status SetDutPowerSupplyResponse_Status `protobuf:"varint,1,opt,name=status,proto3,enum=chromiumos.config.api.test.tls.SetDutPowerSupplyResponse_Status" json:"status,omitempty"`
    // reason provides human friendly context for any error status.
    Reason               string   `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"`
    XXX_NoUnkeyedLiteral struct{} `json:"-"`
    XXX_unrecognized     []byte   `json:"-"`
    XXX_sizecache        int32    `json:"-"`
}

type SetDutPowerSupplyResponse_Status int32

const (
    SetDutPowerSupplyResponse_STATUS_UNKNOWN SetDutPowerSupplyResponse_Status = 0
    SetDutPowerSupplyResponse_STATUS_OK      SetDutPowerSupplyResponse_Status = 1
    // STATUS_BAD_DUT indicates that the DUT is not known,
    // or the caller does not have access to it.
    SetDutPowerSupplyResponse_STATUS_BAD_DUT SetDutPowerSupplyResponse_Status = 2
    // STATUS_BAD_REQUEST indicates that the request was invalid,
    // e.g., passing an invalid state.
    SetDutPowerSupplyResponse_STATUS_BAD_REQUEST SetDutPowerSupplyResponse_Status = 3
    SetDutPowerSupplyResponse_STATUS_NO_RPM      SetDutPowerSupplyResponse_Status = 4
    SetDutPowerSupplyResponse_STATUS_RPM_ERROR   SetDutPowerSupplyResponse_Status = 5
)

type UnimplementedCommonServer struct {
}

type UnimplementedWiringServer struct {
}

type WiringClient interface {
    // Open a port on the DUT and return an address which the client can
    // use to connect to the port on the DUT.
    // The TLE SHOULD attempt to keep this address-to-port connection open for
    // the duration of the RTD's runtime.
    // The connection is not restarted if it is interrupted.
    //
    // If the connection from a previous call with the same arguments is
    // still open, this RPC SHOULD do nothing and return the same
    // response.
    // If the previous connection was closed, the implementation SHOULD
    // attempt to rebind and return the same address.
    // If the implementation lost and cannot reobtain the previous
    // address, it MAY return a new address.
    //
    // This RPC does NOT ensure that there is a service running on the
    // DUT for the given port.
    // A service running on the given port MUST NOT required for this RPC
    // to succeed.
    // It is not specified whether this RPC will open the given port in
    // the DUT's firewall, if the DUT has a firewall.
    OpenDutPort(ctx context.Context, in *OpenDutPortRequest, opts ...grpc.CallOption) (*OpenDutPortResponse, error)
    // SetDutPowerSupply sets the connected power state for the DUT.  It is
    // the caller's responsibility to wait for the effects of the call
    // to propagate, e.g. waiting in between calls to set the power OFF
    // and ON.
    //
    // EXPERIMENTAL
    SetDutPowerSupply(ctx context.Context, in *SetDutPowerSupplyRequest, opts ...grpc.CallOption) (*SetDutPowerSupplyResponse, error)
    // CacheForDut caches some data to be accessible for the DUT.
    // This will be made available to the DUT via a returned URL.
    // The implementation MUST ensure the returned URL is usable at least for the
    // lifetime of the RTD invocation.
    CacheForDut(ctx context.Context, in *CacheForDutRequest, opts ...grpc.CallOption) (*longrunning.Operation, error)
    // CallServoXmlRpc performs an XML-RPC call against the servo connected to a
    // DUT.
    //
    // This RPC mirrors the XML-RPC specification (http://xmlrpc.com/spec.md).
    //
    // EXPERIMENTAL
    CallServoXmlRpc(ctx context.Context, in *CallServoXmlRpcRequest, opts ...grpc.CallOption) (*CallServoXmlRpcResponse, error)
    // ExposePortToDut exposes an RTD port to the specified DUT.
    //
    // The TLE SHOULD attempt to keep this address-to-port connection open for
    // the duration of the RTD's runtime.
    // The connection is not restarted if it is interrupted.
    // By default, the implementation MAY expose a port that cannot persist
    // across DUT reboots.
    // By default, the implementation MAY use 'localhost' as the exposed address.
    ExposePortToDut(ctx context.Context, in *ExposePortToDutRequest, opts ...grpc.CallOption) (*ExposePortToDutResponse, error)
}

type WiringServer interface {
    // Open a port on the DUT and return an address which the client can
    // use to connect to the port on the DUT.
    // The TLE SHOULD attempt to keep this address-to-port connection open for
    // the duration of the RTD's runtime.
    // The connection is not restarted if it is interrupted.
    //
    // If the connection from a previous call with the same arguments is
    // still open, this RPC SHOULD do nothing and return the same
    // response.
    // If the previous connection was closed, the implementation SHOULD
    // attempt to rebind and return the same address.
    // If the implementation lost and cannot reobtain the previous
    // address, it MAY return a new address.
    //
    // This RPC does NOT ensure that there is a service running on the
    // DUT for the given port.
    // A service running on the given port MUST NOT required for this RPC
    // to succeed.
    // It is not specified whether this RPC will open the given port in
    // the DUT's firewall, if the DUT has a firewall.
    OpenDutPort(context.Context, *OpenDutPortRequest) (*OpenDutPortResponse, error)
    // SetDutPowerSupply sets the connected power state for the DUT.  It is
    // the caller's responsibility to wait for the effects of the call
    // to propagate, e.g. waiting in between calls to set the power OFF
    // and ON.
    //
    // EXPERIMENTAL
    SetDutPowerSupply(context.Context, *SetDutPowerSupplyRequest) (*SetDutPowerSupplyResponse, error)
    // CacheForDut caches some data to be accessible for the DUT.
    // This will be made available to the DUT via a returned URL.
    // The implementation MUST ensure the returned URL is usable at least for the
    // lifetime of the RTD invocation.
    CacheForDut(context.Context, *CacheForDutRequest) (*longrunning.Operation, error)
    // CallServoXmlRpc performs an XML-RPC call against the servo connected to a
    // DUT.
    //
    // This RPC mirrors the XML-RPC specification (http://xmlrpc.com/spec.md).
    //
    // EXPERIMENTAL
    CallServoXmlRpc(context.Context, *CallServoXmlRpcRequest) (*CallServoXmlRpcResponse, error)
    // ExposePortToDut exposes an RTD port to the specified DUT.
    //
    // The TLE SHOULD attempt to keep this address-to-port connection open for
    // the duration of the RTD's runtime.
    // The connection is not restarted if it is interrupted.
    // By default, the implementation MAY expose a port that cannot persist
    // across DUT reboots.
    // By default, the implementation MAY use 'localhost' as the exposed address.
    ExposePortToDut(context.Context, *ExposePortToDutRequest) (*ExposePortToDutResponse, error)
}