# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
"""Client and server classes corresponding to protobuf-defined services."""
import grpc
import warnings

from cline_core.proto.cline import common_pb2 as cline_dot_common__pb2
from cline_core.proto.cline import file_pb2 as cline_dot_file__pb2

GRPC_GENERATED_VERSION = '1.76.0'
GRPC_VERSION = grpc.__version__
_version_not_supported = False

try:
    from grpc._utilities import first_version_is_lower
    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
except ImportError:
    _version_not_supported = True

if _version_not_supported:
    raise RuntimeError(
        f'The grpc package installed is at version {GRPC_VERSION},'
        + ' but the generated code in cline/file_pb2_grpc.py depends on'
        + f' grpcio>={GRPC_GENERATED_VERSION}.'
        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
    )


class FileServiceStub(object):
    """Service for file-related operations
    """

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.copyToClipboard = channel.unary_unary(
                '/cline.FileService/copyToClipboard',
                request_serializer=cline_dot_common__pb2.StringRequest.SerializeToString,
                response_deserializer=cline_dot_common__pb2.Empty.FromString,
                _registered_method=True)
        self.openFile = channel.unary_unary(
                '/cline.FileService/openFile',
                request_serializer=cline_dot_common__pb2.StringRequest.SerializeToString,
                response_deserializer=cline_dot_common__pb2.Empty.FromString,
                _registered_method=True)
        self.openImage = channel.unary_unary(
                '/cline.FileService/openImage',
                request_serializer=cline_dot_common__pb2.StringRequest.SerializeToString,
                response_deserializer=cline_dot_common__pb2.Empty.FromString,
                _registered_method=True)
        self.openMention = channel.unary_unary(
                '/cline.FileService/openMention',
                request_serializer=cline_dot_common__pb2.StringRequest.SerializeToString,
                response_deserializer=cline_dot_common__pb2.Empty.FromString,
                _registered_method=True)
        self.deleteRuleFile = channel.unary_unary(
                '/cline.FileService/deleteRuleFile',
                request_serializer=cline_dot_file__pb2.RuleFileRequest.SerializeToString,
                response_deserializer=cline_dot_file__pb2.RuleFile.FromString,
                _registered_method=True)
        self.createRuleFile = channel.unary_unary(
                '/cline.FileService/createRuleFile',
                request_serializer=cline_dot_file__pb2.RuleFileRequest.SerializeToString,
                response_deserializer=cline_dot_file__pb2.RuleFile.FromString,
                _registered_method=True)
        self.searchCommits = channel.unary_unary(
                '/cline.FileService/searchCommits',
                request_serializer=cline_dot_common__pb2.StringRequest.SerializeToString,
                response_deserializer=cline_dot_file__pb2.GitCommits.FromString,
                _registered_method=True)
        self.selectFiles = channel.unary_unary(
                '/cline.FileService/selectFiles',
                request_serializer=cline_dot_common__pb2.BooleanRequest.SerializeToString,
                response_deserializer=cline_dot_common__pb2.StringArrays.FromString,
                _registered_method=True)
        self.getRelativePaths = channel.unary_unary(
                '/cline.FileService/getRelativePaths',
                request_serializer=cline_dot_file__pb2.RelativePathsRequest.SerializeToString,
                response_deserializer=cline_dot_file__pb2.RelativePaths.FromString,
                _registered_method=True)
        self.searchFiles = channel.unary_unary(
                '/cline.FileService/searchFiles',
                request_serializer=cline_dot_file__pb2.FileSearchRequest.SerializeToString,
                response_deserializer=cline_dot_file__pb2.FileSearchResults.FromString,
                _registered_method=True)
        self.toggleClineRule = channel.unary_unary(
                '/cline.FileService/toggleClineRule',
                request_serializer=cline_dot_file__pb2.ToggleClineRuleRequest.SerializeToString,
                response_deserializer=cline_dot_file__pb2.ToggleClineRules.FromString,
                _registered_method=True)
        self.toggleCursorRule = channel.unary_unary(
                '/cline.FileService/toggleCursorRule',
                request_serializer=cline_dot_file__pb2.ToggleCursorRuleRequest.SerializeToString,
                response_deserializer=cline_dot_file__pb2.ClineRulesToggles.FromString,
                _registered_method=True)
        self.toggleWindsurfRule = channel.unary_unary(
                '/cline.FileService/toggleWindsurfRule',
                request_serializer=cline_dot_file__pb2.ToggleWindsurfRuleRequest.SerializeToString,
                response_deserializer=cline_dot_file__pb2.ClineRulesToggles.FromString,
                _registered_method=True)
        self.refreshRules = channel.unary_unary(
                '/cline.FileService/refreshRules',
                request_serializer=cline_dot_common__pb2.EmptyRequest.SerializeToString,
                response_deserializer=cline_dot_file__pb2.RefreshedRules.FromString,
                _registered_method=True)
        self.openDiskConversationHistory = channel.unary_unary(
                '/cline.FileService/openDiskConversationHistory',
                request_serializer=cline_dot_common__pb2.StringRequest.SerializeToString,
                response_deserializer=cline_dot_common__pb2.Empty.FromString,
                _registered_method=True)
        self.toggleWorkflow = channel.unary_unary(
                '/cline.FileService/toggleWorkflow',
                request_serializer=cline_dot_file__pb2.ToggleWorkflowRequest.SerializeToString,
                response_deserializer=cline_dot_file__pb2.ClineRulesToggles.FromString,
                _registered_method=True)
        self.ifFileExistsRelativePath = channel.unary_unary(
                '/cline.FileService/ifFileExistsRelativePath',
                request_serializer=cline_dot_common__pb2.StringRequest.SerializeToString,
                response_deserializer=cline_dot_common__pb2.BooleanResponse.FromString,
                _registered_method=True)
        self.openFileRelativePath = channel.unary_unary(
                '/cline.FileService/openFileRelativePath',
                request_serializer=cline_dot_common__pb2.StringRequest.SerializeToString,
                response_deserializer=cline_dot_common__pb2.Empty.FromString,
                _registered_method=True)
        self.openFocusChainFile = channel.unary_unary(
                '/cline.FileService/openFocusChainFile',
                request_serializer=cline_dot_common__pb2.StringRequest.SerializeToString,
                response_deserializer=cline_dot_common__pb2.Empty.FromString,
                _registered_method=True)


class FileServiceServicer(object):
    """Service for file-related operations
    """

    def copyToClipboard(self, request, context):
        """Copies text to clipboard
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def openFile(self, request, context):
        """Opens a file in the editor
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def openImage(self, request, context):
        """Opens an image in the system viewer
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def openMention(self, request, context):
        """Opens a mention (file, path, git commit, problem, terminal, or URL)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def deleteRuleFile(self, request, context):
        """Deletes a rule file from either global or workspace rules directory
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def createRuleFile(self, request, context):
        """Creates a rule file from either global or workspace rules directory
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def searchCommits(self, request, context):
        """Search git commits in the workspace
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def selectFiles(self, request, context):
        """Select images and other files from the file system and returns as data URLs & paths respectively
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def getRelativePaths(self, request, context):
        """Convert URIs to workspace-relative paths
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def searchFiles(self, request, context):
        """Search for files in the workspace with fuzzy matching
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def toggleClineRule(self, request, context):
        """Toggle a Cline rule (enable or disable)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def toggleCursorRule(self, request, context):
        """Toggle a Cursor rule (enable or disable)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def toggleWindsurfRule(self, request, context):
        """Toggle a Windsurf rule (enable or disable)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def refreshRules(self, request, context):
        """Refreshes all rule toggles (Cline, External, and Workflows)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def openDiskConversationHistory(self, request, context):
        """Opens a task's conversation history file on disk
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def toggleWorkflow(self, request, context):
        """Toggles a workflow on or off
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ifFileExistsRelativePath(self, request, context):
        """Check if file exists in the project
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def openFileRelativePath(self, request, context):
        """Open a file in editor by a relative path
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def openFocusChainFile(self, request, context):
        """Opens or creates a focus chain checklist markdown file for editing
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_FileServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'copyToClipboard': grpc.unary_unary_rpc_method_handler(
                    servicer.copyToClipboard,
                    request_deserializer=cline_dot_common__pb2.StringRequest.FromString,
                    response_serializer=cline_dot_common__pb2.Empty.SerializeToString,
            ),
            'openFile': grpc.unary_unary_rpc_method_handler(
                    servicer.openFile,
                    request_deserializer=cline_dot_common__pb2.StringRequest.FromString,
                    response_serializer=cline_dot_common__pb2.Empty.SerializeToString,
            ),
            'openImage': grpc.unary_unary_rpc_method_handler(
                    servicer.openImage,
                    request_deserializer=cline_dot_common__pb2.StringRequest.FromString,
                    response_serializer=cline_dot_common__pb2.Empty.SerializeToString,
            ),
            'openMention': grpc.unary_unary_rpc_method_handler(
                    servicer.openMention,
                    request_deserializer=cline_dot_common__pb2.StringRequest.FromString,
                    response_serializer=cline_dot_common__pb2.Empty.SerializeToString,
            ),
            'deleteRuleFile': grpc.unary_unary_rpc_method_handler(
                    servicer.deleteRuleFile,
                    request_deserializer=cline_dot_file__pb2.RuleFileRequest.FromString,
                    response_serializer=cline_dot_file__pb2.RuleFile.SerializeToString,
            ),
            'createRuleFile': grpc.unary_unary_rpc_method_handler(
                    servicer.createRuleFile,
                    request_deserializer=cline_dot_file__pb2.RuleFileRequest.FromString,
                    response_serializer=cline_dot_file__pb2.RuleFile.SerializeToString,
            ),
            'searchCommits': grpc.unary_unary_rpc_method_handler(
                    servicer.searchCommits,
                    request_deserializer=cline_dot_common__pb2.StringRequest.FromString,
                    response_serializer=cline_dot_file__pb2.GitCommits.SerializeToString,
            ),
            'selectFiles': grpc.unary_unary_rpc_method_handler(
                    servicer.selectFiles,
                    request_deserializer=cline_dot_common__pb2.BooleanRequest.FromString,
                    response_serializer=cline_dot_common__pb2.StringArrays.SerializeToString,
            ),
            'getRelativePaths': grpc.unary_unary_rpc_method_handler(
                    servicer.getRelativePaths,
                    request_deserializer=cline_dot_file__pb2.RelativePathsRequest.FromString,
                    response_serializer=cline_dot_file__pb2.RelativePaths.SerializeToString,
            ),
            'searchFiles': grpc.unary_unary_rpc_method_handler(
                    servicer.searchFiles,
                    request_deserializer=cline_dot_file__pb2.FileSearchRequest.FromString,
                    response_serializer=cline_dot_file__pb2.FileSearchResults.SerializeToString,
            ),
            'toggleClineRule': grpc.unary_unary_rpc_method_handler(
                    servicer.toggleClineRule,
                    request_deserializer=cline_dot_file__pb2.ToggleClineRuleRequest.FromString,
                    response_serializer=cline_dot_file__pb2.ToggleClineRules.SerializeToString,
            ),
            'toggleCursorRule': grpc.unary_unary_rpc_method_handler(
                    servicer.toggleCursorRule,
                    request_deserializer=cline_dot_file__pb2.ToggleCursorRuleRequest.FromString,
                    response_serializer=cline_dot_file__pb2.ClineRulesToggles.SerializeToString,
            ),
            'toggleWindsurfRule': grpc.unary_unary_rpc_method_handler(
                    servicer.toggleWindsurfRule,
                    request_deserializer=cline_dot_file__pb2.ToggleWindsurfRuleRequest.FromString,
                    response_serializer=cline_dot_file__pb2.ClineRulesToggles.SerializeToString,
            ),
            'refreshRules': grpc.unary_unary_rpc_method_handler(
                    servicer.refreshRules,
                    request_deserializer=cline_dot_common__pb2.EmptyRequest.FromString,
                    response_serializer=cline_dot_file__pb2.RefreshedRules.SerializeToString,
            ),
            'openDiskConversationHistory': grpc.unary_unary_rpc_method_handler(
                    servicer.openDiskConversationHistory,
                    request_deserializer=cline_dot_common__pb2.StringRequest.FromString,
                    response_serializer=cline_dot_common__pb2.Empty.SerializeToString,
            ),
            'toggleWorkflow': grpc.unary_unary_rpc_method_handler(
                    servicer.toggleWorkflow,
                    request_deserializer=cline_dot_file__pb2.ToggleWorkflowRequest.FromString,
                    response_serializer=cline_dot_file__pb2.ClineRulesToggles.SerializeToString,
            ),
            'ifFileExistsRelativePath': grpc.unary_unary_rpc_method_handler(
                    servicer.ifFileExistsRelativePath,
                    request_deserializer=cline_dot_common__pb2.StringRequest.FromString,
                    response_serializer=cline_dot_common__pb2.BooleanResponse.SerializeToString,
            ),
            'openFileRelativePath': grpc.unary_unary_rpc_method_handler(
                    servicer.openFileRelativePath,
                    request_deserializer=cline_dot_common__pb2.StringRequest.FromString,
                    response_serializer=cline_dot_common__pb2.Empty.SerializeToString,
            ),
            'openFocusChainFile': grpc.unary_unary_rpc_method_handler(
                    servicer.openFocusChainFile,
                    request_deserializer=cline_dot_common__pb2.StringRequest.FromString,
                    response_serializer=cline_dot_common__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'cline.FileService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('cline.FileService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class FileService(object):
    """Service for file-related operations
    """

    @staticmethod
    def copyToClipboard(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/cline.FileService/copyToClipboard',
            cline_dot_common__pb2.StringRequest.SerializeToString,
            cline_dot_common__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def openFile(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/cline.FileService/openFile',
            cline_dot_common__pb2.StringRequest.SerializeToString,
            cline_dot_common__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def openImage(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/cline.FileService/openImage',
            cline_dot_common__pb2.StringRequest.SerializeToString,
            cline_dot_common__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def openMention(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/cline.FileService/openMention',
            cline_dot_common__pb2.StringRequest.SerializeToString,
            cline_dot_common__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def deleteRuleFile(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/cline.FileService/deleteRuleFile',
            cline_dot_file__pb2.RuleFileRequest.SerializeToString,
            cline_dot_file__pb2.RuleFile.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def createRuleFile(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/cline.FileService/createRuleFile',
            cline_dot_file__pb2.RuleFileRequest.SerializeToString,
            cline_dot_file__pb2.RuleFile.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def searchCommits(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/cline.FileService/searchCommits',
            cline_dot_common__pb2.StringRequest.SerializeToString,
            cline_dot_file__pb2.GitCommits.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def selectFiles(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/cline.FileService/selectFiles',
            cline_dot_common__pb2.BooleanRequest.SerializeToString,
            cline_dot_common__pb2.StringArrays.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def getRelativePaths(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/cline.FileService/getRelativePaths',
            cline_dot_file__pb2.RelativePathsRequest.SerializeToString,
            cline_dot_file__pb2.RelativePaths.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def searchFiles(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/cline.FileService/searchFiles',
            cline_dot_file__pb2.FileSearchRequest.SerializeToString,
            cline_dot_file__pb2.FileSearchResults.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def toggleClineRule(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/cline.FileService/toggleClineRule',
            cline_dot_file__pb2.ToggleClineRuleRequest.SerializeToString,
            cline_dot_file__pb2.ToggleClineRules.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def toggleCursorRule(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/cline.FileService/toggleCursorRule',
            cline_dot_file__pb2.ToggleCursorRuleRequest.SerializeToString,
            cline_dot_file__pb2.ClineRulesToggles.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def toggleWindsurfRule(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/cline.FileService/toggleWindsurfRule',
            cline_dot_file__pb2.ToggleWindsurfRuleRequest.SerializeToString,
            cline_dot_file__pb2.ClineRulesToggles.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def refreshRules(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/cline.FileService/refreshRules',
            cline_dot_common__pb2.EmptyRequest.SerializeToString,
            cline_dot_file__pb2.RefreshedRules.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def openDiskConversationHistory(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/cline.FileService/openDiskConversationHistory',
            cline_dot_common__pb2.StringRequest.SerializeToString,
            cline_dot_common__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def toggleWorkflow(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/cline.FileService/toggleWorkflow',
            cline_dot_file__pb2.ToggleWorkflowRequest.SerializeToString,
            cline_dot_file__pb2.ClineRulesToggles.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ifFileExistsRelativePath(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/cline.FileService/ifFileExistsRelativePath',
            cline_dot_common__pb2.StringRequest.SerializeToString,
            cline_dot_common__pb2.BooleanResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def openFileRelativePath(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/cline.FileService/openFileRelativePath',
            cline_dot_common__pb2.StringRequest.SerializeToString,
            cline_dot_common__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def openFocusChainFile(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/cline.FileService/openFocusChainFile',
            cline_dot_common__pb2.StringRequest.SerializeToString,
            cline_dot_common__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
