// 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 (
	ContainerService_ContainerKill_FullMethodName                            = "/container.ContainerService/ContainerKill"
	ContainerService_ContainerStatus_FullMethodName                          = "/container.ContainerService/ContainerStatus"
	ContainerService_ContainerExec_FullMethodName                            = "/container.ContainerService/ContainerExec"
	ContainerService_ContainerStreamLogs_FullMethodName                      = "/container.ContainerService/ContainerStreamLogs"
	ContainerService_ContainerArchive_FullMethodName                         = "/container.ContainerService/ContainerArchive"
	ContainerService_ContainerCheckpoint_FullMethodName                      = "/container.ContainerService/ContainerCheckpoint"
	ContainerService_ContainerSnapshotDisks_FullMethodName                   = "/container.ContainerService/ContainerSnapshotDisks"
	ContainerService_ContainerSyncWorkspace_FullMethodName                   = "/container.ContainerService/ContainerSyncWorkspace"
	ContainerService_ContainerSandboxExec_FullMethodName                     = "/container.ContainerService/ContainerSandboxExec"
	ContainerService_ContainerSandboxStatus_FullMethodName                   = "/container.ContainerService/ContainerSandboxStatus"
	ContainerService_ContainerSandboxStdout_FullMethodName                   = "/container.ContainerService/ContainerSandboxStdout"
	ContainerService_ContainerSandboxStderr_FullMethodName                   = "/container.ContainerService/ContainerSandboxStderr"
	ContainerService_ContainerSandboxKill_FullMethodName                     = "/container.ContainerService/ContainerSandboxKill"
	ContainerService_ContainerSandboxListFiles_FullMethodName                = "/container.ContainerService/ContainerSandboxListFiles"
	ContainerService_ContainerSandboxUploadFile_FullMethodName               = "/container.ContainerService/ContainerSandboxUploadFile"
	ContainerService_ContainerSandboxDownloadFile_FullMethodName             = "/container.ContainerService/ContainerSandboxDownloadFile"
	ContainerService_ContainerSandboxStatFile_FullMethodName                 = "/container.ContainerService/ContainerSandboxStatFile"
	ContainerService_ContainerSandboxDeleteFile_FullMethodName               = "/container.ContainerService/ContainerSandboxDeleteFile"
	ContainerService_ContainerSandboxCreateDirectory_FullMethodName          = "/container.ContainerService/ContainerSandboxCreateDirectory"
	ContainerService_ContainerSandboxDeleteDirectory_FullMethodName          = "/container.ContainerService/ContainerSandboxDeleteDirectory"
	ContainerService_ContainerSandboxExposePort_FullMethodName               = "/container.ContainerService/ContainerSandboxExposePort"
	ContainerService_ContainerSandboxUpdateNetworkPermissions_FullMethodName = "/container.ContainerService/ContainerSandboxUpdateNetworkPermissions"
	ContainerService_ContainerSandboxReplaceInFiles_FullMethodName           = "/container.ContainerService/ContainerSandboxReplaceInFiles"
	ContainerService_ContainerSandboxFindInFiles_FullMethodName              = "/container.ContainerService/ContainerSandboxFindInFiles"
	ContainerService_ContainerSandboxListExposedPorts_FullMethodName         = "/container.ContainerService/ContainerSandboxListExposedPorts"
	ContainerService_ContainerSandboxListProcesses_FullMethodName            = "/container.ContainerService/ContainerSandboxListProcesses"
	ContainerService_ContainerTunnel_FullMethodName                          = "/container.ContainerService/ContainerTunnel"
)

// ContainerServiceClient is the client API for ContainerService 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 ContainerServiceClient interface {
	ContainerKill(ctx context.Context, in *ContainerKillRequest, opts ...grpc.CallOption) (*ContainerKillResponse, error)
	ContainerStatus(ctx context.Context, in *ContainerStatusRequest, opts ...grpc.CallOption) (*ContainerStatusResponse, error)
	ContainerExec(ctx context.Context, in *ContainerExecRequest, opts ...grpc.CallOption) (*ContainerExecResponse, error)
	ContainerStreamLogs(ctx context.Context, in *ContainerStreamLogsRequest, opts ...grpc.CallOption) (ContainerService_ContainerStreamLogsClient, error)
	ContainerArchive(ctx context.Context, in *ContainerArchiveRequest, opts ...grpc.CallOption) (ContainerService_ContainerArchiveClient, error)
	ContainerCheckpoint(ctx context.Context, in *ContainerCheckpointRequest, opts ...grpc.CallOption) (*ContainerCheckpointResponse, error)
	ContainerSnapshotDisks(ctx context.Context, in *ContainerSnapshotDisksRequest, opts ...grpc.CallOption) (*ContainerSnapshotDisksResponse, error)
	ContainerSyncWorkspace(ctx context.Context, in *SyncContainerWorkspaceRequest, opts ...grpc.CallOption) (*SyncContainerWorkspaceResponse, error)
	ContainerSandboxExec(ctx context.Context, in *ContainerSandboxExecRequest, opts ...grpc.CallOption) (*ContainerSandboxExecResponse, error)
	ContainerSandboxStatus(ctx context.Context, in *ContainerSandboxStatusRequest, opts ...grpc.CallOption) (*ContainerSandboxStatusResponse, error)
	ContainerSandboxStdout(ctx context.Context, in *ContainerSandboxStdoutRequest, opts ...grpc.CallOption) (*ContainerSandboxStdoutResponse, error)
	ContainerSandboxStderr(ctx context.Context, in *ContainerSandboxStderrRequest, opts ...grpc.CallOption) (*ContainerSandboxStderrResponse, error)
	ContainerSandboxKill(ctx context.Context, in *ContainerSandboxKillRequest, opts ...grpc.CallOption) (*ContainerSandboxKillResponse, error)
	ContainerSandboxListFiles(ctx context.Context, in *ContainerSandboxListFilesRequest, opts ...grpc.CallOption) (*ContainerSandboxListFilesResponse, error)
	ContainerSandboxUploadFile(ctx context.Context, in *ContainerSandboxUploadFileRequest, opts ...grpc.CallOption) (*ContainerSandboxUploadFileResponse, error)
	ContainerSandboxDownloadFile(ctx context.Context, in *ContainerSandboxDownloadFileRequest, opts ...grpc.CallOption) (*ContainerSandboxDownloadFileResponse, error)
	ContainerSandboxStatFile(ctx context.Context, in *ContainerSandboxStatFileRequest, opts ...grpc.CallOption) (*ContainerSandboxStatFileResponse, error)
	ContainerSandboxDeleteFile(ctx context.Context, in *ContainerSandboxDeleteFileRequest, opts ...grpc.CallOption) (*ContainerSandboxDeleteFileResponse, error)
	ContainerSandboxCreateDirectory(ctx context.Context, in *ContainerSandboxCreateDirectoryRequest, opts ...grpc.CallOption) (*ContainerSandboxCreateDirectoryResponse, error)
	ContainerSandboxDeleteDirectory(ctx context.Context, in *ContainerSandboxDeleteDirectoryRequest, opts ...grpc.CallOption) (*ContainerSandboxDeleteDirectoryResponse, error)
	ContainerSandboxExposePort(ctx context.Context, in *ContainerSandboxExposePortRequest, opts ...grpc.CallOption) (*ContainerSandboxExposePortResponse, error)
	ContainerSandboxUpdateNetworkPermissions(ctx context.Context, in *ContainerSandboxUpdateNetworkPermissionsRequest, opts ...grpc.CallOption) (*ContainerSandboxUpdateNetworkPermissionsResponse, error)
	ContainerSandboxReplaceInFiles(ctx context.Context, in *ContainerSandboxReplaceInFilesRequest, opts ...grpc.CallOption) (*ContainerSandboxReplaceInFilesResponse, error)
	ContainerSandboxFindInFiles(ctx context.Context, in *ContainerSandboxFindInFilesRequest, opts ...grpc.CallOption) (*ContainerSandboxFindInFilesResponse, error)
	ContainerSandboxListExposedPorts(ctx context.Context, in *ContainerSandboxListExposedPortsRequest, opts ...grpc.CallOption) (*ContainerSandboxListExposedPortsResponse, error)
	ContainerSandboxListProcesses(ctx context.Context, in *ContainerSandboxListProcessesRequest, opts ...grpc.CallOption) (*ContainerSandboxListProcessesResponse, error)
	ContainerTunnel(ctx context.Context, in *ContainerTunnelRequest, opts ...grpc.CallOption) (*ContainerTunnelResponse, error)
}

type containerServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewContainerServiceClient(cc grpc.ClientConnInterface) ContainerServiceClient {
	return &containerServiceClient{cc}
}

func (c *containerServiceClient) ContainerKill(ctx context.Context, in *ContainerKillRequest, opts ...grpc.CallOption) (*ContainerKillResponse, error) {
	out := new(ContainerKillResponse)
	err := c.cc.Invoke(ctx, ContainerService_ContainerKill_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *containerServiceClient) ContainerStatus(ctx context.Context, in *ContainerStatusRequest, opts ...grpc.CallOption) (*ContainerStatusResponse, error) {
	out := new(ContainerStatusResponse)
	err := c.cc.Invoke(ctx, ContainerService_ContainerStatus_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *containerServiceClient) ContainerExec(ctx context.Context, in *ContainerExecRequest, opts ...grpc.CallOption) (*ContainerExecResponse, error) {
	out := new(ContainerExecResponse)
	err := c.cc.Invoke(ctx, ContainerService_ContainerExec_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *containerServiceClient) ContainerStreamLogs(ctx context.Context, in *ContainerStreamLogsRequest, opts ...grpc.CallOption) (ContainerService_ContainerStreamLogsClient, error) {
	stream, err := c.cc.NewStream(ctx, &ContainerService_ServiceDesc.Streams[0], ContainerService_ContainerStreamLogs_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &containerServiceContainerStreamLogsClient{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 ContainerService_ContainerStreamLogsClient interface {
	Recv() (*ContainerLogEntry, error)
	grpc.ClientStream
}

type containerServiceContainerStreamLogsClient struct {
	grpc.ClientStream
}

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

func (c *containerServiceClient) ContainerArchive(ctx context.Context, in *ContainerArchiveRequest, opts ...grpc.CallOption) (ContainerService_ContainerArchiveClient, error) {
	stream, err := c.cc.NewStream(ctx, &ContainerService_ServiceDesc.Streams[1], ContainerService_ContainerArchive_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &containerServiceContainerArchiveClient{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 ContainerService_ContainerArchiveClient interface {
	Recv() (*ContainerArchiveResponse, error)
	grpc.ClientStream
}

type containerServiceContainerArchiveClient struct {
	grpc.ClientStream
}

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

func (c *containerServiceClient) ContainerCheckpoint(ctx context.Context, in *ContainerCheckpointRequest, opts ...grpc.CallOption) (*ContainerCheckpointResponse, error) {
	out := new(ContainerCheckpointResponse)
	err := c.cc.Invoke(ctx, ContainerService_ContainerCheckpoint_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *containerServiceClient) ContainerSnapshotDisks(ctx context.Context, in *ContainerSnapshotDisksRequest, opts ...grpc.CallOption) (*ContainerSnapshotDisksResponse, error) {
	out := new(ContainerSnapshotDisksResponse)
	err := c.cc.Invoke(ctx, ContainerService_ContainerSnapshotDisks_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

func (c *containerServiceClient) ContainerSandboxExec(ctx context.Context, in *ContainerSandboxExecRequest, opts ...grpc.CallOption) (*ContainerSandboxExecResponse, error) {
	out := new(ContainerSandboxExecResponse)
	err := c.cc.Invoke(ctx, ContainerService_ContainerSandboxExec_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *containerServiceClient) ContainerSandboxStatus(ctx context.Context, in *ContainerSandboxStatusRequest, opts ...grpc.CallOption) (*ContainerSandboxStatusResponse, error) {
	out := new(ContainerSandboxStatusResponse)
	err := c.cc.Invoke(ctx, ContainerService_ContainerSandboxStatus_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *containerServiceClient) ContainerSandboxStdout(ctx context.Context, in *ContainerSandboxStdoutRequest, opts ...grpc.CallOption) (*ContainerSandboxStdoutResponse, error) {
	out := new(ContainerSandboxStdoutResponse)
	err := c.cc.Invoke(ctx, ContainerService_ContainerSandboxStdout_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *containerServiceClient) ContainerSandboxStderr(ctx context.Context, in *ContainerSandboxStderrRequest, opts ...grpc.CallOption) (*ContainerSandboxStderrResponse, error) {
	out := new(ContainerSandboxStderrResponse)
	err := c.cc.Invoke(ctx, ContainerService_ContainerSandboxStderr_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *containerServiceClient) ContainerSandboxKill(ctx context.Context, in *ContainerSandboxKillRequest, opts ...grpc.CallOption) (*ContainerSandboxKillResponse, error) {
	out := new(ContainerSandboxKillResponse)
	err := c.cc.Invoke(ctx, ContainerService_ContainerSandboxKill_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *containerServiceClient) ContainerSandboxListFiles(ctx context.Context, in *ContainerSandboxListFilesRequest, opts ...grpc.CallOption) (*ContainerSandboxListFilesResponse, error) {
	out := new(ContainerSandboxListFilesResponse)
	err := c.cc.Invoke(ctx, ContainerService_ContainerSandboxListFiles_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *containerServiceClient) ContainerSandboxUploadFile(ctx context.Context, in *ContainerSandboxUploadFileRequest, opts ...grpc.CallOption) (*ContainerSandboxUploadFileResponse, error) {
	out := new(ContainerSandboxUploadFileResponse)
	err := c.cc.Invoke(ctx, ContainerService_ContainerSandboxUploadFile_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *containerServiceClient) ContainerSandboxDownloadFile(ctx context.Context, in *ContainerSandboxDownloadFileRequest, opts ...grpc.CallOption) (*ContainerSandboxDownloadFileResponse, error) {
	out := new(ContainerSandboxDownloadFileResponse)
	err := c.cc.Invoke(ctx, ContainerService_ContainerSandboxDownloadFile_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *containerServiceClient) ContainerSandboxStatFile(ctx context.Context, in *ContainerSandboxStatFileRequest, opts ...grpc.CallOption) (*ContainerSandboxStatFileResponse, error) {
	out := new(ContainerSandboxStatFileResponse)
	err := c.cc.Invoke(ctx, ContainerService_ContainerSandboxStatFile_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *containerServiceClient) ContainerSandboxDeleteFile(ctx context.Context, in *ContainerSandboxDeleteFileRequest, opts ...grpc.CallOption) (*ContainerSandboxDeleteFileResponse, error) {
	out := new(ContainerSandboxDeleteFileResponse)
	err := c.cc.Invoke(ctx, ContainerService_ContainerSandboxDeleteFile_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *containerServiceClient) ContainerSandboxCreateDirectory(ctx context.Context, in *ContainerSandboxCreateDirectoryRequest, opts ...grpc.CallOption) (*ContainerSandboxCreateDirectoryResponse, error) {
	out := new(ContainerSandboxCreateDirectoryResponse)
	err := c.cc.Invoke(ctx, ContainerService_ContainerSandboxCreateDirectory_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *containerServiceClient) ContainerSandboxDeleteDirectory(ctx context.Context, in *ContainerSandboxDeleteDirectoryRequest, opts ...grpc.CallOption) (*ContainerSandboxDeleteDirectoryResponse, error) {
	out := new(ContainerSandboxDeleteDirectoryResponse)
	err := c.cc.Invoke(ctx, ContainerService_ContainerSandboxDeleteDirectory_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *containerServiceClient) ContainerSandboxExposePort(ctx context.Context, in *ContainerSandboxExposePortRequest, opts ...grpc.CallOption) (*ContainerSandboxExposePortResponse, error) {
	out := new(ContainerSandboxExposePortResponse)
	err := c.cc.Invoke(ctx, ContainerService_ContainerSandboxExposePort_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *containerServiceClient) ContainerSandboxUpdateNetworkPermissions(ctx context.Context, in *ContainerSandboxUpdateNetworkPermissionsRequest, opts ...grpc.CallOption) (*ContainerSandboxUpdateNetworkPermissionsResponse, error) {
	out := new(ContainerSandboxUpdateNetworkPermissionsResponse)
	err := c.cc.Invoke(ctx, ContainerService_ContainerSandboxUpdateNetworkPermissions_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *containerServiceClient) ContainerSandboxReplaceInFiles(ctx context.Context, in *ContainerSandboxReplaceInFilesRequest, opts ...grpc.CallOption) (*ContainerSandboxReplaceInFilesResponse, error) {
	out := new(ContainerSandboxReplaceInFilesResponse)
	err := c.cc.Invoke(ctx, ContainerService_ContainerSandboxReplaceInFiles_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *containerServiceClient) ContainerSandboxFindInFiles(ctx context.Context, in *ContainerSandboxFindInFilesRequest, opts ...grpc.CallOption) (*ContainerSandboxFindInFilesResponse, error) {
	out := new(ContainerSandboxFindInFilesResponse)
	err := c.cc.Invoke(ctx, ContainerService_ContainerSandboxFindInFiles_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *containerServiceClient) ContainerSandboxListExposedPorts(ctx context.Context, in *ContainerSandboxListExposedPortsRequest, opts ...grpc.CallOption) (*ContainerSandboxListExposedPortsResponse, error) {
	out := new(ContainerSandboxListExposedPortsResponse)
	err := c.cc.Invoke(ctx, ContainerService_ContainerSandboxListExposedPorts_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *containerServiceClient) ContainerSandboxListProcesses(ctx context.Context, in *ContainerSandboxListProcessesRequest, opts ...grpc.CallOption) (*ContainerSandboxListProcessesResponse, error) {
	out := new(ContainerSandboxListProcessesResponse)
	err := c.cc.Invoke(ctx, ContainerService_ContainerSandboxListProcesses_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *containerServiceClient) ContainerTunnel(ctx context.Context, in *ContainerTunnelRequest, opts ...grpc.CallOption) (*ContainerTunnelResponse, error) {
	out := new(ContainerTunnelResponse)
	err := c.cc.Invoke(ctx, ContainerService_ContainerTunnel_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ContainerServiceServer is the server API for ContainerService service.
// All implementations must embed UnimplementedContainerServiceServer
// for forward compatibility
type ContainerServiceServer interface {
	ContainerKill(context.Context, *ContainerKillRequest) (*ContainerKillResponse, error)
	ContainerStatus(context.Context, *ContainerStatusRequest) (*ContainerStatusResponse, error)
	ContainerExec(context.Context, *ContainerExecRequest) (*ContainerExecResponse, error)
	ContainerStreamLogs(*ContainerStreamLogsRequest, ContainerService_ContainerStreamLogsServer) error
	ContainerArchive(*ContainerArchiveRequest, ContainerService_ContainerArchiveServer) error
	ContainerCheckpoint(context.Context, *ContainerCheckpointRequest) (*ContainerCheckpointResponse, error)
	ContainerSnapshotDisks(context.Context, *ContainerSnapshotDisksRequest) (*ContainerSnapshotDisksResponse, error)
	ContainerSyncWorkspace(context.Context, *SyncContainerWorkspaceRequest) (*SyncContainerWorkspaceResponse, error)
	ContainerSandboxExec(context.Context, *ContainerSandboxExecRequest) (*ContainerSandboxExecResponse, error)
	ContainerSandboxStatus(context.Context, *ContainerSandboxStatusRequest) (*ContainerSandboxStatusResponse, error)
	ContainerSandboxStdout(context.Context, *ContainerSandboxStdoutRequest) (*ContainerSandboxStdoutResponse, error)
	ContainerSandboxStderr(context.Context, *ContainerSandboxStderrRequest) (*ContainerSandboxStderrResponse, error)
	ContainerSandboxKill(context.Context, *ContainerSandboxKillRequest) (*ContainerSandboxKillResponse, error)
	ContainerSandboxListFiles(context.Context, *ContainerSandboxListFilesRequest) (*ContainerSandboxListFilesResponse, error)
	ContainerSandboxUploadFile(context.Context, *ContainerSandboxUploadFileRequest) (*ContainerSandboxUploadFileResponse, error)
	ContainerSandboxDownloadFile(context.Context, *ContainerSandboxDownloadFileRequest) (*ContainerSandboxDownloadFileResponse, error)
	ContainerSandboxStatFile(context.Context, *ContainerSandboxStatFileRequest) (*ContainerSandboxStatFileResponse, error)
	ContainerSandboxDeleteFile(context.Context, *ContainerSandboxDeleteFileRequest) (*ContainerSandboxDeleteFileResponse, error)
	ContainerSandboxCreateDirectory(context.Context, *ContainerSandboxCreateDirectoryRequest) (*ContainerSandboxCreateDirectoryResponse, error)
	ContainerSandboxDeleteDirectory(context.Context, *ContainerSandboxDeleteDirectoryRequest) (*ContainerSandboxDeleteDirectoryResponse, error)
	ContainerSandboxExposePort(context.Context, *ContainerSandboxExposePortRequest) (*ContainerSandboxExposePortResponse, error)
	ContainerSandboxUpdateNetworkPermissions(context.Context, *ContainerSandboxUpdateNetworkPermissionsRequest) (*ContainerSandboxUpdateNetworkPermissionsResponse, error)
	ContainerSandboxReplaceInFiles(context.Context, *ContainerSandboxReplaceInFilesRequest) (*ContainerSandboxReplaceInFilesResponse, error)
	ContainerSandboxFindInFiles(context.Context, *ContainerSandboxFindInFilesRequest) (*ContainerSandboxFindInFilesResponse, error)
	ContainerSandboxListExposedPorts(context.Context, *ContainerSandboxListExposedPortsRequest) (*ContainerSandboxListExposedPortsResponse, error)
	ContainerSandboxListProcesses(context.Context, *ContainerSandboxListProcessesRequest) (*ContainerSandboxListProcessesResponse, error)
	ContainerTunnel(context.Context, *ContainerTunnelRequest) (*ContainerTunnelResponse, error)
	mustEmbedUnimplementedContainerServiceServer()
}

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

func (UnimplementedContainerServiceServer) ContainerKill(context.Context, *ContainerKillRequest) (*ContainerKillResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainerKill not implemented")
}
func (UnimplementedContainerServiceServer) ContainerStatus(context.Context, *ContainerStatusRequest) (*ContainerStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainerStatus not implemented")
}
func (UnimplementedContainerServiceServer) ContainerExec(context.Context, *ContainerExecRequest) (*ContainerExecResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainerExec not implemented")
}
func (UnimplementedContainerServiceServer) ContainerStreamLogs(*ContainerStreamLogsRequest, ContainerService_ContainerStreamLogsServer) error {
	return status.Errorf(codes.Unimplemented, "method ContainerStreamLogs not implemented")
}
func (UnimplementedContainerServiceServer) ContainerArchive(*ContainerArchiveRequest, ContainerService_ContainerArchiveServer) error {
	return status.Errorf(codes.Unimplemented, "method ContainerArchive not implemented")
}
func (UnimplementedContainerServiceServer) ContainerCheckpoint(context.Context, *ContainerCheckpointRequest) (*ContainerCheckpointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainerCheckpoint not implemented")
}
func (UnimplementedContainerServiceServer) ContainerSnapshotDisks(context.Context, *ContainerSnapshotDisksRequest) (*ContainerSnapshotDisksResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainerSnapshotDisks not implemented")
}
func (UnimplementedContainerServiceServer) ContainerSyncWorkspace(context.Context, *SyncContainerWorkspaceRequest) (*SyncContainerWorkspaceResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainerSyncWorkspace not implemented")
}
func (UnimplementedContainerServiceServer) ContainerSandboxExec(context.Context, *ContainerSandboxExecRequest) (*ContainerSandboxExecResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainerSandboxExec not implemented")
}
func (UnimplementedContainerServiceServer) ContainerSandboxStatus(context.Context, *ContainerSandboxStatusRequest) (*ContainerSandboxStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainerSandboxStatus not implemented")
}
func (UnimplementedContainerServiceServer) ContainerSandboxStdout(context.Context, *ContainerSandboxStdoutRequest) (*ContainerSandboxStdoutResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainerSandboxStdout not implemented")
}
func (UnimplementedContainerServiceServer) ContainerSandboxStderr(context.Context, *ContainerSandboxStderrRequest) (*ContainerSandboxStderrResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainerSandboxStderr not implemented")
}
func (UnimplementedContainerServiceServer) ContainerSandboxKill(context.Context, *ContainerSandboxKillRequest) (*ContainerSandboxKillResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainerSandboxKill not implemented")
}
func (UnimplementedContainerServiceServer) ContainerSandboxListFiles(context.Context, *ContainerSandboxListFilesRequest) (*ContainerSandboxListFilesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainerSandboxListFiles not implemented")
}
func (UnimplementedContainerServiceServer) ContainerSandboxUploadFile(context.Context, *ContainerSandboxUploadFileRequest) (*ContainerSandboxUploadFileResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainerSandboxUploadFile not implemented")
}
func (UnimplementedContainerServiceServer) ContainerSandboxDownloadFile(context.Context, *ContainerSandboxDownloadFileRequest) (*ContainerSandboxDownloadFileResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainerSandboxDownloadFile not implemented")
}
func (UnimplementedContainerServiceServer) ContainerSandboxStatFile(context.Context, *ContainerSandboxStatFileRequest) (*ContainerSandboxStatFileResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainerSandboxStatFile not implemented")
}
func (UnimplementedContainerServiceServer) ContainerSandboxDeleteFile(context.Context, *ContainerSandboxDeleteFileRequest) (*ContainerSandboxDeleteFileResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainerSandboxDeleteFile not implemented")
}
func (UnimplementedContainerServiceServer) ContainerSandboxCreateDirectory(context.Context, *ContainerSandboxCreateDirectoryRequest) (*ContainerSandboxCreateDirectoryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainerSandboxCreateDirectory not implemented")
}
func (UnimplementedContainerServiceServer) ContainerSandboxDeleteDirectory(context.Context, *ContainerSandboxDeleteDirectoryRequest) (*ContainerSandboxDeleteDirectoryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainerSandboxDeleteDirectory not implemented")
}
func (UnimplementedContainerServiceServer) ContainerSandboxExposePort(context.Context, *ContainerSandboxExposePortRequest) (*ContainerSandboxExposePortResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainerSandboxExposePort not implemented")
}
func (UnimplementedContainerServiceServer) ContainerSandboxUpdateNetworkPermissions(context.Context, *ContainerSandboxUpdateNetworkPermissionsRequest) (*ContainerSandboxUpdateNetworkPermissionsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainerSandboxUpdateNetworkPermissions not implemented")
}
func (UnimplementedContainerServiceServer) ContainerSandboxReplaceInFiles(context.Context, *ContainerSandboxReplaceInFilesRequest) (*ContainerSandboxReplaceInFilesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainerSandboxReplaceInFiles not implemented")
}
func (UnimplementedContainerServiceServer) ContainerSandboxFindInFiles(context.Context, *ContainerSandboxFindInFilesRequest) (*ContainerSandboxFindInFilesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainerSandboxFindInFiles not implemented")
}
func (UnimplementedContainerServiceServer) ContainerSandboxListExposedPorts(context.Context, *ContainerSandboxListExposedPortsRequest) (*ContainerSandboxListExposedPortsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainerSandboxListExposedPorts not implemented")
}
func (UnimplementedContainerServiceServer) ContainerSandboxListProcesses(context.Context, *ContainerSandboxListProcessesRequest) (*ContainerSandboxListProcessesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainerSandboxListProcesses not implemented")
}
func (UnimplementedContainerServiceServer) ContainerTunnel(context.Context, *ContainerTunnelRequest) (*ContainerTunnelResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ContainerTunnel not implemented")
}
func (UnimplementedContainerServiceServer) mustEmbedUnimplementedContainerServiceServer() {}

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

func RegisterContainerServiceServer(s grpc.ServiceRegistrar, srv ContainerServiceServer) {
	s.RegisterService(&ContainerService_ServiceDesc, srv)
}

func _ContainerService_ContainerKill_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContainerKillRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ContainerServiceServer).ContainerKill(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ContainerService_ContainerKill_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ContainerServiceServer).ContainerKill(ctx, req.(*ContainerKillRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ContainerService_ContainerStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContainerStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ContainerServiceServer).ContainerStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ContainerService_ContainerStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ContainerServiceServer).ContainerStatus(ctx, req.(*ContainerStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ContainerService_ContainerExec_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContainerExecRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ContainerServiceServer).ContainerExec(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ContainerService_ContainerExec_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ContainerServiceServer).ContainerExec(ctx, req.(*ContainerExecRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ContainerService_ContainerStreamLogs_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ContainerStreamLogsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ContainerServiceServer).ContainerStreamLogs(m, &containerServiceContainerStreamLogsServer{stream})
}

type ContainerService_ContainerStreamLogsServer interface {
	Send(*ContainerLogEntry) error
	grpc.ServerStream
}

type containerServiceContainerStreamLogsServer struct {
	grpc.ServerStream
}

func (x *containerServiceContainerStreamLogsServer) Send(m *ContainerLogEntry) error {
	return x.ServerStream.SendMsg(m)
}

func _ContainerService_ContainerArchive_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ContainerArchiveRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ContainerServiceServer).ContainerArchive(m, &containerServiceContainerArchiveServer{stream})
}

type ContainerService_ContainerArchiveServer interface {
	Send(*ContainerArchiveResponse) error
	grpc.ServerStream
}

type containerServiceContainerArchiveServer struct {
	grpc.ServerStream
}

func (x *containerServiceContainerArchiveServer) Send(m *ContainerArchiveResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _ContainerService_ContainerCheckpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContainerCheckpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ContainerServiceServer).ContainerCheckpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ContainerService_ContainerCheckpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ContainerServiceServer).ContainerCheckpoint(ctx, req.(*ContainerCheckpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ContainerService_ContainerSnapshotDisks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContainerSnapshotDisksRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ContainerServiceServer).ContainerSnapshotDisks(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ContainerService_ContainerSnapshotDisks_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ContainerServiceServer).ContainerSnapshotDisks(ctx, req.(*ContainerSnapshotDisksRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ContainerService_ContainerSyncWorkspace_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.(ContainerServiceServer).ContainerSyncWorkspace(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ContainerService_ContainerSyncWorkspace_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ContainerServiceServer).ContainerSyncWorkspace(ctx, req.(*SyncContainerWorkspaceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ContainerService_ContainerSandboxExec_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContainerSandboxExecRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ContainerServiceServer).ContainerSandboxExec(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ContainerService_ContainerSandboxExec_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ContainerServiceServer).ContainerSandboxExec(ctx, req.(*ContainerSandboxExecRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ContainerService_ContainerSandboxStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContainerSandboxStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ContainerServiceServer).ContainerSandboxStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ContainerService_ContainerSandboxStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ContainerServiceServer).ContainerSandboxStatus(ctx, req.(*ContainerSandboxStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ContainerService_ContainerSandboxStdout_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContainerSandboxStdoutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ContainerServiceServer).ContainerSandboxStdout(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ContainerService_ContainerSandboxStdout_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ContainerServiceServer).ContainerSandboxStdout(ctx, req.(*ContainerSandboxStdoutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ContainerService_ContainerSandboxStderr_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContainerSandboxStderrRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ContainerServiceServer).ContainerSandboxStderr(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ContainerService_ContainerSandboxStderr_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ContainerServiceServer).ContainerSandboxStderr(ctx, req.(*ContainerSandboxStderrRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ContainerService_ContainerSandboxKill_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContainerSandboxKillRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ContainerServiceServer).ContainerSandboxKill(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ContainerService_ContainerSandboxKill_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ContainerServiceServer).ContainerSandboxKill(ctx, req.(*ContainerSandboxKillRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ContainerService_ContainerSandboxListFiles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContainerSandboxListFilesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ContainerServiceServer).ContainerSandboxListFiles(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ContainerService_ContainerSandboxListFiles_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ContainerServiceServer).ContainerSandboxListFiles(ctx, req.(*ContainerSandboxListFilesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ContainerService_ContainerSandboxUploadFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContainerSandboxUploadFileRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ContainerServiceServer).ContainerSandboxUploadFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ContainerService_ContainerSandboxUploadFile_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ContainerServiceServer).ContainerSandboxUploadFile(ctx, req.(*ContainerSandboxUploadFileRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ContainerService_ContainerSandboxDownloadFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContainerSandboxDownloadFileRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ContainerServiceServer).ContainerSandboxDownloadFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ContainerService_ContainerSandboxDownloadFile_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ContainerServiceServer).ContainerSandboxDownloadFile(ctx, req.(*ContainerSandboxDownloadFileRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ContainerService_ContainerSandboxStatFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContainerSandboxStatFileRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ContainerServiceServer).ContainerSandboxStatFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ContainerService_ContainerSandboxStatFile_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ContainerServiceServer).ContainerSandboxStatFile(ctx, req.(*ContainerSandboxStatFileRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ContainerService_ContainerSandboxDeleteFile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContainerSandboxDeleteFileRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ContainerServiceServer).ContainerSandboxDeleteFile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ContainerService_ContainerSandboxDeleteFile_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ContainerServiceServer).ContainerSandboxDeleteFile(ctx, req.(*ContainerSandboxDeleteFileRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ContainerService_ContainerSandboxCreateDirectory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContainerSandboxCreateDirectoryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ContainerServiceServer).ContainerSandboxCreateDirectory(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ContainerService_ContainerSandboxCreateDirectory_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ContainerServiceServer).ContainerSandboxCreateDirectory(ctx, req.(*ContainerSandboxCreateDirectoryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ContainerService_ContainerSandboxDeleteDirectory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContainerSandboxDeleteDirectoryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ContainerServiceServer).ContainerSandboxDeleteDirectory(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ContainerService_ContainerSandboxDeleteDirectory_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ContainerServiceServer).ContainerSandboxDeleteDirectory(ctx, req.(*ContainerSandboxDeleteDirectoryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ContainerService_ContainerSandboxExposePort_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContainerSandboxExposePortRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ContainerServiceServer).ContainerSandboxExposePort(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ContainerService_ContainerSandboxExposePort_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ContainerServiceServer).ContainerSandboxExposePort(ctx, req.(*ContainerSandboxExposePortRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ContainerService_ContainerSandboxUpdateNetworkPermissions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContainerSandboxUpdateNetworkPermissionsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ContainerServiceServer).ContainerSandboxUpdateNetworkPermissions(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ContainerService_ContainerSandboxUpdateNetworkPermissions_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ContainerServiceServer).ContainerSandboxUpdateNetworkPermissions(ctx, req.(*ContainerSandboxUpdateNetworkPermissionsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ContainerService_ContainerSandboxReplaceInFiles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContainerSandboxReplaceInFilesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ContainerServiceServer).ContainerSandboxReplaceInFiles(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ContainerService_ContainerSandboxReplaceInFiles_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ContainerServiceServer).ContainerSandboxReplaceInFiles(ctx, req.(*ContainerSandboxReplaceInFilesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ContainerService_ContainerSandboxFindInFiles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContainerSandboxFindInFilesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ContainerServiceServer).ContainerSandboxFindInFiles(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ContainerService_ContainerSandboxFindInFiles_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ContainerServiceServer).ContainerSandboxFindInFiles(ctx, req.(*ContainerSandboxFindInFilesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ContainerService_ContainerSandboxListExposedPorts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContainerSandboxListExposedPortsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ContainerServiceServer).ContainerSandboxListExposedPorts(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ContainerService_ContainerSandboxListExposedPorts_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ContainerServiceServer).ContainerSandboxListExposedPorts(ctx, req.(*ContainerSandboxListExposedPortsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ContainerService_ContainerSandboxListProcesses_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContainerSandboxListProcessesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ContainerServiceServer).ContainerSandboxListProcesses(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ContainerService_ContainerSandboxListProcesses_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ContainerServiceServer).ContainerSandboxListProcesses(ctx, req.(*ContainerSandboxListProcessesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ContainerService_ContainerTunnel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ContainerTunnelRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ContainerServiceServer).ContainerTunnel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ContainerService_ContainerTunnel_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ContainerServiceServer).ContainerTunnel(ctx, req.(*ContainerTunnelRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// ContainerService_ServiceDesc is the grpc.ServiceDesc for ContainerService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ContainerService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "container.ContainerService",
	HandlerType: (*ContainerServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ContainerKill",
			Handler:    _ContainerService_ContainerKill_Handler,
		},
		{
			MethodName: "ContainerStatus",
			Handler:    _ContainerService_ContainerStatus_Handler,
		},
		{
			MethodName: "ContainerExec",
			Handler:    _ContainerService_ContainerExec_Handler,
		},
		{
			MethodName: "ContainerCheckpoint",
			Handler:    _ContainerService_ContainerCheckpoint_Handler,
		},
		{
			MethodName: "ContainerSnapshotDisks",
			Handler:    _ContainerService_ContainerSnapshotDisks_Handler,
		},
		{
			MethodName: "ContainerSyncWorkspace",
			Handler:    _ContainerService_ContainerSyncWorkspace_Handler,
		},
		{
			MethodName: "ContainerSandboxExec",
			Handler:    _ContainerService_ContainerSandboxExec_Handler,
		},
		{
			MethodName: "ContainerSandboxStatus",
			Handler:    _ContainerService_ContainerSandboxStatus_Handler,
		},
		{
			MethodName: "ContainerSandboxStdout",
			Handler:    _ContainerService_ContainerSandboxStdout_Handler,
		},
		{
			MethodName: "ContainerSandboxStderr",
			Handler:    _ContainerService_ContainerSandboxStderr_Handler,
		},
		{
			MethodName: "ContainerSandboxKill",
			Handler:    _ContainerService_ContainerSandboxKill_Handler,
		},
		{
			MethodName: "ContainerSandboxListFiles",
			Handler:    _ContainerService_ContainerSandboxListFiles_Handler,
		},
		{
			MethodName: "ContainerSandboxUploadFile",
			Handler:    _ContainerService_ContainerSandboxUploadFile_Handler,
		},
		{
			MethodName: "ContainerSandboxDownloadFile",
			Handler:    _ContainerService_ContainerSandboxDownloadFile_Handler,
		},
		{
			MethodName: "ContainerSandboxStatFile",
			Handler:    _ContainerService_ContainerSandboxStatFile_Handler,
		},
		{
			MethodName: "ContainerSandboxDeleteFile",
			Handler:    _ContainerService_ContainerSandboxDeleteFile_Handler,
		},
		{
			MethodName: "ContainerSandboxCreateDirectory",
			Handler:    _ContainerService_ContainerSandboxCreateDirectory_Handler,
		},
		{
			MethodName: "ContainerSandboxDeleteDirectory",
			Handler:    _ContainerService_ContainerSandboxDeleteDirectory_Handler,
		},
		{
			MethodName: "ContainerSandboxExposePort",
			Handler:    _ContainerService_ContainerSandboxExposePort_Handler,
		},
		{
			MethodName: "ContainerSandboxUpdateNetworkPermissions",
			Handler:    _ContainerService_ContainerSandboxUpdateNetworkPermissions_Handler,
		},
		{
			MethodName: "ContainerSandboxReplaceInFiles",
			Handler:    _ContainerService_ContainerSandboxReplaceInFiles_Handler,
		},
		{
			MethodName: "ContainerSandboxFindInFiles",
			Handler:    _ContainerService_ContainerSandboxFindInFiles_Handler,
		},
		{
			MethodName: "ContainerSandboxListExposedPorts",
			Handler:    _ContainerService_ContainerSandboxListExposedPorts_Handler,
		},
		{
			MethodName: "ContainerSandboxListProcesses",
			Handler:    _ContainerService_ContainerSandboxListProcesses_Handler,
		},
		{
			MethodName: "ContainerTunnel",
			Handler:    _ContainerService_ContainerTunnel_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ContainerStreamLogs",
			Handler:       _ContainerService_ContainerStreamLogs_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ContainerArchive",
			Handler:       _ContainerService_ContainerArchive_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "worker.proto",
}