github.com/qiniu/go-sdk/v7@v7.27.0/sandbox/internal/envdapi/process/process.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        (unknown)
// source: process/process.proto

package process

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

const (
	Signal_SIGNAL_UNSPECIFIED Signal = 0
	Signal_SIGNAL_SIGTERM     Signal = 15
	Signal_SIGNAL_SIGKILL     Signal = 9
)

// Enum value maps for Signal.
var (
	Signal_name = map[int32]string{
		0:  "SIGNAL_UNSPECIFIED",
		15: "SIGNAL_SIGTERM",
		9:  "SIGNAL_SIGKILL",
	}
	Signal_value = map[string]int32{
		"SIGNAL_UNSPECIFIED": 0,
		"SIGNAL_SIGTERM":     15,
		"SIGNAL_SIGKILL":     9,
	}
)

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

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

func (Signal) Descriptor() protoreflect.EnumDescriptor {
	return file_process_process_proto_enumTypes[0].Descriptor()
}

func (Signal) Type() protoreflect.EnumType {
	return &file_process_process_proto_enumTypes[0]
}

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

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

type PTY struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Size          *PTY_Size              `protobuf:"bytes,1,opt,name=size,proto3" json:"size,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*PTY) ProtoMessage() {}

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

func (x *PTY) GetSize() *PTY_Size {
	if x != nil {
		return x.Size
	}
	return nil
}

type ProcessConfig struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Cmd           string                 `protobuf:"bytes,1,opt,name=cmd,proto3" json:"cmd,omitempty"`
	Args          []string               `protobuf:"bytes,2,rep,name=args,proto3" json:"args,omitempty"`
	Envs          map[string]string      `protobuf:"bytes,3,rep,name=envs,proto3" json:"envs,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	Cwd           *string                `protobuf:"bytes,4,opt,name=cwd,proto3,oneof" json:"cwd,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ProcessConfig) ProtoMessage() {}

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

func (x *ProcessConfig) GetCmd() string {
	if x != nil {
		return x.Cmd
	}
	return ""
}

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

func (x *ProcessConfig) GetEnvs() map[string]string {
	if x != nil {
		return x.Envs
	}
	return nil
}

func (x *ProcessConfig) GetCwd() string {
	if x != nil && x.Cwd != nil {
		return *x.Cwd
	}
	return ""
}

type ListRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListRequest) ProtoMessage() {}

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

type ProcessInfo struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Config        *ProcessConfig         `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"`
	Pid           uint32                 `protobuf:"varint,2,opt,name=pid,proto3" json:"pid,omitempty"`
	Tag           *string                `protobuf:"bytes,3,opt,name=tag,proto3,oneof" json:"tag,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ProcessInfo) ProtoMessage() {}

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

func (x *ProcessInfo) GetConfig() *ProcessConfig {
	if x != nil {
		return x.Config
	}
	return nil
}

func (x *ProcessInfo) GetPid() uint32 {
	if x != nil {
		return x.Pid
	}
	return 0
}

func (x *ProcessInfo) GetTag() string {
	if x != nil && x.Tag != nil {
		return *x.Tag
	}
	return ""
}

type ListResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Processes     []*ProcessInfo         `protobuf:"bytes,1,rep,name=processes,proto3" json:"processes,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ListResponse) ProtoMessage() {}

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

func (x *ListResponse) GetProcesses() []*ProcessInfo {
	if x != nil {
		return x.Processes
	}
	return nil
}

type StartRequest struct {
	state   protoimpl.MessageState `protogen:"open.v1"`
	Process *ProcessConfig         `protobuf:"bytes,1,opt,name=process,proto3" json:"process,omitempty"`
	Pty     *PTY                   `protobuf:"bytes,2,opt,name=pty,proto3,oneof" json:"pty,omitempty"`
	Tag     *string                `protobuf:"bytes,3,opt,name=tag,proto3,oneof" json:"tag,omitempty"`
	// This is optional for backwards compatibility.
	// We default to true. New SDK versions will set this to false by default.
	Stdin         *bool `protobuf:"varint,4,opt,name=stdin,proto3,oneof" json:"stdin,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*StartRequest) ProtoMessage() {}

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

func (x *StartRequest) GetProcess() *ProcessConfig {
	if x != nil {
		return x.Process
	}
	return nil
}

func (x *StartRequest) GetPty() *PTY {
	if x != nil {
		return x.Pty
	}
	return nil
}

func (x *StartRequest) GetTag() string {
	if x != nil && x.Tag != nil {
		return *x.Tag
	}
	return ""
}

func (x *StartRequest) GetStdin() bool {
	if x != nil && x.Stdin != nil {
		return *x.Stdin
	}
	return false
}

type UpdateRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Process       *ProcessSelector       `protobuf:"bytes,1,opt,name=process,proto3" json:"process,omitempty"`
	Pty           *PTY                   `protobuf:"bytes,2,opt,name=pty,proto3,oneof" json:"pty,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UpdateRequest) ProtoMessage() {}

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

func (x *UpdateRequest) GetProcess() *ProcessSelector {
	if x != nil {
		return x.Process
	}
	return nil
}

func (x *UpdateRequest) GetPty() *PTY {
	if x != nil {
		return x.Pty
	}
	return nil
}

type UpdateResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*UpdateResponse) ProtoMessage() {}

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

type ProcessEvent struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Event:
	//
	//	*ProcessEvent_Start
	//	*ProcessEvent_Data
	//	*ProcessEvent_End
	//	*ProcessEvent_Keepalive
	Event         isProcessEvent_Event `protobuf_oneof:"event"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ProcessEvent) ProtoMessage() {}

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

func (x *ProcessEvent) GetEvent() isProcessEvent_Event {
	if x != nil {
		return x.Event
	}
	return nil
}

func (x *ProcessEvent) GetStart() *ProcessEvent_StartEvent {
	if x != nil {
		if x, ok := x.Event.(*ProcessEvent_Start); ok {
			return x.Start
		}
	}
	return nil
}

func (x *ProcessEvent) GetData() *ProcessEvent_DataEvent {
	if x != nil {
		if x, ok := x.Event.(*ProcessEvent_Data); ok {
			return x.Data
		}
	}
	return nil
}

func (x *ProcessEvent) GetEnd() *ProcessEvent_EndEvent {
	if x != nil {
		if x, ok := x.Event.(*ProcessEvent_End); ok {
			return x.End
		}
	}
	return nil
}

func (x *ProcessEvent) GetKeepalive() *ProcessEvent_KeepAlive {
	if x != nil {
		if x, ok := x.Event.(*ProcessEvent_Keepalive); ok {
			return x.Keepalive
		}
	}
	return nil
}

type isProcessEvent_Event interface {
	isProcessEvent_Event()
}

type ProcessEvent_Start struct {
	Start *ProcessEvent_StartEvent `protobuf:"bytes,1,opt,name=start,proto3,oneof"`
}

type ProcessEvent_Data struct {
	Data *ProcessEvent_DataEvent `protobuf:"bytes,2,opt,name=data,proto3,oneof"`
}

type ProcessEvent_End struct {
	End *ProcessEvent_EndEvent `protobuf:"bytes,3,opt,name=end,proto3,oneof"`
}

type ProcessEvent_Keepalive struct {
	Keepalive *ProcessEvent_KeepAlive `protobuf:"bytes,4,opt,name=keepalive,proto3,oneof"`
}

func (*ProcessEvent_Start) isProcessEvent_Event() {}

func (*ProcessEvent_Data) isProcessEvent_Event() {}

func (*ProcessEvent_End) isProcessEvent_Event() {}

func (*ProcessEvent_Keepalive) isProcessEvent_Event() {}

type StartResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Event         *ProcessEvent          `protobuf:"bytes,1,opt,name=event,proto3" json:"event,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*StartResponse) ProtoMessage() {}

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

func (x *StartResponse) GetEvent() *ProcessEvent {
	if x != nil {
		return x.Event
	}
	return nil
}

type ConnectResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Event         *ProcessEvent          `protobuf:"bytes,1,opt,name=event,proto3" json:"event,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ConnectResponse) ProtoMessage() {}

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

func (x *ConnectResponse) GetEvent() *ProcessEvent {
	if x != nil {
		return x.Event
	}
	return nil
}

type SendInputRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Process       *ProcessSelector       `protobuf:"bytes,1,opt,name=process,proto3" json:"process,omitempty"`
	Input         *ProcessInput          `protobuf:"bytes,2,opt,name=input,proto3" json:"input,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SendInputRequest) ProtoMessage() {}

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

func (x *SendInputRequest) GetProcess() *ProcessSelector {
	if x != nil {
		return x.Process
	}
	return nil
}

func (x *SendInputRequest) GetInput() *ProcessInput {
	if x != nil {
		return x.Input
	}
	return nil
}

type SendInputResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SendInputResponse) ProtoMessage() {}

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

type ProcessInput struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Input:
	//
	//	*ProcessInput_Stdin
	//	*ProcessInput_Pty
	Input         isProcessInput_Input `protobuf_oneof:"input"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ProcessInput) ProtoMessage() {}

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

func (x *ProcessInput) GetInput() isProcessInput_Input {
	if x != nil {
		return x.Input
	}
	return nil
}

func (x *ProcessInput) GetStdin() []byte {
	if x != nil {
		if x, ok := x.Input.(*ProcessInput_Stdin); ok {
			return x.Stdin
		}
	}
	return nil
}

func (x *ProcessInput) GetPty() []byte {
	if x != nil {
		if x, ok := x.Input.(*ProcessInput_Pty); ok {
			return x.Pty
		}
	}
	return nil
}

type isProcessInput_Input interface {
	isProcessInput_Input()
}

type ProcessInput_Stdin struct {
	Stdin []byte `protobuf:"bytes,1,opt,name=stdin,proto3,oneof"`
}

type ProcessInput_Pty struct {
	Pty []byte `protobuf:"bytes,2,opt,name=pty,proto3,oneof"`
}

func (*ProcessInput_Stdin) isProcessInput_Input() {}

func (*ProcessInput_Pty) isProcessInput_Input() {}

type StreamInputRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Event:
	//
	//	*StreamInputRequest_Start
	//	*StreamInputRequest_Data
	//	*StreamInputRequest_Keepalive
	Event         isStreamInputRequest_Event `protobuf_oneof:"event"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*StreamInputRequest) ProtoMessage() {}

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

func (x *StreamInputRequest) GetEvent() isStreamInputRequest_Event {
	if x != nil {
		return x.Event
	}
	return nil
}

func (x *StreamInputRequest) GetStart() *StreamInputRequest_StartEvent {
	if x != nil {
		if x, ok := x.Event.(*StreamInputRequest_Start); ok {
			return x.Start
		}
	}
	return nil
}

func (x *StreamInputRequest) GetData() *StreamInputRequest_DataEvent {
	if x != nil {
		if x, ok := x.Event.(*StreamInputRequest_Data); ok {
			return x.Data
		}
	}
	return nil
}

func (x *StreamInputRequest) GetKeepalive() *StreamInputRequest_KeepAlive {
	if x != nil {
		if x, ok := x.Event.(*StreamInputRequest_Keepalive); ok {
			return x.Keepalive
		}
	}
	return nil
}

type isStreamInputRequest_Event interface {
	isStreamInputRequest_Event()
}

type StreamInputRequest_Start struct {
	Start *StreamInputRequest_StartEvent `protobuf:"bytes,1,opt,name=start,proto3,oneof"`
}

type StreamInputRequest_Data struct {
	Data *StreamInputRequest_DataEvent `protobuf:"bytes,2,opt,name=data,proto3,oneof"`
}

type StreamInputRequest_Keepalive struct {
	Keepalive *StreamInputRequest_KeepAlive `protobuf:"bytes,3,opt,name=keepalive,proto3,oneof"`
}

func (*StreamInputRequest_Start) isStreamInputRequest_Event() {}

func (*StreamInputRequest_Data) isStreamInputRequest_Event() {}

func (*StreamInputRequest_Keepalive) isStreamInputRequest_Event() {}

type StreamInputResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*StreamInputResponse) ProtoMessage() {}

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

type SendSignalRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Process       *ProcessSelector       `protobuf:"bytes,1,opt,name=process,proto3" json:"process,omitempty"`
	Signal        Signal                 `protobuf:"varint,2,opt,name=signal,proto3,enum=process.Signal" json:"signal,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SendSignalRequest) ProtoMessage() {}

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

func (x *SendSignalRequest) GetProcess() *ProcessSelector {
	if x != nil {
		return x.Process
	}
	return nil
}

func (x *SendSignalRequest) GetSignal() Signal {
	if x != nil {
		return x.Signal
	}
	return Signal_SIGNAL_UNSPECIFIED
}

type SendSignalResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SendSignalResponse) ProtoMessage() {}

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

type CloseStdinRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Process       *ProcessSelector       `protobuf:"bytes,1,opt,name=process,proto3" json:"process,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CloseStdinRequest) ProtoMessage() {}

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

func (x *CloseStdinRequest) GetProcess() *ProcessSelector {
	if x != nil {
		return x.Process
	}
	return nil
}

type CloseStdinResponse struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CloseStdinResponse) ProtoMessage() {}

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

type ConnectRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Process       *ProcessSelector       `protobuf:"bytes,1,opt,name=process,proto3" json:"process,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ConnectRequest) Reset() {
	*x = ConnectRequest{}
	mi := &file_process_process_proto_msgTypes[20]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ConnectRequest) ProtoMessage() {}

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

func (x *ConnectRequest) GetProcess() *ProcessSelector {
	if x != nil {
		return x.Process
	}
	return nil
}

type ProcessSelector struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Selector:
	//
	//	*ProcessSelector_Pid
	//	*ProcessSelector_Tag
	Selector      isProcessSelector_Selector `protobuf_oneof:"selector"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ProcessSelector) Reset() {
	*x = ProcessSelector{}
	mi := &file_process_process_proto_msgTypes[21]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ProcessSelector) ProtoMessage() {}

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

func (x *ProcessSelector) GetSelector() isProcessSelector_Selector {
	if x != nil {
		return x.Selector
	}
	return nil
}

func (x *ProcessSelector) GetPid() uint32 {
	if x != nil {
		if x, ok := x.Selector.(*ProcessSelector_Pid); ok {
			return x.Pid
		}
	}
	return 0
}

func (x *ProcessSelector) GetTag() string {
	if x != nil {
		if x, ok := x.Selector.(*ProcessSelector_Tag); ok {
			return x.Tag
		}
	}
	return ""
}

type isProcessSelector_Selector interface {
	isProcessSelector_Selector()
}

type ProcessSelector_Pid struct {
	Pid uint32 `protobuf:"varint,1,opt,name=pid,proto3,oneof"`
}

type ProcessSelector_Tag struct {
	Tag string `protobuf:"bytes,2,opt,name=tag,proto3,oneof"`
}

func (*ProcessSelector_Pid) isProcessSelector_Selector() {}

func (*ProcessSelector_Tag) isProcessSelector_Selector() {}

type PTY_Size struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Cols          uint32                 `protobuf:"varint,1,opt,name=cols,proto3" json:"cols,omitempty"`
	Rows          uint32                 `protobuf:"varint,2,opt,name=rows,proto3" json:"rows,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *PTY_Size) Reset() {
	*x = PTY_Size{}
	mi := &file_process_process_proto_msgTypes[22]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*PTY_Size) ProtoMessage() {}

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

func (x *PTY_Size) GetCols() uint32 {
	if x != nil {
		return x.Cols
	}
	return 0
}

func (x *PTY_Size) GetRows() uint32 {
	if x != nil {
		return x.Rows
	}
	return 0
}

type ProcessEvent_StartEvent struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Pid           uint32                 `protobuf:"varint,1,opt,name=pid,proto3" json:"pid,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ProcessEvent_StartEvent) Reset() {
	*x = ProcessEvent_StartEvent{}
	mi := &file_process_process_proto_msgTypes[24]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ProcessEvent_StartEvent) ProtoMessage() {}

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

func (x *ProcessEvent_StartEvent) GetPid() uint32 {
	if x != nil {
		return x.Pid
	}
	return 0
}

type ProcessEvent_DataEvent struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Output:
	//
	//	*ProcessEvent_DataEvent_Stdout
	//	*ProcessEvent_DataEvent_Stderr
	//	*ProcessEvent_DataEvent_Pty
	Output        isProcessEvent_DataEvent_Output `protobuf_oneof:"output"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ProcessEvent_DataEvent) Reset() {
	*x = ProcessEvent_DataEvent{}
	mi := &file_process_process_proto_msgTypes[25]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ProcessEvent_DataEvent) ProtoMessage() {}

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

func (x *ProcessEvent_DataEvent) GetOutput() isProcessEvent_DataEvent_Output {
	if x != nil {
		return x.Output
	}
	return nil
}

func (x *ProcessEvent_DataEvent) GetStdout() []byte {
	if x != nil {
		if x, ok := x.Output.(*ProcessEvent_DataEvent_Stdout); ok {
			return x.Stdout
		}
	}
	return nil
}

func (x *ProcessEvent_DataEvent) GetStderr() []byte {
	if x != nil {
		if x, ok := x.Output.(*ProcessEvent_DataEvent_Stderr); ok {
			return x.Stderr
		}
	}
	return nil
}

func (x *ProcessEvent_DataEvent) GetPty() []byte {
	if x != nil {
		if x, ok := x.Output.(*ProcessEvent_DataEvent_Pty); ok {
			return x.Pty
		}
	}
	return nil
}

type isProcessEvent_DataEvent_Output interface {
	isProcessEvent_DataEvent_Output()
}

type ProcessEvent_DataEvent_Stdout struct {
	Stdout []byte `protobuf:"bytes,1,opt,name=stdout,proto3,oneof"`
}

type ProcessEvent_DataEvent_Stderr struct {
	Stderr []byte `protobuf:"bytes,2,opt,name=stderr,proto3,oneof"`
}

type ProcessEvent_DataEvent_Pty struct {
	Pty []byte `protobuf:"bytes,3,opt,name=pty,proto3,oneof"`
}

func (*ProcessEvent_DataEvent_Stdout) isProcessEvent_DataEvent_Output() {}

func (*ProcessEvent_DataEvent_Stderr) isProcessEvent_DataEvent_Output() {}

func (*ProcessEvent_DataEvent_Pty) isProcessEvent_DataEvent_Output() {}

type ProcessEvent_EndEvent struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	ExitCode      int32                  `protobuf:"zigzag32,1,opt,name=exit_code,json=exitCode,proto3" json:"exit_code,omitempty"`
	Exited        bool                   `protobuf:"varint,2,opt,name=exited,proto3" json:"exited,omitempty"`
	Status        string                 `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
	Error         *string                `protobuf:"bytes,4,opt,name=error,proto3,oneof" json:"error,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ProcessEvent_EndEvent) Reset() {
	*x = ProcessEvent_EndEvent{}
	mi := &file_process_process_proto_msgTypes[26]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ProcessEvent_EndEvent) ProtoMessage() {}

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

func (x *ProcessEvent_EndEvent) GetExitCode() int32 {
	if x != nil {
		return x.ExitCode
	}
	return 0
}

func (x *ProcessEvent_EndEvent) GetExited() bool {
	if x != nil {
		return x.Exited
	}
	return false
}

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

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

type ProcessEvent_KeepAlive struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ProcessEvent_KeepAlive) Reset() {
	*x = ProcessEvent_KeepAlive{}
	mi := &file_process_process_proto_msgTypes[27]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ProcessEvent_KeepAlive) ProtoMessage() {}

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

type StreamInputRequest_StartEvent struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Process       *ProcessSelector       `protobuf:"bytes,1,opt,name=process,proto3" json:"process,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *StreamInputRequest_StartEvent) Reset() {
	*x = StreamInputRequest_StartEvent{}
	mi := &file_process_process_proto_msgTypes[28]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*StreamInputRequest_StartEvent) ProtoMessage() {}

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

func (x *StreamInputRequest_StartEvent) GetProcess() *ProcessSelector {
	if x != nil {
		return x.Process
	}
	return nil
}

type StreamInputRequest_DataEvent struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Input         *ProcessInput          `protobuf:"bytes,2,opt,name=input,proto3" json:"input,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *StreamInputRequest_DataEvent) Reset() {
	*x = StreamInputRequest_DataEvent{}
	mi := &file_process_process_proto_msgTypes[29]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*StreamInputRequest_DataEvent) ProtoMessage() {}

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

func (x *StreamInputRequest_DataEvent) GetInput() *ProcessInput {
	if x != nil {
		return x.Input
	}
	return nil
}

type StreamInputRequest_KeepAlive struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *StreamInputRequest_KeepAlive) Reset() {
	*x = StreamInputRequest_KeepAlive{}
	mi := &file_process_process_proto_msgTypes[30]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*StreamInputRequest_KeepAlive) ProtoMessage() {}

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

var File_process_process_proto protoreflect.FileDescriptor

const file_process_process_proto_rawDesc = "" +
	"\n" +
	"\x15process/process.proto\x12\aprocess\"\\\n" +
	"\x03PTY\x12%\n" +
	"\x04size\x18\x01 \x01(\v2\x11.process.PTY.SizeR\x04size\x1a.\n" +
	"\x04Size\x12\x12\n" +
	"\x04cols\x18\x01 \x01(\rR\x04cols\x12\x12\n" +
	"\x04rows\x18\x02 \x01(\rR\x04rows\"\xc3\x01\n" +
	"\rProcessConfig\x12\x10\n" +
	"\x03cmd\x18\x01 \x01(\tR\x03cmd\x12\x12\n" +
	"\x04args\x18\x02 \x03(\tR\x04args\x124\n" +
	"\x04envs\x18\x03 \x03(\v2 .process.ProcessConfig.EnvsEntryR\x04envs\x12\x15\n" +
	"\x03cwd\x18\x04 \x01(\tH\x00R\x03cwd\x88\x01\x01\x1a7\n" +
	"\tEnvsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01B\x06\n" +
	"\x04_cwd\"\r\n" +
	"\vListRequest\"n\n" +
	"\vProcessInfo\x12.\n" +
	"\x06config\x18\x01 \x01(\v2\x16.process.ProcessConfigR\x06config\x12\x10\n" +
	"\x03pid\x18\x02 \x01(\rR\x03pid\x12\x15\n" +
	"\x03tag\x18\x03 \x01(\tH\x00R\x03tag\x88\x01\x01B\x06\n" +
	"\x04_tag\"B\n" +
	"\fListResponse\x122\n" +
	"\tprocesses\x18\x01 \x03(\v2\x14.process.ProcessInfoR\tprocesses\"\xb1\x01\n" +
	"\fStartRequest\x120\n" +
	"\aprocess\x18\x01 \x01(\v2\x16.process.ProcessConfigR\aprocess\x12#\n" +
	"\x03pty\x18\x02 \x01(\v2\f.process.PTYH\x00R\x03pty\x88\x01\x01\x12\x15\n" +
	"\x03tag\x18\x03 \x01(\tH\x01R\x03tag\x88\x01\x01\x12\x19\n" +
	"\x05stdin\x18\x04 \x01(\bH\x02R\x05stdin\x88\x01\x01B\x06\n" +
	"\x04_ptyB\x06\n" +
	"\x04_tagB\b\n" +
	"\x06_stdin\"p\n" +
	"\rUpdateRequest\x122\n" +
	"\aprocess\x18\x01 \x01(\v2\x18.process.ProcessSelectorR\aprocess\x12#\n" +
	"\x03pty\x18\x02 \x01(\v2\f.process.PTYH\x00R\x03pty\x88\x01\x01B\x06\n" +
	"\x04_pty\"\x10\n" +
	"\x0eUpdateResponse\"\x87\x04\n" +
	"\fProcessEvent\x128\n" +
	"\x05start\x18\x01 \x01(\v2 .process.ProcessEvent.StartEventH\x00R\x05start\x125\n" +
	"\x04data\x18\x02 \x01(\v2\x1f.process.ProcessEvent.DataEventH\x00R\x04data\x122\n" +
	"\x03end\x18\x03 \x01(\v2\x1e.process.ProcessEvent.EndEventH\x00R\x03end\x12?\n" +
	"\tkeepalive\x18\x04 \x01(\v2\x1f.process.ProcessEvent.KeepAliveH\x00R\tkeepalive\x1a\x1e\n" +
	"\n" +
	"StartEvent\x12\x10\n" +
	"\x03pid\x18\x01 \x01(\rR\x03pid\x1a]\n" +
	"\tDataEvent\x12\x18\n" +
	"\x06stdout\x18\x01 \x01(\fH\x00R\x06stdout\x12\x18\n" +
	"\x06stderr\x18\x02 \x01(\fH\x00R\x06stderr\x12\x12\n" +
	"\x03pty\x18\x03 \x01(\fH\x00R\x03ptyB\b\n" +
	"\x06output\x1a|\n" +
	"\bEndEvent\x12\x1b\n" +
	"\texit_code\x18\x01 \x01(\x11R\bexitCode\x12\x16\n" +
	"\x06exited\x18\x02 \x01(\bR\x06exited\x12\x16\n" +
	"\x06status\x18\x03 \x01(\tR\x06status\x12\x19\n" +
	"\x05error\x18\x04 \x01(\tH\x00R\x05error\x88\x01\x01B\b\n" +
	"\x06_error\x1a\v\n" +
	"\tKeepAliveB\a\n" +
	"\x05event\"<\n" +
	"\rStartResponse\x12+\n" +
	"\x05event\x18\x01 \x01(\v2\x15.process.ProcessEventR\x05event\">\n" +
	"\x0fConnectResponse\x12+\n" +
	"\x05event\x18\x01 \x01(\v2\x15.process.ProcessEventR\x05event\"s\n" +
	"\x10SendInputRequest\x122\n" +
	"\aprocess\x18\x01 \x01(\v2\x18.process.ProcessSelectorR\aprocess\x12+\n" +
	"\x05input\x18\x02 \x01(\v2\x15.process.ProcessInputR\x05input\"\x13\n" +
	"\x11SendInputResponse\"C\n" +
	"\fProcessInput\x12\x16\n" +
	"\x05stdin\x18\x01 \x01(\fH\x00R\x05stdin\x12\x12\n" +
	"\x03pty\x18\x02 \x01(\fH\x00R\x03ptyB\a\n" +
	"\x05input\"\xea\x02\n" +
	"\x12StreamInputRequest\x12>\n" +
	"\x05start\x18\x01 \x01(\v2&.process.StreamInputRequest.StartEventH\x00R\x05start\x12;\n" +
	"\x04data\x18\x02 \x01(\v2%.process.StreamInputRequest.DataEventH\x00R\x04data\x12E\n" +
	"\tkeepalive\x18\x03 \x01(\v2%.process.StreamInputRequest.KeepAliveH\x00R\tkeepalive\x1a@\n" +
	"\n" +
	"StartEvent\x122\n" +
	"\aprocess\x18\x01 \x01(\v2\x18.process.ProcessSelectorR\aprocess\x1a8\n" +
	"\tDataEvent\x12+\n" +
	"\x05input\x18\x02 \x01(\v2\x15.process.ProcessInputR\x05input\x1a\v\n" +
	"\tKeepAliveB\a\n" +
	"\x05event\"\x15\n" +
	"\x13StreamInputResponse\"p\n" +
	"\x11SendSignalRequest\x122\n" +
	"\aprocess\x18\x01 \x01(\v2\x18.process.ProcessSelectorR\aprocess\x12'\n" +
	"\x06signal\x18\x02 \x01(\x0e2\x0f.process.SignalR\x06signal\"\x14\n" +
	"\x12SendSignalResponse\"G\n" +
	"\x11CloseStdinRequest\x122\n" +
	"\aprocess\x18\x01 \x01(\v2\x18.process.ProcessSelectorR\aprocess\"\x14\n" +
	"\x12CloseStdinResponse\"D\n" +
	"\x0eConnectRequest\x122\n" +
	"\aprocess\x18\x01 \x01(\v2\x18.process.ProcessSelectorR\aprocess\"E\n" +
	"\x0fProcessSelector\x12\x12\n" +
	"\x03pid\x18\x01 \x01(\rH\x00R\x03pid\x12\x12\n" +
	"\x03tag\x18\x02 \x01(\tH\x00R\x03tagB\n" +
	"\n" +
	"\bselector*H\n" +
	"\x06Signal\x12\x16\n" +
	"\x12SIGNAL_UNSPECIFIED\x10\x00\x12\x12\n" +
	"\x0eSIGNAL_SIGTERM\x10\x0f\x12\x12\n" +
	"\x0eSIGNAL_SIGKILL\x10\t2\x91\x04\n" +
	"\aProcess\x123\n" +
	"\x04List\x12\x14.process.ListRequest\x1a\x15.process.ListResponse\x12>\n" +
	"\aConnect\x12\x17.process.ConnectRequest\x1a\x18.process.ConnectResponse0\x01\x128\n" +
	"\x05Start\x12\x15.process.StartRequest\x1a\x16.process.StartResponse0\x01\x129\n" +
	"\x06Update\x12\x16.process.UpdateRequest\x1a\x17.process.UpdateResponse\x12J\n" +
	"\vStreamInput\x12\x1b.process.StreamInputRequest\x1a\x1c.process.StreamInputResponse(\x01\x12B\n" +
	"\tSendInput\x12\x19.process.SendInputRequest\x1a\x1a.process.SendInputResponse\x12E\n" +
	"\n" +
	"SendSignal\x12\x1a.process.SendSignalRequest\x1a\x1b.process.SendSignalResponse\x12E\n" +
	"\n" +
	"CloseStdin\x12\x1a.process.CloseStdinRequest\x1a\x1b.process.CloseStdinResponseB\x94\x01\n" +
	"\vcom.processB\fProcessProtoP\x01Z;github.com/qiniu/go-sdk/v7/sandbox/internal/envdapi/process\xa2\x02\x03PXX\xaa\x02\aProcess\xca\x02\aProcess\xe2\x02\x13Process\\GPBMetadata\xea\x02\aProcessb\x06proto3"

var (
	file_process_process_proto_rawDescOnce sync.Once
	file_process_process_proto_rawDescData []byte
)

func file_process_process_proto_rawDescGZIP() []byte {
	file_process_process_proto_rawDescOnce.Do(func() {
		file_process_process_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_process_process_proto_rawDesc), len(file_process_process_proto_rawDesc)))
	})
	return file_process_process_proto_rawDescData
}

var file_process_process_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_process_process_proto_msgTypes = make([]protoimpl.MessageInfo, 31)
var file_process_process_proto_goTypes = []any{
	(Signal)(0),                           // 0: process.Signal
	(*PTY)(nil),                           // 1: process.PTY
	(*ProcessConfig)(nil),                 // 2: process.ProcessConfig
	(*ListRequest)(nil),                   // 3: process.ListRequest
	(*ProcessInfo)(nil),                   // 4: process.ProcessInfo
	(*ListResponse)(nil),                  // 5: process.ListResponse
	(*StartRequest)(nil),                  // 6: process.StartRequest
	(*UpdateRequest)(nil),                 // 7: process.UpdateRequest
	(*UpdateResponse)(nil),                // 8: process.UpdateResponse
	(*ProcessEvent)(nil),                  // 9: process.ProcessEvent
	(*StartResponse)(nil),                 // 10: process.StartResponse
	(*ConnectResponse)(nil),               // 11: process.ConnectResponse
	(*SendInputRequest)(nil),              // 12: process.SendInputRequest
	(*SendInputResponse)(nil),             // 13: process.SendInputResponse
	(*ProcessInput)(nil),                  // 14: process.ProcessInput
	(*StreamInputRequest)(nil),            // 15: process.StreamInputRequest
	(*StreamInputResponse)(nil),           // 16: process.StreamInputResponse
	(*SendSignalRequest)(nil),             // 17: process.SendSignalRequest
	(*SendSignalResponse)(nil),            // 18: process.SendSignalResponse
	(*CloseStdinRequest)(nil),             // 19: process.CloseStdinRequest
	(*CloseStdinResponse)(nil),            // 20: process.CloseStdinResponse
	(*ConnectRequest)(nil),                // 21: process.ConnectRequest
	(*ProcessSelector)(nil),               // 22: process.ProcessSelector
	(*PTY_Size)(nil),                      // 23: process.PTY.Size
	nil,                                   // 24: process.ProcessConfig.EnvsEntry
	(*ProcessEvent_StartEvent)(nil),       // 25: process.ProcessEvent.StartEvent
	(*ProcessEvent_DataEvent)(nil),        // 26: process.ProcessEvent.DataEvent
	(*ProcessEvent_EndEvent)(nil),         // 27: process.ProcessEvent.EndEvent
	(*ProcessEvent_KeepAlive)(nil),        // 28: process.ProcessEvent.KeepAlive
	(*StreamInputRequest_StartEvent)(nil), // 29: process.StreamInputRequest.StartEvent
	(*StreamInputRequest_DataEvent)(nil),  // 30: process.StreamInputRequest.DataEvent
	(*StreamInputRequest_KeepAlive)(nil),  // 31: process.StreamInputRequest.KeepAlive
}
var file_process_process_proto_depIdxs = []int32{
	23, // 0: process.PTY.size:type_name -> process.PTY.Size
	24, // 1: process.ProcessConfig.envs:type_name -> process.ProcessConfig.EnvsEntry
	2,  // 2: process.ProcessInfo.config:type_name -> process.ProcessConfig
	4,  // 3: process.ListResponse.processes:type_name -> process.ProcessInfo
	2,  // 4: process.StartRequest.process:type_name -> process.ProcessConfig
	1,  // 5: process.StartRequest.pty:type_name -> process.PTY
	22, // 6: process.UpdateRequest.process:type_name -> process.ProcessSelector
	1,  // 7: process.UpdateRequest.pty:type_name -> process.PTY
	25, // 8: process.ProcessEvent.start:type_name -> process.ProcessEvent.StartEvent
	26, // 9: process.ProcessEvent.data:type_name -> process.ProcessEvent.DataEvent
	27, // 10: process.ProcessEvent.end:type_name -> process.ProcessEvent.EndEvent
	28, // 11: process.ProcessEvent.keepalive:type_name -> process.ProcessEvent.KeepAlive
	9,  // 12: process.StartResponse.event:type_name -> process.ProcessEvent
	9,  // 13: process.ConnectResponse.event:type_name -> process.ProcessEvent
	22, // 14: process.SendInputRequest.process:type_name -> process.ProcessSelector
	14, // 15: process.SendInputRequest.input:type_name -> process.ProcessInput
	29, // 16: process.StreamInputRequest.start:type_name -> process.StreamInputRequest.StartEvent
	30, // 17: process.StreamInputRequest.data:type_name -> process.StreamInputRequest.DataEvent
	31, // 18: process.StreamInputRequest.keepalive:type_name -> process.StreamInputRequest.KeepAlive
	22, // 19: process.SendSignalRequest.process:type_name -> process.ProcessSelector
	0,  // 20: process.SendSignalRequest.signal:type_name -> process.Signal
	22, // 21: process.CloseStdinRequest.process:type_name -> process.ProcessSelector
	22, // 22: process.ConnectRequest.process:type_name -> process.ProcessSelector
	22, // 23: process.StreamInputRequest.StartEvent.process:type_name -> process.ProcessSelector
	14, // 24: process.StreamInputRequest.DataEvent.input:type_name -> process.ProcessInput
	3,  // 25: process.Process.List:input_type -> process.ListRequest
	21, // 26: process.Process.Connect:input_type -> process.ConnectRequest
	6,  // 27: process.Process.Start:input_type -> process.StartRequest
	7,  // 28: process.Process.Update:input_type -> process.UpdateRequest
	15, // 29: process.Process.StreamInput:input_type -> process.StreamInputRequest
	12, // 30: process.Process.SendInput:input_type -> process.SendInputRequest
	17, // 31: process.Process.SendSignal:input_type -> process.SendSignalRequest
	19, // 32: process.Process.CloseStdin:input_type -> process.CloseStdinRequest
	5,  // 33: process.Process.List:output_type -> process.ListResponse
	11, // 34: process.Process.Connect:output_type -> process.ConnectResponse
	10, // 35: process.Process.Start:output_type -> process.StartResponse
	8,  // 36: process.Process.Update:output_type -> process.UpdateResponse
	16, // 37: process.Process.StreamInput:output_type -> process.StreamInputResponse
	13, // 38: process.Process.SendInput:output_type -> process.SendInputResponse
	18, // 39: process.Process.SendSignal:output_type -> process.SendSignalResponse
	20, // 40: process.Process.CloseStdin:output_type -> process.CloseStdinResponse
	33, // [33:41] is the sub-list for method output_type
	25, // [25:33] is the sub-list for method input_type
	25, // [25:25] is the sub-list for extension type_name
	25, // [25:25] is the sub-list for extension extendee
	0,  // [0:25] is the sub-list for field type_name
}

func init() { file_process_process_proto_init() }
func file_process_process_proto_init() {
	if File_process_process_proto != nil {
		return
	}
	file_process_process_proto_msgTypes[1].OneofWrappers = []any{}
	file_process_process_proto_msgTypes[3].OneofWrappers = []any{}
	file_process_process_proto_msgTypes[5].OneofWrappers = []any{}
	file_process_process_proto_msgTypes[6].OneofWrappers = []any{}
	file_process_process_proto_msgTypes[8].OneofWrappers = []any{
		(*ProcessEvent_Start)(nil),
		(*ProcessEvent_Data)(nil),
		(*ProcessEvent_End)(nil),
		(*ProcessEvent_Keepalive)(nil),
	}
	file_process_process_proto_msgTypes[13].OneofWrappers = []any{
		(*ProcessInput_Stdin)(nil),
		(*ProcessInput_Pty)(nil),
	}
	file_process_process_proto_msgTypes[14].OneofWrappers = []any{
		(*StreamInputRequest_Start)(nil),
		(*StreamInputRequest_Data)(nil),
		(*StreamInputRequest_Keepalive)(nil),
	}
	file_process_process_proto_msgTypes[21].OneofWrappers = []any{
		(*ProcessSelector_Pid)(nil),
		(*ProcessSelector_Tag)(nil),
	}
	file_process_process_proto_msgTypes[25].OneofWrappers = []any{
		(*ProcessEvent_DataEvent_Stdout)(nil),
		(*ProcessEvent_DataEvent_Stderr)(nil),
		(*ProcessEvent_DataEvent_Pty)(nil),
	}
	file_process_process_proto_msgTypes[26].OneofWrappers = []any{}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_process_process_proto_rawDesc), len(file_process_process_proto_rawDesc)),
			NumEnums:      1,
			NumMessages:   31,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_process_process_proto_goTypes,
		DependencyIndexes: file_process_process_proto_depIdxs,
		EnumInfos:         file_process_process_proto_enumTypes,
		MessageInfos:      file_process_process_proto_msgTypes,
	}.Build()
	File_process_process_proto = out.File
	file_process_process_proto_goTypes = nil
	file_process_process_proto_depIdxs = nil
}