// Code generated by protoc-gen-go. DO NOT EDIT.
// source: test/rtd/v1/progress.proto

package invocation

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

// Enum entries *may* be added to this enum in the future.
type Result_State int32

const (
	// No end state specified. Must not be used.
	Result_STATE_UNSPECIFIED Result_State = 0
	// Test request succeeded. All was well.
	Result_SUCCEEDED Result_State = 1
	// Test request failed. See `error` for more information.
	Result_FAILED Result_State = 2
	// Test did not run because the Remote Test Driver decided to skip it.
	//
	// Common reasons a test may be skipped:
	//
	// * A runtime check by the Remote Test Driver concluded that the test is
	//   not applicable to the targeted device(s). The Remote Test Driver should
	//   include detailed reasons in `errors`.
	Result_SKIPPED Result_State = 3
)

var Result_State_name = map[int32]string{
	0: "STATE_UNSPECIFIED",
	1: "SUCCEEDED",
	2: "FAILED",
	3: "SKIPPED",
}

var Result_State_value = map[string]int32{
	"STATE_UNSPECIFIED": 0,
	"SUCCEEDED":         1,
	"FAILED":            2,
	"SKIPPED":           3,
}

func (x Result_State) String() string {
	return proto.EnumName(Result_State_name, int32(x))
}

func (Result_State) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_53459f08935e9319, []int{2, 0}
}

// Enum entries *may* be added in the future.
type Result_Error_Source int32

const (
	// No Source specified. Should not be used.
	//
	// If source is unspecified, the Test Lab Environment should assume the
	// source to be the Remote Test Driver.
	Result_Error_SOURCE_UNSPECIFIED Result_Error_Source = 0
	// The test failed.
	Result_Error_TEST Result_Error_Source = 1
	// There was an error in Remote Test Driver invocation.
	Result_Error_REMOTE_TEST_DRIVER Result_Error_Source = 2
	// There was an error in a Test Lab Services API call.
	Result_Error_TEST_LAB_SERVICES Result_Error_Source = 3
)

var Result_Error_Source_name = map[int32]string{
	0: "SOURCE_UNSPECIFIED",
	1: "TEST",
	2: "REMOTE_TEST_DRIVER",
	3: "TEST_LAB_SERVICES",
}

var Result_Error_Source_value = map[string]int32{
	"SOURCE_UNSPECIFIED": 0,
	"TEST":               1,
	"REMOTE_TEST_DRIVER": 2,
	"TEST_LAB_SERVICES":  3,
}

func (x Result_Error_Source) String() string {
	return proto.EnumName(Result_Error_Source_name, int32(x))
}

func (Result_Error_Source) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_53459f08935e9319, []int{2, 0, 0}
}

// Enum entries *may* be added in the future.
type Result_Error_Severity int32

const (
	// No Severity set. Should not be used.
	Result_Error_SEVERITY_UNSPECIFIED Result_Error_Severity = 0
	// Remote Test Server should validate that a Result contains a CRITICAL
	// message iff state == FAILED.
	Result_Error_CRITICAL Result_Error_Severity = 1
	// Must not, by itself, lead to a FAILED Result.state.
	Result_Error_WARNING Result_Error_Severity = 2
)

var Result_Error_Severity_name = map[int32]string{
	0: "SEVERITY_UNSPECIFIED",
	1: "CRITICAL",
	2: "WARNING",
}

var Result_Error_Severity_value = map[string]int32{
	"SEVERITY_UNSPECIFIED": 0,
	"CRITICAL":             1,
	"WARNING":              2,
}

func (x Result_Error_Severity) String() string {
	return proto.EnumName(Result_Error_Severity_name, int32(x))
}

func (Result_Error_Severity) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_53459f08935e9319, []int{2, 0, 1}
}

// Configuration data needed by clients of ProgressSink.
type ProgressSinkClientConfig struct {
	// Local TCP port to be used by the Remote Test Driver to communicate with
	// InvocationProgressSink service.
	Port                 int32    `protobuf:"varint,1,opt,name=port,proto3" json:"port,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ProgressSinkClientConfig proto.InternalMessageInfo

func (m *ProgressSinkClientConfig) GetPort() int32 {
	if m != nil {
		return m.Port
	}
	return 0
}

type ReportResultRequest struct {
	// The request to report results for, identified by the
	// Invocation.Request.name field.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Result to report.
	Result               *Result  `protobuf:"bytes,2,opt,name=result,proto3" json:"result,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ReportResultRequest proto.InternalMessageInfo

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

func (m *ReportResultRequest) GetResult() *Result {
	if m != nil {
		return m.Result
	}
	return nil
}

// Result for a single invocation request.
type Result struct {
	// Final state of the test execution.
	//
	// Error details must be available in `errors` if state != SUCCEEDED.
	State Result_State `protobuf:"varint,1,opt,name=state,proto3,enum=test.rtd.v1.Result_State" json:"state,omitempty"`
	// errors must be set if state != SUCCEEDED.
	//
	// errors may be provided even if state == SUCCEEDED. Remote Test Drivers are
	// encouraged to provide multiple observed errors in Result to aid end-user
	// visibility of problems encountered.
	Errors               []*Result_Error `protobuf:"bytes,2,rep,name=errors,proto3" json:"errors,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

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

var xxx_messageInfo_Result proto.InternalMessageInfo

func (m *Result) GetState() Result_State {
	if m != nil {
		return m.State
	}
	return Result_STATE_UNSPECIFIED
}

func (m *Result) GetErrors() []*Result_Error {
	if m != nil {
		return m.Errors
	}
	return nil
}

type Result_Error struct {
	// Provenance of the detected error.
	Source Result_Error_Source `protobuf:"varint,1,opt,name=source,proto3,enum=test.rtd.v1.Result_Error_Source" json:"source,omitempty"`
	// Severity of reported error.
	Severity Result_Error_Severity `protobuf:"varint,2,opt,name=severity,proto3,enum=test.rtd.v1.Result_Error_Severity" json:"severity,omitempty"`
	// Machine parseable details about the error.
	//
	// Test Lab Environments and Remote Test Servers must not interpret the
	// details.
	//
	// Remote Test Drivers should use uniform stable schema for `details` to
	// enable robust analytics.
	Details              *_struct.Struct `protobuf:"bytes,3,opt,name=details,proto3" json:"details,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

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

var xxx_messageInfo_Result_Error proto.InternalMessageInfo

func (m *Result_Error) GetSource() Result_Error_Source {
	if m != nil {
		return m.Source
	}
	return Result_Error_SOURCE_UNSPECIFIED
}

func (m *Result_Error) GetSeverity() Result_Error_Severity {
	if m != nil {
		return m.Severity
	}
	return Result_Error_SEVERITY_UNSPECIFIED
}

func (m *Result_Error) GetDetails() *_struct.Struct {
	if m != nil {
		return m.Details
	}
	return nil
}

type ReportResultResponse struct {
	// If set, the invocation should immediately terminate, skipping remaining
	// requests.
	Terminate            bool     `protobuf:"varint,1,opt,name=terminate,proto3" json:"terminate,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ReportResultResponse proto.InternalMessageInfo

func (m *ReportResultResponse) GetTerminate() bool {
	if m != nil {
		return m.Terminate
	}
	return false
}

type ReportLogRequest struct {
	// The request to report logs for, identified by the
	// Invocation.Request.name field.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// path of the log "file".
	//
	// path may be interpreted as local file paths or parts of a URL. path must be
	// a valid resource name per https://aip.dev/122 and must be a valid POSIX
	// file path.
	Path string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	// Uninterpreted chunk of log-data.
	Data                 []byte   `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_ReportLogRequest proto.InternalMessageInfo

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

func (m *ReportLogRequest) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *ReportLogRequest) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

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

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

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

var xxx_messageInfo_ReportLogResponse proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("test.rtd.v1.Result_State", Result_State_name, Result_State_value)
	proto.RegisterEnum("test.rtd.v1.Result_Error_Source", Result_Error_Source_name, Result_Error_Source_value)
	proto.RegisterEnum("test.rtd.v1.Result_Error_Severity", Result_Error_Severity_name, Result_Error_Severity_value)
	proto.RegisterType((*ProgressSinkClientConfig)(nil), "test.rtd.v1.ProgressSinkClientConfig")
	proto.RegisterType((*ReportResultRequest)(nil), "test.rtd.v1.ReportResultRequest")
	proto.RegisterType((*Result)(nil), "test.rtd.v1.Result")
	proto.RegisterType((*Result_Error)(nil), "test.rtd.v1.Result.Error")
	proto.RegisterType((*ReportResultResponse)(nil), "test.rtd.v1.ReportResultResponse")
	proto.RegisterType((*ReportLogRequest)(nil), "test.rtd.v1.ReportLogRequest")
	proto.RegisterType((*ReportLogResponse)(nil), "test.rtd.v1.ReportLogResponse")
}

func init() { proto.RegisterFile("test/rtd/v1/progress.proto", fileDescriptor_53459f08935e9319) }

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

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

// 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.SupportPackageIsVersion4

// ProgressSinkClient is the client API for ProgressSink service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ProgressSinkClient interface {
	// A Remote Test Driver invocation must call ReportResult exactly once per
	// request.
	ReportResult(ctx context.Context, in *ReportResultRequest, opts ...grpc.CallOption) (*ReportResultResponse, error)
	// A log stream from the Remote Test Driver invocation.
	//
	// Each call to this method must stream logs for a single invocation request
	// and log file. Data for the same file may be split over multiple ReportLog
	// calls. Data received from concurrent methods calls for the same log file
	// may be interleved arbitrarily.
	ReportLog(ctx context.Context, opts ...grpc.CallOption) (ProgressSink_ReportLogClient, error)
}

type progressSinkClient struct {
	cc *grpc.ClientConn
}

func NewProgressSinkClient(cc *grpc.ClientConn) ProgressSinkClient {
	return &progressSinkClient{cc}
}

func (c *progressSinkClient) ReportResult(ctx context.Context, in *ReportResultRequest, opts ...grpc.CallOption) (*ReportResultResponse, error) {
	out := new(ReportResultResponse)
	err := c.cc.Invoke(ctx, "/test.rtd.v1.ProgressSink/ReportResult", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *progressSinkClient) ReportLog(ctx context.Context, opts ...grpc.CallOption) (ProgressSink_ReportLogClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ProgressSink_serviceDesc.Streams[0], "/test.rtd.v1.ProgressSink/ReportLog", opts...)
	if err != nil {
		return nil, err
	}
	x := &progressSinkReportLogClient{stream}
	return x, nil
}

type ProgressSink_ReportLogClient interface {
	Send(*ReportLogRequest) error
	CloseAndRecv() (*ReportLogResponse, error)
	grpc.ClientStream
}

type progressSinkReportLogClient struct {
	grpc.ClientStream
}

func (x *progressSinkReportLogClient) Send(m *ReportLogRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *progressSinkReportLogClient) CloseAndRecv() (*ReportLogResponse, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(ReportLogResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// ProgressSinkServer is the server API for ProgressSink service.
type ProgressSinkServer interface {
	// A Remote Test Driver invocation must call ReportResult exactly once per
	// request.
	ReportResult(context.Context, *ReportResultRequest) (*ReportResultResponse, error)
	// A log stream from the Remote Test Driver invocation.
	//
	// Each call to this method must stream logs for a single invocation request
	// and log file. Data for the same file may be split over multiple ReportLog
	// calls. Data received from concurrent methods calls for the same log file
	// may be interleved arbitrarily.
	ReportLog(ProgressSink_ReportLogServer) error
}

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

func (*UnimplementedProgressSinkServer) ReportResult(ctx context.Context, req *ReportResultRequest) (*ReportResultResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReportResult not implemented")
}
func (*UnimplementedProgressSinkServer) ReportLog(srv ProgressSink_ReportLogServer) error {
	return status.Errorf(codes.Unimplemented, "method ReportLog not implemented")
}

func RegisterProgressSinkServer(s *grpc.Server, srv ProgressSinkServer) {
	s.RegisterService(&_ProgressSink_serviceDesc, srv)
}

func _ProgressSink_ReportResult_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReportResultRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProgressSinkServer).ReportResult(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.rtd.v1.ProgressSink/ReportResult",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProgressSinkServer).ReportResult(ctx, req.(*ReportResultRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ProgressSink_ReportLog_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ProgressSinkServer).ReportLog(&progressSinkReportLogServer{stream})
}

type ProgressSink_ReportLogServer interface {
	SendAndClose(*ReportLogResponse) error
	Recv() (*ReportLogRequest, error)
	grpc.ServerStream
}

type progressSinkReportLogServer struct {
	grpc.ServerStream
}

func (x *progressSinkReportLogServer) SendAndClose(m *ReportLogResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *progressSinkReportLogServer) Recv() (*ReportLogRequest, error) {
	m := new(ReportLogRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

var _ProgressSink_serviceDesc = grpc.ServiceDesc{
	ServiceName: "test.rtd.v1.ProgressSink",
	HandlerType: (*ProgressSinkServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ReportResult",
			Handler:    _ProgressSink_ReportResult_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ReportLog",
			Handler:       _ProgressSink_ReportLog_Handler,
			ClientStreams: true,
		},
	},
	Metadata: "test/rtd/v1/progress.proto",
}