// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v6.33.2
// source: proto/engine.proto

package proto

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	anypb "google.golang.org/protobuf/types/known/anypb"
	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 LogLevel int32

const (
	LogLevel_LOG_LEVEL_UNSPECIFIED LogLevel = 0
	LogLevel_LOG_LEVEL_DEBUG       LogLevel = 1
	LogLevel_LOG_LEVEL_INFO        LogLevel = 2
	LogLevel_LOG_LEVEL_WARN        LogLevel = 3
	LogLevel_LOG_LEVEL_ERROR       LogLevel = 4
)

// Enum value maps for LogLevel.
var (
	LogLevel_name = map[int32]string{
		0: "LOG_LEVEL_UNSPECIFIED",
		1: "LOG_LEVEL_DEBUG",
		2: "LOG_LEVEL_INFO",
		3: "LOG_LEVEL_WARN",
		4: "LOG_LEVEL_ERROR",
	}
	LogLevel_value = map[string]int32{
		"LOG_LEVEL_UNSPECIFIED": 0,
		"LOG_LEVEL_DEBUG":       1,
		"LOG_LEVEL_INFO":        2,
		"LOG_LEVEL_WARN":        3,
		"LOG_LEVEL_ERROR":       4,
	}
)

func (x LogLevel) Enum() *LogLevel {
	p := new(LogLevel)
	*p = x
	return p
}

func (x LogLevel) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (LogLevel) Descriptor() protoreflect.EnumDescriptor {
	return file_proto_engine_proto_enumTypes[0].Descriptor()
}

func (LogLevel) Type() protoreflect.EnumType {
	return &file_proto_engine_proto_enumTypes[0]
}

func (x LogLevel) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use LogLevel.Descriptor instead.
func (LogLevel) EnumDescriptor() ([]byte, []int) {
	return file_proto_engine_proto_rawDescGZIP(), []int{0}
}

type InitRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Metadata information as a map of string keys to protobuf Any values.
	Meta map[string]*anypb.Any `protobuf:"bytes,1,rep,name=meta,proto3" json:"meta,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// Working directory path.
	WorkingDir string `protobuf:"bytes,2,opt,name=working_dir,json=workingDir,proto3" json:"working_dir,omitempty"`
	// Environment variables as a map of string keys to string values.
	EnvVars       map[string]string `protobuf:"bytes,3,rep,name=env_vars,json=envVars,proto3" json:"env_vars,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*InitRequest) ProtoMessage() {}

func (x *InitRequest) ProtoReflect() protoreflect.Message {
	mi := &file_proto_engine_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 InitRequest.ProtoReflect.Descriptor instead.
func (*InitRequest) Descriptor() ([]byte, []int) {
	return file_proto_engine_proto_rawDescGZIP(), []int{0}
}

func (x *InitRequest) GetMeta() map[string]*anypb.Any {
	if x != nil {
		return x.Meta
	}
	return nil
}

func (x *InitRequest) GetWorkingDir() string {
	if x != nil {
		return x.WorkingDir
	}
	return ""
}

func (x *InitRequest) GetEnvVars() map[string]string {
	if x != nil {
		return x.EnvVars
	}
	return nil
}

type InitResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Response:
	//
	//	*InitResponse_Stdout
	//	*InitResponse_Stderr
	//	*InitResponse_ExitResult
	//	*InitResponse_Log
	Response      isInitResponse_Response `protobuf_oneof:"response"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*InitResponse) ProtoMessage() {}

func (x *InitResponse) ProtoReflect() protoreflect.Message {
	mi := &file_proto_engine_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 InitResponse.ProtoReflect.Descriptor instead.
func (*InitResponse) Descriptor() ([]byte, []int) {
	return file_proto_engine_proto_rawDescGZIP(), []int{1}
}

func (x *InitResponse) GetResponse() isInitResponse_Response {
	if x != nil {
		return x.Response
	}
	return nil
}

func (x *InitResponse) GetStdout() *StdoutMessage {
	if x != nil {
		if x, ok := x.Response.(*InitResponse_Stdout); ok {
			return x.Stdout
		}
	}
	return nil
}

func (x *InitResponse) GetStderr() *StderrMessage {
	if x != nil {
		if x, ok := x.Response.(*InitResponse_Stderr); ok {
			return x.Stderr
		}
	}
	return nil
}

func (x *InitResponse) GetExitResult() *ExitResultMessage {
	if x != nil {
		if x, ok := x.Response.(*InitResponse_ExitResult); ok {
			return x.ExitResult
		}
	}
	return nil
}

func (x *InitResponse) GetLog() *LogMessage {
	if x != nil {
		if x, ok := x.Response.(*InitResponse_Log); ok {
			return x.Log
		}
	}
	return nil
}

type isInitResponse_Response interface {
	isInitResponse_Response()
}

type InitResponse_Stdout struct {
	Stdout *StdoutMessage `protobuf:"bytes,1,opt,name=stdout,proto3,oneof"`
}

type InitResponse_Stderr struct {
	Stderr *StderrMessage `protobuf:"bytes,2,opt,name=stderr,proto3,oneof"`
}

type InitResponse_ExitResult struct {
	ExitResult *ExitResultMessage `protobuf:"bytes,3,opt,name=exit_result,json=exitResult,proto3,oneof"`
}

type InitResponse_Log struct {
	Log *LogMessage `protobuf:"bytes,4,opt,name=log,proto3,oneof"`
}

func (*InitResponse_Stdout) isInitResponse_Response() {}

func (*InitResponse_Stderr) isInitResponse_Response() {}

func (*InitResponse_ExitResult) isInitResponse_Response() {}

func (*InitResponse_Log) isInitResponse_Response() {}

type ShutdownRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Metadata information as a map of string keys to protobuf Any values.
	Meta map[string]*anypb.Any `protobuf:"bytes,1,rep,name=meta,proto3" json:"meta,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// Working directory path.
	WorkingDir string `protobuf:"bytes,2,opt,name=working_dir,json=workingDir,proto3" json:"working_dir,omitempty"`
	// Environment variables as a map of string keys to string values.
	EnvVars       map[string]string `protobuf:"bytes,3,rep,name=env_vars,json=envVars,proto3" json:"env_vars,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ShutdownRequest) ProtoMessage() {}

func (x *ShutdownRequest) ProtoReflect() protoreflect.Message {
	mi := &file_proto_engine_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 ShutdownRequest.ProtoReflect.Descriptor instead.
func (*ShutdownRequest) Descriptor() ([]byte, []int) {
	return file_proto_engine_proto_rawDescGZIP(), []int{2}
}

func (x *ShutdownRequest) GetMeta() map[string]*anypb.Any {
	if x != nil {
		return x.Meta
	}
	return nil
}

func (x *ShutdownRequest) GetWorkingDir() string {
	if x != nil {
		return x.WorkingDir
	}
	return ""
}

func (x *ShutdownRequest) GetEnvVars() map[string]string {
	if x != nil {
		return x.EnvVars
	}
	return nil
}

type ShutdownResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Response:
	//
	//	*ShutdownResponse_Stdout
	//	*ShutdownResponse_Stderr
	//	*ShutdownResponse_ExitResult
	//	*ShutdownResponse_Log
	Response      isShutdownResponse_Response `protobuf_oneof:"response"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ShutdownResponse) ProtoMessage() {}

func (x *ShutdownResponse) ProtoReflect() protoreflect.Message {
	mi := &file_proto_engine_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 ShutdownResponse.ProtoReflect.Descriptor instead.
func (*ShutdownResponse) Descriptor() ([]byte, []int) {
	return file_proto_engine_proto_rawDescGZIP(), []int{3}
}

func (x *ShutdownResponse) GetResponse() isShutdownResponse_Response {
	if x != nil {
		return x.Response
	}
	return nil
}

func (x *ShutdownResponse) GetStdout() *StdoutMessage {
	if x != nil {
		if x, ok := x.Response.(*ShutdownResponse_Stdout); ok {
			return x.Stdout
		}
	}
	return nil
}

func (x *ShutdownResponse) GetStderr() *StderrMessage {
	if x != nil {
		if x, ok := x.Response.(*ShutdownResponse_Stderr); ok {
			return x.Stderr
		}
	}
	return nil
}

func (x *ShutdownResponse) GetExitResult() *ExitResultMessage {
	if x != nil {
		if x, ok := x.Response.(*ShutdownResponse_ExitResult); ok {
			return x.ExitResult
		}
	}
	return nil
}

func (x *ShutdownResponse) GetLog() *LogMessage {
	if x != nil {
		if x, ok := x.Response.(*ShutdownResponse_Log); ok {
			return x.Log
		}
	}
	return nil
}

type isShutdownResponse_Response interface {
	isShutdownResponse_Response()
}

type ShutdownResponse_Stdout struct {
	Stdout *StdoutMessage `protobuf:"bytes,1,opt,name=stdout,proto3,oneof"`
}

type ShutdownResponse_Stderr struct {
	Stderr *StderrMessage `protobuf:"bytes,2,opt,name=stderr,proto3,oneof"`
}

type ShutdownResponse_ExitResult struct {
	ExitResult *ExitResultMessage `protobuf:"bytes,3,opt,name=exit_result,json=exitResult,proto3,oneof"`
}

type ShutdownResponse_Log struct {
	Log *LogMessage `protobuf:"bytes,4,opt,name=log,proto3,oneof"`
}

func (*ShutdownResponse_Stdout) isShutdownResponse_Response() {}

func (*ShutdownResponse_Stderr) isShutdownResponse_Response() {}

func (*ShutdownResponse_ExitResult) isShutdownResponse_Response() {}

func (*ShutdownResponse_Log) isShutdownResponse_Response() {}

type RunRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Metadata information as a map of string keys to protobuf Any values.
	Meta map[string]*anypb.Any `protobuf:"bytes,1,rep,name=meta,proto3" json:"meta,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// Working directory path.
	WorkingDir string `protobuf:"bytes,2,opt,name=working_dir,json=workingDir,proto3" json:"working_dir,omitempty"`
	// Command to be executed.
	Command string `protobuf:"bytes,3,opt,name=command,proto3" json:"command,omitempty"`
	// Arguments for the command.
	Args []string `protobuf:"bytes,4,rep,name=args,proto3" json:"args,omitempty"`
	// Flag indicating if a pseudo-terminal should be allocated.
	AllocatePseudoTty bool `protobuf:"varint,5,opt,name=allocate_pseudo_tty,json=allocatePseudoTty,proto3" json:"allocate_pseudo_tty,omitempty"`
	// Environment variables as a map of string keys to string values.
	EnvVars       map[string]string `protobuf:"bytes,6,rep,name=env_vars,json=envVars,proto3" json:"env_vars,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RunRequest) ProtoMessage() {}

func (x *RunRequest) ProtoReflect() protoreflect.Message {
	mi := &file_proto_engine_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 RunRequest.ProtoReflect.Descriptor instead.
func (*RunRequest) Descriptor() ([]byte, []int) {
	return file_proto_engine_proto_rawDescGZIP(), []int{4}
}

func (x *RunRequest) GetMeta() map[string]*anypb.Any {
	if x != nil {
		return x.Meta
	}
	return nil
}

func (x *RunRequest) GetWorkingDir() string {
	if x != nil {
		return x.WorkingDir
	}
	return ""
}

func (x *RunRequest) GetCommand() string {
	if x != nil {
		return x.Command
	}
	return ""
}

func (x *RunRequest) GetArgs() []string {
	if x != nil {
		return x.Args
	}
	return nil
}

func (x *RunRequest) GetAllocatePseudoTty() bool {
	if x != nil {
		return x.AllocatePseudoTty
	}
	return false
}

func (x *RunRequest) GetEnvVars() map[string]string {
	if x != nil {
		return x.EnvVars
	}
	return nil
}

type RunResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Response:
	//
	//	*RunResponse_Stdout
	//	*RunResponse_Stderr
	//	*RunResponse_ExitResult
	//	*RunResponse_Log
	Response      isRunResponse_Response `protobuf_oneof:"response"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *RunResponse) Reset() {
	*x = RunResponse{}
	mi := &file_proto_engine_proto_msgTypes[5]
	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_proto_engine_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 RunResponse.ProtoReflect.Descriptor instead.
func (*RunResponse) Descriptor() ([]byte, []int) {
	return file_proto_engine_proto_rawDescGZIP(), []int{5}
}

func (x *RunResponse) GetResponse() isRunResponse_Response {
	if x != nil {
		return x.Response
	}
	return nil
}

func (x *RunResponse) GetStdout() *StdoutMessage {
	if x != nil {
		if x, ok := x.Response.(*RunResponse_Stdout); ok {
			return x.Stdout
		}
	}
	return nil
}

func (x *RunResponse) GetStderr() *StderrMessage {
	if x != nil {
		if x, ok := x.Response.(*RunResponse_Stderr); ok {
			return x.Stderr
		}
	}
	return nil
}

func (x *RunResponse) GetExitResult() *ExitResultMessage {
	if x != nil {
		if x, ok := x.Response.(*RunResponse_ExitResult); ok {
			return x.ExitResult
		}
	}
	return nil
}

func (x *RunResponse) GetLog() *LogMessage {
	if x != nil {
		if x, ok := x.Response.(*RunResponse_Log); ok {
			return x.Log
		}
	}
	return nil
}

type isRunResponse_Response interface {
	isRunResponse_Response()
}

type RunResponse_Stdout struct {
	Stdout *StdoutMessage `protobuf:"bytes,1,opt,name=stdout,proto3,oneof"`
}

type RunResponse_Stderr struct {
	Stderr *StderrMessage `protobuf:"bytes,2,opt,name=stderr,proto3,oneof"`
}

type RunResponse_ExitResult struct {
	ExitResult *ExitResultMessage `protobuf:"bytes,3,opt,name=exit_result,json=exitResult,proto3,oneof"`
}

type RunResponse_Log struct {
	Log *LogMessage `protobuf:"bytes,4,opt,name=log,proto3,oneof"`
}

func (*RunResponse_Stdout) isRunResponse_Response() {}

func (*RunResponse_Stderr) isRunResponse_Response() {}

func (*RunResponse_ExitResult) isRunResponse_Response() {}

func (*RunResponse_Log) isRunResponse_Response() {}

// StdoutMessage contains standard output content.
type StdoutMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Content       string                 `protobuf:"bytes,1,opt,name=content,proto3" json:"content,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*StdoutMessage) ProtoMessage() {}

func (x *StdoutMessage) ProtoReflect() protoreflect.Message {
	mi := &file_proto_engine_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 StdoutMessage.ProtoReflect.Descriptor instead.
func (*StdoutMessage) Descriptor() ([]byte, []int) {
	return file_proto_engine_proto_rawDescGZIP(), []int{6}
}

func (x *StdoutMessage) GetContent() string {
	if x != nil {
		return x.Content
	}
	return ""
}

// StderrMessage contains standard error output content.
type StderrMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Content       string                 `protobuf:"bytes,1,opt,name=content,proto3" json:"content,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*StderrMessage) ProtoMessage() {}

func (x *StderrMessage) ProtoReflect() protoreflect.Message {
	mi := &file_proto_engine_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 StderrMessage.ProtoReflect.Descriptor instead.
func (*StderrMessage) Descriptor() ([]byte, []int) {
	return file_proto_engine_proto_rawDescGZIP(), []int{7}
}

func (x *StderrMessage) GetContent() string {
	if x != nil {
		return x.Content
	}
	return ""
}

// ExitResultMessage contains the exit code from a process.
type ExitResultMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Code          int32                  `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ExitResultMessage) ProtoMessage() {}

func (x *ExitResultMessage) ProtoReflect() protoreflect.Message {
	mi := &file_proto_engine_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 ExitResultMessage.ProtoReflect.Descriptor instead.
func (*ExitResultMessage) Descriptor() ([]byte, []int) {
	return file_proto_engine_proto_rawDescGZIP(), []int{8}
}

func (x *ExitResultMessage) GetCode() int32 {
	if x != nil {
		return x.Code
	}
	return 0
}

// LogMessage contains a log message with a level and content.
// This is intended for informational/logging purposes, distinct from stdout/stderr.
type LogMessage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Level         LogLevel               `protobuf:"varint,1,opt,name=level,proto3,enum=proto.LogLevel" json:"level,omitempty"`
	Content       string                 `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LogMessage) ProtoMessage() {}

func (x *LogMessage) ProtoReflect() protoreflect.Message {
	mi := &file_proto_engine_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 LogMessage.ProtoReflect.Descriptor instead.
func (*LogMessage) Descriptor() ([]byte, []int) {
	return file_proto_engine_proto_rawDescGZIP(), []int{9}
}

func (x *LogMessage) GetLevel() LogLevel {
	if x != nil {
		return x.Level
	}
	return LogLevel_LOG_LEVEL_UNSPECIFIED
}

func (x *LogMessage) GetContent() string {
	if x != nil {
		return x.Content
	}
	return ""
}

var File_proto_engine_proto protoreflect.FileDescriptor

const file_proto_engine_proto_rawDesc = "" +
	"\n" +
	"\x12proto/engine.proto\x12\x05proto\x1a\x19google/protobuf/any.proto\"\xa7\x02\n" +
	"\vInitRequest\x120\n" +
	"\x04meta\x18\x01 \x03(\v2\x1c.proto.InitRequest.MetaEntryR\x04meta\x12\x1f\n" +
	"\vworking_dir\x18\x02 \x01(\tR\n" +
	"workingDir\x12:\n" +
	"\benv_vars\x18\x03 \x03(\v2\x1f.proto.InitRequest.EnvVarsEntryR\aenvVars\x1aM\n" +
	"\tMetaEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12*\n" +
	"\x05value\x18\x02 \x01(\v2\x14.google.protobuf.AnyR\x05value:\x028\x01\x1a:\n" +
	"\fEnvVarsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xde\x01\n" +
	"\fInitResponse\x12.\n" +
	"\x06stdout\x18\x01 \x01(\v2\x14.proto.StdoutMessageH\x00R\x06stdout\x12.\n" +
	"\x06stderr\x18\x02 \x01(\v2\x14.proto.StderrMessageH\x00R\x06stderr\x12;\n" +
	"\vexit_result\x18\x03 \x01(\v2\x18.proto.ExitResultMessageH\x00R\n" +
	"exitResult\x12%\n" +
	"\x03log\x18\x04 \x01(\v2\x11.proto.LogMessageH\x00R\x03logB\n" +
	"\n" +
	"\bresponse\"\xb3\x02\n" +
	"\x0fShutdownRequest\x124\n" +
	"\x04meta\x18\x01 \x03(\v2 .proto.ShutdownRequest.MetaEntryR\x04meta\x12\x1f\n" +
	"\vworking_dir\x18\x02 \x01(\tR\n" +
	"workingDir\x12>\n" +
	"\benv_vars\x18\x03 \x03(\v2#.proto.ShutdownRequest.EnvVarsEntryR\aenvVars\x1aM\n" +
	"\tMetaEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12*\n" +
	"\x05value\x18\x02 \x01(\v2\x14.google.protobuf.AnyR\x05value:\x028\x01\x1a:\n" +
	"\fEnvVarsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xe2\x01\n" +
	"\x10ShutdownResponse\x12.\n" +
	"\x06stdout\x18\x01 \x01(\v2\x14.proto.StdoutMessageH\x00R\x06stdout\x12.\n" +
	"\x06stderr\x18\x02 \x01(\v2\x14.proto.StderrMessageH\x00R\x06stderr\x12;\n" +
	"\vexit_result\x18\x03 \x01(\v2\x18.proto.ExitResultMessageH\x00R\n" +
	"exitResult\x12%\n" +
	"\x03log\x18\x04 \x01(\v2\x11.proto.LogMessageH\x00R\x03logB\n" +
	"\n" +
	"\bresponse\"\x82\x03\n" +
	"\n" +
	"RunRequest\x12/\n" +
	"\x04meta\x18\x01 \x03(\v2\x1b.proto.RunRequest.MetaEntryR\x04meta\x12\x1f\n" +
	"\vworking_dir\x18\x02 \x01(\tR\n" +
	"workingDir\x12\x18\n" +
	"\acommand\x18\x03 \x01(\tR\acommand\x12\x12\n" +
	"\x04args\x18\x04 \x03(\tR\x04args\x12.\n" +
	"\x13allocate_pseudo_tty\x18\x05 \x01(\bR\x11allocatePseudoTty\x129\n" +
	"\benv_vars\x18\x06 \x03(\v2\x1e.proto.RunRequest.EnvVarsEntryR\aenvVars\x1aM\n" +
	"\tMetaEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12*\n" +
	"\x05value\x18\x02 \x01(\v2\x14.google.protobuf.AnyR\x05value:\x028\x01\x1a:\n" +
	"\fEnvVarsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xdd\x01\n" +
	"\vRunResponse\x12.\n" +
	"\x06stdout\x18\x01 \x01(\v2\x14.proto.StdoutMessageH\x00R\x06stdout\x12.\n" +
	"\x06stderr\x18\x02 \x01(\v2\x14.proto.StderrMessageH\x00R\x06stderr\x12;\n" +
	"\vexit_result\x18\x03 \x01(\v2\x18.proto.ExitResultMessageH\x00R\n" +
	"exitResult\x12%\n" +
	"\x03log\x18\x04 \x01(\v2\x11.proto.LogMessageH\x00R\x03logB\n" +
	"\n" +
	"\bresponse\")\n" +
	"\rStdoutMessage\x12\x18\n" +
	"\acontent\x18\x01 \x01(\tR\acontent\")\n" +
	"\rStderrMessage\x12\x18\n" +
	"\acontent\x18\x01 \x01(\tR\acontent\"'\n" +
	"\x11ExitResultMessage\x12\x12\n" +
	"\x04code\x18\x01 \x01(\x05R\x04code\"M\n" +
	"\n" +
	"LogMessage\x12%\n" +
	"\x05level\x18\x01 \x01(\x0e2\x0f.proto.LogLevelR\x05level\x12\x18\n" +
	"\acontent\x18\x02 \x01(\tR\acontent*w\n" +
	"\bLogLevel\x12\x19\n" +
	"\x15LOG_LEVEL_UNSPECIFIED\x10\x00\x12\x13\n" +
	"\x0fLOG_LEVEL_DEBUG\x10\x01\x12\x12\n" +
	"\x0eLOG_LEVEL_INFO\x10\x02\x12\x12\n" +
	"\x0eLOG_LEVEL_WARN\x10\x03\x12\x13\n" +
	"\x0fLOG_LEVEL_ERROR\x10\x042\xaa\x01\n" +
	"\x06Engine\x121\n" +
	"\x04Init\x12\x12.proto.InitRequest\x1a\x13.proto.InitResponse0\x01\x12.\n" +
	"\x03Run\x12\x11.proto.RunRequest\x1a\x12.proto.RunResponse0\x01\x12=\n" +
	"\bShutdown\x12\x16.proto.ShutdownRequest\x1a\x17.proto.ShutdownResponse0\x01B\tZ\a./protob\x06proto3"

var (
	file_proto_engine_proto_rawDescOnce sync.Once
	file_proto_engine_proto_rawDescData []byte
)

func file_proto_engine_proto_rawDescGZIP() []byte {
	file_proto_engine_proto_rawDescOnce.Do(func() {
		file_proto_engine_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_proto_engine_proto_rawDesc), len(file_proto_engine_proto_rawDesc)))
	})
	return file_proto_engine_proto_rawDescData
}

var file_proto_engine_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_proto_engine_proto_msgTypes = make([]protoimpl.MessageInfo, 16)
var file_proto_engine_proto_goTypes = []any{
	(LogLevel)(0),             // 0: proto.LogLevel
	(*InitRequest)(nil),       // 1: proto.InitRequest
	(*InitResponse)(nil),      // 2: proto.InitResponse
	(*ShutdownRequest)(nil),   // 3: proto.ShutdownRequest
	(*ShutdownResponse)(nil),  // 4: proto.ShutdownResponse
	(*RunRequest)(nil),        // 5: proto.RunRequest
	(*RunResponse)(nil),       // 6: proto.RunResponse
	(*StdoutMessage)(nil),     // 7: proto.StdoutMessage
	(*StderrMessage)(nil),     // 8: proto.StderrMessage
	(*ExitResultMessage)(nil), // 9: proto.ExitResultMessage
	(*LogMessage)(nil),        // 10: proto.LogMessage
	nil,                       // 11: proto.InitRequest.MetaEntry
	nil,                       // 12: proto.InitRequest.EnvVarsEntry
	nil,                       // 13: proto.ShutdownRequest.MetaEntry
	nil,                       // 14: proto.ShutdownRequest.EnvVarsEntry
	nil,                       // 15: proto.RunRequest.MetaEntry
	nil,                       // 16: proto.RunRequest.EnvVarsEntry
	(*anypb.Any)(nil),         // 17: google.protobuf.Any
}
var file_proto_engine_proto_depIdxs = []int32{
	11, // 0: proto.InitRequest.meta:type_name -> proto.InitRequest.MetaEntry
	12, // 1: proto.InitRequest.env_vars:type_name -> proto.InitRequest.EnvVarsEntry
	7,  // 2: proto.InitResponse.stdout:type_name -> proto.StdoutMessage
	8,  // 3: proto.InitResponse.stderr:type_name -> proto.StderrMessage
	9,  // 4: proto.InitResponse.exit_result:type_name -> proto.ExitResultMessage
	10, // 5: proto.InitResponse.log:type_name -> proto.LogMessage
	13, // 6: proto.ShutdownRequest.meta:type_name -> proto.ShutdownRequest.MetaEntry
	14, // 7: proto.ShutdownRequest.env_vars:type_name -> proto.ShutdownRequest.EnvVarsEntry
	7,  // 8: proto.ShutdownResponse.stdout:type_name -> proto.StdoutMessage
	8,  // 9: proto.ShutdownResponse.stderr:type_name -> proto.StderrMessage
	9,  // 10: proto.ShutdownResponse.exit_result:type_name -> proto.ExitResultMessage
	10, // 11: proto.ShutdownResponse.log:type_name -> proto.LogMessage
	15, // 12: proto.RunRequest.meta:type_name -> proto.RunRequest.MetaEntry
	16, // 13: proto.RunRequest.env_vars:type_name -> proto.RunRequest.EnvVarsEntry
	7,  // 14: proto.RunResponse.stdout:type_name -> proto.StdoutMessage
	8,  // 15: proto.RunResponse.stderr:type_name -> proto.StderrMessage
	9,  // 16: proto.RunResponse.exit_result:type_name -> proto.ExitResultMessage
	10, // 17: proto.RunResponse.log:type_name -> proto.LogMessage
	0,  // 18: proto.LogMessage.level:type_name -> proto.LogLevel
	17, // 19: proto.InitRequest.MetaEntry.value:type_name -> google.protobuf.Any
	17, // 20: proto.ShutdownRequest.MetaEntry.value:type_name -> google.protobuf.Any
	17, // 21: proto.RunRequest.MetaEntry.value:type_name -> google.protobuf.Any
	1,  // 22: proto.Engine.Init:input_type -> proto.InitRequest
	5,  // 23: proto.Engine.Run:input_type -> proto.RunRequest
	3,  // 24: proto.Engine.Shutdown:input_type -> proto.ShutdownRequest
	2,  // 25: proto.Engine.Init:output_type -> proto.InitResponse
	6,  // 26: proto.Engine.Run:output_type -> proto.RunResponse
	4,  // 27: proto.Engine.Shutdown:output_type -> proto.ShutdownResponse
	25, // [25:28] is the sub-list for method output_type
	22, // [22:25] is the sub-list for method input_type
	22, // [22:22] is the sub-list for extension type_name
	22, // [22:22] is the sub-list for extension extendee
	0,  // [0:22] is the sub-list for field type_name
}

func init() { file_proto_engine_proto_init() }
func file_proto_engine_proto_init() {
	if File_proto_engine_proto != nil {
		return
	}
	file_proto_engine_proto_msgTypes[1].OneofWrappers = []any{
		(*InitResponse_Stdout)(nil),
		(*InitResponse_Stderr)(nil),
		(*InitResponse_ExitResult)(nil),
		(*InitResponse_Log)(nil),
	}
	file_proto_engine_proto_msgTypes[3].OneofWrappers = []any{
		(*ShutdownResponse_Stdout)(nil),
		(*ShutdownResponse_Stderr)(nil),
		(*ShutdownResponse_ExitResult)(nil),
		(*ShutdownResponse_Log)(nil),
	}
	file_proto_engine_proto_msgTypes[5].OneofWrappers = []any{
		(*RunResponse_Stdout)(nil),
		(*RunResponse_Stderr)(nil),
		(*RunResponse_ExitResult)(nil),
		(*RunResponse_Log)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_proto_engine_proto_rawDesc), len(file_proto_engine_proto_rawDesc)),
			NumEnums:      1,
			NumMessages:   16,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_proto_engine_proto_goTypes,
		DependencyIndexes: file_proto_engine_proto_depIdxs,
		EnumInfos:         file_proto_engine_proto_enumTypes,
		MessageInfos:      file_proto_engine_proto_msgTypes,
	}.Build()
	File_proto_engine_proto = out.File
	file_proto_engine_proto_goTypes = nil
	file_proto_engine_proto_depIdxs = nil
}
