// Copyright (c) Ultraviolet
// SPDX-License-Identifier: Apache-2.0

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v6.33.1
// source: agent/cvms/cvms.proto

package cvms

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

type AgentStateReq struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Id            string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AgentStateReq) Reset() {
	*x = AgentStateReq{}
	mi := &file_agent_cvms_cvms_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AgentStateReq) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AgentStateReq) ProtoMessage() {}

func (x *AgentStateReq) ProtoReflect() protoreflect.Message {
	mi := &file_agent_cvms_cvms_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AgentStateReq.ProtoReflect.Descriptor instead.
func (*AgentStateReq) Descriptor() ([]byte, []int) {
	return file_agent_cvms_cvms_proto_rawDescGZIP(), []int{0}
}

func (x *AgentStateReq) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

type AgentStateRes struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Id            string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	State         string                 `protobuf:"bytes,2,opt,name=state,proto3" json:"state,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AgentStateRes) Reset() {
	*x = AgentStateRes{}
	mi := &file_agent_cvms_cvms_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AgentStateRes) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AgentStateRes) ProtoMessage() {}

func (x *AgentStateRes) ProtoReflect() protoreflect.Message {
	mi := &file_agent_cvms_cvms_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AgentStateRes.ProtoReflect.Descriptor instead.
func (*AgentStateRes) Descriptor() ([]byte, []int) {
	return file_agent_cvms_cvms_proto_rawDescGZIP(), []int{1}
}

func (x *AgentStateRes) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

func (x *AgentStateRes) GetState() string {
	if x != nil {
		return x.State
	}
	return ""
}

type StopComputation struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ComputationId string                 `protobuf:"bytes,1,opt,name=computation_id,json=computationId,proto3" json:"computation_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *StopComputation) Reset() {
	*x = StopComputation{}
	mi := &file_agent_cvms_cvms_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *StopComputation) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*StopComputation) ProtoMessage() {}

func (x *StopComputation) ProtoReflect() protoreflect.Message {
	mi := &file_agent_cvms_cvms_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use StopComputation.ProtoReflect.Descriptor instead.
func (*StopComputation) Descriptor() ([]byte, []int) {
	return file_agent_cvms_cvms_proto_rawDescGZIP(), []int{2}
}

func (x *StopComputation) GetComputationId() string {
	if x != nil {
		return x.ComputationId
	}
	return ""
}

type StopComputationResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ComputationId string                 `protobuf:"bytes,1,opt,name=computation_id,json=computationId,proto3" json:"computation_id,omitempty"`
	Message       string                 `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *StopComputationResponse) Reset() {
	*x = StopComputationResponse{}
	mi := &file_agent_cvms_cvms_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *StopComputationResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*StopComputationResponse) ProtoMessage() {}

func (x *StopComputationResponse) ProtoReflect() protoreflect.Message {
	mi := &file_agent_cvms_cvms_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use StopComputationResponse.ProtoReflect.Descriptor instead.
func (*StopComputationResponse) Descriptor() ([]byte, []int) {
	return file_agent_cvms_cvms_proto_rawDescGZIP(), []int{3}
}

func (x *StopComputationResponse) GetComputationId() string {
	if x != nil {
		return x.ComputationId
	}
	return ""
}

func (x *StopComputationResponse) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

type RunResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ComputationId string                 `protobuf:"bytes,1,opt,name=computation_id,json=computationId,proto3" json:"computation_id,omitempty"`
	Error         string                 `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RunResponse) Reset() {
	*x = RunResponse{}
	mi := &file_agent_cvms_cvms_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RunResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RunResponse) ProtoMessage() {}

func (x *RunResponse) ProtoReflect() protoreflect.Message {
	mi := &file_agent_cvms_cvms_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RunResponse.ProtoReflect.Descriptor instead.
func (*RunResponse) Descriptor() ([]byte, []int) {
	return file_agent_cvms_cvms_proto_rawDescGZIP(), []int{4}
}

func (x *RunResponse) GetComputationId() string {
	if x != nil {
		return x.ComputationId
	}
	return ""
}

func (x *RunResponse) GetError() string {
	if x != nil {
		return x.Error
	}
	return ""
}

type AgentEvent struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	EventType     string                 `protobuf:"bytes,1,opt,name=event_type,json=eventType,proto3" json:"event_type,omitempty"`
	Timestamp     *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	ComputationId string                 `protobuf:"bytes,3,opt,name=computation_id,json=computationId,proto3" json:"computation_id,omitempty"`
	Details       []byte                 `protobuf:"bytes,4,opt,name=details,proto3" json:"details,omitempty"`
	Originator    string                 `protobuf:"bytes,5,opt,name=originator,proto3" json:"originator,omitempty"`
	Status        string                 `protobuf:"bytes,6,opt,name=status,proto3" json:"status,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AgentEvent) Reset() {
	*x = AgentEvent{}
	mi := &file_agent_cvms_cvms_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AgentEvent) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AgentEvent) ProtoMessage() {}

func (x *AgentEvent) ProtoReflect() protoreflect.Message {
	mi := &file_agent_cvms_cvms_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AgentEvent.ProtoReflect.Descriptor instead.
func (*AgentEvent) Descriptor() ([]byte, []int) {
	return file_agent_cvms_cvms_proto_rawDescGZIP(), []int{5}
}

func (x *AgentEvent) GetEventType() string {
	if x != nil {
		return x.EventType
	}
	return ""
}

func (x *AgentEvent) GetTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.Timestamp
	}
	return nil
}

func (x *AgentEvent) GetComputationId() string {
	if x != nil {
		return x.ComputationId
	}
	return ""
}

func (x *AgentEvent) GetDetails() []byte {
	if x != nil {
		return x.Details
	}
	return nil
}

func (x *AgentEvent) GetOriginator() string {
	if x != nil {
		return x.Originator
	}
	return ""
}

func (x *AgentEvent) GetStatus() string {
	if x != nil {
		return x.Status
	}
	return ""
}

type AgentLog struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Message       string                 `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	ComputationId string                 `protobuf:"bytes,2,opt,name=computation_id,json=computationId,proto3" json:"computation_id,omitempty"`
	Level         string                 `protobuf:"bytes,3,opt,name=level,proto3" json:"level,omitempty"`
	Timestamp     *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AgentLog) Reset() {
	*x = AgentLog{}
	mi := &file_agent_cvms_cvms_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AgentLog) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AgentLog) ProtoMessage() {}

func (x *AgentLog) ProtoReflect() protoreflect.Message {
	mi := &file_agent_cvms_cvms_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AgentLog.ProtoReflect.Descriptor instead.
func (*AgentLog) Descriptor() ([]byte, []int) {
	return file_agent_cvms_cvms_proto_rawDescGZIP(), []int{6}
}

func (x *AgentLog) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

func (x *AgentLog) GetComputationId() string {
	if x != nil {
		return x.ComputationId
	}
	return ""
}

func (x *AgentLog) GetLevel() string {
	if x != nil {
		return x.Level
	}
	return ""
}

func (x *AgentLog) GetTimestamp() *timestamppb.Timestamp {
	if x != nil {
		return x.Timestamp
	}
	return nil
}

type ClientStreamMessage struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Message:
	//
	//	*ClientStreamMessage_AgentLog
	//	*ClientStreamMessage_AgentEvent
	//	*ClientStreamMessage_RunRes
	//	*ClientStreamMessage_StopComputationRes
	//	*ClientStreamMessage_AgentStateRes
	//	*ClientStreamMessage_VTPMattestationReport
	//	*ClientStreamMessage_AzureAttestationToken
	Message       isClientStreamMessage_Message `protobuf_oneof:"message"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ClientStreamMessage) Reset() {
	*x = ClientStreamMessage{}
	mi := &file_agent_cvms_cvms_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ClientStreamMessage) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ClientStreamMessage) ProtoMessage() {}

func (x *ClientStreamMessage) ProtoReflect() protoreflect.Message {
	mi := &file_agent_cvms_cvms_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ClientStreamMessage.ProtoReflect.Descriptor instead.
func (*ClientStreamMessage) Descriptor() ([]byte, []int) {
	return file_agent_cvms_cvms_proto_rawDescGZIP(), []int{7}
}

func (x *ClientStreamMessage) GetMessage() isClientStreamMessage_Message {
	if x != nil {
		return x.Message
	}
	return nil
}

func (x *ClientStreamMessage) GetAgentLog() *AgentLog {
	if x != nil {
		if x, ok := x.Message.(*ClientStreamMessage_AgentLog); ok {
			return x.AgentLog
		}
	}
	return nil
}

func (x *ClientStreamMessage) GetAgentEvent() *AgentEvent {
	if x != nil {
		if x, ok := x.Message.(*ClientStreamMessage_AgentEvent); ok {
			return x.AgentEvent
		}
	}
	return nil
}

func (x *ClientStreamMessage) GetRunRes() *RunResponse {
	if x != nil {
		if x, ok := x.Message.(*ClientStreamMessage_RunRes); ok {
			return x.RunRes
		}
	}
	return nil
}

func (x *ClientStreamMessage) GetStopComputationRes() *StopComputationResponse {
	if x != nil {
		if x, ok := x.Message.(*ClientStreamMessage_StopComputationRes); ok {
			return x.StopComputationRes
		}
	}
	return nil
}

func (x *ClientStreamMessage) GetAgentStateRes() *AgentStateRes {
	if x != nil {
		if x, ok := x.Message.(*ClientStreamMessage_AgentStateRes); ok {
			return x.AgentStateRes
		}
	}
	return nil
}

func (x *ClientStreamMessage) GetVTPMattestationReport() *AttestationResponse {
	if x != nil {
		if x, ok := x.Message.(*ClientStreamMessage_VTPMattestationReport); ok {
			return x.VTPMattestationReport
		}
	}
	return nil
}

func (x *ClientStreamMessage) GetAzureAttestationToken() *AzureAttestationToken {
	if x != nil {
		if x, ok := x.Message.(*ClientStreamMessage_AzureAttestationToken); ok {
			return x.AzureAttestationToken
		}
	}
	return nil
}

type isClientStreamMessage_Message interface {
	isClientStreamMessage_Message()
}

type ClientStreamMessage_AgentLog struct {
	AgentLog *AgentLog `protobuf:"bytes,1,opt,name=agent_log,json=agentLog,proto3,oneof"`
}

type ClientStreamMessage_AgentEvent struct {
	AgentEvent *AgentEvent `protobuf:"bytes,2,opt,name=agent_event,json=agentEvent,proto3,oneof"`
}

type ClientStreamMessage_RunRes struct {
	RunRes *RunResponse `protobuf:"bytes,3,opt,name=run_res,json=runRes,proto3,oneof"`
}

type ClientStreamMessage_StopComputationRes struct {
	StopComputationRes *StopComputationResponse `protobuf:"bytes,4,opt,name=stopComputationRes,proto3,oneof"`
}

type ClientStreamMessage_AgentStateRes struct {
	AgentStateRes *AgentStateRes `protobuf:"bytes,5,opt,name=agentStateRes,proto3,oneof"`
}

type ClientStreamMessage_VTPMattestationReport struct {
	VTPMattestationReport *AttestationResponse `protobuf:"bytes,6,opt,name=vTPMattestationReport,proto3,oneof"`
}

type ClientStreamMessage_AzureAttestationToken struct {
	AzureAttestationToken *AzureAttestationToken `protobuf:"bytes,7,opt,name=azureAttestationToken,proto3,oneof"`
}

func (*ClientStreamMessage_AgentLog) isClientStreamMessage_Message() {}

func (*ClientStreamMessage_AgentEvent) isClientStreamMessage_Message() {}

func (*ClientStreamMessage_RunRes) isClientStreamMessage_Message() {}

func (*ClientStreamMessage_StopComputationRes) isClientStreamMessage_Message() {}

func (*ClientStreamMessage_AgentStateRes) isClientStreamMessage_Message() {}

func (*ClientStreamMessage_VTPMattestationReport) isClientStreamMessage_Message() {}

func (*ClientStreamMessage_AzureAttestationToken) isClientStreamMessage_Message() {}

type ServerStreamMessage struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Message:
	//
	//	*ServerStreamMessage_RunReqChunks
	//	*ServerStreamMessage_RunReq
	//	*ServerStreamMessage_StopComputation
	//	*ServerStreamMessage_AgentStateReq
	//	*ServerStreamMessage_DisconnectReq
	Message       isServerStreamMessage_Message `protobuf_oneof:"message"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ServerStreamMessage) Reset() {
	*x = ServerStreamMessage{}
	mi := &file_agent_cvms_cvms_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ServerStreamMessage) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ServerStreamMessage) ProtoMessage() {}

func (x *ServerStreamMessage) ProtoReflect() protoreflect.Message {
	mi := &file_agent_cvms_cvms_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ServerStreamMessage.ProtoReflect.Descriptor instead.
func (*ServerStreamMessage) Descriptor() ([]byte, []int) {
	return file_agent_cvms_cvms_proto_rawDescGZIP(), []int{8}
}

func (x *ServerStreamMessage) GetMessage() isServerStreamMessage_Message {
	if x != nil {
		return x.Message
	}
	return nil
}

func (x *ServerStreamMessage) GetRunReqChunks() *RunReqChunks {
	if x != nil {
		if x, ok := x.Message.(*ServerStreamMessage_RunReqChunks); ok {
			return x.RunReqChunks
		}
	}
	return nil
}

func (x *ServerStreamMessage) GetRunReq() *ComputationRunReq {
	if x != nil {
		if x, ok := x.Message.(*ServerStreamMessage_RunReq); ok {
			return x.RunReq
		}
	}
	return nil
}

func (x *ServerStreamMessage) GetStopComputation() *StopComputation {
	if x != nil {
		if x, ok := x.Message.(*ServerStreamMessage_StopComputation); ok {
			return x.StopComputation
		}
	}
	return nil
}

func (x *ServerStreamMessage) GetAgentStateReq() *AgentStateReq {
	if x != nil {
		if x, ok := x.Message.(*ServerStreamMessage_AgentStateReq); ok {
			return x.AgentStateReq
		}
	}
	return nil
}

func (x *ServerStreamMessage) GetDisconnectReq() *DisconnectReq {
	if x != nil {
		if x, ok := x.Message.(*ServerStreamMessage_DisconnectReq); ok {
			return x.DisconnectReq
		}
	}
	return nil
}

type isServerStreamMessage_Message interface {
	isServerStreamMessage_Message()
}

type ServerStreamMessage_RunReqChunks struct {
	RunReqChunks *RunReqChunks `protobuf:"bytes,1,opt,name=runReqChunks,proto3,oneof"`
}

type ServerStreamMessage_RunReq struct {
	RunReq *ComputationRunReq `protobuf:"bytes,2,opt,name=runReq,proto3,oneof"`
}

type ServerStreamMessage_StopComputation struct {
	StopComputation *StopComputation `protobuf:"bytes,3,opt,name=stopComputation,proto3,oneof"`
}

type ServerStreamMessage_AgentStateReq struct {
	AgentStateReq *AgentStateReq `protobuf:"bytes,4,opt,name=agentStateReq,proto3,oneof"`
}

type ServerStreamMessage_DisconnectReq struct {
	DisconnectReq *DisconnectReq `protobuf:"bytes,5,opt,name=disconnectReq,proto3,oneof"`
}

func (*ServerStreamMessage_RunReqChunks) isServerStreamMessage_Message() {}

func (*ServerStreamMessage_RunReq) isServerStreamMessage_Message() {}

func (*ServerStreamMessage_StopComputation) isServerStreamMessage_Message() {}

func (*ServerStreamMessage_AgentStateReq) isServerStreamMessage_Message() {}

func (*ServerStreamMessage_DisconnectReq) isServerStreamMessage_Message() {}

type DisconnectReq struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Id            string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DisconnectReq) Reset() {
	*x = DisconnectReq{}
	mi := &file_agent_cvms_cvms_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *DisconnectReq) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*DisconnectReq) ProtoMessage() {}

func (x *DisconnectReq) ProtoReflect() protoreflect.Message {
	mi := &file_agent_cvms_cvms_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use DisconnectReq.ProtoReflect.Descriptor instead.
func (*DisconnectReq) Descriptor() ([]byte, []int) {
	return file_agent_cvms_cvms_proto_rawDescGZIP(), []int{9}
}

func (x *DisconnectReq) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

type RunReqChunks struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Data          []byte                 `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	Id            string                 `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	IsLast        bool                   `protobuf:"varint,3,opt,name=is_last,json=isLast,proto3" json:"is_last,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RunReqChunks) Reset() {
	*x = RunReqChunks{}
	mi := &file_agent_cvms_cvms_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RunReqChunks) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RunReqChunks) ProtoMessage() {}

func (x *RunReqChunks) ProtoReflect() protoreflect.Message {
	mi := &file_agent_cvms_cvms_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use RunReqChunks.ProtoReflect.Descriptor instead.
func (*RunReqChunks) Descriptor() ([]byte, []int) {
	return file_agent_cvms_cvms_proto_rawDescGZIP(), []int{10}
}

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

func (x *RunReqChunks) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

func (x *RunReqChunks) GetIsLast() bool {
	if x != nil {
		return x.IsLast
	}
	return false
}

type ComputationRunReq struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	Id              string                 `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Name            string                 `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Description     string                 `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"`
	Datasets        []*Dataset             `protobuf:"bytes,4,rep,name=datasets,proto3" json:"datasets,omitempty"`
	Algorithm       *Algorithm             `protobuf:"bytes,5,opt,name=algorithm,proto3" json:"algorithm,omitempty"`
	ResultConsumers []*ResultConsumer      `protobuf:"bytes,6,rep,name=result_consumers,json=resultConsumers,proto3" json:"result_consumers,omitempty"`
	AgentConfig     *AgentConfig           `protobuf:"bytes,7,opt,name=agent_config,json=agentConfig,proto3" json:"agent_config,omitempty"`
	Kbs             *KBSConfig             `protobuf:"bytes,8,opt,name=kbs,proto3" json:"kbs,omitempty"` // Optional KBS configuration for remote resources
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *ComputationRunReq) Reset() {
	*x = ComputationRunReq{}
	mi := &file_agent_cvms_cvms_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ComputationRunReq) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ComputationRunReq) ProtoMessage() {}

func (x *ComputationRunReq) ProtoReflect() protoreflect.Message {
	mi := &file_agent_cvms_cvms_proto_msgTypes[11]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ComputationRunReq.ProtoReflect.Descriptor instead.
func (*ComputationRunReq) Descriptor() ([]byte, []int) {
	return file_agent_cvms_cvms_proto_rawDescGZIP(), []int{11}
}

func (x *ComputationRunReq) GetId() string {
	if x != nil {
		return x.Id
	}
	return ""
}

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

func (x *ComputationRunReq) GetDescription() string {
	if x != nil {
		return x.Description
	}
	return ""
}

func (x *ComputationRunReq) GetDatasets() []*Dataset {
	if x != nil {
		return x.Datasets
	}
	return nil
}

func (x *ComputationRunReq) GetAlgorithm() *Algorithm {
	if x != nil {
		return x.Algorithm
	}
	return nil
}

func (x *ComputationRunReq) GetResultConsumers() []*ResultConsumer {
	if x != nil {
		return x.ResultConsumers
	}
	return nil
}

func (x *ComputationRunReq) GetAgentConfig() *AgentConfig {
	if x != nil {
		return x.AgentConfig
	}
	return nil
}

func (x *ComputationRunReq) GetKbs() *KBSConfig {
	if x != nil {
		return x.Kbs
	}
	return nil
}

type ResultConsumer struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	UserKey       []byte                 `protobuf:"bytes,1,opt,name=userKey,proto3" json:"userKey,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ResultConsumer) Reset() {
	*x = ResultConsumer{}
	mi := &file_agent_cvms_cvms_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ResultConsumer) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ResultConsumer) ProtoMessage() {}

func (x *ResultConsumer) ProtoReflect() protoreflect.Message {
	mi := &file_agent_cvms_cvms_proto_msgTypes[12]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ResultConsumer.ProtoReflect.Descriptor instead.
func (*ResultConsumer) Descriptor() ([]byte, []int) {
	return file_agent_cvms_cvms_proto_rawDescGZIP(), []int{12}
}

func (x *ResultConsumer) GetUserKey() []byte {
	if x != nil {
		return x.UserKey
	}
	return nil
}

type Dataset struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Hash          []byte                 `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"` // should be sha3.Sum256, 32 byte length.
	UserKey       []byte                 `protobuf:"bytes,2,opt,name=userKey,proto3" json:"userKey,omitempty"`
	Filename      string                 `protobuf:"bytes,3,opt,name=filename,proto3" json:"filename,omitempty"`
	Source        *Source                `protobuf:"bytes,4,opt,name=source,proto3" json:"source,omitempty"` // Optional remote source for encrypted dataset
	Decompress    bool                   `protobuf:"varint,5,opt,name=decompress,proto3" json:"decompress,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Dataset) Reset() {
	*x = Dataset{}
	mi := &file_agent_cvms_cvms_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Dataset) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Dataset) ProtoMessage() {}

func (x *Dataset) ProtoReflect() protoreflect.Message {
	mi := &file_agent_cvms_cvms_proto_msgTypes[13]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Dataset.ProtoReflect.Descriptor instead.
func (*Dataset) Descriptor() ([]byte, []int) {
	return file_agent_cvms_cvms_proto_rawDescGZIP(), []int{13}
}

func (x *Dataset) GetHash() []byte {
	if x != nil {
		return x.Hash
	}
	return nil
}

func (x *Dataset) GetUserKey() []byte {
	if x != nil {
		return x.UserKey
	}
	return nil
}

func (x *Dataset) GetFilename() string {
	if x != nil {
		return x.Filename
	}
	return ""
}

func (x *Dataset) GetSource() *Source {
	if x != nil {
		return x.Source
	}
	return nil
}

func (x *Dataset) GetDecompress() bool {
	if x != nil {
		return x.Decompress
	}
	return false
}

type Algorithm struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Hash          []byte                 `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"` // should be sha3.Sum256, 32 byte length.
	UserKey       []byte                 `protobuf:"bytes,2,opt,name=userKey,proto3" json:"userKey,omitempty"`
	Source        *Source                `protobuf:"bytes,3,opt,name=source,proto3" json:"source,omitempty"` // Optional remote source for encrypted algorithm
	AlgoType      string                 `protobuf:"bytes,4,opt,name=algo_type,json=algoType,proto3" json:"algo_type,omitempty"`
	AlgoArgs      []string               `protobuf:"bytes,5,rep,name=algo_args,json=algoArgs,proto3" json:"algo_args,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Algorithm) Reset() {
	*x = Algorithm{}
	mi := &file_agent_cvms_cvms_proto_msgTypes[14]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Algorithm) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Algorithm) ProtoMessage() {}

func (x *Algorithm) ProtoReflect() protoreflect.Message {
	mi := &file_agent_cvms_cvms_proto_msgTypes[14]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Algorithm.ProtoReflect.Descriptor instead.
func (*Algorithm) Descriptor() ([]byte, []int) {
	return file_agent_cvms_cvms_proto_rawDescGZIP(), []int{14}
}

func (x *Algorithm) GetHash() []byte {
	if x != nil {
		return x.Hash
	}
	return nil
}

func (x *Algorithm) GetUserKey() []byte {
	if x != nil {
		return x.UserKey
	}
	return nil
}

func (x *Algorithm) GetSource() *Source {
	if x != nil {
		return x.Source
	}
	return nil
}

func (x *Algorithm) GetAlgoType() string {
	if x != nil {
		return x.AlgoType
	}
	return ""
}

func (x *Algorithm) GetAlgoArgs() []string {
	if x != nil {
		return x.AlgoArgs
	}
	return nil
}

type Source struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	Type            string                 `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`                                                // Type of source: "oci-image" (only OCI images supported for CoCo)
	Url             string                 `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`                                                  // URL of the OCI image (e.g., docker://registry/repo:tag)
	KbsResourcePath string                 `protobuf:"bytes,3,opt,name=kbs_resource_path,json=kbsResourcePath,proto3" json:"kbs_resource_path,omitempty"` // Path to decryption key in KBS (e.g., "default/key/my-key")
	Encrypted       bool                   `protobuf:"varint,4,opt,name=encrypted,proto3" json:"encrypted,omitempty"`                                     // Whether the resource is encrypted (requires KBS)
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *Source) Reset() {
	*x = Source{}
	mi := &file_agent_cvms_cvms_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Source) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Source) ProtoMessage() {}

func (x *Source) ProtoReflect() protoreflect.Message {
	mi := &file_agent_cvms_cvms_proto_msgTypes[15]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Source.ProtoReflect.Descriptor instead.
func (*Source) Descriptor() ([]byte, []int) {
	return file_agent_cvms_cvms_proto_rawDescGZIP(), []int{15}
}

func (x *Source) GetType() string {
	if x != nil {
		return x.Type
	}
	return ""
}

func (x *Source) GetUrl() string {
	if x != nil {
		return x.Url
	}
	return ""
}

func (x *Source) GetKbsResourcePath() string {
	if x != nil {
		return x.KbsResourcePath
	}
	return ""
}

func (x *Source) GetEncrypted() bool {
	if x != nil {
		return x.Encrypted
	}
	return false
}

type KBSConfig struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Url           string                 `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`          // KBS endpoint URL (e.g., "https://kbs.example.com")
	Enabled       bool                   `protobuf:"varint,2,opt,name=enabled,proto3" json:"enabled,omitempty"` // Whether to use KBS for key retrieval
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *KBSConfig) Reset() {
	*x = KBSConfig{}
	mi := &file_agent_cvms_cvms_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *KBSConfig) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*KBSConfig) ProtoMessage() {}

func (x *KBSConfig) ProtoReflect() protoreflect.Message {
	mi := &file_agent_cvms_cvms_proto_msgTypes[16]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use KBSConfig.ProtoReflect.Descriptor instead.
func (*KBSConfig) Descriptor() ([]byte, []int) {
	return file_agent_cvms_cvms_proto_rawDescGZIP(), []int{16}
}

func (x *KBSConfig) GetUrl() string {
	if x != nil {
		return x.Url
	}
	return ""
}

func (x *KBSConfig) GetEnabled() bool {
	if x != nil {
		return x.Enabled
	}
	return false
}

type AgentConfig struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Port          string                 `protobuf:"bytes,1,opt,name=port,proto3" json:"port,omitempty"`
	CertFile      string                 `protobuf:"bytes,2,opt,name=cert_file,json=certFile,proto3" json:"cert_file,omitempty"`
	KeyFile       string                 `protobuf:"bytes,3,opt,name=key_file,json=keyFile,proto3" json:"key_file,omitempty"`
	ClientCaFile  string                 `protobuf:"bytes,4,opt,name=client_ca_file,json=clientCaFile,proto3" json:"client_ca_file,omitempty"`
	ServerCaFile  string                 `protobuf:"bytes,5,opt,name=server_ca_file,json=serverCaFile,proto3" json:"server_ca_file,omitempty"`
	LogLevel      string                 `protobuf:"bytes,6,opt,name=log_level,json=logLevel,proto3" json:"log_level,omitempty"`
	AttestedTls   bool                   `protobuf:"varint,7,opt,name=attested_tls,json=attestedTls,proto3" json:"attested_tls,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AgentConfig) Reset() {
	*x = AgentConfig{}
	mi := &file_agent_cvms_cvms_proto_msgTypes[17]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AgentConfig) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AgentConfig) ProtoMessage() {}

func (x *AgentConfig) ProtoReflect() protoreflect.Message {
	mi := &file_agent_cvms_cvms_proto_msgTypes[17]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AgentConfig.ProtoReflect.Descriptor instead.
func (*AgentConfig) Descriptor() ([]byte, []int) {
	return file_agent_cvms_cvms_proto_rawDescGZIP(), []int{17}
}

func (x *AgentConfig) GetPort() string {
	if x != nil {
		return x.Port
	}
	return ""
}

func (x *AgentConfig) GetCertFile() string {
	if x != nil {
		return x.CertFile
	}
	return ""
}

func (x *AgentConfig) GetKeyFile() string {
	if x != nil {
		return x.KeyFile
	}
	return ""
}

func (x *AgentConfig) GetClientCaFile() string {
	if x != nil {
		return x.ClientCaFile
	}
	return ""
}

func (x *AgentConfig) GetServerCaFile() string {
	if x != nil {
		return x.ServerCaFile
	}
	return ""
}

func (x *AgentConfig) GetLogLevel() string {
	if x != nil {
		return x.LogLevel
	}
	return ""
}

func (x *AgentConfig) GetAttestedTls() bool {
	if x != nil {
		return x.AttestedTls
	}
	return false
}

type AttestationResponse struct {
	state            protoimpl.MessageState `protogen:"open.v1"`
	File             []byte                 `protobuf:"bytes,1,opt,name=file,proto3" json:"file,omitempty"`
	CertSerialNumber string                 `protobuf:"bytes,2,opt,name=certSerialNumber,proto3" json:"certSerialNumber,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *AttestationResponse) Reset() {
	*x = AttestationResponse{}
	mi := &file_agent_cvms_cvms_proto_msgTypes[18]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AttestationResponse) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AttestationResponse) ProtoMessage() {}

func (x *AttestationResponse) ProtoReflect() protoreflect.Message {
	mi := &file_agent_cvms_cvms_proto_msgTypes[18]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AttestationResponse.ProtoReflect.Descriptor instead.
func (*AttestationResponse) Descriptor() ([]byte, []int) {
	return file_agent_cvms_cvms_proto_rawDescGZIP(), []int{18}
}

func (x *AttestationResponse) GetFile() []byte {
	if x != nil {
		return x.File
	}
	return nil
}

func (x *AttestationResponse) GetCertSerialNumber() string {
	if x != nil {
		return x.CertSerialNumber
	}
	return ""
}

type AzureAttestationToken struct {
	state            protoimpl.MessageState `protogen:"open.v1"`
	File             []byte                 `protobuf:"bytes,1,opt,name=file,proto3" json:"file,omitempty"`
	CertSerialNumber string                 `protobuf:"bytes,2,opt,name=certSerialNumber,proto3" json:"certSerialNumber,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *AzureAttestationToken) Reset() {
	*x = AzureAttestationToken{}
	mi := &file_agent_cvms_cvms_proto_msgTypes[19]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AzureAttestationToken) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AzureAttestationToken) ProtoMessage() {}

func (x *AzureAttestationToken) ProtoReflect() protoreflect.Message {
	mi := &file_agent_cvms_cvms_proto_msgTypes[19]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AzureAttestationToken.ProtoReflect.Descriptor instead.
func (*AzureAttestationToken) Descriptor() ([]byte, []int) {
	return file_agent_cvms_cvms_proto_rawDescGZIP(), []int{19}
}

func (x *AzureAttestationToken) GetFile() []byte {
	if x != nil {
		return x.File
	}
	return nil
}

func (x *AzureAttestationToken) GetCertSerialNumber() string {
	if x != nil {
		return x.CertSerialNumber
	}
	return ""
}

var File_agent_cvms_cvms_proto protoreflect.FileDescriptor

const file_agent_cvms_cvms_proto_rawDesc = "" +
	"\n" +
	"\x15agent/cvms/cvms.proto\x12\x04cvms\x1a\x1fgoogle/protobuf/timestamp.proto\"\x1f\n" +
	"\rAgentStateReq\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\"5\n" +
	"\rAgentStateRes\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\x12\x14\n" +
	"\x05state\x18\x02 \x01(\tR\x05state\"8\n" +
	"\x0fStopComputation\x12%\n" +
	"\x0ecomputation_id\x18\x01 \x01(\tR\rcomputationId\"Z\n" +
	"\x17StopComputationResponse\x12%\n" +
	"\x0ecomputation_id\x18\x01 \x01(\tR\rcomputationId\x12\x18\n" +
	"\amessage\x18\x02 \x01(\tR\amessage\"J\n" +
	"\vRunResponse\x12%\n" +
	"\x0ecomputation_id\x18\x01 \x01(\tR\rcomputationId\x12\x14\n" +
	"\x05error\x18\x02 \x01(\tR\x05error\"\xde\x01\n" +
	"\n" +
	"AgentEvent\x12\x1d\n" +
	"\n" +
	"event_type\x18\x01 \x01(\tR\teventType\x128\n" +
	"\ttimestamp\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\ttimestamp\x12%\n" +
	"\x0ecomputation_id\x18\x03 \x01(\tR\rcomputationId\x12\x18\n" +
	"\adetails\x18\x04 \x01(\fR\adetails\x12\x1e\n" +
	"\n" +
	"originator\x18\x05 \x01(\tR\n" +
	"originator\x12\x16\n" +
	"\x06status\x18\x06 \x01(\tR\x06status\"\x9b\x01\n" +
	"\bAgentLog\x12\x18\n" +
	"\amessage\x18\x01 \x01(\tR\amessage\x12%\n" +
	"\x0ecomputation_id\x18\x02 \x01(\tR\rcomputationId\x12\x14\n" +
	"\x05level\x18\x03 \x01(\tR\x05level\x128\n" +
	"\ttimestamp\x18\x04 \x01(\v2\x1a.google.protobuf.TimestampR\ttimestamp\"\xe8\x03\n" +
	"\x13ClientStreamMessage\x12-\n" +
	"\tagent_log\x18\x01 \x01(\v2\x0e.cvms.AgentLogH\x00R\bagentLog\x123\n" +
	"\vagent_event\x18\x02 \x01(\v2\x10.cvms.AgentEventH\x00R\n" +
	"agentEvent\x12,\n" +
	"\arun_res\x18\x03 \x01(\v2\x11.cvms.RunResponseH\x00R\x06runRes\x12O\n" +
	"\x12stopComputationRes\x18\x04 \x01(\v2\x1d.cvms.StopComputationResponseH\x00R\x12stopComputationRes\x12;\n" +
	"\ragentStateRes\x18\x05 \x01(\v2\x13.cvms.AgentStateResH\x00R\ragentStateRes\x12Q\n" +
	"\x15vTPMattestationReport\x18\x06 \x01(\v2\x19.cvms.AttestationResponseH\x00R\x15vTPMattestationReport\x12S\n" +
	"\x15azureAttestationToken\x18\a \x01(\v2\x1b.cvms.azureAttestationTokenH\x00R\x15azureAttestationTokenB\t\n" +
	"\amessage\"\xca\x02\n" +
	"\x13ServerStreamMessage\x128\n" +
	"\frunReqChunks\x18\x01 \x01(\v2\x12.cvms.RunReqChunksH\x00R\frunReqChunks\x121\n" +
	"\x06runReq\x18\x02 \x01(\v2\x17.cvms.ComputationRunReqH\x00R\x06runReq\x12A\n" +
	"\x0fstopComputation\x18\x03 \x01(\v2\x15.cvms.StopComputationH\x00R\x0fstopComputation\x12;\n" +
	"\ragentStateReq\x18\x04 \x01(\v2\x13.cvms.AgentStateReqH\x00R\ragentStateReq\x12;\n" +
	"\rdisconnectReq\x18\x05 \x01(\v2\x13.cvms.DisconnectReqH\x00R\rdisconnectReqB\t\n" +
	"\amessage\"\x1f\n" +
	"\rDisconnectReq\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\"K\n" +
	"\fRunReqChunks\x12\x12\n" +
	"\x04data\x18\x01 \x01(\fR\x04data\x12\x0e\n" +
	"\x02id\x18\x02 \x01(\tR\x02id\x12\x17\n" +
	"\ais_last\x18\x03 \x01(\bR\x06isLast\"\xcd\x02\n" +
	"\x11ComputationRunReq\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\tR\x02id\x12\x12\n" +
	"\x04name\x18\x02 \x01(\tR\x04name\x12 \n" +
	"\vdescription\x18\x03 \x01(\tR\vdescription\x12)\n" +
	"\bdatasets\x18\x04 \x03(\v2\r.cvms.DatasetR\bdatasets\x12-\n" +
	"\talgorithm\x18\x05 \x01(\v2\x0f.cvms.AlgorithmR\talgorithm\x12?\n" +
	"\x10result_consumers\x18\x06 \x03(\v2\x14.cvms.ResultConsumerR\x0fresultConsumers\x124\n" +
	"\fagent_config\x18\a \x01(\v2\x11.cvms.AgentConfigR\vagentConfig\x12!\n" +
	"\x03kbs\x18\b \x01(\v2\x0f.cvms.KBSConfigR\x03kbs\"*\n" +
	"\x0eResultConsumer\x12\x18\n" +
	"\auserKey\x18\x01 \x01(\fR\auserKey\"\x99\x01\n" +
	"\aDataset\x12\x12\n" +
	"\x04hash\x18\x01 \x01(\fR\x04hash\x12\x18\n" +
	"\auserKey\x18\x02 \x01(\fR\auserKey\x12\x1a\n" +
	"\bfilename\x18\x03 \x01(\tR\bfilename\x12$\n" +
	"\x06source\x18\x04 \x01(\v2\f.cvms.SourceR\x06source\x12\x1e\n" +
	"\n" +
	"decompress\x18\x05 \x01(\bR\n" +
	"decompress\"\x99\x01\n" +
	"\tAlgorithm\x12\x12\n" +
	"\x04hash\x18\x01 \x01(\fR\x04hash\x12\x18\n" +
	"\auserKey\x18\x02 \x01(\fR\auserKey\x12$\n" +
	"\x06source\x18\x03 \x01(\v2\f.cvms.SourceR\x06source\x12\x1b\n" +
	"\talgo_type\x18\x04 \x01(\tR\balgoType\x12\x1b\n" +
	"\talgo_args\x18\x05 \x03(\tR\balgoArgs\"x\n" +
	"\x06Source\x12\x12\n" +
	"\x04type\x18\x01 \x01(\tR\x04type\x12\x10\n" +
	"\x03url\x18\x02 \x01(\tR\x03url\x12*\n" +
	"\x11kbs_resource_path\x18\x03 \x01(\tR\x0fkbsResourcePath\x12\x1c\n" +
	"\tencrypted\x18\x04 \x01(\bR\tencrypted\"7\n" +
	"\tKBSConfig\x12\x10\n" +
	"\x03url\x18\x01 \x01(\tR\x03url\x12\x18\n" +
	"\aenabled\x18\x02 \x01(\bR\aenabled\"\xe5\x01\n" +
	"\vAgentConfig\x12\x12\n" +
	"\x04port\x18\x01 \x01(\tR\x04port\x12\x1b\n" +
	"\tcert_file\x18\x02 \x01(\tR\bcertFile\x12\x19\n" +
	"\bkey_file\x18\x03 \x01(\tR\akeyFile\x12$\n" +
	"\x0eclient_ca_file\x18\x04 \x01(\tR\fclientCaFile\x12$\n" +
	"\x0eserver_ca_file\x18\x05 \x01(\tR\fserverCaFile\x12\x1b\n" +
	"\tlog_level\x18\x06 \x01(\tR\blogLevel\x12!\n" +
	"\fattested_tls\x18\a \x01(\bR\vattestedTls\"U\n" +
	"\x13AttestationResponse\x12\x12\n" +
	"\x04file\x18\x01 \x01(\fR\x04file\x12*\n" +
	"\x10certSerialNumber\x18\x02 \x01(\tR\x10certSerialNumber\"W\n" +
	"\x15azureAttestationToken\x12\x12\n" +
	"\x04file\x18\x01 \x01(\fR\x04file\x12*\n" +
	"\x10certSerialNumber\x18\x02 \x01(\tR\x10certSerialNumber2P\n" +
	"\aService\x12E\n" +
	"\aProcess\x12\x19.cvms.ClientStreamMessage\x1a\x19.cvms.ServerStreamMessage\"\x00(\x010\x01B\bZ\x06./cvmsb\x06proto3"

var (
	file_agent_cvms_cvms_proto_rawDescOnce sync.Once
	file_agent_cvms_cvms_proto_rawDescData []byte
)

func file_agent_cvms_cvms_proto_rawDescGZIP() []byte {
	file_agent_cvms_cvms_proto_rawDescOnce.Do(func() {
		file_agent_cvms_cvms_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_agent_cvms_cvms_proto_rawDesc), len(file_agent_cvms_cvms_proto_rawDesc)))
	})
	return file_agent_cvms_cvms_proto_rawDescData
}

var file_agent_cvms_cvms_proto_msgTypes = make([]protoimpl.MessageInfo, 20)
var file_agent_cvms_cvms_proto_goTypes = []any{
	(*AgentStateReq)(nil),           // 0: cvms.AgentStateReq
	(*AgentStateRes)(nil),           // 1: cvms.AgentStateRes
	(*StopComputation)(nil),         // 2: cvms.StopComputation
	(*StopComputationResponse)(nil), // 3: cvms.StopComputationResponse
	(*RunResponse)(nil),             // 4: cvms.RunResponse
	(*AgentEvent)(nil),              // 5: cvms.AgentEvent
	(*AgentLog)(nil),                // 6: cvms.AgentLog
	(*ClientStreamMessage)(nil),     // 7: cvms.ClientStreamMessage
	(*ServerStreamMessage)(nil),     // 8: cvms.ServerStreamMessage
	(*DisconnectReq)(nil),           // 9: cvms.DisconnectReq
	(*RunReqChunks)(nil),            // 10: cvms.RunReqChunks
	(*ComputationRunReq)(nil),       // 11: cvms.ComputationRunReq
	(*ResultConsumer)(nil),          // 12: cvms.ResultConsumer
	(*Dataset)(nil),                 // 13: cvms.Dataset
	(*Algorithm)(nil),               // 14: cvms.Algorithm
	(*Source)(nil),                  // 15: cvms.Source
	(*KBSConfig)(nil),               // 16: cvms.KBSConfig
	(*AgentConfig)(nil),             // 17: cvms.AgentConfig
	(*AttestationResponse)(nil),     // 18: cvms.AttestationResponse
	(*AzureAttestationToken)(nil),   // 19: cvms.azureAttestationToken
	(*timestamppb.Timestamp)(nil),   // 20: google.protobuf.Timestamp
}
var file_agent_cvms_cvms_proto_depIdxs = []int32{
	20, // 0: cvms.AgentEvent.timestamp:type_name -> google.protobuf.Timestamp
	20, // 1: cvms.AgentLog.timestamp:type_name -> google.protobuf.Timestamp
	6,  // 2: cvms.ClientStreamMessage.agent_log:type_name -> cvms.AgentLog
	5,  // 3: cvms.ClientStreamMessage.agent_event:type_name -> cvms.AgentEvent
	4,  // 4: cvms.ClientStreamMessage.run_res:type_name -> cvms.RunResponse
	3,  // 5: cvms.ClientStreamMessage.stopComputationRes:type_name -> cvms.StopComputationResponse
	1,  // 6: cvms.ClientStreamMessage.agentStateRes:type_name -> cvms.AgentStateRes
	18, // 7: cvms.ClientStreamMessage.vTPMattestationReport:type_name -> cvms.AttestationResponse
	19, // 8: cvms.ClientStreamMessage.azureAttestationToken:type_name -> cvms.azureAttestationToken
	10, // 9: cvms.ServerStreamMessage.runReqChunks:type_name -> cvms.RunReqChunks
	11, // 10: cvms.ServerStreamMessage.runReq:type_name -> cvms.ComputationRunReq
	2,  // 11: cvms.ServerStreamMessage.stopComputation:type_name -> cvms.StopComputation
	0,  // 12: cvms.ServerStreamMessage.agentStateReq:type_name -> cvms.AgentStateReq
	9,  // 13: cvms.ServerStreamMessage.disconnectReq:type_name -> cvms.DisconnectReq
	13, // 14: cvms.ComputationRunReq.datasets:type_name -> cvms.Dataset
	14, // 15: cvms.ComputationRunReq.algorithm:type_name -> cvms.Algorithm
	12, // 16: cvms.ComputationRunReq.result_consumers:type_name -> cvms.ResultConsumer
	17, // 17: cvms.ComputationRunReq.agent_config:type_name -> cvms.AgentConfig
	16, // 18: cvms.ComputationRunReq.kbs:type_name -> cvms.KBSConfig
	15, // 19: cvms.Dataset.source:type_name -> cvms.Source
	15, // 20: cvms.Algorithm.source:type_name -> cvms.Source
	7,  // 21: cvms.Service.Process:input_type -> cvms.ClientStreamMessage
	8,  // 22: cvms.Service.Process:output_type -> cvms.ServerStreamMessage
	22, // [22:23] is the sub-list for method output_type
	21, // [21:22] is the sub-list for method input_type
	21, // [21:21] is the sub-list for extension type_name
	21, // [21:21] is the sub-list for extension extendee
	0,  // [0:21] is the sub-list for field type_name
}

func init() { file_agent_cvms_cvms_proto_init() }
func file_agent_cvms_cvms_proto_init() {
	if File_agent_cvms_cvms_proto != nil {
		return
	}
	file_agent_cvms_cvms_proto_msgTypes[7].OneofWrappers = []any{
		(*ClientStreamMessage_AgentLog)(nil),
		(*ClientStreamMessage_AgentEvent)(nil),
		(*ClientStreamMessage_RunRes)(nil),
		(*ClientStreamMessage_StopComputationRes)(nil),
		(*ClientStreamMessage_AgentStateRes)(nil),
		(*ClientStreamMessage_VTPMattestationReport)(nil),
		(*ClientStreamMessage_AzureAttestationToken)(nil),
	}
	file_agent_cvms_cvms_proto_msgTypes[8].OneofWrappers = []any{
		(*ServerStreamMessage_RunReqChunks)(nil),
		(*ServerStreamMessage_RunReq)(nil),
		(*ServerStreamMessage_StopComputation)(nil),
		(*ServerStreamMessage_AgentStateReq)(nil),
		(*ServerStreamMessage_DisconnectReq)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_agent_cvms_cvms_proto_rawDesc), len(file_agent_cvms_cvms_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   20,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_agent_cvms_cvms_proto_goTypes,
		DependencyIndexes: file_agent_cvms_cvms_proto_depIdxs,
		MessageInfos:      file_agent_cvms_cvms_proto_msgTypes,
	}.Build()
	File_agent_cvms_cvms_proto = out.File
	file_agent_cvms_cvms_proto_goTypes = nil
	file_agent_cvms_cvms_proto_depIdxs = nil
}