// Copyright 2026 The Forgejo Authors. All rights reserved.
// SPDX-License-Identifier: MIT
//
// Licensing note: while most of forgejo/runner is distributed under the terms
// of GPL-3.0-or-later, this plugin definition file is more permissively
// licensed under the MIT license.  This choice allows plugin authors to embed
// it, create derived works of it (e.g. generated source files), and
// distribute derived products under a wider variety of licenses.

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.12
// 	protoc        (unknown)
// source: act/plugin/proto/v1alpha/plugin.proto

package pluginv1alpha

import (
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"

	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
)

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 DataChunk_Stream int32

const (
	DataChunk_STDOUT DataChunk_Stream = 0
	DataChunk_STDERR DataChunk_Stream = 1
)

// Enum value maps for DataChunk_Stream.
var (
	DataChunk_Stream_name = map[int32]string{
		0: "STDOUT",
		1: "STDERR",
	}
	DataChunk_Stream_value = map[string]int32{
		"STDOUT": 0,
		"STDERR": 1,
	}
)

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

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

func (DataChunk_Stream) Descriptor() protoreflect.EnumDescriptor {
	return file_act_plugin_proto_v1alpha_plugin_proto_enumTypes[0].Descriptor()
}

func (DataChunk_Stream) Type() protoreflect.EnumType {
	return &file_act_plugin_proto_v1alpha_plugin_proto_enumTypes[0]
}

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

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

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

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

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

func (*CapabilitiesRequest) ProtoMessage() {}

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

type CapabilitiesResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// name identifies the backend (e.g. "kubernetes"); used in logs and as the
	// container back-end name.
	Name          string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CapabilitiesResponse) ProtoMessage() {}

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

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

type ServiceContainer struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// name is the service ID from the workflow `services:` block.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// image is the backend-defined image reference for the service.
	Image string `protobuf:"bytes,2,opt,name=image,proto3" json:"image,omitempty"`
	// env are the service container's environment variables.
	Env map[string]string `protobuf:"bytes,3,rep,name=env,proto3" json:"env,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// ports are host:container port mappings requested for the service.
	Ports         []string `protobuf:"bytes,4,rep,name=ports,proto3" json:"ports,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ServiceContainer) ProtoMessage() {}

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

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

func (x *ServiceContainer) GetImage() string {
	if x != nil {
		return x.Image
	}
	return ""
}

func (x *ServiceContainer) GetEnv() map[string]string {
	if x != nil {
		return x.Env
	}
	return nil
}

func (x *ServiceContainer) GetPorts() []string {
	if x != nil {
		return x.Ports
	}
	return nil
}

type CreateRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// image is the backend-defined reference for the job container image, opaque
	// to the protocol (a Docker image name, a VM template, ...).
	Image string `protobuf:"bytes,1,opt,name=image,proto3" json:"image,omitempty"`
	// name is a runner-assigned handle for the environment, unique per job.
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// cap_add / cap_drop are advisory Linux capability adjustments; backends that
	// cannot apply them ignore them.
	CapAdd  []string `protobuf:"bytes,5,rep,name=cap_add,json=capAdd,proto3" json:"cap_add,omitempty"`
	CapDrop []string `protobuf:"bytes,6,rep,name=cap_drop,json=capDrop,proto3" json:"cap_drop,omitempty"`
	// services are the service containers to bring up alongside the job.
	Services []*ServiceContainer `protobuf:"bytes,7,rep,name=services,proto3" json:"services,omitempty"`
	// backend_options are opaque, backend-specific options taken verbatim from
	// the runner's per-label plugin configuration (e.g. namespace, VM flavour).
	BackendOptions map[string]string `protobuf:"bytes,8,rep,name=backend_options,json=backendOptions,proto3" json:"backend_options,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// label_arg is the optional suffix of the runs-on plugin label.
	LabelArg string `protobuf:"bytes,9,opt,name=label_arg,json=labelArg,proto3" json:"label_arg,omitempty"`
	// environment_timeout limits the lifetime of this execution environment.
	EnvironmentTimeout *durationpb.Duration `protobuf:"bytes,10,opt,name=environment_timeout,json=environmentTimeout,proto3" json:"environment_timeout,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

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

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

func (*CreateRequest) ProtoMessage() {}

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

func (x *CreateRequest) GetImage() string {
	if x != nil {
		return x.Image
	}
	return ""
}

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

func (x *CreateRequest) GetCapAdd() []string {
	if x != nil {
		return x.CapAdd
	}
	return nil
}

func (x *CreateRequest) GetCapDrop() []string {
	if x != nil {
		return x.CapDrop
	}
	return nil
}

func (x *CreateRequest) GetServices() []*ServiceContainer {
	if x != nil {
		return x.Services
	}
	return nil
}

func (x *CreateRequest) GetBackendOptions() map[string]string {
	if x != nil {
		return x.BackendOptions
	}
	return nil
}

func (x *CreateRequest) GetLabelArg() string {
	if x != nil {
		return x.LabelArg
	}
	return ""
}

func (x *CreateRequest) GetEnvironmentTimeout() *durationpb.Duration {
	if x != nil {
		return x.EnvironmentTimeout
	}
	return nil
}

type CreateResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// environment_id is the handle for all later RPCs targeting this environment.
	EnvironmentId string `protobuf:"bytes,1,opt,name=environment_id,json=environmentId,proto3" json:"environment_id,omitempty"`
	// root_path is the base directory the runner lays workflow files out
	// under.
	RootPath string `protobuf:"bytes,2,opt,name=root_path,json=rootPath,proto3" json:"root_path,omitempty"`
	// act_path is the directory where the runner stages its helper binaries and
	// action code.
	ActPath string `protobuf:"bytes,3,opt,name=act_path,json=actPath,proto3" json:"act_path,omitempty"`
	// tool_cache_path is exposed to jobs as RUNNER_TOOL_CACHE.
	ToolCachePath string `protobuf:"bytes,4,opt,name=tool_cache_path,json=toolCachePath,proto3" json:"tool_cache_path,omitempty"`
	// temp_path is exposed to jobs as RUNNER_TEMP.
	TempPath string `protobuf:"bytes,5,opt,name=temp_path,json=tempPath,proto3" json:"temp_path,omitempty"`
	// path_variable_name is the search-path environment variable; the runner uses
	// "PATH" when unset.
	PathVariableName *string `protobuf:"bytes,6,opt,name=path_variable_name,json=pathVariableName,proto3,oneof" json:"path_variable_name,omitempty"`
	// default_path_variable is the search path used when a job sets none.
	DefaultPathVariable *string `protobuf:"bytes,7,opt,name=default_path_variable,json=defaultPathVariable,proto3,oneof" json:"default_path_variable,omitempty"`
	// path_separator joins path entries; the runner uses ":" when unset.
	PathSeparator *string `protobuf:"bytes,8,opt,name=path_separator,json=pathSeparator,proto3,oneof" json:"path_separator,omitempty"`
	// environment_case_insensitive marks environments whose variable names are
	// case-insensitive (Windows), so the runner de-duplicates accordingly.
	EnvironmentCaseInsensitive bool `protobuf:"varint,9,opt,name=environment_case_insensitive,json=environmentCaseInsensitive,proto3" json:"environment_case_insensitive,omitempty"`
	// os populates the RUNNER_OS environment variable exposed to the job.
	Os string `protobuf:"bytes,10,opt,name=os,proto3" json:"os,omitempty"`
	// arch populates the RUNNER_ARCH environment variable exposed to the job.
	Arch          string `protobuf:"bytes,11,opt,name=arch,proto3" json:"arch,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CreateResponse) ProtoMessage() {}

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

func (x *CreateResponse) GetEnvironmentId() string {
	if x != nil {
		return x.EnvironmentId
	}
	return ""
}

func (x *CreateResponse) GetRootPath() string {
	if x != nil {
		return x.RootPath
	}
	return ""
}

func (x *CreateResponse) GetActPath() string {
	if x != nil {
		return x.ActPath
	}
	return ""
}

func (x *CreateResponse) GetToolCachePath() string {
	if x != nil {
		return x.ToolCachePath
	}
	return ""
}

func (x *CreateResponse) GetTempPath() string {
	if x != nil {
		return x.TempPath
	}
	return ""
}

func (x *CreateResponse) GetPathVariableName() string {
	if x != nil && x.PathVariableName != nil {
		return *x.PathVariableName
	}
	return ""
}

func (x *CreateResponse) GetDefaultPathVariable() string {
	if x != nil && x.DefaultPathVariable != nil {
		return *x.DefaultPathVariable
	}
	return ""
}

func (x *CreateResponse) GetPathSeparator() string {
	if x != nil && x.PathSeparator != nil {
		return *x.PathSeparator
	}
	return ""
}

func (x *CreateResponse) GetEnvironmentCaseInsensitive() bool {
	if x != nil {
		return x.EnvironmentCaseInsensitive
	}
	return false
}

func (x *CreateResponse) GetOs() string {
	if x != nil {
		return x.Os
	}
	return ""
}

func (x *CreateResponse) GetArch() string {
	if x != nil {
		return x.Arch
	}
	return ""
}

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

func (x *StartRequest) Reset() {
	*x = StartRequest{}
	mi := &file_act_plugin_proto_v1alpha_plugin_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_act_plugin_proto_v1alpha_plugin_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_act_plugin_proto_v1alpha_plugin_proto_rawDescGZIP(), []int{5}
}

func (x *StartRequest) GetEnvironmentId() string {
	if x != nil {
		return x.EnvironmentId
	}
	return ""
}

type StartOutput struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Output:
	//
	//	*StartOutput_Data
	//	*StartOutput_StartComplete
	Output        isStartOutput_Output `protobuf_oneof:"Output"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*StartOutput) ProtoMessage() {}

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

func (x *StartOutput) GetOutput() isStartOutput_Output {
	if x != nil {
		return x.Output
	}
	return nil
}

func (x *StartOutput) GetData() *DataChunk {
	if x != nil {
		if x, ok := x.Output.(*StartOutput_Data); ok {
			return x.Data
		}
	}
	return nil
}

func (x *StartOutput) GetStartComplete() *StartComplete {
	if x != nil {
		if x, ok := x.Output.(*StartOutput_StartComplete); ok {
			return x.StartComplete
		}
	}
	return nil
}

type isStartOutput_Output interface {
	isStartOutput_Output()
}

type StartOutput_Data struct {
	Data *DataChunk `protobuf:"bytes,1,opt,name=data,proto3,oneof"`
}

type StartOutput_StartComplete struct {
	StartComplete *StartComplete `protobuf:"bytes,2,opt,name=start_complete,json=startComplete,proto3,oneof"`
}

func (*StartOutput_Data) isStartOutput_Output() {}

func (*StartOutput_StartComplete) isStartOutput_Output() {}

type StartComplete struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// image_env are environment variables baked into the resolved image (e.g. a
	// Docker image's ENV). The runner layers them under the job's own variables.
	ImageEnv      map[string]string `protobuf:"bytes,1,rep,name=image_env,json=imageEnv,proto3" json:"image_env,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*StartComplete) ProtoMessage() {}

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

func (x *StartComplete) GetImageEnv() map[string]string {
	if x != nil {
		return x.ImageEnv
	}
	return nil
}

type ExecRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	EnvironmentId string                 `protobuf:"bytes,1,opt,name=environment_id,json=environmentId,proto3" json:"environment_id,omitempty"`
	// command is the argv to run; command[0] is the executable.
	Command []string `protobuf:"bytes,2,rep,name=command,proto3" json:"command,omitempty"`
	// env are environment variables to set for this command.
	Env map[string]string `protobuf:"bytes,3,rep,name=env,proto3" json:"env,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// user is the user to run as; the backend's default is used when unset.
	User *string `protobuf:"bytes,4,opt,name=user,proto3,oneof" json:"user,omitempty"`
	// workdir overrides the working directory for this command; the environment's
	// default is used when unset.
	Workdir       string `protobuf:"bytes,5,opt,name=workdir,proto3" json:"workdir,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ExecRequest) ProtoMessage() {}

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

func (x *ExecRequest) GetEnvironmentId() string {
	if x != nil {
		return x.EnvironmentId
	}
	return ""
}

func (x *ExecRequest) GetCommand() []string {
	if x != nil {
		return x.Command
	}
	return nil
}

func (x *ExecRequest) GetEnv() map[string]string {
	if x != nil {
		return x.Env
	}
	return nil
}

func (x *ExecRequest) GetUser() string {
	if x != nil && x.User != nil {
		return *x.User
	}
	return ""
}

func (x *ExecRequest) GetWorkdir() string {
	if x != nil {
		return x.Workdir
	}
	return ""
}

type ExecOutput struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Output:
	//
	//	*ExecOutput_Data
	//	*ExecOutput_ExecComplete
	//	*ExecOutput_ExecFailed
	Output        isExecOutput_Output `protobuf_oneof:"Output"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ExecOutput) ProtoMessage() {}

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

func (x *ExecOutput) GetOutput() isExecOutput_Output {
	if x != nil {
		return x.Output
	}
	return nil
}

func (x *ExecOutput) GetData() *DataChunk {
	if x != nil {
		if x, ok := x.Output.(*ExecOutput_Data); ok {
			return x.Data
		}
	}
	return nil
}

func (x *ExecOutput) GetExecComplete() *ExecComplete {
	if x != nil {
		if x, ok := x.Output.(*ExecOutput_ExecComplete); ok {
			return x.ExecComplete
		}
	}
	return nil
}

func (x *ExecOutput) GetExecFailed() *ExecFailed {
	if x != nil {
		if x, ok := x.Output.(*ExecOutput_ExecFailed); ok {
			return x.ExecFailed
		}
	}
	return nil
}

type isExecOutput_Output interface {
	isExecOutput_Output()
}

type ExecOutput_Data struct {
	Data *DataChunk `protobuf:"bytes,1,opt,name=data,proto3,oneof"`
}

type ExecOutput_ExecComplete struct {
	ExecComplete *ExecComplete `protobuf:"bytes,2,opt,name=exec_complete,json=execComplete,proto3,oneof"`
}

type ExecOutput_ExecFailed struct {
	ExecFailed *ExecFailed `protobuf:"bytes,3,opt,name=exec_failed,json=execFailed,proto3,oneof"`
}

func (*ExecOutput_Data) isExecOutput_Output() {}

func (*ExecOutput_ExecComplete) isExecOutput_Output() {}

func (*ExecOutput_ExecFailed) isExecOutput_Output() {}

type DataChunk struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// stream identifies which output data belongs to.
	Stream DataChunk_Stream `protobuf:"varint,1,opt,name=stream,proto3,enum=plugin.v1alpha.DataChunk_Stream" json:"stream,omitempty"`
	// data is a chunk of output bytes.
	Data          []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DataChunk) ProtoMessage() {}

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

func (x *DataChunk) GetStream() DataChunk_Stream {
	if x != nil {
		return x.Stream
	}
	return DataChunk_STDOUT
}

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

type ExecComplete struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// exit_code is the command's exit status; only set on the final message.
	ExitCode      int32 `protobuf:"varint,1,opt,name=exit_code,json=exitCode,proto3" json:"exit_code,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ExecComplete) ProtoMessage() {}

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

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

type ExecFailed struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// error_message describes a failure to run the command (as opposed to the
	// command failing); only set on the final message.
	ErrorMessage  string `protobuf:"bytes,1,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ExecFailed) ProtoMessage() {}

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

func (x *ExecFailed) GetErrorMessage() string {
	if x != nil {
		return x.ErrorMessage
	}
	return ""
}

// CopyInChunk frames the client-streaming CopyIn RPC. The first chunk MUST set
// environment_id and dest_path; subsequent chunks carry only data. Servers MUST
// reject environment_id or dest_path on later chunks with codes.InvalidArgument.
type CopyInChunk struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	EnvironmentId *string                `protobuf:"bytes,1,opt,name=environment_id,json=environmentId,proto3,oneof" json:"environment_id,omitempty"`
	// dest_path is the directory the tar archive is extracted into. The plugin
	// must ensure that the destination folder exists in the target environment
	// before extracting the incoming data stream.
	DestPath *string `protobuf:"bytes,2,opt,name=dest_path,json=destPath,proto3,oneof" json:"dest_path,omitempty"`
	// data is a chunk of the tar archive.
	Data          []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CopyInChunk) ProtoMessage() {}

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

func (x *CopyInChunk) GetEnvironmentId() string {
	if x != nil && x.EnvironmentId != nil {
		return *x.EnvironmentId
	}
	return ""
}

func (x *CopyInChunk) GetDestPath() string {
	if x != nil && x.DestPath != nil {
		return *x.DestPath
	}
	return ""
}

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

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

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

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

func (*CopyInResponse) ProtoMessage() {}

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

type CopyOutRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	EnvironmentId string                 `protobuf:"bytes,1,opt,name=environment_id,json=environmentId,proto3" json:"environment_id,omitempty"`
	// src_path is the path inside the environment to archive and stream out.
	SrcPath       string `protobuf:"bytes,2,opt,name=src_path,json=srcPath,proto3" json:"src_path,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CopyOutRequest) ProtoMessage() {}

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

func (x *CopyOutRequest) GetEnvironmentId() string {
	if x != nil {
		return x.EnvironmentId
	}
	return ""
}

func (x *CopyOutRequest) GetSrcPath() string {
	if x != nil {
		return x.SrcPath
	}
	return ""
}

type CopyOutChunk struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// data is a chunk of the tar archive.
	Data          []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CopyOutChunk) ProtoMessage() {}

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

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

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

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

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

func (*RemoveRequest) ProtoMessage() {}

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

func (x *RemoveRequest) GetEnvironmentId() string {
	if x != nil {
		return x.EnvironmentId
	}
	return ""
}

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

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

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

func (*RemoveResponse) ProtoMessage() {}

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

var File_act_plugin_proto_v1alpha_plugin_proto protoreflect.FileDescriptor

const file_act_plugin_proto_v1alpha_plugin_proto_rawDesc = "" +
	"\n" +
	"%act/plugin/proto/v1alpha/plugin.proto\x12\x0eplugin.v1alpha\x1a\x1egoogle/protobuf/duration.proto\"\x15\n" +
	"\x13CapabilitiesRequest\"N\n" +
	"\x14CapabilitiesResponse\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04nameJ\x04\b\x02\x10\x03J\x04\b\x03\x10\x04J\x04\b\x04\x10\x05J\x04\b\x05\x10\x06J\x04\b\x06\x10\aJ\x04\b\a\x10\b\"\xc7\x01\n" +
	"\x10ServiceContainer\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12\x14\n" +
	"\x05image\x18\x02 \x01(\tR\x05image\x12;\n" +
	"\x03env\x18\x03 \x03(\v2).plugin.v1alpha.ServiceContainer.EnvEntryR\x03env\x12\x14\n" +
	"\x05ports\x18\x04 \x03(\tR\x05ports\x1a6\n" +
	"\bEnvEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xbf\x03\n" +
	"\rCreateRequest\x12\x14\n" +
	"\x05image\x18\x01 \x01(\tR\x05image\x12\x12\n" +
	"\x04name\x18\x02 \x01(\tR\x04name\x12\x17\n" +
	"\acap_add\x18\x05 \x03(\tR\x06capAdd\x12\x19\n" +
	"\bcap_drop\x18\x06 \x03(\tR\acapDrop\x12<\n" +
	"\bservices\x18\a \x03(\v2 .plugin.v1alpha.ServiceContainerR\bservices\x12Z\n" +
	"\x0fbackend_options\x18\b \x03(\v21.plugin.v1alpha.CreateRequest.BackendOptionsEntryR\x0ebackendOptions\x12\x1b\n" +
	"\tlabel_arg\x18\t \x01(\tR\blabelArg\x12J\n" +
	"\x13environment_timeout\x18\n" +
	" \x01(\v2\x19.google.protobuf.DurationR\x12environmentTimeout\x1aA\n" +
	"\x13BackendOptionsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01J\x04\b\x03\x10\x04J\x04\b\x04\x10\x05\"\xf6\x03\n" +
	"\x0eCreateResponse\x12%\n" +
	"\x0eenvironment_id\x18\x01 \x01(\tR\renvironmentId\x12\x1b\n" +
	"\troot_path\x18\x02 \x01(\tR\brootPath\x12\x19\n" +
	"\bact_path\x18\x03 \x01(\tR\aactPath\x12&\n" +
	"\x0ftool_cache_path\x18\x04 \x01(\tR\rtoolCachePath\x12\x1b\n" +
	"\ttemp_path\x18\x05 \x01(\tR\btempPath\x121\n" +
	"\x12path_variable_name\x18\x06 \x01(\tH\x00R\x10pathVariableName\x88\x01\x01\x127\n" +
	"\x15default_path_variable\x18\a \x01(\tH\x01R\x13defaultPathVariable\x88\x01\x01\x12*\n" +
	"\x0epath_separator\x18\b \x01(\tH\x02R\rpathSeparator\x88\x01\x01\x12@\n" +
	"\x1cenvironment_case_insensitive\x18\t \x01(\bR\x1aenvironmentCaseInsensitive\x12\x0e\n" +
	"\x02os\x18\n" +
	" \x01(\tR\x02os\x12\x12\n" +
	"\x04arch\x18\v \x01(\tR\x04archB\x15\n" +
	"\x13_path_variable_nameB\x18\n" +
	"\x16_default_path_variableB\x11\n" +
	"\x0f_path_separator\"5\n" +
	"\fStartRequest\x12%\n" +
	"\x0eenvironment_id\x18\x01 \x01(\tR\renvironmentId\"\x90\x01\n" +
	"\vStartOutput\x12/\n" +
	"\x04data\x18\x01 \x01(\v2\x19.plugin.v1alpha.DataChunkH\x00R\x04data\x12F\n" +
	"\x0estart_complete\x18\x02 \x01(\v2\x1d.plugin.v1alpha.StartCompleteH\x00R\rstartCompleteB\b\n" +
	"\x06Output\"\x96\x01\n" +
	"\rStartComplete\x12H\n" +
	"\timage_env\x18\x01 \x03(\v2+.plugin.v1alpha.StartComplete.ImageEnvEntryR\bimageEnv\x1a;\n" +
	"\rImageEnvEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xfa\x01\n" +
	"\vExecRequest\x12%\n" +
	"\x0eenvironment_id\x18\x01 \x01(\tR\renvironmentId\x12\x18\n" +
	"\acommand\x18\x02 \x03(\tR\acommand\x126\n" +
	"\x03env\x18\x03 \x03(\v2$.plugin.v1alpha.ExecRequest.EnvEntryR\x03env\x12\x17\n" +
	"\x04user\x18\x04 \x01(\tH\x00R\x04user\x88\x01\x01\x12\x18\n" +
	"\aworkdir\x18\x05 \x01(\tR\aworkdir\x1a6\n" +
	"\bEnvEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01B\a\n" +
	"\x05_user\"\xcb\x01\n" +
	"\n" +
	"ExecOutput\x12/\n" +
	"\x04data\x18\x01 \x01(\v2\x19.plugin.v1alpha.DataChunkH\x00R\x04data\x12C\n" +
	"\rexec_complete\x18\x02 \x01(\v2\x1c.plugin.v1alpha.ExecCompleteH\x00R\fexecComplete\x12=\n" +
	"\vexec_failed\x18\x03 \x01(\v2\x1a.plugin.v1alpha.ExecFailedH\x00R\n" +
	"execFailedB\b\n" +
	"\x06Output\"{\n" +
	"\tDataChunk\x128\n" +
	"\x06stream\x18\x01 \x01(\x0e2 .plugin.v1alpha.DataChunk.StreamR\x06stream\x12\x12\n" +
	"\x04data\x18\x02 \x01(\fR\x04data\" \n" +
	"\x06Stream\x12\n" +
	"\n" +
	"\x06STDOUT\x10\x00\x12\n" +
	"\n" +
	"\x06STDERR\x10\x01\"+\n" +
	"\fExecComplete\x12\x1b\n" +
	"\texit_code\x18\x01 \x01(\x05R\bexitCode\"1\n" +
	"\n" +
	"ExecFailed\x12#\n" +
	"\rerror_message\x18\x01 \x01(\tR\ferrorMessage\"\x90\x01\n" +
	"\vCopyInChunk\x12*\n" +
	"\x0eenvironment_id\x18\x01 \x01(\tH\x00R\renvironmentId\x88\x01\x01\x12 \n" +
	"\tdest_path\x18\x02 \x01(\tH\x01R\bdestPath\x88\x01\x01\x12\x12\n" +
	"\x04data\x18\x03 \x01(\fR\x04dataB\x11\n" +
	"\x0f_environment_idB\f\n" +
	"\n" +
	"_dest_path\"\x10\n" +
	"\x0eCopyInResponse\"R\n" +
	"\x0eCopyOutRequest\x12%\n" +
	"\x0eenvironment_id\x18\x01 \x01(\tR\renvironmentId\x12\x19\n" +
	"\bsrc_path\x18\x02 \x01(\tR\asrcPath\"\"\n" +
	"\fCopyOutChunk\x12\x12\n" +
	"\x04data\x18\x01 \x01(\fR\x04data\"6\n" +
	"\rRemoveRequest\x12%\n" +
	"\x0eenvironment_id\x18\x01 \x01(\tR\renvironmentId\"\x10\n" +
	"\x0eRemoveResponse2\x99\x04\n" +
	"\rBackendPlugin\x12Y\n" +
	"\fCapabilities\x12#.plugin.v1alpha.CapabilitiesRequest\x1a$.plugin.v1alpha.CapabilitiesResponse\x12G\n" +
	"\x06Create\x12\x1d.plugin.v1alpha.CreateRequest\x1a\x1e.plugin.v1alpha.CreateResponse\x12D\n" +
	"\x05Start\x12\x1c.plugin.v1alpha.StartRequest\x1a\x1b.plugin.v1alpha.StartOutput0\x01\x12A\n" +
	"\x04Exec\x12\x1b.plugin.v1alpha.ExecRequest\x1a\x1a.plugin.v1alpha.ExecOutput0\x01\x12G\n" +
	"\x06CopyIn\x12\x1b.plugin.v1alpha.CopyInChunk\x1a\x1e.plugin.v1alpha.CopyInResponse(\x01\x12I\n" +
	"\aCopyOut\x12\x1e.plugin.v1alpha.CopyOutRequest\x1a\x1c.plugin.v1alpha.CopyOutChunk0\x01\x12G\n" +
	"\x06Remove\x12\x1d.plugin.v1alpha.RemoveRequest\x1a\x1e.plugin.v1alpha.RemoveResponseB\xdf\x01\n" +
	"\x12com.plugin.v1alphaB\vPluginProtoP\x01Zccode.forgejo.org/forgejo/runner/v13/act/plugin/proto/v1alpha/act/plugin/proto/v1alpha;pluginv1alpha\xa2\x02\x03PXX\xaa\x02\x0ePlugin.V1alpha\xca\x02\x0ePlugin\\V1alpha\xe2\x02\x1aPlugin\\V1alpha\\GPBMetadata\xea\x02\x0fPlugin::V1alphab\x06proto3"

var (
	file_act_plugin_proto_v1alpha_plugin_proto_rawDescOnce sync.Once
	file_act_plugin_proto_v1alpha_plugin_proto_rawDescData []byte
)

func file_act_plugin_proto_v1alpha_plugin_proto_rawDescGZIP() []byte {
	file_act_plugin_proto_v1alpha_plugin_proto_rawDescOnce.Do(func() {
		file_act_plugin_proto_v1alpha_plugin_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_act_plugin_proto_v1alpha_plugin_proto_rawDesc), len(file_act_plugin_proto_v1alpha_plugin_proto_rawDesc)))
	})
	return file_act_plugin_proto_v1alpha_plugin_proto_rawDescData
}

var (
	file_act_plugin_proto_v1alpha_plugin_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
	file_act_plugin_proto_v1alpha_plugin_proto_msgTypes  = make([]protoimpl.MessageInfo, 23)
	file_act_plugin_proto_v1alpha_plugin_proto_goTypes   = []any{
		DataChunk_Stream(0),          // 0: plugin.v1alpha.DataChunk.Stream
		(*CapabilitiesRequest)(nil),  // 1: plugin.v1alpha.CapabilitiesRequest
		(*CapabilitiesResponse)(nil), // 2: plugin.v1alpha.CapabilitiesResponse
		(*ServiceContainer)(nil),     // 3: plugin.v1alpha.ServiceContainer
		(*CreateRequest)(nil),        // 4: plugin.v1alpha.CreateRequest
		(*CreateResponse)(nil),       // 5: plugin.v1alpha.CreateResponse
		(*StartRequest)(nil),         // 6: plugin.v1alpha.StartRequest
		(*StartOutput)(nil),          // 7: plugin.v1alpha.StartOutput
		(*StartComplete)(nil),        // 8: plugin.v1alpha.StartComplete
		(*ExecRequest)(nil),          // 9: plugin.v1alpha.ExecRequest
		(*ExecOutput)(nil),           // 10: plugin.v1alpha.ExecOutput
		(*DataChunk)(nil),            // 11: plugin.v1alpha.DataChunk
		(*ExecComplete)(nil),         // 12: plugin.v1alpha.ExecComplete
		(*ExecFailed)(nil),           // 13: plugin.v1alpha.ExecFailed
		(*CopyInChunk)(nil),          // 14: plugin.v1alpha.CopyInChunk
		(*CopyInResponse)(nil),       // 15: plugin.v1alpha.CopyInResponse
		(*CopyOutRequest)(nil),       // 16: plugin.v1alpha.CopyOutRequest
		(*CopyOutChunk)(nil),         // 17: plugin.v1alpha.CopyOutChunk
		(*RemoveRequest)(nil),        // 18: plugin.v1alpha.RemoveRequest
		(*RemoveResponse)(nil),       // 19: plugin.v1alpha.RemoveResponse
		nil,                          // 20: plugin.v1alpha.ServiceContainer.EnvEntry
		nil,                          // 21: plugin.v1alpha.CreateRequest.BackendOptionsEntry
		nil,                          // 22: plugin.v1alpha.StartComplete.ImageEnvEntry
		nil,                          // 23: plugin.v1alpha.ExecRequest.EnvEntry
		(*durationpb.Duration)(nil),  // 24: google.protobuf.Duration
	}
)

var file_act_plugin_proto_v1alpha_plugin_proto_depIdxs = []int32{
	20, // 0: plugin.v1alpha.ServiceContainer.env:type_name -> plugin.v1alpha.ServiceContainer.EnvEntry
	3,  // 1: plugin.v1alpha.CreateRequest.services:type_name -> plugin.v1alpha.ServiceContainer
	21, // 2: plugin.v1alpha.CreateRequest.backend_options:type_name -> plugin.v1alpha.CreateRequest.BackendOptionsEntry
	24, // 3: plugin.v1alpha.CreateRequest.environment_timeout:type_name -> google.protobuf.Duration
	11, // 4: plugin.v1alpha.StartOutput.data:type_name -> plugin.v1alpha.DataChunk
	8,  // 5: plugin.v1alpha.StartOutput.start_complete:type_name -> plugin.v1alpha.StartComplete
	22, // 6: plugin.v1alpha.StartComplete.image_env:type_name -> plugin.v1alpha.StartComplete.ImageEnvEntry
	23, // 7: plugin.v1alpha.ExecRequest.env:type_name -> plugin.v1alpha.ExecRequest.EnvEntry
	11, // 8: plugin.v1alpha.ExecOutput.data:type_name -> plugin.v1alpha.DataChunk
	12, // 9: plugin.v1alpha.ExecOutput.exec_complete:type_name -> plugin.v1alpha.ExecComplete
	13, // 10: plugin.v1alpha.ExecOutput.exec_failed:type_name -> plugin.v1alpha.ExecFailed
	0,  // 11: plugin.v1alpha.DataChunk.stream:type_name -> plugin.v1alpha.DataChunk.Stream
	1,  // 12: plugin.v1alpha.BackendPlugin.Capabilities:input_type -> plugin.v1alpha.CapabilitiesRequest
	4,  // 13: plugin.v1alpha.BackendPlugin.Create:input_type -> plugin.v1alpha.CreateRequest
	6,  // 14: plugin.v1alpha.BackendPlugin.Start:input_type -> plugin.v1alpha.StartRequest
	9,  // 15: plugin.v1alpha.BackendPlugin.Exec:input_type -> plugin.v1alpha.ExecRequest
	14, // 16: plugin.v1alpha.BackendPlugin.CopyIn:input_type -> plugin.v1alpha.CopyInChunk
	16, // 17: plugin.v1alpha.BackendPlugin.CopyOut:input_type -> plugin.v1alpha.CopyOutRequest
	18, // 18: plugin.v1alpha.BackendPlugin.Remove:input_type -> plugin.v1alpha.RemoveRequest
	2,  // 19: plugin.v1alpha.BackendPlugin.Capabilities:output_type -> plugin.v1alpha.CapabilitiesResponse
	5,  // 20: plugin.v1alpha.BackendPlugin.Create:output_type -> plugin.v1alpha.CreateResponse
	7,  // 21: plugin.v1alpha.BackendPlugin.Start:output_type -> plugin.v1alpha.StartOutput
	10, // 22: plugin.v1alpha.BackendPlugin.Exec:output_type -> plugin.v1alpha.ExecOutput
	15, // 23: plugin.v1alpha.BackendPlugin.CopyIn:output_type -> plugin.v1alpha.CopyInResponse
	17, // 24: plugin.v1alpha.BackendPlugin.CopyOut:output_type -> plugin.v1alpha.CopyOutChunk
	19, // 25: plugin.v1alpha.BackendPlugin.Remove:output_type -> plugin.v1alpha.RemoveResponse
	19, // [19:26] is the sub-list for method output_type
	12, // [12:19] is the sub-list for method input_type
	12, // [12:12] is the sub-list for extension type_name
	12, // [12:12] is the sub-list for extension extendee
	0,  // [0:12] is the sub-list for field type_name
}

func init() { file_act_plugin_proto_v1alpha_plugin_proto_init() }
func file_act_plugin_proto_v1alpha_plugin_proto_init() {
	if File_act_plugin_proto_v1alpha_plugin_proto != nil {
		return
	}
	file_act_plugin_proto_v1alpha_plugin_proto_msgTypes[4].OneofWrappers = []any{}
	file_act_plugin_proto_v1alpha_plugin_proto_msgTypes[6].OneofWrappers = []any{
		(*StartOutput_Data)(nil),
		(*StartOutput_StartComplete)(nil),
	}
	file_act_plugin_proto_v1alpha_plugin_proto_msgTypes[8].OneofWrappers = []any{}
	file_act_plugin_proto_v1alpha_plugin_proto_msgTypes[9].OneofWrappers = []any{
		(*ExecOutput_Data)(nil),
		(*ExecOutput_ExecComplete)(nil),
		(*ExecOutput_ExecFailed)(nil),
	}
	file_act_plugin_proto_v1alpha_plugin_proto_msgTypes[13].OneofWrappers = []any{}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_act_plugin_proto_v1alpha_plugin_proto_rawDesc), len(file_act_plugin_proto_v1alpha_plugin_proto_rawDesc)),
			NumEnums:      1,
			NumMessages:   23,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_act_plugin_proto_v1alpha_plugin_proto_goTypes,
		DependencyIndexes: file_act_plugin_proto_v1alpha_plugin_proto_depIdxs,
		EnumInfos:         file_act_plugin_proto_v1alpha_plugin_proto_enumTypes,
		MessageInfos:      file_act_plugin_proto_v1alpha_plugin_proto_msgTypes,
	}.Build()
	File_act_plugin_proto_v1alpha_plugin_proto = out.File
	file_act_plugin_proto_v1alpha_plugin_proto_goTypes = nil
	file_act_plugin_proto_v1alpha_plugin_proto_depIdxs = nil
}
