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

import agentsd_pb2 as agentsd__pb2

GRPC_GENERATED_VERSION = '1.81.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 agentsd_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 DisplayStub:
    """========== Display ==========
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Text = channel.unary_unary(
                '/agentsd.Display/Text',
                request_serializer=agentsd__pb2.DisplayTextRequest.SerializeToString,
                response_deserializer=agentsd__pb2.DisplayResponse.FromString,
                _registered_method=True)
        self.Rich = channel.unary_unary(
                '/agentsd.Display/Rich',
                request_serializer=agentsd__pb2.DisplayRichRequest.SerializeToString,
                response_deserializer=agentsd__pb2.DisplayResponse.FromString,
                _registered_method=True)
        self.Image = channel.unary_unary(
                '/agentsd.Display/Image',
                request_serializer=agentsd__pb2.DisplayImageRequest.SerializeToString,
                response_deserializer=agentsd__pb2.DisplayResponse.FromString,
                _registered_method=True)
        self.Clear = channel.unary_unary(
                '/agentsd.Display/Clear',
                request_serializer=agentsd__pb2.Empty.SerializeToString,
                response_deserializer=agentsd__pb2.DisplayResponse.FromString,
                _registered_method=True)
        self.Notify = channel.unary_unary(
                '/agentsd.Display/Notify',
                request_serializer=agentsd__pb2.DisplayNotifyRequest.SerializeToString,
                response_deserializer=agentsd__pb2.DisplayResponse.FromString,
                _registered_method=True)


class DisplayServicer:
    """========== Display ==========
    """

    def Text(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Rich(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Image(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Clear(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Notify(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_DisplayServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Text': grpc.unary_unary_rpc_method_handler(
                    servicer.Text,
                    request_deserializer=agentsd__pb2.DisplayTextRequest.FromString,
                    response_serializer=agentsd__pb2.DisplayResponse.SerializeToString,
            ),
            'Rich': grpc.unary_unary_rpc_method_handler(
                    servicer.Rich,
                    request_deserializer=agentsd__pb2.DisplayRichRequest.FromString,
                    response_serializer=agentsd__pb2.DisplayResponse.SerializeToString,
            ),
            'Image': grpc.unary_unary_rpc_method_handler(
                    servicer.Image,
                    request_deserializer=agentsd__pb2.DisplayImageRequest.FromString,
                    response_serializer=agentsd__pb2.DisplayResponse.SerializeToString,
            ),
            'Clear': grpc.unary_unary_rpc_method_handler(
                    servicer.Clear,
                    request_deserializer=agentsd__pb2.Empty.FromString,
                    response_serializer=agentsd__pb2.DisplayResponse.SerializeToString,
            ),
            'Notify': grpc.unary_unary_rpc_method_handler(
                    servicer.Notify,
                    request_deserializer=agentsd__pb2.DisplayNotifyRequest.FromString,
                    response_serializer=agentsd__pb2.DisplayResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'agentsd.Display', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('agentsd.Display', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class Display:
    """========== Display ==========
    """

    @staticmethod
    def Text(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,
            '/agentsd.Display/Text',
            agentsd__pb2.DisplayTextRequest.SerializeToString,
            agentsd__pb2.DisplayResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Rich(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,
            '/agentsd.Display/Rich',
            agentsd__pb2.DisplayRichRequest.SerializeToString,
            agentsd__pb2.DisplayResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Image(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,
            '/agentsd.Display/Image',
            agentsd__pb2.DisplayImageRequest.SerializeToString,
            agentsd__pb2.DisplayResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Clear(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,
            '/agentsd.Display/Clear',
            agentsd__pb2.Empty.SerializeToString,
            agentsd__pb2.DisplayResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Notify(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,
            '/agentsd.Display/Notify',
            agentsd__pb2.DisplayNotifyRequest.SerializeToString,
            agentsd__pb2.DisplayResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class AudioStub:
    """========== Audio ==========
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Play = channel.stream_unary(
                '/agentsd.Audio/Play',
                request_serializer=agentsd__pb2.AudioChunk.SerializeToString,
                response_deserializer=agentsd__pb2.AudioResponse.FromString,
                _registered_method=True)
        self.Stop = channel.unary_unary(
                '/agentsd.Audio/Stop',
                request_serializer=agentsd__pb2.Empty.SerializeToString,
                response_deserializer=agentsd__pb2.AudioResponse.FromString,
                _registered_method=True)
        self.Volume = channel.unary_unary(
                '/agentsd.Audio/Volume',
                request_serializer=agentsd__pb2.VolumeRequest.SerializeToString,
                response_deserializer=agentsd__pb2.AudioResponse.FromString,
                _registered_method=True)
        self.RecordStart = channel.unary_unary(
                '/agentsd.Audio/RecordStart',
                request_serializer=agentsd__pb2.RecordStartRequest.SerializeToString,
                response_deserializer=agentsd__pb2.AudioResponse.FromString,
                _registered_method=True)
        self.RecordStop = channel.unary_unary(
                '/agentsd.Audio/RecordStop',
                request_serializer=agentsd__pb2.Empty.SerializeToString,
                response_deserializer=agentsd__pb2.AudioData.FromString,
                _registered_method=True)
        self.RecordStream = channel.unary_stream(
                '/agentsd.Audio/RecordStream',
                request_serializer=agentsd__pb2.RecordStartRequest.SerializeToString,
                response_deserializer=agentsd__pb2.AudioChunk.FromString,
                _registered_method=True)


class AudioServicer:
    """========== Audio ==========
    """

    def Play(self, request_iterator, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Stop(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Volume(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RecordStart(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RecordStop(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RecordStream(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_AudioServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Play': grpc.stream_unary_rpc_method_handler(
                    servicer.Play,
                    request_deserializer=agentsd__pb2.AudioChunk.FromString,
                    response_serializer=agentsd__pb2.AudioResponse.SerializeToString,
            ),
            'Stop': grpc.unary_unary_rpc_method_handler(
                    servicer.Stop,
                    request_deserializer=agentsd__pb2.Empty.FromString,
                    response_serializer=agentsd__pb2.AudioResponse.SerializeToString,
            ),
            'Volume': grpc.unary_unary_rpc_method_handler(
                    servicer.Volume,
                    request_deserializer=agentsd__pb2.VolumeRequest.FromString,
                    response_serializer=agentsd__pb2.AudioResponse.SerializeToString,
            ),
            'RecordStart': grpc.unary_unary_rpc_method_handler(
                    servicer.RecordStart,
                    request_deserializer=agentsd__pb2.RecordStartRequest.FromString,
                    response_serializer=agentsd__pb2.AudioResponse.SerializeToString,
            ),
            'RecordStop': grpc.unary_unary_rpc_method_handler(
                    servicer.RecordStop,
                    request_deserializer=agentsd__pb2.Empty.FromString,
                    response_serializer=agentsd__pb2.AudioData.SerializeToString,
            ),
            'RecordStream': grpc.unary_stream_rpc_method_handler(
                    servicer.RecordStream,
                    request_deserializer=agentsd__pb2.RecordStartRequest.FromString,
                    response_serializer=agentsd__pb2.AudioChunk.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'agentsd.Audio', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('agentsd.Audio', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class Audio:
    """========== Audio ==========
    """

    @staticmethod
    def Play(request_iterator,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.stream_unary(
            request_iterator,
            target,
            '/agentsd.Audio/Play',
            agentsd__pb2.AudioChunk.SerializeToString,
            agentsd__pb2.AudioResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Stop(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,
            '/agentsd.Audio/Stop',
            agentsd__pb2.Empty.SerializeToString,
            agentsd__pb2.AudioResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Volume(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,
            '/agentsd.Audio/Volume',
            agentsd__pb2.VolumeRequest.SerializeToString,
            agentsd__pb2.AudioResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RecordStart(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,
            '/agentsd.Audio/RecordStart',
            agentsd__pb2.RecordStartRequest.SerializeToString,
            agentsd__pb2.AudioResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RecordStop(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,
            '/agentsd.Audio/RecordStop',
            agentsd__pb2.Empty.SerializeToString,
            agentsd__pb2.AudioData.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RecordStream(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_stream(
            request,
            target,
            '/agentsd.Audio/RecordStream',
            agentsd__pb2.RecordStartRequest.SerializeToString,
            agentsd__pb2.AudioChunk.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class FSStub:
    """========== FS ==========
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Read = channel.unary_unary(
                '/agentsd.FS/Read',
                request_serializer=agentsd__pb2.FsReadRequest.SerializeToString,
                response_deserializer=agentsd__pb2.FsReadResponse.FromString,
                _registered_method=True)
        self.Write = channel.unary_unary(
                '/agentsd.FS/Write',
                request_serializer=agentsd__pb2.FsWriteRequest.SerializeToString,
                response_deserializer=agentsd__pb2.FsResponse.FromString,
                _registered_method=True)
        self.Delete = channel.unary_unary(
                '/agentsd.FS/Delete',
                request_serializer=agentsd__pb2.FsPathRequest.SerializeToString,
                response_deserializer=agentsd__pb2.FsResponse.FromString,
                _registered_method=True)
        self.Rename = channel.unary_unary(
                '/agentsd.FS/Rename',
                request_serializer=agentsd__pb2.FsRenameRequest.SerializeToString,
                response_deserializer=agentsd__pb2.FsResponse.FromString,
                _registered_method=True)
        self.Stat = channel.unary_unary(
                '/agentsd.FS/Stat',
                request_serializer=agentsd__pb2.FsPathRequest.SerializeToString,
                response_deserializer=agentsd__pb2.FsStatResponse.FromString,
                _registered_method=True)
        self.List = channel.unary_unary(
                '/agentsd.FS/List',
                request_serializer=agentsd__pb2.FsPathRequest.SerializeToString,
                response_deserializer=agentsd__pb2.FsListResponse.FromString,
                _registered_method=True)
        self.Watch = channel.unary_stream(
                '/agentsd.FS/Watch',
                request_serializer=agentsd__pb2.FsPathRequest.SerializeToString,
                response_deserializer=agentsd__pb2.FsWatchEvent.FromString,
                _registered_method=True)


class FSServicer:
    """========== FS ==========
    """

    def Read(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Write(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Delete(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Rename(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Stat(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def List(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Watch(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_FSServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Read': grpc.unary_unary_rpc_method_handler(
                    servicer.Read,
                    request_deserializer=agentsd__pb2.FsReadRequest.FromString,
                    response_serializer=agentsd__pb2.FsReadResponse.SerializeToString,
            ),
            'Write': grpc.unary_unary_rpc_method_handler(
                    servicer.Write,
                    request_deserializer=agentsd__pb2.FsWriteRequest.FromString,
                    response_serializer=agentsd__pb2.FsResponse.SerializeToString,
            ),
            'Delete': grpc.unary_unary_rpc_method_handler(
                    servicer.Delete,
                    request_deserializer=agentsd__pb2.FsPathRequest.FromString,
                    response_serializer=agentsd__pb2.FsResponse.SerializeToString,
            ),
            'Rename': grpc.unary_unary_rpc_method_handler(
                    servicer.Rename,
                    request_deserializer=agentsd__pb2.FsRenameRequest.FromString,
                    response_serializer=agentsd__pb2.FsResponse.SerializeToString,
            ),
            'Stat': grpc.unary_unary_rpc_method_handler(
                    servicer.Stat,
                    request_deserializer=agentsd__pb2.FsPathRequest.FromString,
                    response_serializer=agentsd__pb2.FsStatResponse.SerializeToString,
            ),
            'List': grpc.unary_unary_rpc_method_handler(
                    servicer.List,
                    request_deserializer=agentsd__pb2.FsPathRequest.FromString,
                    response_serializer=agentsd__pb2.FsListResponse.SerializeToString,
            ),
            'Watch': grpc.unary_stream_rpc_method_handler(
                    servicer.Watch,
                    request_deserializer=agentsd__pb2.FsPathRequest.FromString,
                    response_serializer=agentsd__pb2.FsWatchEvent.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'agentsd.FS', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('agentsd.FS', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class FS:
    """========== FS ==========
    """

    @staticmethod
    def Read(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,
            '/agentsd.FS/Read',
            agentsd__pb2.FsReadRequest.SerializeToString,
            agentsd__pb2.FsReadResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Write(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,
            '/agentsd.FS/Write',
            agentsd__pb2.FsWriteRequest.SerializeToString,
            agentsd__pb2.FsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Delete(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,
            '/agentsd.FS/Delete',
            agentsd__pb2.FsPathRequest.SerializeToString,
            agentsd__pb2.FsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Rename(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,
            '/agentsd.FS/Rename',
            agentsd__pb2.FsRenameRequest.SerializeToString,
            agentsd__pb2.FsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Stat(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,
            '/agentsd.FS/Stat',
            agentsd__pb2.FsPathRequest.SerializeToString,
            agentsd__pb2.FsStatResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def List(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,
            '/agentsd.FS/List',
            agentsd__pb2.FsPathRequest.SerializeToString,
            agentsd__pb2.FsListResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Watch(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_stream(
            request,
            target,
            '/agentsd.FS/Watch',
            agentsd__pb2.FsPathRequest.SerializeToString,
            agentsd__pb2.FsWatchEvent.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class MemoryStub:
    """========== Memory ==========
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Read = channel.unary_unary(
                '/agentsd.Memory/Read',
                request_serializer=agentsd__pb2.MemoryReadRequest.SerializeToString,
                response_deserializer=agentsd__pb2.MemoryReadResponse.FromString,
                _registered_method=True)
        self.Write = channel.unary_unary(
                '/agentsd.Memory/Write',
                request_serializer=agentsd__pb2.MemoryWriteRequest.SerializeToString,
                response_deserializer=agentsd__pb2.MemoryResponse.FromString,
                _registered_method=True)
        self.Delete = channel.unary_unary(
                '/agentsd.Memory/Delete',
                request_serializer=agentsd__pb2.MemoryKeyRequest.SerializeToString,
                response_deserializer=agentsd__pb2.MemoryResponse.FromString,
                _registered_method=True)
        self.List = channel.unary_unary(
                '/agentsd.Memory/List',
                request_serializer=agentsd__pb2.MemoryListRequest.SerializeToString,
                response_deserializer=agentsd__pb2.MemoryListResponse.FromString,
                _registered_method=True)
        self.Search = channel.unary_unary(
                '/agentsd.Memory/Search',
                request_serializer=agentsd__pb2.MemorySearchRequest.SerializeToString,
                response_deserializer=agentsd__pb2.MemorySearchResponse.FromString,
                _registered_method=True)


class MemoryServicer:
    """========== Memory ==========
    """

    def Read(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Write(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Delete(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def List(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Search(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_MemoryServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Read': grpc.unary_unary_rpc_method_handler(
                    servicer.Read,
                    request_deserializer=agentsd__pb2.MemoryReadRequest.FromString,
                    response_serializer=agentsd__pb2.MemoryReadResponse.SerializeToString,
            ),
            'Write': grpc.unary_unary_rpc_method_handler(
                    servicer.Write,
                    request_deserializer=agentsd__pb2.MemoryWriteRequest.FromString,
                    response_serializer=agentsd__pb2.MemoryResponse.SerializeToString,
            ),
            'Delete': grpc.unary_unary_rpc_method_handler(
                    servicer.Delete,
                    request_deserializer=agentsd__pb2.MemoryKeyRequest.FromString,
                    response_serializer=agentsd__pb2.MemoryResponse.SerializeToString,
            ),
            'List': grpc.unary_unary_rpc_method_handler(
                    servicer.List,
                    request_deserializer=agentsd__pb2.MemoryListRequest.FromString,
                    response_serializer=agentsd__pb2.MemoryListResponse.SerializeToString,
            ),
            'Search': grpc.unary_unary_rpc_method_handler(
                    servicer.Search,
                    request_deserializer=agentsd__pb2.MemorySearchRequest.FromString,
                    response_serializer=agentsd__pb2.MemorySearchResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'agentsd.Memory', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('agentsd.Memory', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class Memory:
    """========== Memory ==========
    """

    @staticmethod
    def Read(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,
            '/agentsd.Memory/Read',
            agentsd__pb2.MemoryReadRequest.SerializeToString,
            agentsd__pb2.MemoryReadResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Write(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,
            '/agentsd.Memory/Write',
            agentsd__pb2.MemoryWriteRequest.SerializeToString,
            agentsd__pb2.MemoryResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Delete(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,
            '/agentsd.Memory/Delete',
            agentsd__pb2.MemoryKeyRequest.SerializeToString,
            agentsd__pb2.MemoryResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def List(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,
            '/agentsd.Memory/List',
            agentsd__pb2.MemoryListRequest.SerializeToString,
            agentsd__pb2.MemoryListResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Search(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,
            '/agentsd.Memory/Search',
            agentsd__pb2.MemorySearchRequest.SerializeToString,
            agentsd__pb2.MemorySearchResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class NetworkStub:
    """========== Network ==========
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Request = channel.unary_unary(
                '/agentsd.Network/Request',
                request_serializer=agentsd__pb2.HttpRequest.SerializeToString,
                response_deserializer=agentsd__pb2.HttpResponse.FromString,
                _registered_method=True)
        self.OpenConn = channel.unary_stream(
                '/agentsd.Network/OpenConn',
                request_serializer=agentsd__pb2.ConnectRequest.SerializeToString,
                response_deserializer=agentsd__pb2.ConnEvent.FromString,
                _registered_method=True)
        self.Listen = channel.unary_stream(
                '/agentsd.Network/Listen',
                request_serializer=agentsd__pb2.ListenRequest.SerializeToString,
                response_deserializer=agentsd__pb2.ConnEvent.FromString,
                _registered_method=True)
        self.Send = channel.unary_unary(
                '/agentsd.Network/Send',
                request_serializer=agentsd__pb2.SendRequest.SerializeToString,
                response_deserializer=agentsd__pb2.NetResponse.FromString,
                _registered_method=True)
        self.Close = channel.unary_unary(
                '/agentsd.Network/Close',
                request_serializer=agentsd__pb2.CloseRequest.SerializeToString,
                response_deserializer=agentsd__pb2.NetResponse.FromString,
                _registered_method=True)
        self.Available = channel.unary_unary(
                '/agentsd.Network/Available',
                request_serializer=agentsd__pb2.Empty.SerializeToString,
                response_deserializer=agentsd__pb2.NetAvailableResponse.FromString,
                _registered_method=True)


class NetworkServicer:
    """========== Network ==========
    """

    def Request(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def OpenConn(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Listen(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Send(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Close(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Available(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_NetworkServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Request': grpc.unary_unary_rpc_method_handler(
                    servicer.Request,
                    request_deserializer=agentsd__pb2.HttpRequest.FromString,
                    response_serializer=agentsd__pb2.HttpResponse.SerializeToString,
            ),
            'OpenConn': grpc.unary_stream_rpc_method_handler(
                    servicer.OpenConn,
                    request_deserializer=agentsd__pb2.ConnectRequest.FromString,
                    response_serializer=agentsd__pb2.ConnEvent.SerializeToString,
            ),
            'Listen': grpc.unary_stream_rpc_method_handler(
                    servicer.Listen,
                    request_deserializer=agentsd__pb2.ListenRequest.FromString,
                    response_serializer=agentsd__pb2.ConnEvent.SerializeToString,
            ),
            'Send': grpc.unary_unary_rpc_method_handler(
                    servicer.Send,
                    request_deserializer=agentsd__pb2.SendRequest.FromString,
                    response_serializer=agentsd__pb2.NetResponse.SerializeToString,
            ),
            'Close': grpc.unary_unary_rpc_method_handler(
                    servicer.Close,
                    request_deserializer=agentsd__pb2.CloseRequest.FromString,
                    response_serializer=agentsd__pb2.NetResponse.SerializeToString,
            ),
            'Available': grpc.unary_unary_rpc_method_handler(
                    servicer.Available,
                    request_deserializer=agentsd__pb2.Empty.FromString,
                    response_serializer=agentsd__pb2.NetAvailableResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'agentsd.Network', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('agentsd.Network', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class Network:
    """========== Network ==========
    """

    @staticmethod
    def Request(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,
            '/agentsd.Network/Request',
            agentsd__pb2.HttpRequest.SerializeToString,
            agentsd__pb2.HttpResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def OpenConn(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_stream(
            request,
            target,
            '/agentsd.Network/OpenConn',
            agentsd__pb2.ConnectRequest.SerializeToString,
            agentsd__pb2.ConnEvent.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Listen(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_stream(
            request,
            target,
            '/agentsd.Network/Listen',
            agentsd__pb2.ListenRequest.SerializeToString,
            agentsd__pb2.ConnEvent.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Send(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,
            '/agentsd.Network/Send',
            agentsd__pb2.SendRequest.SerializeToString,
            agentsd__pb2.NetResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Close(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,
            '/agentsd.Network/Close',
            agentsd__pb2.CloseRequest.SerializeToString,
            agentsd__pb2.NetResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Available(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,
            '/agentsd.Network/Available',
            agentsd__pb2.Empty.SerializeToString,
            agentsd__pb2.NetAvailableResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class ProcessStub:
    """========== Process ==========
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Spawn = channel.unary_unary(
                '/agentsd.Process/Spawn',
                request_serializer=agentsd__pb2.SpawnRequest.SerializeToString,
                response_deserializer=agentsd__pb2.SpawnResponse.FromString,
                _registered_method=True)
        self.Kill = channel.unary_unary(
                '/agentsd.Process/Kill',
                request_serializer=agentsd__pb2.PidRequest.SerializeToString,
                response_deserializer=agentsd__pb2.ProcResponse.FromString,
                _registered_method=True)
        self.Wait = channel.unary_unary(
                '/agentsd.Process/Wait',
                request_serializer=agentsd__pb2.PidRequest.SerializeToString,
                response_deserializer=agentsd__pb2.WaitResponse.FromString,
                _registered_method=True)
        self.Stdin = channel.unary_unary(
                '/agentsd.Process/Stdin',
                request_serializer=agentsd__pb2.StdinRequest.SerializeToString,
                response_deserializer=agentsd__pb2.ProcResponse.FromString,
                _registered_method=True)
        self.Stdout = channel.unary_stream(
                '/agentsd.Process/Stdout',
                request_serializer=agentsd__pb2.PidRequest.SerializeToString,
                response_deserializer=agentsd__pb2.DataChunk.FromString,
                _registered_method=True)
        self.Signal = channel.unary_unary(
                '/agentsd.Process/Signal',
                request_serializer=agentsd__pb2.SignalRequest.SerializeToString,
                response_deserializer=agentsd__pb2.ProcResponse.FromString,
                _registered_method=True)
        self.ListProc = channel.unary_unary(
                '/agentsd.Process/ListProc',
                request_serializer=agentsd__pb2.Empty.SerializeToString,
                response_deserializer=agentsd__pb2.ProcListResponse.FromString,
                _registered_method=True)


class ProcessServicer:
    """========== Process ==========
    """

    def Spawn(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Kill(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Wait(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Stdin(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Stdout(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Signal(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ListProc(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_ProcessServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Spawn': grpc.unary_unary_rpc_method_handler(
                    servicer.Spawn,
                    request_deserializer=agentsd__pb2.SpawnRequest.FromString,
                    response_serializer=agentsd__pb2.SpawnResponse.SerializeToString,
            ),
            'Kill': grpc.unary_unary_rpc_method_handler(
                    servicer.Kill,
                    request_deserializer=agentsd__pb2.PidRequest.FromString,
                    response_serializer=agentsd__pb2.ProcResponse.SerializeToString,
            ),
            'Wait': grpc.unary_unary_rpc_method_handler(
                    servicer.Wait,
                    request_deserializer=agentsd__pb2.PidRequest.FromString,
                    response_serializer=agentsd__pb2.WaitResponse.SerializeToString,
            ),
            'Stdin': grpc.unary_unary_rpc_method_handler(
                    servicer.Stdin,
                    request_deserializer=agentsd__pb2.StdinRequest.FromString,
                    response_serializer=agentsd__pb2.ProcResponse.SerializeToString,
            ),
            'Stdout': grpc.unary_stream_rpc_method_handler(
                    servicer.Stdout,
                    request_deserializer=agentsd__pb2.PidRequest.FromString,
                    response_serializer=agentsd__pb2.DataChunk.SerializeToString,
            ),
            'Signal': grpc.unary_unary_rpc_method_handler(
                    servicer.Signal,
                    request_deserializer=agentsd__pb2.SignalRequest.FromString,
                    response_serializer=agentsd__pb2.ProcResponse.SerializeToString,
            ),
            'ListProc': grpc.unary_unary_rpc_method_handler(
                    servicer.ListProc,
                    request_deserializer=agentsd__pb2.Empty.FromString,
                    response_serializer=agentsd__pb2.ProcListResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'agentsd.Process', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('agentsd.Process', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class Process:
    """========== Process ==========
    """

    @staticmethod
    def Spawn(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,
            '/agentsd.Process/Spawn',
            agentsd__pb2.SpawnRequest.SerializeToString,
            agentsd__pb2.SpawnResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Kill(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,
            '/agentsd.Process/Kill',
            agentsd__pb2.PidRequest.SerializeToString,
            agentsd__pb2.ProcResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Wait(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,
            '/agentsd.Process/Wait',
            agentsd__pb2.PidRequest.SerializeToString,
            agentsd__pb2.WaitResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Stdin(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,
            '/agentsd.Process/Stdin',
            agentsd__pb2.StdinRequest.SerializeToString,
            agentsd__pb2.ProcResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Stdout(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_stream(
            request,
            target,
            '/agentsd.Process/Stdout',
            agentsd__pb2.PidRequest.SerializeToString,
            agentsd__pb2.DataChunk.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Signal(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,
            '/agentsd.Process/Signal',
            agentsd__pb2.SignalRequest.SerializeToString,
            agentsd__pb2.ProcResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListProc(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,
            '/agentsd.Process/ListProc',
            agentsd__pb2.Empty.SerializeToString,
            agentsd__pb2.ProcListResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class TimerStub:
    """========== Timer ==========
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Once = channel.unary_unary(
                '/agentsd.Timer/Once',
                request_serializer=agentsd__pb2.TimerOnceRequest.SerializeToString,
                response_deserializer=agentsd__pb2.TimerResponse.FromString,
                _registered_method=True)
        self.Cron = channel.unary_unary(
                '/agentsd.Timer/Cron',
                request_serializer=agentsd__pb2.TimerCronRequest.SerializeToString,
                response_deserializer=agentsd__pb2.TimerResponse.FromString,
                _registered_method=True)
        self.Cancel = channel.unary_unary(
                '/agentsd.Timer/Cancel',
                request_serializer=agentsd__pb2.TimerCancelRequest.SerializeToString,
                response_deserializer=agentsd__pb2.TimerResponse.FromString,
                _registered_method=True)
        self.Now = channel.unary_unary(
                '/agentsd.Timer/Now',
                request_serializer=agentsd__pb2.Empty.SerializeToString,
                response_deserializer=agentsd__pb2.TimerNowResponse.FromString,
                _registered_method=True)


class TimerServicer:
    """========== Timer ==========
    """

    def Once(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Cron(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Cancel(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Now(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_TimerServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Once': grpc.unary_unary_rpc_method_handler(
                    servicer.Once,
                    request_deserializer=agentsd__pb2.TimerOnceRequest.FromString,
                    response_serializer=agentsd__pb2.TimerResponse.SerializeToString,
            ),
            'Cron': grpc.unary_unary_rpc_method_handler(
                    servicer.Cron,
                    request_deserializer=agentsd__pb2.TimerCronRequest.FromString,
                    response_serializer=agentsd__pb2.TimerResponse.SerializeToString,
            ),
            'Cancel': grpc.unary_unary_rpc_method_handler(
                    servicer.Cancel,
                    request_deserializer=agentsd__pb2.TimerCancelRequest.FromString,
                    response_serializer=agentsd__pb2.TimerResponse.SerializeToString,
            ),
            'Now': grpc.unary_unary_rpc_method_handler(
                    servicer.Now,
                    request_deserializer=agentsd__pb2.Empty.FromString,
                    response_serializer=agentsd__pb2.TimerNowResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'agentsd.Timer', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('agentsd.Timer', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class Timer:
    """========== Timer ==========
    """

    @staticmethod
    def Once(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,
            '/agentsd.Timer/Once',
            agentsd__pb2.TimerOnceRequest.SerializeToString,
            agentsd__pb2.TimerResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Cron(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,
            '/agentsd.Timer/Cron',
            agentsd__pb2.TimerCronRequest.SerializeToString,
            agentsd__pb2.TimerResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Cancel(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,
            '/agentsd.Timer/Cancel',
            agentsd__pb2.TimerCancelRequest.SerializeToString,
            agentsd__pb2.TimerResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Now(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,
            '/agentsd.Timer/Now',
            agentsd__pb2.Empty.SerializeToString,
            agentsd__pb2.TimerNowResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class HIDStub:
    """========== HID ==========
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Capture = channel.unary_unary(
                '/agentsd.HID/Capture',
                request_serializer=agentsd__pb2.CaptureRequest.SerializeToString,
                response_deserializer=agentsd__pb2.CaptureResponse.FromString,
                _registered_method=True)
        self.Mouse = channel.unary_unary(
                '/agentsd.HID/Mouse',
                request_serializer=agentsd__pb2.MouseRequest.SerializeToString,
                response_deserializer=agentsd__pb2.HidResponse.FromString,
                _registered_method=True)
        self.Keyboard = channel.unary_unary(
                '/agentsd.HID/Keyboard',
                request_serializer=agentsd__pb2.KeyboardRequest.SerializeToString,
                response_deserializer=agentsd__pb2.HidResponse.FromString,
                _registered_method=True)
        self.Ocr = channel.unary_unary(
                '/agentsd.HID/Ocr',
                request_serializer=agentsd__pb2.CaptureRequest.SerializeToString,
                response_deserializer=agentsd__pb2.OcrResponse.FromString,
                _registered_method=True)


class HIDServicer:
    """========== HID ==========
    """

    def Capture(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Mouse(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Keyboard(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Ocr(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_HIDServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Capture': grpc.unary_unary_rpc_method_handler(
                    servicer.Capture,
                    request_deserializer=agentsd__pb2.CaptureRequest.FromString,
                    response_serializer=agentsd__pb2.CaptureResponse.SerializeToString,
            ),
            'Mouse': grpc.unary_unary_rpc_method_handler(
                    servicer.Mouse,
                    request_deserializer=agentsd__pb2.MouseRequest.FromString,
                    response_serializer=agentsd__pb2.HidResponse.SerializeToString,
            ),
            'Keyboard': grpc.unary_unary_rpc_method_handler(
                    servicer.Keyboard,
                    request_deserializer=agentsd__pb2.KeyboardRequest.FromString,
                    response_serializer=agentsd__pb2.HidResponse.SerializeToString,
            ),
            'Ocr': grpc.unary_unary_rpc_method_handler(
                    servicer.Ocr,
                    request_deserializer=agentsd__pb2.CaptureRequest.FromString,
                    response_serializer=agentsd__pb2.OcrResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'agentsd.HID', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('agentsd.HID', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class HID:
    """========== HID ==========
    """

    @staticmethod
    def Capture(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,
            '/agentsd.HID/Capture',
            agentsd__pb2.CaptureRequest.SerializeToString,
            agentsd__pb2.CaptureResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Mouse(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,
            '/agentsd.HID/Mouse',
            agentsd__pb2.MouseRequest.SerializeToString,
            agentsd__pb2.HidResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Keyboard(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,
            '/agentsd.HID/Keyboard',
            agentsd__pb2.KeyboardRequest.SerializeToString,
            agentsd__pb2.HidResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Ocr(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,
            '/agentsd.HID/Ocr',
            agentsd__pb2.CaptureRequest.SerializeToString,
            agentsd__pb2.OcrResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class InputStub:
    """========== Input ==========
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Text = channel.unary_unary(
                '/agentsd.Input/Text',
                request_serializer=agentsd__pb2.Empty.SerializeToString,
                response_deserializer=agentsd__pb2.InputTextResponse.FromString,
                _registered_method=True)
        self.Key = channel.unary_unary(
                '/agentsd.Input/Key',
                request_serializer=agentsd__pb2.Empty.SerializeToString,
                response_deserializer=agentsd__pb2.InputKeyResponse.FromString,
                _registered_method=True)
        self.Clipboard = channel.unary_unary(
                '/agentsd.Input/Clipboard',
                request_serializer=agentsd__pb2.Empty.SerializeToString,
                response_deserializer=agentsd__pb2.InputClipboardResponse.FromString,
                _registered_method=True)
        self.Events = channel.unary_stream(
                '/agentsd.Input/Events',
                request_serializer=agentsd__pb2.Empty.SerializeToString,
                response_deserializer=agentsd__pb2.InputEvent.FromString,
                _registered_method=True)


class InputServicer:
    """========== Input ==========
    """

    def Text(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Key(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Clipboard(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Events(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_InputServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Text': grpc.unary_unary_rpc_method_handler(
                    servicer.Text,
                    request_deserializer=agentsd__pb2.Empty.FromString,
                    response_serializer=agentsd__pb2.InputTextResponse.SerializeToString,
            ),
            'Key': grpc.unary_unary_rpc_method_handler(
                    servicer.Key,
                    request_deserializer=agentsd__pb2.Empty.FromString,
                    response_serializer=agentsd__pb2.InputKeyResponse.SerializeToString,
            ),
            'Clipboard': grpc.unary_unary_rpc_method_handler(
                    servicer.Clipboard,
                    request_deserializer=agentsd__pb2.Empty.FromString,
                    response_serializer=agentsd__pb2.InputClipboardResponse.SerializeToString,
            ),
            'Events': grpc.unary_stream_rpc_method_handler(
                    servicer.Events,
                    request_deserializer=agentsd__pb2.Empty.FromString,
                    response_serializer=agentsd__pb2.InputEvent.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'agentsd.Input', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('agentsd.Input', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class Input:
    """========== Input ==========
    """

    @staticmethod
    def Text(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,
            '/agentsd.Input/Text',
            agentsd__pb2.Empty.SerializeToString,
            agentsd__pb2.InputTextResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Key(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,
            '/agentsd.Input/Key',
            agentsd__pb2.Empty.SerializeToString,
            agentsd__pb2.InputKeyResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Clipboard(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,
            '/agentsd.Input/Clipboard',
            agentsd__pb2.Empty.SerializeToString,
            agentsd__pb2.InputClipboardResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Events(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_stream(
            request,
            target,
            '/agentsd.Input/Events',
            agentsd__pb2.Empty.SerializeToString,
            agentsd__pb2.InputEvent.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class PluginBridgeStub:
    """========== Plugin Bridge ==========
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Register = channel.unary_unary(
                '/agentsd.PluginBridge/Register',
                request_serializer=agentsd__pb2.PluginInfo.SerializeToString,
                response_deserializer=agentsd__pb2.RegisterResponse.FromString,
                _registered_method=True)
        self.Call = channel.unary_unary(
                '/agentsd.PluginBridge/Call',
                request_serializer=agentsd__pb2.CallRequest.SerializeToString,
                response_deserializer=agentsd__pb2.CallResponse.FromString,
                _registered_method=True)
        self.StreamCall = channel.unary_stream(
                '/agentsd.PluginBridge/StreamCall',
                request_serializer=agentsd__pb2.CallRequest.SerializeToString,
                response_deserializer=agentsd__pb2.CallResponse.FromString,
                _registered_method=True)
        self.Heartbeat = channel.unary_unary(
                '/agentsd.PluginBridge/Heartbeat',
                request_serializer=agentsd__pb2.HeartbeatRequest.SerializeToString,
                response_deserializer=agentsd__pb2.HeartbeatResponse.FromString,
                _registered_method=True)


class PluginBridgeServicer:
    """========== Plugin Bridge ==========
    """

    def Register(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Call(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StreamCall(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Heartbeat(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_PluginBridgeServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Register': grpc.unary_unary_rpc_method_handler(
                    servicer.Register,
                    request_deserializer=agentsd__pb2.PluginInfo.FromString,
                    response_serializer=agentsd__pb2.RegisterResponse.SerializeToString,
            ),
            'Call': grpc.unary_unary_rpc_method_handler(
                    servicer.Call,
                    request_deserializer=agentsd__pb2.CallRequest.FromString,
                    response_serializer=agentsd__pb2.CallResponse.SerializeToString,
            ),
            'StreamCall': grpc.unary_stream_rpc_method_handler(
                    servicer.StreamCall,
                    request_deserializer=agentsd__pb2.CallRequest.FromString,
                    response_serializer=agentsd__pb2.CallResponse.SerializeToString,
            ),
            'Heartbeat': grpc.unary_unary_rpc_method_handler(
                    servicer.Heartbeat,
                    request_deserializer=agentsd__pb2.HeartbeatRequest.FromString,
                    response_serializer=agentsd__pb2.HeartbeatResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'agentsd.PluginBridge', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('agentsd.PluginBridge', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class PluginBridge:
    """========== Plugin Bridge ==========
    """

    @staticmethod
    def Register(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,
            '/agentsd.PluginBridge/Register',
            agentsd__pb2.PluginInfo.SerializeToString,
            agentsd__pb2.RegisterResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Call(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,
            '/agentsd.PluginBridge/Call',
            agentsd__pb2.CallRequest.SerializeToString,
            agentsd__pb2.CallResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StreamCall(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_stream(
            request,
            target,
            '/agentsd.PluginBridge/StreamCall',
            agentsd__pb2.CallRequest.SerializeToString,
            agentsd__pb2.CallResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Heartbeat(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,
            '/agentsd.PluginBridge/Heartbeat',
            agentsd__pb2.HeartbeatRequest.SerializeToString,
            agentsd__pb2.HeartbeatResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)