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

package v1

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

const (
	ErrorCode_ERROR_CODE_UNSPECIFIED ErrorCode = 0
	// Stdin / CloseStdin / Signal referencing a command_id that
	// is not currently running (never started, or already terminal).
	ErrorCode_ERROR_CODE_UNKNOWN_COMMAND_ID ErrorCode = 1
	// Empty argv, contradictory fields, etc.
	ErrorCode_ERROR_CODE_INVALID_REQUEST ErrorCode = 2
	// execve failed (ENOENT, EPERM, EACCES, ...).
	ErrorCode_ERROR_CODE_SPAWN_FAILED ErrorCode = 3
	// Killed because timeout_seconds elapsed.
	ErrorCode_ERROR_CODE_TIMEOUT ErrorCode = 4
	// Pipe between stages broke unexpectedly mid-execution.
	ErrorCode_ERROR_CODE_IO_ERROR ErrorCode = 5
	// Required filesystem entry missing (e.g. AgentReady fifo
	// never created — distinct from IO_ERROR which covers
	// syscall failures on existing entries).
	ErrorCode_ERROR_CODE_NOT_FOUND ErrorCode = 6
)

// Enum value maps for ErrorCode.
var (
	ErrorCode_name = map[int32]string{
		0: "ERROR_CODE_UNSPECIFIED",
		1: "ERROR_CODE_UNKNOWN_COMMAND_ID",
		2: "ERROR_CODE_INVALID_REQUEST",
		3: "ERROR_CODE_SPAWN_FAILED",
		4: "ERROR_CODE_TIMEOUT",
		5: "ERROR_CODE_IO_ERROR",
		6: "ERROR_CODE_NOT_FOUND",
	}
	ErrorCode_value = map[string]int32{
		"ERROR_CODE_UNSPECIFIED":        0,
		"ERROR_CODE_UNKNOWN_COMMAND_ID": 1,
		"ERROR_CODE_INVALID_REQUEST":    2,
		"ERROR_CODE_SPAWN_FAILED":       3,
		"ERROR_CODE_TIMEOUT":            4,
		"ERROR_CODE_IO_ERROR":           5,
		"ERROR_CODE_NOT_FOUND":          6,
	}
)

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

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

func (ErrorCode) Descriptor() protoreflect.EnumDescriptor {
	return file_clawkerd_v1_clawkerd_proto_enumTypes[0].Descriptor()
}

func (ErrorCode) Type() protoreflect.EnumType {
	return &file_clawkerd_v1_clawkerd_proto_enumTypes[0]
}

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

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

// Command is one CP→clawkerd request. command_id is a CP-generated
// opaque correlation token; clawkerd echoes it on every Response.
// Concurrent commands are permitted on a single Session — clawkerd
// distinguishes them by command_id.
type Command struct {
	state     protoimpl.MessageState `protogen:"open.v1"`
	CommandId string                 `protobuf:"bytes,1,opt,name=command_id,json=commandId,proto3" json:"command_id,omitempty"`
	// Types that are valid to be assigned to Payload:
	//
	//	*Command_Hello
	//	*Command_Shell
	//	*Command_Stdin
	//	*Command_CloseStdin
	//	*Command_Signal
	//	*Command_RegisterRequired
	//	*Command_AgentReady
	Payload       isCommand_Payload `protobuf_oneof:"payload"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Command) ProtoMessage() {}

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

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

func (x *Command) GetPayload() isCommand_Payload {
	if x != nil {
		return x.Payload
	}
	return nil
}

func (x *Command) GetHello() *Hello {
	if x != nil {
		if x, ok := x.Payload.(*Command_Hello); ok {
			return x.Hello
		}
	}
	return nil
}

func (x *Command) GetShell() *ShellCommand {
	if x != nil {
		if x, ok := x.Payload.(*Command_Shell); ok {
			return x.Shell
		}
	}
	return nil
}

func (x *Command) GetStdin() *Stdin {
	if x != nil {
		if x, ok := x.Payload.(*Command_Stdin); ok {
			return x.Stdin
		}
	}
	return nil
}

func (x *Command) GetCloseStdin() *CloseStdin {
	if x != nil {
		if x, ok := x.Payload.(*Command_CloseStdin); ok {
			return x.CloseStdin
		}
	}
	return nil
}

func (x *Command) GetSignal() *Signal {
	if x != nil {
		if x, ok := x.Payload.(*Command_Signal); ok {
			return x.Signal
		}
	}
	return nil
}

func (x *Command) GetRegisterRequired() *RegisterRequired {
	if x != nil {
		if x, ok := x.Payload.(*Command_RegisterRequired); ok {
			return x.RegisterRequired
		}
	}
	return nil
}

func (x *Command) GetAgentReady() *AgentReady {
	if x != nil {
		if x, ok := x.Payload.(*Command_AgentReady); ok {
			return x.AgentReady
		}
	}
	return nil
}

type isCommand_Payload interface {
	isCommand_Payload()
}

type Command_Hello struct {
	Hello *Hello `protobuf:"bytes,2,opt,name=hello,proto3,oneof"`
}

type Command_Shell struct {
	Shell *ShellCommand `protobuf:"bytes,3,opt,name=shell,proto3,oneof"`
}

type Command_Stdin struct {
	Stdin *Stdin `protobuf:"bytes,4,opt,name=stdin,proto3,oneof"`
}

type Command_CloseStdin struct {
	CloseStdin *CloseStdin `protobuf:"bytes,5,opt,name=close_stdin,json=closeStdin,proto3,oneof"`
}

type Command_Signal struct {
	Signal *Signal `protobuf:"bytes,6,opt,name=signal,proto3,oneof"`
}

type Command_RegisterRequired struct {
	RegisterRequired *RegisterRequired `protobuf:"bytes,7,opt,name=register_required,json=registerRequired,proto3,oneof"`
}

type Command_AgentReady struct {
	AgentReady *AgentReady `protobuf:"bytes,8,opt,name=agent_ready,json=agentReady,proto3,oneof"`
}

func (*Command_Hello) isCommand_Payload() {}

func (*Command_Shell) isCommand_Payload() {}

func (*Command_Stdin) isCommand_Payload() {}

func (*Command_CloseStdin) isCommand_Payload() {}

func (*Command_Signal) isCommand_Payload() {}

func (*Command_RegisterRequired) isCommand_Payload() {}

func (*Command_AgentReady) isCommand_Payload() {}

// Hello is the first Command CP sends after the Session stream
// opens. clawkerd replies with HelloAck. Liveness is otherwise
// maintained via gRPC keepalive.
type Hello struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Hello) ProtoMessage() {}

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

// RegisterRequired tells clawkerd to perform the one-time CP-driven
// Register handshake: exchange the CLI-signed client_assertion JWT at
// Hydra for an access token, mTLS-dial CP's AgentService, and call
// Register. Empty payload — the command itself is the signal.
//
// CP sends RegisterRequired when, post-Hello, it observes the agent's
// container_id is missing from the agentregistry (Miss outcome).
// clawkerd replies with RegisterDone correlated by command_id.
type RegisterRequired struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RegisterRequired) ProtoMessage() {}

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

// AgentReady is the terminal init-sequence signal. clawkerd releases
// the entrypoint to exec the user CMD. Idempotent on reconnect (no
// reader → no-op success). Reply: Done{exit_code:0} on release or
// reconnect-replay; Error{NOT_FOUND} if the fifo is missing entirely
// (build drift); Error{IO_ERROR} on syscall-level failure.
type AgentReady struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*AgentReady) ProtoMessage() {}

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

// ShellCommand starts a shell pipeline. stages.len == 1 runs a
// single command; stages.len > 1 chains stage[i].stdout into
// stage[i+1].stdin (a | b | c). stage[0].stdin is fed by
// initial_stdin then by subsequent Stdin frames matching this
// command_id.
type ShellCommand struct {
	state  protoimpl.MessageState `protogen:"open.v1"`
	Stages []*PipeStage           `protobuf:"bytes,1,rep,name=stages,proto3" json:"stages,omitempty"`
	// 0 = no timeout. Timeout fires SIGKILL on every stage and
	// terminates the command with ERROR_CODE_TIMEOUT.
	TimeoutSeconds uint32 `protobuf:"varint,2,opt,name=timeout_seconds,json=timeoutSeconds,proto3" json:"timeout_seconds,omitempty"`
	InitialStdin   []byte `protobuf:"bytes,3,opt,name=initial_stdin,json=initialStdin,proto3" json:"initial_stdin,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*ShellCommand) ProtoMessage() {}

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

func (x *ShellCommand) GetStages() []*PipeStage {
	if x != nil {
		return x.Stages
	}
	return nil
}

func (x *ShellCommand) GetTimeoutSeconds() uint32 {
	if x != nil {
		return x.TimeoutSeconds
	}
	return 0
}

func (x *ShellCommand) GetInitialStdin() []byte {
	if x != nil {
		return x.InitialStdin
	}
	return nil
}

// PipeStage is one process in the pipeline. uid/gid drop privileges
// per stage (e.g. install as root, post-install hook as user).
type PipeStage struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Argv          []string               `protobuf:"bytes,1,rep,name=argv,proto3" json:"argv,omitempty"`
	Uid           uint32                 `protobuf:"varint,2,opt,name=uid,proto3" json:"uid,omitempty"`
	Gid           uint32                 `protobuf:"varint,3,opt,name=gid,proto3" json:"gid,omitempty"`
	Cwd           string                 `protobuf:"bytes,4,opt,name=cwd,proto3" json:"cwd,omitempty"`
	Env           map[string]string      `protobuf:"bytes,5,rep,name=env,proto3" json:"env,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*PipeStage) ProtoMessage() {}

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

func (x *PipeStage) GetArgv() []string {
	if x != nil {
		return x.Argv
	}
	return nil
}

func (x *PipeStage) GetUid() uint32 {
	if x != nil {
		return x.Uid
	}
	return 0
}

func (x *PipeStage) GetGid() uint32 {
	if x != nil {
		return x.Gid
	}
	return 0
}

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

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

// Stdin writes bytes to a running command's stage[0] stdin. Refers
// to the in-flight ShellCommand by command_id on the parent Command.
type Stdin struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Data          []byte                 `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Stdin) ProtoMessage() {}

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

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

// CloseStdin signals EOF on the running command's stage[0] stdin.
type CloseStdin struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CloseStdin) ProtoMessage() {}

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

// Signal sends a POSIX signal to every stage in the pipeline (or to
// the single command for stages.len == 1). signo is the numeric
// signal value (e.g. 9 SIGKILL, 15 SIGTERM, 2 SIGINT).
type Signal struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Signo         int32                  `protobuf:"varint,1,opt,name=signo,proto3" json:"signo,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Signal) ProtoMessage() {}

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

func (x *Signal) GetSigno() int32 {
	if x != nil {
		return x.Signo
	}
	return 0
}

// Response is one clawkerd→CP message correlated by command_id.
// Every ShellCommand command_id terminates with exactly one of Done
// OR Error. HelloAck is the sole terminal Response for a Hello.
// Stdin / CloseStdin / Signal produce a Started-or-Error Response
// only on failure (UNKNOWN_COMMAND_ID / INVALID_REQUEST); successful
// Stdin/CloseStdin/Signal are silent.
type Response struct {
	state     protoimpl.MessageState `protogen:"open.v1"`
	CommandId string                 `protobuf:"bytes,1,opt,name=command_id,json=commandId,proto3" json:"command_id,omitempty"`
	// Types that are valid to be assigned to Payload:
	//
	//	*Response_HelloAck
	//	*Response_Started
	//	*Response_Stdout
	//	*Response_Stderr
	//	*Response_StageExit
	//	*Response_Done
	//	*Response_Error
	//	*Response_RegisterDone
	Payload       isResponse_Payload `protobuf_oneof:"payload"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Response) ProtoMessage() {}

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

func (x *Response) GetCommandId() string {
	if x != nil {
		return x.CommandId
	}
	return ""
}

func (x *Response) GetPayload() isResponse_Payload {
	if x != nil {
		return x.Payload
	}
	return nil
}

func (x *Response) GetHelloAck() *HelloAck {
	if x != nil {
		if x, ok := x.Payload.(*Response_HelloAck); ok {
			return x.HelloAck
		}
	}
	return nil
}

func (x *Response) GetStarted() *Started {
	if x != nil {
		if x, ok := x.Payload.(*Response_Started); ok {
			return x.Started
		}
	}
	return nil
}

func (x *Response) GetStdout() *StdoutChunk {
	if x != nil {
		if x, ok := x.Payload.(*Response_Stdout); ok {
			return x.Stdout
		}
	}
	return nil
}

func (x *Response) GetStderr() *StderrChunk {
	if x != nil {
		if x, ok := x.Payload.(*Response_Stderr); ok {
			return x.Stderr
		}
	}
	return nil
}

func (x *Response) GetStageExit() *StageExit {
	if x != nil {
		if x, ok := x.Payload.(*Response_StageExit); ok {
			return x.StageExit
		}
	}
	return nil
}

func (x *Response) GetDone() *Done {
	if x != nil {
		if x, ok := x.Payload.(*Response_Done); ok {
			return x.Done
		}
	}
	return nil
}

func (x *Response) GetError() *Error {
	if x != nil {
		if x, ok := x.Payload.(*Response_Error); ok {
			return x.Error
		}
	}
	return nil
}

func (x *Response) GetRegisterDone() *RegisterDone {
	if x != nil {
		if x, ok := x.Payload.(*Response_RegisterDone); ok {
			return x.RegisterDone
		}
	}
	return nil
}

type isResponse_Payload interface {
	isResponse_Payload()
}

type Response_HelloAck struct {
	HelloAck *HelloAck `protobuf:"bytes,2,opt,name=hello_ack,json=helloAck,proto3,oneof"`
}

type Response_Started struct {
	Started *Started `protobuf:"bytes,3,opt,name=started,proto3,oneof"`
}

type Response_Stdout struct {
	Stdout *StdoutChunk `protobuf:"bytes,4,opt,name=stdout,proto3,oneof"`
}

type Response_Stderr struct {
	Stderr *StderrChunk `protobuf:"bytes,5,opt,name=stderr,proto3,oneof"`
}

type Response_StageExit struct {
	StageExit *StageExit `protobuf:"bytes,6,opt,name=stage_exit,json=stageExit,proto3,oneof"`
}

type Response_Done struct {
	Done *Done `protobuf:"bytes,7,opt,name=done,proto3,oneof"`
}

type Response_Error struct {
	Error *Error `protobuf:"bytes,8,opt,name=error,proto3,oneof"`
}

type Response_RegisterDone struct {
	RegisterDone *RegisterDone `protobuf:"bytes,9,opt,name=register_done,json=registerDone,proto3,oneof"`
}

func (*Response_HelloAck) isResponse_Payload() {}

func (*Response_Started) isResponse_Payload() {}

func (*Response_Stdout) isResponse_Payload() {}

func (*Response_Stderr) isResponse_Payload() {}

func (*Response_StageExit) isResponse_Payload() {}

func (*Response_Done) isResponse_Payload() {}

func (*Response_Error) isResponse_Payload() {}

func (*Response_RegisterDone) isResponse_Payload() {}

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

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

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

func (*HelloAck) ProtoMessage() {}

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

// RegisterDone is the terminal Response to a RegisterRequired Command.
// ok=true signals AgentService.Register returned Welcome. ok=false
// carries the human-readable failure reason in error (Hydra exchange
// failed, dial failed, Register returned PermissionDenied, etc.).
type RegisterDone struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Ok            bool                   `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"`
	Error         string                 `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*RegisterDone) ProtoMessage() {}

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

func (x *RegisterDone) GetOk() bool {
	if x != nil {
		return x.Ok
	}
	return false
}

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

// Started signals that ShellCommand has spawned all stages.
type Started struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Started) ProtoMessage() {}

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

// StdoutChunk carries bytes from the final stage's stdout.
type StdoutChunk struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Data          []byte                 `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*StdoutChunk) ProtoMessage() {}

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

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

// StderrChunk carries bytes from a specific stage's stderr.
type StderrChunk struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	StageIndex    uint32                 `protobuf:"varint,1,opt,name=stage_index,json=stageIndex,proto3" json:"stage_index,omitempty"`
	Data          []byte                 `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*StderrChunk) ProtoMessage() {}

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

func (x *StderrChunk) GetStageIndex() uint32 {
	if x != nil {
		return x.StageIndex
	}
	return 0
}

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

// StageExit is emitted as each pipeline stage exits. exit_code is
// the process exit code; signo is the POSIX signal that killed it
// (non-zero only for signaled exits, in which case exit_code is -1).
type StageExit struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	StageIndex    uint32                 `protobuf:"varint,1,opt,name=stage_index,json=stageIndex,proto3" json:"stage_index,omitempty"`
	ExitCode      int32                  `protobuf:"varint,2,opt,name=exit_code,json=exitCode,proto3" json:"exit_code,omitempty"`
	Signo         int32                  `protobuf:"varint,3,opt,name=signo,proto3" json:"signo,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*StageExit) ProtoMessage() {}

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

func (x *StageExit) GetStageIndex() uint32 {
	if x != nil {
		return x.StageIndex
	}
	return 0
}

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

func (x *StageExit) GetSigno() int32 {
	if x != nil {
		return x.Signo
	}
	return 0
}

// Done is the terminal Response for a successful ShellCommand.
// final_exit_code = last stage's exit_code.
type Done struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	FinalExitCode int32                  `protobuf:"varint,1,opt,name=final_exit_code,json=finalExitCode,proto3" json:"final_exit_code,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Done) ProtoMessage() {}

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

func (x *Done) GetFinalExitCode() int32 {
	if x != nil {
		return x.FinalExitCode
	}
	return 0
}

// Error is the terminal Response for a failed Command.
type Error struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Code          ErrorCode              `protobuf:"varint,1,opt,name=code,proto3,enum=clawker.clawkerd.v1.ErrorCode" json:"code,omitempty"`
	Message       string                 `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Error) ProtoMessage() {}

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

func (x *Error) GetCode() ErrorCode {
	if x != nil {
		return x.Code
	}
	return ErrorCode_ERROR_CODE_UNSPECIFIED
}

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

var File_clawkerd_v1_clawkerd_proto protoreflect.FileDescriptor

const file_clawkerd_v1_clawkerd_proto_rawDesc = "" +
	"\n" +
	"\x1aclawkerd/v1/clawkerd.proto\x12\x13clawker.clawkerd.v1\"\xeb\x03\n" +
	"\aCommand\x12\x1d\n" +
	"\n" +
	"command_id\x18\x01 \x01(\tR\tcommandId\x122\n" +
	"\x05hello\x18\x02 \x01(\v2\x1a.clawker.clawkerd.v1.HelloH\x00R\x05hello\x129\n" +
	"\x05shell\x18\x03 \x01(\v2!.clawker.clawkerd.v1.ShellCommandH\x00R\x05shell\x122\n" +
	"\x05stdin\x18\x04 \x01(\v2\x1a.clawker.clawkerd.v1.StdinH\x00R\x05stdin\x12B\n" +
	"\vclose_stdin\x18\x05 \x01(\v2\x1f.clawker.clawkerd.v1.CloseStdinH\x00R\n" +
	"closeStdin\x125\n" +
	"\x06signal\x18\x06 \x01(\v2\x1b.clawker.clawkerd.v1.SignalH\x00R\x06signal\x12T\n" +
	"\x11register_required\x18\a \x01(\v2%.clawker.clawkerd.v1.RegisterRequiredH\x00R\x10registerRequired\x12B\n" +
	"\vagent_ready\x18\b \x01(\v2\x1f.clawker.clawkerd.v1.AgentReadyH\x00R\n" +
	"agentReadyB\t\n" +
	"\apayload\"\a\n" +
	"\x05Hello\"\x12\n" +
	"\x10RegisterRequired\"\f\n" +
	"\n" +
	"AgentReady\"\x94\x01\n" +
	"\fShellCommand\x126\n" +
	"\x06stages\x18\x01 \x03(\v2\x1e.clawker.clawkerd.v1.PipeStageR\x06stages\x12'\n" +
	"\x0ftimeout_seconds\x18\x02 \x01(\rR\x0etimeoutSeconds\x12#\n" +
	"\rinitial_stdin\x18\x03 \x01(\fR\finitialStdin\"\xc8\x01\n" +
	"\tPipeStage\x12\x12\n" +
	"\x04argv\x18\x01 \x03(\tR\x04argv\x12\x10\n" +
	"\x03uid\x18\x02 \x01(\rR\x03uid\x12\x10\n" +
	"\x03gid\x18\x03 \x01(\rR\x03gid\x12\x10\n" +
	"\x03cwd\x18\x04 \x01(\tR\x03cwd\x129\n" +
	"\x03env\x18\x05 \x03(\v2'.clawker.clawkerd.v1.PipeStage.EnvEntryR\x03env\x1a6\n" +
	"\bEnvEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\x1b\n" +
	"\x05Stdin\x12\x12\n" +
	"\x04data\x18\x01 \x01(\fR\x04data\"\f\n" +
	"\n" +
	"CloseStdin\"\x1e\n" +
	"\x06Signal\x12\x14\n" +
	"\x05signo\x18\x01 \x01(\x05R\x05signo\"\x94\x04\n" +
	"\bResponse\x12\x1d\n" +
	"\n" +
	"command_id\x18\x01 \x01(\tR\tcommandId\x12<\n" +
	"\thello_ack\x18\x02 \x01(\v2\x1d.clawker.clawkerd.v1.HelloAckH\x00R\bhelloAck\x128\n" +
	"\astarted\x18\x03 \x01(\v2\x1c.clawker.clawkerd.v1.StartedH\x00R\astarted\x12:\n" +
	"\x06stdout\x18\x04 \x01(\v2 .clawker.clawkerd.v1.StdoutChunkH\x00R\x06stdout\x12:\n" +
	"\x06stderr\x18\x05 \x01(\v2 .clawker.clawkerd.v1.StderrChunkH\x00R\x06stderr\x12?\n" +
	"\n" +
	"stage_exit\x18\x06 \x01(\v2\x1e.clawker.clawkerd.v1.StageExitH\x00R\tstageExit\x12/\n" +
	"\x04done\x18\a \x01(\v2\x19.clawker.clawkerd.v1.DoneH\x00R\x04done\x122\n" +
	"\x05error\x18\b \x01(\v2\x1a.clawker.clawkerd.v1.ErrorH\x00R\x05error\x12H\n" +
	"\rregister_done\x18\t \x01(\v2!.clawker.clawkerd.v1.RegisterDoneH\x00R\fregisterDoneB\t\n" +
	"\apayload\"\n" +
	"\n" +
	"\bHelloAck\"4\n" +
	"\fRegisterDone\x12\x0e\n" +
	"\x02ok\x18\x01 \x01(\bR\x02ok\x12\x14\n" +
	"\x05error\x18\x02 \x01(\tR\x05error\"\t\n" +
	"\aStarted\"!\n" +
	"\vStdoutChunk\x12\x12\n" +
	"\x04data\x18\x01 \x01(\fR\x04data\"B\n" +
	"\vStderrChunk\x12\x1f\n" +
	"\vstage_index\x18\x01 \x01(\rR\n" +
	"stageIndex\x12\x12\n" +
	"\x04data\x18\x02 \x01(\fR\x04data\"_\n" +
	"\tStageExit\x12\x1f\n" +
	"\vstage_index\x18\x01 \x01(\rR\n" +
	"stageIndex\x12\x1b\n" +
	"\texit_code\x18\x02 \x01(\x05R\bexitCode\x12\x14\n" +
	"\x05signo\x18\x03 \x01(\x05R\x05signo\".\n" +
	"\x04Done\x12&\n" +
	"\x0ffinal_exit_code\x18\x01 \x01(\x05R\rfinalExitCode\"U\n" +
	"\x05Error\x122\n" +
	"\x04code\x18\x01 \x01(\x0e2\x1e.clawker.clawkerd.v1.ErrorCodeR\x04code\x12\x18\n" +
	"\amessage\x18\x02 \x01(\tR\amessage*\xd2\x01\n" +
	"\tErrorCode\x12\x1a\n" +
	"\x16ERROR_CODE_UNSPECIFIED\x10\x00\x12!\n" +
	"\x1dERROR_CODE_UNKNOWN_COMMAND_ID\x10\x01\x12\x1e\n" +
	"\x1aERROR_CODE_INVALID_REQUEST\x10\x02\x12\x1b\n" +
	"\x17ERROR_CODE_SPAWN_FAILED\x10\x03\x12\x16\n" +
	"\x12ERROR_CODE_TIMEOUT\x10\x04\x12\x17\n" +
	"\x13ERROR_CODE_IO_ERROR\x10\x05\x12\x18\n" +
	"\x14ERROR_CODE_NOT_FOUND\x10\x062]\n" +
	"\x0fClawkerdService\x12J\n" +
	"\aSession\x12\x1c.clawker.clawkerd.v1.Command\x1a\x1d.clawker.clawkerd.v1.Response(\x010\x01B/Z-github.com/schmitthub/clawker/api/clawkerd/v1b\x06proto3"

var (
	file_clawkerd_v1_clawkerd_proto_rawDescOnce sync.Once
	file_clawkerd_v1_clawkerd_proto_rawDescData []byte
)

func file_clawkerd_v1_clawkerd_proto_rawDescGZIP() []byte {
	file_clawkerd_v1_clawkerd_proto_rawDescOnce.Do(func() {
		file_clawkerd_v1_clawkerd_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_clawkerd_v1_clawkerd_proto_rawDesc), len(file_clawkerd_v1_clawkerd_proto_rawDesc)))
	})
	return file_clawkerd_v1_clawkerd_proto_rawDescData
}

var file_clawkerd_v1_clawkerd_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_clawkerd_v1_clawkerd_proto_msgTypes = make([]protoimpl.MessageInfo, 19)
var file_clawkerd_v1_clawkerd_proto_goTypes = []any{
	(ErrorCode)(0),           // 0: clawker.clawkerd.v1.ErrorCode
	(*Command)(nil),          // 1: clawker.clawkerd.v1.Command
	(*Hello)(nil),            // 2: clawker.clawkerd.v1.Hello
	(*RegisterRequired)(nil), // 3: clawker.clawkerd.v1.RegisterRequired
	(*AgentReady)(nil),       // 4: clawker.clawkerd.v1.AgentReady
	(*ShellCommand)(nil),     // 5: clawker.clawkerd.v1.ShellCommand
	(*PipeStage)(nil),        // 6: clawker.clawkerd.v1.PipeStage
	(*Stdin)(nil),            // 7: clawker.clawkerd.v1.Stdin
	(*CloseStdin)(nil),       // 8: clawker.clawkerd.v1.CloseStdin
	(*Signal)(nil),           // 9: clawker.clawkerd.v1.Signal
	(*Response)(nil),         // 10: clawker.clawkerd.v1.Response
	(*HelloAck)(nil),         // 11: clawker.clawkerd.v1.HelloAck
	(*RegisterDone)(nil),     // 12: clawker.clawkerd.v1.RegisterDone
	(*Started)(nil),          // 13: clawker.clawkerd.v1.Started
	(*StdoutChunk)(nil),      // 14: clawker.clawkerd.v1.StdoutChunk
	(*StderrChunk)(nil),      // 15: clawker.clawkerd.v1.StderrChunk
	(*StageExit)(nil),        // 16: clawker.clawkerd.v1.StageExit
	(*Done)(nil),             // 17: clawker.clawkerd.v1.Done
	(*Error)(nil),            // 18: clawker.clawkerd.v1.Error
	nil,                      // 19: clawker.clawkerd.v1.PipeStage.EnvEntry
}
var file_clawkerd_v1_clawkerd_proto_depIdxs = []int32{
	2,  // 0: clawker.clawkerd.v1.Command.hello:type_name -> clawker.clawkerd.v1.Hello
	5,  // 1: clawker.clawkerd.v1.Command.shell:type_name -> clawker.clawkerd.v1.ShellCommand
	7,  // 2: clawker.clawkerd.v1.Command.stdin:type_name -> clawker.clawkerd.v1.Stdin
	8,  // 3: clawker.clawkerd.v1.Command.close_stdin:type_name -> clawker.clawkerd.v1.CloseStdin
	9,  // 4: clawker.clawkerd.v1.Command.signal:type_name -> clawker.clawkerd.v1.Signal
	3,  // 5: clawker.clawkerd.v1.Command.register_required:type_name -> clawker.clawkerd.v1.RegisterRequired
	4,  // 6: clawker.clawkerd.v1.Command.agent_ready:type_name -> clawker.clawkerd.v1.AgentReady
	6,  // 7: clawker.clawkerd.v1.ShellCommand.stages:type_name -> clawker.clawkerd.v1.PipeStage
	19, // 8: clawker.clawkerd.v1.PipeStage.env:type_name -> clawker.clawkerd.v1.PipeStage.EnvEntry
	11, // 9: clawker.clawkerd.v1.Response.hello_ack:type_name -> clawker.clawkerd.v1.HelloAck
	13, // 10: clawker.clawkerd.v1.Response.started:type_name -> clawker.clawkerd.v1.Started
	14, // 11: clawker.clawkerd.v1.Response.stdout:type_name -> clawker.clawkerd.v1.StdoutChunk
	15, // 12: clawker.clawkerd.v1.Response.stderr:type_name -> clawker.clawkerd.v1.StderrChunk
	16, // 13: clawker.clawkerd.v1.Response.stage_exit:type_name -> clawker.clawkerd.v1.StageExit
	17, // 14: clawker.clawkerd.v1.Response.done:type_name -> clawker.clawkerd.v1.Done
	18, // 15: clawker.clawkerd.v1.Response.error:type_name -> clawker.clawkerd.v1.Error
	12, // 16: clawker.clawkerd.v1.Response.register_done:type_name -> clawker.clawkerd.v1.RegisterDone
	0,  // 17: clawker.clawkerd.v1.Error.code:type_name -> clawker.clawkerd.v1.ErrorCode
	1,  // 18: clawker.clawkerd.v1.ClawkerdService.Session:input_type -> clawker.clawkerd.v1.Command
	10, // 19: clawker.clawkerd.v1.ClawkerdService.Session:output_type -> clawker.clawkerd.v1.Response
	19, // [19:20] is the sub-list for method output_type
	18, // [18:19] is the sub-list for method input_type
	18, // [18:18] is the sub-list for extension type_name
	18, // [18:18] is the sub-list for extension extendee
	0,  // [0:18] is the sub-list for field type_name
}

func init() { file_clawkerd_v1_clawkerd_proto_init() }
func file_clawkerd_v1_clawkerd_proto_init() {
	if File_clawkerd_v1_clawkerd_proto != nil {
		return
	}
	file_clawkerd_v1_clawkerd_proto_msgTypes[0].OneofWrappers = []any{
		(*Command_Hello)(nil),
		(*Command_Shell)(nil),
		(*Command_Stdin)(nil),
		(*Command_CloseStdin)(nil),
		(*Command_Signal)(nil),
		(*Command_RegisterRequired)(nil),
		(*Command_AgentReady)(nil),
	}
	file_clawkerd_v1_clawkerd_proto_msgTypes[9].OneofWrappers = []any{
		(*Response_HelloAck)(nil),
		(*Response_Started)(nil),
		(*Response_Stdout)(nil),
		(*Response_Stderr)(nil),
		(*Response_StageExit)(nil),
		(*Response_Done)(nil),
		(*Response_Error)(nil),
		(*Response_RegisterDone)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_clawkerd_v1_clawkerd_proto_rawDesc), len(file_clawkerd_v1_clawkerd_proto_rawDesc)),
			NumEnums:      1,
			NumMessages:   19,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_clawkerd_v1_clawkerd_proto_goTypes,
		DependencyIndexes: file_clawkerd_v1_clawkerd_proto_depIdxs,
		EnumInfos:         file_clawkerd_v1_clawkerd_proto_enumTypes,
		MessageInfos:      file_clawkerd_v1_clawkerd_proto_msgTypes,
	}.Build()
	File_clawkerd_v1_clawkerd_proto = out.File
	file_clawkerd_v1_clawkerd_proto_goTypes = nil
	file_clawkerd_v1_clawkerd_proto_depIdxs = nil
}
