// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             v4.25.1
// source: worker.proto

package proto

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

const (
	RunCService_RunCKill_FullMethodName                    = "/runc.RunCService/RunCKill"
	RunCService_RunCStatus_FullMethodName                  = "/runc.RunCService/RunCStatus"
	RunCService_RunCExec_FullMethodName                    = "/runc.RunCService/RunCExec"
	RunCService_RunCStreamLogs_FullMethodName              = "/runc.RunCService/RunCStreamLogs"
	RunCService_RunCArchive_FullMethodName                 = "/runc.RunCService/RunCArchive"
	RunCService_RunCCheckpoint_FullMethodName              = "/runc.RunCService/RunCCheckpoint"
	RunCService_RunCSyncWorkspace_FullMethodName           = "/runc.RunCService/RunCSyncWorkspace"
	RunCService_RunCSandboxExec_FullMethodName             = "/runc.RunCService/RunCSandboxExec"
	RunCService_RunCSandboxStatus_FullMethodName           = "/runc.RunCService/RunCSandboxStatus"
	RunCService_RunCSandboxStdout_FullMethodName           = "/runc.RunCService/RunCSandboxStdout"
	RunCService_RunCSandboxStderr_FullMethodName           = "/runc.RunCService/RunCSandboxStderr"
	RunCService_RunCSandboxKill_FullMethodName             = "/runc.RunCService/RunCSandboxKill"
	RunCService_RunCSandboxListFiles_FullMethodName        = "/runc.RunCService/RunCSandboxListFiles"
	RunCService_RunCSandboxUploadFile_FullMethodName       = "/runc.RunCService/RunCSandboxUploadFile"
	RunCService_RunCSandboxDownloadFile_FullMethodName     = "/runc.RunCService/RunCSandboxDownloadFile"
	RunCService_RunCSandboxStatFile_FullMethodName         = "/runc.RunCService/RunCSandboxStatFile"
	RunCService_RunCSandboxDeleteFile_FullMethodName       = "/runc.RunCService/RunCSandboxDeleteFile"
	RunCService_RunCSandboxCreateDirectory_FullMethodName  = "/runc.RunCService/RunCSandboxCreateDirectory"
	RunCService_RunCSandboxDeleteDirectory_FullMethodName  = "/runc.RunCService/RunCSandboxDeleteDirectory"
	RunCService_RunCSandboxExposePort_FullMethodName       = "/runc.RunCService/RunCSandboxExposePort"
	RunCService_RunCSandboxReplaceInFiles_FullMethodName   = "/runc.RunCService/RunCSandboxReplaceInFiles"
	RunCService_RunCSandboxFindInFiles_FullMethodName      = "/runc.RunCService/RunCSandboxFindInFiles"
	RunCService_RunCSandboxListExposedPorts_FullMethodName = "/runc.RunCService/RunCSandboxListExposedPorts"
	RunCService_RunCSandboxListProcesses_FullMethodName    = "/runc.RunCService/RunCSandboxListProcesses"
)

// RunCServiceClient is the client API for RunCService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type RunCServiceClient interface {
	RunCKill(ctx context.Context, in *RunCKillRequest, opts ...grpc.CallOption) (*RunCKillResponse, error)
	RunCStatus(ctx context.Context, in *RunCStatusRequest, opts ...grpc.CallOption) (*RunCStatusResponse, error)
	RunCExec(ctx context.Context, in *RunCExecRequest, opts ...grpc.CallOption) (*RunCExecResponse, error)
	RunCStreamLogs(ctx context.Context, in *RunCStreamLogsRequest, opts ...grpc.CallOption) (RunCService_RunCStreamLogsClient, error)
	RunCArchive(ctx context.Context, in *RunCArchiveRequest, opts ...grpc.CallOption) (RunCService_RunCArchiveClient, error)
	RunCCheckpoint(ctx context.Context, in *RunCCheckpointRequest, opts ...grpc.CallOption) (*RunCCheckpointResponse, error)
	RunCSyncWorkspace(ctx context.Context, in *SyncContainerWorkspaceRequest, opts ...grpc.CallOption) (*SyncContainerWorkspaceResponse, error)
	RunCSandboxExec(ctx context.Context, in *RunCSandboxExecRequest, opts ...grpc.CallOption) (*RunCSandboxExecResponse, error)
	RunCSandboxStatus(ctx context.Context, in *RunCSandboxStatusRequest, opts ...grpc.CallOption) (*RunCSandboxStatusResponse, error)
	RunCSandboxStdout(ctx context.Context, in *RunCSandboxStdoutRequest, opts ...grpc.CallOption) (*RunCSandboxStdoutResponse, error)
	RunCSandboxStderr(ctx context.Context, in *RunCSandboxStderrRequest, opts ...grpc.CallOption) (*RunCSandboxStderrResponse, error)
	RunCSandboxKill(ctx context.Context, in *RunCSandboxKillRequest, opts ...grpc.CallOption) (*RunCSandboxKillResponse, error)
	RunCSandboxListFiles(ctx context.Context, in *RunCSandboxListFilesRequest, opts ...grpc.CallOption) (*RunCSandboxListFilesResponse, error)
	RunCSandboxUploadFile(ctx context.Context, in *RunCSandboxUploadFileRequest, opts ...grpc.CallOption) (*RunCSandboxUploadFileResponse, error)
	RunCSandboxDownloadFile(ctx context.Context, in *RunCSandboxDownloadFileRequest, opts ...grpc.CallOption) (*RunCSandboxDownloadFileResponse, error)
	RunCSandboxStatFile(ctx context.Context, in *RunCSandboxStatFileRequest, opts ...grpc.CallOption) (*RunCSandboxStatFileResponse, error)
	RunCSandboxDeleteFile(ctx context.Context, in *RunCSandboxDeleteFileRequest, opts ...grpc.CallOption) (*RunCSandboxDeleteFileResponse, error)
	RunCSandboxCreateDirectory(ctx context.Context, in *RunCSandboxCreateDirectoryRequest, opts ...grpc.CallOption) (*RunCSandboxCreateDirectoryResponse, error)
	RunCSandboxDeleteDirectory(ctx context.Context, in *RunCSandboxDeleteDirectoryRequest, opts ...grpc.CallOption) (*RunCSandboxDeleteDirectoryResponse, error)
	RunCSandboxExposePort(ctx context.Context, in *RunCSandboxExposePortRequest, opts ...grpc.CallOption) (*RunCSandboxExposePortResponse, error)
	RunCSandboxReplaceInFiles(ctx context.Context, in *RunCSandboxReplaceInFilesRequest, opts ...grpc.CallOption) (*RunCSandboxReplaceInFilesResponse, error)
	RunCSandboxFindInFiles(ctx context.Context, in *RunCSandboxFindInFilesRequest, opts ...grpc.CallOption) (*RunCSandboxFindInFilesResponse, error)
	RunCSandboxListExposedPorts(ctx context.Context, in *RunCSandboxListExposedPortsRequest, opts ...grpc.CallOption) (*RunCSandboxListExposedPortsResponse, error)
	RunCSandboxListProcesses(ctx context.Context, in *RunCSandboxListProcessesRequest, opts ...grpc.CallOption) (*RunCSandboxListProcessesResponse, error)
}

type runCServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewRunCServiceClient(cc grpc.ClientConnInterface) RunCServiceClient {
	return &runCServiceClient{cc}
}

func (c *runCServiceClient) RunCKill(ctx context.Context, in *RunCKillRequest, opts ...grpc.CallOption) (*RunCKillResponse, error) {
	out := new(RunCKillResponse)
	err := c.cc.Invoke(ctx, RunCService_RunCKill_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runCServiceClient) RunCStatus(ctx context.Context, in *RunCStatusRequest, opts ...grpc.CallOption) (*RunCStatusResponse, error) {
	out := new(RunCStatusResponse)
	err := c.cc.Invoke(ctx, RunCService_RunCStatus_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runCServiceClient) RunCExec(ctx context.Context, in *RunCExecRequest, opts ...grpc.CallOption) (*RunCExecResponse, error) {
	out := new(RunCExecResponse)
	err := c.cc.Invoke(ctx, RunCService_RunCExec_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runCServiceClient) RunCStreamLogs(ctx context.Context, in *RunCStreamLogsRequest, opts ...grpc.CallOption) (RunCService_RunCStreamLogsClient, error) {
	stream, err := c.cc.NewStream(ctx, &RunCService_ServiceDesc.Streams[0], RunCService_RunCStreamLogs_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &runCServiceRunCStreamLogsClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type RunCService_RunCStreamLogsClient interface {
	Recv() (*RunCLogEntry, error)
	grpc.ClientStream
}

type runCServiceRunCStreamLogsClient struct {
	grpc.ClientStream
}

func (x *runCServiceRunCStreamLogsClient) Recv() (*RunCLogEntry, error) {
	m := new(RunCLogEntry)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *runCServiceClient) RunCArchive(ctx context.Context, in *RunCArchiveRequest, opts ...grpc.CallOption) (RunCService_RunCArchiveClient, error) {
	stream, err := c.cc.NewStream(ctx, &RunCService_ServiceDesc.Streams[1], RunCService_RunCArchive_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &runCServiceRunCArchiveClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type RunCService_RunCArchiveClient interface {
	Recv() (*RunCArchiveResponse, error)
	grpc.ClientStream
}

type runCServiceRunCArchiveClient struct {
	grpc.ClientStream
}

func (x *runCServiceRunCArchiveClient) Recv() (*RunCArchiveResponse, error) {
	m := new(RunCArchiveResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *runCServiceClient) RunCCheckpoint(ctx context.Context, in *RunCCheckpointRequest, opts ...grpc.CallOption) (*RunCCheckpointResponse, error) {
	out := new(RunCCheckpointResponse)
	err := c.cc.Invoke(ctx, RunCService_RunCCheckpoint_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runCServiceClient) RunCSyncWorkspace(ctx context.Context, in *SyncContainerWorkspaceRequest, opts ...grpc.CallOption) (*SyncContainerWorkspaceResponse, error) {
	out := new(SyncContainerWorkspaceResponse)
	err := c.cc.Invoke(ctx, RunCService_RunCSyncWorkspace_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runCServiceClient) RunCSandboxExec(ctx context.Context, in *RunCSandboxExecRequest, opts ...grpc.CallOption) (*RunCSandboxExecResponse, error) {
	out := new(RunCSandboxExecResponse)
	err := c.cc.Invoke(ctx, RunCService_RunCSandboxExec_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runCServiceClient) RunCSandboxStatus(ctx context.Context, in *RunCSandboxStatusRequest, opts ...grpc.CallOption) (*RunCSandboxStatusResponse, error) {
	out := new(RunCSandboxStatusResponse)
	err := c.cc.Invoke(ctx, RunCService_RunCSandboxStatus_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runCServiceClient) RunCSandboxStdout(ctx context.Context, in *RunCSandboxStdoutRequest, opts ...grpc.CallOption) (*RunCSandboxStdoutResponse, error) {
	out := new(RunCSandboxStdoutResponse)
	err := c.cc.Invoke(ctx, RunCService_RunCSandboxStdout_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runCServiceClient) RunCSandboxStderr(ctx context.Context, in *RunCSandboxStderrRequest, opts ...grpc.CallOption) (*RunCSandboxStderrResponse, error) {
	out := new(RunCSandboxStderrResponse)
	err := c.cc.Invoke(ctx, RunCService_RunCSandboxStderr_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runCServiceClient) RunCSandboxKill(ctx context.Context, in *RunCSandboxKillRequest, opts ...grpc.CallOption) (*RunCSandboxKillResponse, error) {
	out := new(RunCSandboxKillResponse)
	err := c.cc.Invoke(ctx, RunCService_RunCSandboxKill_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runCServiceClient) RunCSandboxListFiles(ctx context.Context, in *RunCSandboxListFilesRequest, opts ...grpc.CallOption) (*RunCSandboxListFilesResponse, error) {
	out := new(RunCSandboxListFilesResponse)
	err := c.cc.Invoke(ctx, RunCService_RunCSandboxListFiles_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runCServiceClient) RunCSandboxUploadFile(ctx context.Context, in *RunCSandboxUploadFileRequest, opts ...grpc.CallOption) (*RunCSandboxUploadFileResponse, error) {
	out := new(RunCSandboxUploadFileResponse)
	err := c.cc.Invoke(ctx, RunCService_RunCSandboxUploadFile_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runCServiceClient) RunCSandboxDownloadFile(ctx context.Context, in *RunCSandboxDownloadFileRequest, opts ...grpc.CallOption) (*RunCSandboxDownloadFileResponse, error) {
	out := new(RunCSandboxDownloadFileResponse)
	err := c.cc.Invoke(ctx, RunCService_RunCSandboxDownloadFile_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runCServiceClient) RunCSandboxStatFile(ctx context.Context, in *RunCSandboxStatFileRequest, opts ...grpc.CallOption) (*RunCSandboxStatFileResponse, error) {
	out := new(RunCSandboxStatFileResponse)
	err := c.cc.Invoke(ctx, RunCService_RunCSandboxStatFile_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runCServiceClient) RunCSandboxDeleteFile(ctx context.Context, in *RunCSandboxDeleteFileRequest, opts ...grpc.CallOption) (*RunCSandboxDeleteFileResponse, error) {
	out := new(RunCSandboxDeleteFileResponse)
	err := c.cc.Invoke(ctx, RunCService_RunCSandboxDeleteFile_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runCServiceClient) RunCSandboxCreateDirectory(ctx context.Context, in *RunCSandboxCreateDirectoryRequest, opts ...grpc.CallOption) (*RunCSandboxCreateDirectoryResponse, error) {
	out := new(RunCSandboxCreateDirectoryResponse)
	err := c.cc.Invoke(ctx, RunCService_RunCSandboxCreateDirectory_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runCServiceClient) RunCSandboxDeleteDirectory(ctx context.Context, in *RunCSandboxDeleteDirectoryRequest, opts ...grpc.CallOption) (*RunCSandboxDeleteDirectoryResponse, error) {
	out := new(RunCSandboxDeleteDirectoryResponse)
	err := c.cc.Invoke(ctx, RunCService_RunCSandboxDeleteDirectory_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runCServiceClient) RunCSandboxExposePort(ctx context.Context, in *RunCSandboxExposePortRequest, opts ...grpc.CallOption) (*RunCSandboxExposePortResponse, error) {
	out := new(RunCSandboxExposePortResponse)
	err := c.cc.Invoke(ctx, RunCService_RunCSandboxExposePort_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runCServiceClient) RunCSandboxReplaceInFiles(ctx context.Context, in *RunCSandboxReplaceInFilesRequest, opts ...grpc.CallOption) (*RunCSandboxReplaceInFilesResponse, error) {
	out := new(RunCSandboxReplaceInFilesResponse)
	err := c.cc.Invoke(ctx, RunCService_RunCSandboxReplaceInFiles_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runCServiceClient) RunCSandboxFindInFiles(ctx context.Context, in *RunCSandboxFindInFilesRequest, opts ...grpc.CallOption) (*RunCSandboxFindInFilesResponse, error) {
	out := new(RunCSandboxFindInFilesResponse)
	err := c.cc.Invoke(ctx, RunCService_RunCSandboxFindInFiles_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runCServiceClient) RunCSandboxListExposedPorts(ctx context.Context, in *RunCSandboxListExposedPortsRequest, opts ...grpc.CallOption) (*RunCSandboxListExposedPortsResponse, error) {
	out := new(RunCSandboxListExposedPortsResponse)
	err := c.cc.Invoke(ctx, RunCService_RunCSandboxListExposedPorts_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *runCServiceClient) RunCSandboxListProcesses(ctx context.Context, in *RunCSandboxListProcessesRequest, opts ...grpc.CallOption) (*RunCSandboxListProcessesResponse, error) {
	out := new(RunCSandboxListProcessesResponse)
	err := c.cc.Invoke(ctx, RunCService_RunCSandboxListProcesses_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RunCServiceServer is the server API for RunCService service.
// All implementations must embed UnimplementedRunCServiceServer
// for forward compatibility
type RunCServiceServer interface {
	RunCKill(context.Context, *RunCKillRequest) (*RunCKillResponse, error)
	RunCStatus(context.Context, *RunCStatusRequest) (*RunCStatusResponse, error)
	RunCExec(context.Context, *RunCExecRequest) (*RunCExecResponse, error)
	RunCStreamLogs(*RunCStreamLogsRequest, RunCService_RunCStreamLogsServer) error
	RunCArchive(*RunCArchiveRequest, RunCService_RunCArchiveServer) error
	RunCCheckpoint(context.Context, *RunCCheckpointRequest) (*RunCCheckpointResponse, error)
	RunCSyncWorkspace(context.Context, *SyncContainerWorkspaceRequest) (*SyncContainerWorkspaceResponse, error)
	RunCSandboxExec(context.Context, *RunCSandboxExecRequest) (*RunCSandboxExecResponse, error)
	RunCSandboxStatus(context.Context, *RunCSandboxStatusRequest) (*RunCSandboxStatusResponse, error)
	RunCSandboxStdout(context.Context, *RunCSandboxStdoutRequest) (*RunCSandboxStdoutResponse, error)
	RunCSandboxStderr(context.Context, *RunCSandboxStderrRequest) (*RunCSandboxStderrResponse, error)
	RunCSandboxKill(context.Context, *RunCSandboxKillRequest) (*RunCSandboxKillResponse, error)
	RunCSandboxListFiles(context.Context, *RunCSandboxListFilesRequest) (*RunCSandboxListFilesResponse, error)
	RunCSandboxUploadFile(context.Context, *RunCSandboxUploadFileRequest) (*RunCSandboxUploadFileResponse, error)
	RunCSandboxDownloadFile(context.Context, *RunCSandboxDownloadFileRequest) (*RunCSandboxDownloadFileResponse, error)
	RunCSandboxStatFile(context.Context, *RunCSandboxStatFileRequest) (*RunCSandboxStatFileResponse, error)
	RunCSandboxDeleteFile(context.Context, *RunCSandboxDeleteFileRequest) (*RunCSandboxDeleteFileResponse, error)
	RunCSandboxCreateDirectory(context.Context, *RunCSandboxCreateDirectoryRequest) (*RunCSandboxCreateDirectoryResponse, error)
	RunCSandboxDeleteDirectory(context.Context, *RunCSandboxDeleteDirectoryRequest) (*RunCSandboxDeleteDirectoryResponse, error)
	RunCSandboxExposePort(context.Context, *RunCSandboxExposePortRequest) (*RunCSandboxExposePortResponse, error)
	RunCSandboxReplaceInFiles(context.Context, *RunCSandboxReplaceInFilesRequest) (*RunCSandboxReplaceInFilesResponse, error)
	RunCSandboxFindInFiles(context.Context, *RunCSandboxFindInFilesRequest) (*RunCSandboxFindInFilesResponse, error)
	RunCSandboxListExposedPorts(context.Context, *RunCSandboxListExposedPortsRequest) (*RunCSandboxListExposedPortsResponse, error)
	RunCSandboxListProcesses(context.Context, *RunCSandboxListProcessesRequest) (*RunCSandboxListProcessesResponse, error)
	mustEmbedUnimplementedRunCServiceServer()
}

// UnimplementedRunCServiceServer must be embedded to have forward compatible implementations.
type UnimplementedRunCServiceServer struct {
}

func (UnimplementedRunCServiceServer) RunCKill(context.Context, *RunCKillRequest) (*RunCKillResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCKill not implemented")
}
func (UnimplementedRunCServiceServer) RunCStatus(context.Context, *RunCStatusRequest) (*RunCStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCStatus not implemented")
}
func (UnimplementedRunCServiceServer) RunCExec(context.Context, *RunCExecRequest) (*RunCExecResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCExec not implemented")
}
func (UnimplementedRunCServiceServer) RunCStreamLogs(*RunCStreamLogsRequest, RunCService_RunCStreamLogsServer) error {
	return status.Errorf(codes.Unimplemented, "method RunCStreamLogs not implemented")
}
func (UnimplementedRunCServiceServer) RunCArchive(*RunCArchiveRequest, RunCService_RunCArchiveServer) error {
	return status.Errorf(codes.Unimplemented, "method RunCArchive not implemented")
}
func (UnimplementedRunCServiceServer) RunCCheckpoint(context.Context, *RunCCheckpointRequest) (*RunCCheckpointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCCheckpoint not implemented")
}
func (UnimplementedRunCServiceServer) RunCSyncWorkspace(context.Context, *SyncContainerWorkspaceRequest) (*SyncContainerWorkspaceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCSyncWorkspace not implemented")
}
func (UnimplementedRunCServiceServer) RunCSandboxExec(context.Context, *RunCSandboxExecRequest) (*RunCSandboxExecResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCSandboxExec not implemented")
}
func (UnimplementedRunCServiceServer) RunCSandboxStatus(context.Context, *RunCSandboxStatusRequest) (*RunCSandboxStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCSandboxStatus not implemented")
}
func (UnimplementedRunCServiceServer) RunCSandboxStdout(context.Context, *RunCSandboxStdoutRequest) (*RunCSandboxStdoutResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCSandboxStdout not implemented")
}
func (UnimplementedRunCServiceServer) RunCSandboxStderr(context.Context, *RunCSandboxStderrRequest) (*RunCSandboxStderrResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCSandboxStderr not implemented")
}
func (UnimplementedRunCServiceServer) RunCSandboxKill(context.Context, *RunCSandboxKillRequest) (*RunCSandboxKillResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCSandboxKill not implemented")
}
func (UnimplementedRunCServiceServer) RunCSandboxListFiles(context.Context, *RunCSandboxListFilesRequest) (*RunCSandboxListFilesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCSandboxListFiles not implemented")
}
func (UnimplementedRunCServiceServer) RunCSandboxUploadFile(context.Context, *RunCSandboxUploadFileRequest) (*RunCSandboxUploadFileResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCSandboxUploadFile not implemented")
}
func (UnimplementedRunCServiceServer) RunCSandboxDownloadFile(context.Context, *RunCSandboxDownloadFileRequest) (*RunCSandboxDownloadFileResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCSandboxDownloadFile not implemented")
}
func (UnimplementedRunCServiceServer) RunCSandboxStatFile(context.Context, *RunCSandboxStatFileRequest) (*RunCSandboxStatFileResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCSandboxStatFile not implemented")
}
func (UnimplementedRunCServiceServer) RunCSandboxDeleteFile(context.Context, *RunCSandboxDeleteFileRequest) (*RunCSandboxDeleteFileResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCSandboxDeleteFile not implemented")
}
func (UnimplementedRunCServiceServer) RunCSandboxCreateDirectory(context.Context, *RunCSandboxCreateDirectoryRequest) (*RunCSandboxCreateDirectoryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCSandboxCreateDirectory not implemented")
}
func (UnimplementedRunCServiceServer) RunCSandboxDeleteDirectory(context.Context, *RunCSandboxDeleteDirectoryRequest) (*RunCSandboxDeleteDirectoryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCSandboxDeleteDirectory not implemented")
}
func (UnimplementedRunCServiceServer) RunCSandboxExposePort(context.Context, *RunCSandboxExposePortRequest) (*RunCSandboxExposePortResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCSandboxExposePort not implemented")
}
func (UnimplementedRunCServiceServer) RunCSandboxReplaceInFiles(context.Context, *RunCSandboxReplaceInFilesRequest) (*RunCSandboxReplaceInFilesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCSandboxReplaceInFiles not implemented")
}
func (UnimplementedRunCServiceServer) RunCSandboxFindInFiles(context.Context, *RunCSandboxFindInFilesRequest) (*RunCSandboxFindInFilesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCSandboxFindInFiles not implemented")
}
func (UnimplementedRunCServiceServer) RunCSandboxListExposedPorts(context.Context, *RunCSandboxListExposedPortsRequest) (*RunCSandboxListExposedPortsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCSandboxListExposedPorts not implemented")
}
func (UnimplementedRunCServiceServer) RunCSandboxListProcesses(context.Context, *RunCSandboxListProcessesRequest) (*RunCSandboxListProcessesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCSandboxListProcesses not implemented")
}
func (UnimplementedRunCServiceServer) mustEmbedUnimplementedRunCServiceServer() {}

// UnsafeRunCServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to RunCServiceServer will
// result in compilation errors.
type UnsafeRunCServiceServer interface {
	mustEmbedUnimplementedRunCServiceServer()
}

func RegisterRunCServiceServer(s grpc.ServiceRegistrar, srv RunCServiceServer) {
	s.RegisterService(&RunCService_ServiceDesc, srv)
}

func _RunCService_RunCKill_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunCKillRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunCServiceServer).RunCKill(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RunCService_RunCKill_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunCServiceServer).RunCKill(ctx, req.(*RunCKillRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RunCService_RunCStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunCStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunCServiceServer).RunCStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RunCService_RunCStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunCServiceServer).RunCStatus(ctx, req.(*RunCStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RunCService_RunCExec_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunCExecRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunCServiceServer).RunCExec(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RunCService_RunCExec_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunCServiceServer).RunCExec(ctx, req.(*RunCExecRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RunCService_RunCStreamLogs_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RunCStreamLogsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(RunCServiceServer).RunCStreamLogs(m, &runCServiceRunCStreamLogsServer{stream})
}

type RunCService_RunCStreamLogsServer interface {
	Send(*RunCLogEntry) error
	grpc.ServerStream
}

type runCServiceRunCStreamLogsServer struct {
	grpc.ServerStream
}

func (x *runCServiceRunCStreamLogsServer) Send(m *RunCLogEntry) error {
	return x.ServerStream.SendMsg(m)
}

func _RunCService_RunCArchive_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(RunCArchiveRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(RunCServiceServer).RunCArchive(m, &runCServiceRunCArchiveServer{stream})
}

type RunCService_RunCArchiveServer interface {
	Send(*RunCArchiveResponse) error
	grpc.ServerStream
}

type runCServiceRunCArchiveServer struct {
	grpc.ServerStream
}

func (x *runCServiceRunCArchiveServer) Send(m *RunCArchiveResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _RunCService_RunCCheckpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunCCheckpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunCServiceServer).RunCCheckpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RunCService_RunCCheckpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunCServiceServer).RunCCheckpoint(ctx, req.(*RunCCheckpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RunCService_RunCSyncWorkspace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SyncContainerWorkspaceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunCServiceServer).RunCSyncWorkspace(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RunCService_RunCSyncWorkspace_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunCServiceServer).RunCSyncWorkspace(ctx, req.(*SyncContainerWorkspaceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RunCService_RunCSandboxExec_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunCSandboxExecRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunCServiceServer).RunCSandboxExec(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RunCService_RunCSandboxExec_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunCServiceServer).RunCSandboxExec(ctx, req.(*RunCSandboxExecRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RunCService_RunCSandboxStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunCSandboxStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunCServiceServer).RunCSandboxStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RunCService_RunCSandboxStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunCServiceServer).RunCSandboxStatus(ctx, req.(*RunCSandboxStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RunCService_RunCSandboxStdout_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunCSandboxStdoutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunCServiceServer).RunCSandboxStdout(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RunCService_RunCSandboxStdout_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunCServiceServer).RunCSandboxStdout(ctx, req.(*RunCSandboxStdoutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RunCService_RunCSandboxStderr_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunCSandboxStderrRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunCServiceServer).RunCSandboxStderr(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RunCService_RunCSandboxStderr_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunCServiceServer).RunCSandboxStderr(ctx, req.(*RunCSandboxStderrRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RunCService_RunCSandboxKill_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunCSandboxKillRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunCServiceServer).RunCSandboxKill(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RunCService_RunCSandboxKill_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunCServiceServer).RunCSandboxKill(ctx, req.(*RunCSandboxKillRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RunCService_RunCSandboxListFiles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunCSandboxListFilesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunCServiceServer).RunCSandboxListFiles(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RunCService_RunCSandboxListFiles_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunCServiceServer).RunCSandboxListFiles(ctx, req.(*RunCSandboxListFilesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RunCService_RunCSandboxUploadFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunCSandboxUploadFileRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunCServiceServer).RunCSandboxUploadFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RunCService_RunCSandboxUploadFile_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunCServiceServer).RunCSandboxUploadFile(ctx, req.(*RunCSandboxUploadFileRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RunCService_RunCSandboxDownloadFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunCSandboxDownloadFileRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunCServiceServer).RunCSandboxDownloadFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RunCService_RunCSandboxDownloadFile_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunCServiceServer).RunCSandboxDownloadFile(ctx, req.(*RunCSandboxDownloadFileRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RunCService_RunCSandboxStatFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunCSandboxStatFileRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunCServiceServer).RunCSandboxStatFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RunCService_RunCSandboxStatFile_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunCServiceServer).RunCSandboxStatFile(ctx, req.(*RunCSandboxStatFileRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RunCService_RunCSandboxDeleteFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunCSandboxDeleteFileRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunCServiceServer).RunCSandboxDeleteFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RunCService_RunCSandboxDeleteFile_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunCServiceServer).RunCSandboxDeleteFile(ctx, req.(*RunCSandboxDeleteFileRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RunCService_RunCSandboxCreateDirectory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunCSandboxCreateDirectoryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunCServiceServer).RunCSandboxCreateDirectory(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RunCService_RunCSandboxCreateDirectory_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunCServiceServer).RunCSandboxCreateDirectory(ctx, req.(*RunCSandboxCreateDirectoryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RunCService_RunCSandboxDeleteDirectory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunCSandboxDeleteDirectoryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunCServiceServer).RunCSandboxDeleteDirectory(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RunCService_RunCSandboxDeleteDirectory_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunCServiceServer).RunCSandboxDeleteDirectory(ctx, req.(*RunCSandboxDeleteDirectoryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RunCService_RunCSandboxExposePort_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunCSandboxExposePortRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunCServiceServer).RunCSandboxExposePort(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RunCService_RunCSandboxExposePort_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunCServiceServer).RunCSandboxExposePort(ctx, req.(*RunCSandboxExposePortRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RunCService_RunCSandboxReplaceInFiles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunCSandboxReplaceInFilesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunCServiceServer).RunCSandboxReplaceInFiles(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RunCService_RunCSandboxReplaceInFiles_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunCServiceServer).RunCSandboxReplaceInFiles(ctx, req.(*RunCSandboxReplaceInFilesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RunCService_RunCSandboxFindInFiles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunCSandboxFindInFilesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunCServiceServer).RunCSandboxFindInFiles(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RunCService_RunCSandboxFindInFiles_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunCServiceServer).RunCSandboxFindInFiles(ctx, req.(*RunCSandboxFindInFilesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RunCService_RunCSandboxListExposedPorts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunCSandboxListExposedPortsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunCServiceServer).RunCSandboxListExposedPorts(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RunCService_RunCSandboxListExposedPorts_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunCServiceServer).RunCSandboxListExposedPorts(ctx, req.(*RunCSandboxListExposedPortsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RunCService_RunCSandboxListProcesses_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunCSandboxListProcessesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RunCServiceServer).RunCSandboxListProcesses(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RunCService_RunCSandboxListProcesses_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RunCServiceServer).RunCSandboxListProcesses(ctx, req.(*RunCSandboxListProcessesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// RunCService_ServiceDesc is the grpc.ServiceDesc for RunCService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var RunCService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "runc.RunCService",
	HandlerType: (*RunCServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "RunCKill",
			Handler:    _RunCService_RunCKill_Handler,
		},
		{
			MethodName: "RunCStatus",
			Handler:    _RunCService_RunCStatus_Handler,
		},
		{
			MethodName: "RunCExec",
			Handler:    _RunCService_RunCExec_Handler,
		},
		{
			MethodName: "RunCCheckpoint",
			Handler:    _RunCService_RunCCheckpoint_Handler,
		},
		{
			MethodName: "RunCSyncWorkspace",
			Handler:    _RunCService_RunCSyncWorkspace_Handler,
		},
		{
			MethodName: "RunCSandboxExec",
			Handler:    _RunCService_RunCSandboxExec_Handler,
		},
		{
			MethodName: "RunCSandboxStatus",
			Handler:    _RunCService_RunCSandboxStatus_Handler,
		},
		{
			MethodName: "RunCSandboxStdout",
			Handler:    _RunCService_RunCSandboxStdout_Handler,
		},
		{
			MethodName: "RunCSandboxStderr",
			Handler:    _RunCService_RunCSandboxStderr_Handler,
		},
		{
			MethodName: "RunCSandboxKill",
			Handler:    _RunCService_RunCSandboxKill_Handler,
		},
		{
			MethodName: "RunCSandboxListFiles",
			Handler:    _RunCService_RunCSandboxListFiles_Handler,
		},
		{
			MethodName: "RunCSandboxUploadFile",
			Handler:    _RunCService_RunCSandboxUploadFile_Handler,
		},
		{
			MethodName: "RunCSandboxDownloadFile",
			Handler:    _RunCService_RunCSandboxDownloadFile_Handler,
		},
		{
			MethodName: "RunCSandboxStatFile",
			Handler:    _RunCService_RunCSandboxStatFile_Handler,
		},
		{
			MethodName: "RunCSandboxDeleteFile",
			Handler:    _RunCService_RunCSandboxDeleteFile_Handler,
		},
		{
			MethodName: "RunCSandboxCreateDirectory",
			Handler:    _RunCService_RunCSandboxCreateDirectory_Handler,
		},
		{
			MethodName: "RunCSandboxDeleteDirectory",
			Handler:    _RunCService_RunCSandboxDeleteDirectory_Handler,
		},
		{
			MethodName: "RunCSandboxExposePort",
			Handler:    _RunCService_RunCSandboxExposePort_Handler,
		},
		{
			MethodName: "RunCSandboxReplaceInFiles",
			Handler:    _RunCService_RunCSandboxReplaceInFiles_Handler,
		},
		{
			MethodName: "RunCSandboxFindInFiles",
			Handler:    _RunCService_RunCSandboxFindInFiles_Handler,
		},
		{
			MethodName: "RunCSandboxListExposedPorts",
			Handler:    _RunCService_RunCSandboxListExposedPorts_Handler,
		},
		{
			MethodName: "RunCSandboxListProcesses",
			Handler:    _RunCService_RunCSandboxListProcesses_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "RunCStreamLogs",
			Handler:       _RunCService_RunCStreamLogs_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "RunCArchive",
			Handler:       _RunCService_RunCArchive_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "worker.proto",
}
