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

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
}

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

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

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

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