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

from amplifier_core._grpc_gen import amplifier_module_pb2 as amplifier__module__pb2

GRPC_GENERATED_VERSION = '1.78.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 amplifier_module_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 ToolServiceStub(object):
    """Universal contract for tool modules in any language.
    Implement this service to create an Amplifier tool in Go, TypeScript, C#, etc.
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.GetSpec = channel.unary_unary(
                '/amplifier.module.ToolService/GetSpec',
                request_serializer=amplifier__module__pb2.Empty.SerializeToString,
                response_deserializer=amplifier__module__pb2.ToolSpec.FromString,
                _registered_method=True)
        self.Execute = channel.unary_unary(
                '/amplifier.module.ToolService/Execute',
                request_serializer=amplifier__module__pb2.ToolExecuteRequest.SerializeToString,
                response_deserializer=amplifier__module__pb2.ToolExecuteResponse.FromString,
                _registered_method=True)


class ToolServiceServicer(object):
    """Universal contract for tool modules in any language.
    Implement this service to create an Amplifier tool in Go, TypeScript, C#, etc.
    """

    def GetSpec(self, request, context):
        """Return the tool's name, description, and JSON Schema parameters.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Execute(self, request, context):
        """Execute the tool with JSON (or MessagePack) input.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_ToolServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetSpec': grpc.unary_unary_rpc_method_handler(
                    servicer.GetSpec,
                    request_deserializer=amplifier__module__pb2.Empty.FromString,
                    response_serializer=amplifier__module__pb2.ToolSpec.SerializeToString,
            ),
            'Execute': grpc.unary_unary_rpc_method_handler(
                    servicer.Execute,
                    request_deserializer=amplifier__module__pb2.ToolExecuteRequest.FromString,
                    response_serializer=amplifier__module__pb2.ToolExecuteResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'amplifier.module.ToolService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('amplifier.module.ToolService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class ToolService(object):
    """Universal contract for tool modules in any language.
    Implement this service to create an Amplifier tool in Go, TypeScript, C#, etc.
    """

    @staticmethod
    def GetSpec(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,
            '/amplifier.module.ToolService/GetSpec',
            amplifier__module__pb2.Empty.SerializeToString,
            amplifier__module__pb2.ToolSpec.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Execute(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,
            '/amplifier.module.ToolService/Execute',
            amplifier__module__pb2.ToolExecuteRequest.SerializeToString,
            amplifier__module__pb2.ToolExecuteResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class ProviderServiceStub(object):
    """---------------------------------------------------------------------------
    Module services
    ---------------------------------------------------------------------------

    Provider module contract — LLM completions in any language.
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.GetInfo = channel.unary_unary(
                '/amplifier.module.ProviderService/GetInfo',
                request_serializer=amplifier__module__pb2.Empty.SerializeToString,
                response_deserializer=amplifier__module__pb2.ProviderInfo.FromString,
                _registered_method=True)
        self.ListModels = channel.unary_unary(
                '/amplifier.module.ProviderService/ListModels',
                request_serializer=amplifier__module__pb2.Empty.SerializeToString,
                response_deserializer=amplifier__module__pb2.ListModelsResponse.FromString,
                _registered_method=True)
        self.Complete = channel.unary_unary(
                '/amplifier.module.ProviderService/Complete',
                request_serializer=amplifier__module__pb2.ChatRequest.SerializeToString,
                response_deserializer=amplifier__module__pb2.ChatResponse.FromString,
                _registered_method=True)
        self.CompleteStreaming = channel.unary_stream(
                '/amplifier.module.ProviderService/CompleteStreaming',
                request_serializer=amplifier__module__pb2.ChatRequest.SerializeToString,
                response_deserializer=amplifier__module__pb2.ChatResponse.FromString,
                _registered_method=True)
        self.ParseToolCalls = channel.unary_unary(
                '/amplifier.module.ProviderService/ParseToolCalls',
                request_serializer=amplifier__module__pb2.ChatResponse.SerializeToString,
                response_deserializer=amplifier__module__pb2.ParseToolCallsResponse.FromString,
                _registered_method=True)


class ProviderServiceServicer(object):
    """---------------------------------------------------------------------------
    Module services
    ---------------------------------------------------------------------------

    Provider module contract — LLM completions in any language.
    """

    def GetInfo(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 ListModels(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 Complete(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 CompleteStreaming(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 ParseToolCalls(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_ProviderServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'GetInfo': grpc.unary_unary_rpc_method_handler(
                    servicer.GetInfo,
                    request_deserializer=amplifier__module__pb2.Empty.FromString,
                    response_serializer=amplifier__module__pb2.ProviderInfo.SerializeToString,
            ),
            'ListModels': grpc.unary_unary_rpc_method_handler(
                    servicer.ListModels,
                    request_deserializer=amplifier__module__pb2.Empty.FromString,
                    response_serializer=amplifier__module__pb2.ListModelsResponse.SerializeToString,
            ),
            'Complete': grpc.unary_unary_rpc_method_handler(
                    servicer.Complete,
                    request_deserializer=amplifier__module__pb2.ChatRequest.FromString,
                    response_serializer=amplifier__module__pb2.ChatResponse.SerializeToString,
            ),
            'CompleteStreaming': grpc.unary_stream_rpc_method_handler(
                    servicer.CompleteStreaming,
                    request_deserializer=amplifier__module__pb2.ChatRequest.FromString,
                    response_serializer=amplifier__module__pb2.ChatResponse.SerializeToString,
            ),
            'ParseToolCalls': grpc.unary_unary_rpc_method_handler(
                    servicer.ParseToolCalls,
                    request_deserializer=amplifier__module__pb2.ChatResponse.FromString,
                    response_serializer=amplifier__module__pb2.ParseToolCallsResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'amplifier.module.ProviderService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('amplifier.module.ProviderService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class ProviderService(object):
    """---------------------------------------------------------------------------
    Module services
    ---------------------------------------------------------------------------

    Provider module contract — LLM completions in any language.
    """

    @staticmethod
    def GetInfo(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,
            '/amplifier.module.ProviderService/GetInfo',
            amplifier__module__pb2.Empty.SerializeToString,
            amplifier__module__pb2.ProviderInfo.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListModels(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,
            '/amplifier.module.ProviderService/ListModels',
            amplifier__module__pb2.Empty.SerializeToString,
            amplifier__module__pb2.ListModelsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Complete(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,
            '/amplifier.module.ProviderService/Complete',
            amplifier__module__pb2.ChatRequest.SerializeToString,
            amplifier__module__pb2.ChatResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CompleteStreaming(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,
            '/amplifier.module.ProviderService/CompleteStreaming',
            amplifier__module__pb2.ChatRequest.SerializeToString,
            amplifier__module__pb2.ChatResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ParseToolCalls(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,
            '/amplifier.module.ProviderService/ParseToolCalls',
            amplifier__module__pb2.ChatResponse.SerializeToString,
            amplifier__module__pb2.ParseToolCallsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class OrchestratorServiceStub(object):
    """Orchestrator module contract — high-level prompt execution.
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Execute = channel.unary_unary(
                '/amplifier.module.OrchestratorService/Execute',
                request_serializer=amplifier__module__pb2.OrchestratorExecuteRequest.SerializeToString,
                response_deserializer=amplifier__module__pb2.OrchestratorExecuteResponse.FromString,
                _registered_method=True)


class OrchestratorServiceServicer(object):
    """Orchestrator module contract — high-level prompt execution.
    """

    def Execute(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_OrchestratorServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Execute': grpc.unary_unary_rpc_method_handler(
                    servicer.Execute,
                    request_deserializer=amplifier__module__pb2.OrchestratorExecuteRequest.FromString,
                    response_serializer=amplifier__module__pb2.OrchestratorExecuteResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'amplifier.module.OrchestratorService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('amplifier.module.OrchestratorService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class OrchestratorService(object):
    """Orchestrator module contract — high-level prompt execution.
    """

    @staticmethod
    def Execute(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,
            '/amplifier.module.OrchestratorService/Execute',
            amplifier__module__pb2.OrchestratorExecuteRequest.SerializeToString,
            amplifier__module__pb2.OrchestratorExecuteResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class ContextServiceStub(object):
    """Context module contract — conversation message management.
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.AddMessage = channel.unary_unary(
                '/amplifier.module.ContextService/AddMessage',
                request_serializer=amplifier__module__pb2.AddMessageRequest.SerializeToString,
                response_deserializer=amplifier__module__pb2.Empty.FromString,
                _registered_method=True)
        self.GetMessages = channel.unary_unary(
                '/amplifier.module.ContextService/GetMessages',
                request_serializer=amplifier__module__pb2.Empty.SerializeToString,
                response_deserializer=amplifier__module__pb2.GetMessagesResponse.FromString,
                _registered_method=True)
        self.GetMessagesForRequest = channel.unary_unary(
                '/amplifier.module.ContextService/GetMessagesForRequest',
                request_serializer=amplifier__module__pb2.GetMessagesForRequestParams.SerializeToString,
                response_deserializer=amplifier__module__pb2.GetMessagesResponse.FromString,
                _registered_method=True)
        self.SetMessages = channel.unary_unary(
                '/amplifier.module.ContextService/SetMessages',
                request_serializer=amplifier__module__pb2.SetMessagesRequest.SerializeToString,
                response_deserializer=amplifier__module__pb2.Empty.FromString,
                _registered_method=True)
        self.Clear = channel.unary_unary(
                '/amplifier.module.ContextService/Clear',
                request_serializer=amplifier__module__pb2.Empty.SerializeToString,
                response_deserializer=amplifier__module__pb2.Empty.FromString,
                _registered_method=True)


class ContextServiceServicer(object):
    """Context module contract — conversation message management.
    """

    def AddMessage(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 GetMessages(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 GetMessagesForRequest(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 SetMessages(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 add_ContextServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'AddMessage': grpc.unary_unary_rpc_method_handler(
                    servicer.AddMessage,
                    request_deserializer=amplifier__module__pb2.AddMessageRequest.FromString,
                    response_serializer=amplifier__module__pb2.Empty.SerializeToString,
            ),
            'GetMessages': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMessages,
                    request_deserializer=amplifier__module__pb2.Empty.FromString,
                    response_serializer=amplifier__module__pb2.GetMessagesResponse.SerializeToString,
            ),
            'GetMessagesForRequest': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMessagesForRequest,
                    request_deserializer=amplifier__module__pb2.GetMessagesForRequestParams.FromString,
                    response_serializer=amplifier__module__pb2.GetMessagesResponse.SerializeToString,
            ),
            'SetMessages': grpc.unary_unary_rpc_method_handler(
                    servicer.SetMessages,
                    request_deserializer=amplifier__module__pb2.SetMessagesRequest.FromString,
                    response_serializer=amplifier__module__pb2.Empty.SerializeToString,
            ),
            'Clear': grpc.unary_unary_rpc_method_handler(
                    servicer.Clear,
                    request_deserializer=amplifier__module__pb2.Empty.FromString,
                    response_serializer=amplifier__module__pb2.Empty.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'amplifier.module.ContextService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('amplifier.module.ContextService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class ContextService(object):
    """Context module contract — conversation message management.
    """

    @staticmethod
    def AddMessage(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,
            '/amplifier.module.ContextService/AddMessage',
            amplifier__module__pb2.AddMessageRequest.SerializeToString,
            amplifier__module__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetMessages(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,
            '/amplifier.module.ContextService/GetMessages',
            amplifier__module__pb2.Empty.SerializeToString,
            amplifier__module__pb2.GetMessagesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetMessagesForRequest(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,
            '/amplifier.module.ContextService/GetMessagesForRequest',
            amplifier__module__pb2.GetMessagesForRequestParams.SerializeToString,
            amplifier__module__pb2.GetMessagesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetMessages(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,
            '/amplifier.module.ContextService/SetMessages',
            amplifier__module__pb2.SetMessagesRequest.SerializeToString,
            amplifier__module__pb2.Empty.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,
            '/amplifier.module.ContextService/Clear',
            amplifier__module__pb2.Empty.SerializeToString,
            amplifier__module__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class HookServiceStub(object):
    """Hook module contract — event interception.
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Handle = channel.unary_unary(
                '/amplifier.module.HookService/Handle',
                request_serializer=amplifier__module__pb2.HookHandleRequest.SerializeToString,
                response_deserializer=amplifier__module__pb2.HookResult.FromString,
                _registered_method=True)


class HookServiceServicer(object):
    """Hook module contract — event interception.
    """

    def Handle(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_HookServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Handle': grpc.unary_unary_rpc_method_handler(
                    servicer.Handle,
                    request_deserializer=amplifier__module__pb2.HookHandleRequest.FromString,
                    response_serializer=amplifier__module__pb2.HookResult.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'amplifier.module.HookService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('amplifier.module.HookService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class HookService(object):
    """Hook module contract — event interception.
    """

    @staticmethod
    def Handle(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,
            '/amplifier.module.HookService/Handle',
            amplifier__module__pb2.HookHandleRequest.SerializeToString,
            amplifier__module__pb2.HookResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class ApprovalServiceStub(object):
    """Approval module contract — human-in-the-loop approval.
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.RequestApproval = channel.unary_unary(
                '/amplifier.module.ApprovalService/RequestApproval',
                request_serializer=amplifier__module__pb2.ApprovalRequest.SerializeToString,
                response_deserializer=amplifier__module__pb2.ApprovalResponse.FromString,
                _registered_method=True)


class ApprovalServiceServicer(object):
    """Approval module contract — human-in-the-loop approval.
    """

    def RequestApproval(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_ApprovalServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'RequestApproval': grpc.unary_unary_rpc_method_handler(
                    servicer.RequestApproval,
                    request_deserializer=amplifier__module__pb2.ApprovalRequest.FromString,
                    response_serializer=amplifier__module__pb2.ApprovalResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'amplifier.module.ApprovalService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('amplifier.module.ApprovalService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class ApprovalService(object):
    """Approval module contract — human-in-the-loop approval.
    """

    @staticmethod
    def RequestApproval(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,
            '/amplifier.module.ApprovalService/RequestApproval',
            amplifier__module__pb2.ApprovalRequest.SerializeToString,
            amplifier__module__pb2.ApprovalResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class KernelServiceStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.CompleteWithProvider = channel.unary_unary(
                '/amplifier.module.KernelService/CompleteWithProvider',
                request_serializer=amplifier__module__pb2.CompleteWithProviderRequest.SerializeToString,
                response_deserializer=amplifier__module__pb2.ChatResponse.FromString,
                _registered_method=True)
        self.CompleteWithProviderStreaming = channel.unary_stream(
                '/amplifier.module.KernelService/CompleteWithProviderStreaming',
                request_serializer=amplifier__module__pb2.CompleteWithProviderRequest.SerializeToString,
                response_deserializer=amplifier__module__pb2.ChatResponse.FromString,
                _registered_method=True)
        self.ExecuteTool = channel.unary_unary(
                '/amplifier.module.KernelService/ExecuteTool',
                request_serializer=amplifier__module__pb2.ExecuteToolRequest.SerializeToString,
                response_deserializer=amplifier__module__pb2.ToolResult.FromString,
                _registered_method=True)
        self.EmitHook = channel.unary_unary(
                '/amplifier.module.KernelService/EmitHook',
                request_serializer=amplifier__module__pb2.EmitHookRequest.SerializeToString,
                response_deserializer=amplifier__module__pb2.HookResult.FromString,
                _registered_method=True)
        self.EmitHookAndCollect = channel.unary_unary(
                '/amplifier.module.KernelService/EmitHookAndCollect',
                request_serializer=amplifier__module__pb2.EmitHookAndCollectRequest.SerializeToString,
                response_deserializer=amplifier__module__pb2.EmitHookAndCollectResponse.FromString,
                _registered_method=True)
        self.GetMessages = channel.unary_unary(
                '/amplifier.module.KernelService/GetMessages',
                request_serializer=amplifier__module__pb2.GetMessagesRequest.SerializeToString,
                response_deserializer=amplifier__module__pb2.GetMessagesResponse.FromString,
                _registered_method=True)
        self.AddMessage = channel.unary_unary(
                '/amplifier.module.KernelService/AddMessage',
                request_serializer=amplifier__module__pb2.KernelAddMessageRequest.SerializeToString,
                response_deserializer=amplifier__module__pb2.Empty.FromString,
                _registered_method=True)
        self.GetMountedModule = channel.unary_unary(
                '/amplifier.module.KernelService/GetMountedModule',
                request_serializer=amplifier__module__pb2.GetMountedModuleRequest.SerializeToString,
                response_deserializer=amplifier__module__pb2.GetMountedModuleResponse.FromString,
                _registered_method=True)
        self.RegisterCapability = channel.unary_unary(
                '/amplifier.module.KernelService/RegisterCapability',
                request_serializer=amplifier__module__pb2.RegisterCapabilityRequest.SerializeToString,
                response_deserializer=amplifier__module__pb2.Empty.FromString,
                _registered_method=True)
        self.GetCapability = channel.unary_unary(
                '/amplifier.module.KernelService/GetCapability',
                request_serializer=amplifier__module__pb2.GetCapabilityRequest.SerializeToString,
                response_deserializer=amplifier__module__pb2.GetCapabilityResponse.FromString,
                _registered_method=True)


class KernelServiceServicer(object):
    """Missing associated documentation comment in .proto file."""

    def CompleteWithProvider(self, request, context):
        """LLM completions via a named provider.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CompleteWithProviderStreaming(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 ExecuteTool(self, request, context):
        """Tool execution.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def EmitHook(self, request, context):
        """Hook emission.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def EmitHookAndCollect(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 GetMessages(self, request, context):
        """Conversation message access.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AddMessage(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 GetMountedModule(self, request, context):
        """Module registry queries.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RegisterCapability(self, request, context):
        """Capability registration and lookup.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetCapability(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_KernelServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'CompleteWithProvider': grpc.unary_unary_rpc_method_handler(
                    servicer.CompleteWithProvider,
                    request_deserializer=amplifier__module__pb2.CompleteWithProviderRequest.FromString,
                    response_serializer=amplifier__module__pb2.ChatResponse.SerializeToString,
            ),
            'CompleteWithProviderStreaming': grpc.unary_stream_rpc_method_handler(
                    servicer.CompleteWithProviderStreaming,
                    request_deserializer=amplifier__module__pb2.CompleteWithProviderRequest.FromString,
                    response_serializer=amplifier__module__pb2.ChatResponse.SerializeToString,
            ),
            'ExecuteTool': grpc.unary_unary_rpc_method_handler(
                    servicer.ExecuteTool,
                    request_deserializer=amplifier__module__pb2.ExecuteToolRequest.FromString,
                    response_serializer=amplifier__module__pb2.ToolResult.SerializeToString,
            ),
            'EmitHook': grpc.unary_unary_rpc_method_handler(
                    servicer.EmitHook,
                    request_deserializer=amplifier__module__pb2.EmitHookRequest.FromString,
                    response_serializer=amplifier__module__pb2.HookResult.SerializeToString,
            ),
            'EmitHookAndCollect': grpc.unary_unary_rpc_method_handler(
                    servicer.EmitHookAndCollect,
                    request_deserializer=amplifier__module__pb2.EmitHookAndCollectRequest.FromString,
                    response_serializer=amplifier__module__pb2.EmitHookAndCollectResponse.SerializeToString,
            ),
            'GetMessages': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMessages,
                    request_deserializer=amplifier__module__pb2.GetMessagesRequest.FromString,
                    response_serializer=amplifier__module__pb2.GetMessagesResponse.SerializeToString,
            ),
            'AddMessage': grpc.unary_unary_rpc_method_handler(
                    servicer.AddMessage,
                    request_deserializer=amplifier__module__pb2.KernelAddMessageRequest.FromString,
                    response_serializer=amplifier__module__pb2.Empty.SerializeToString,
            ),
            'GetMountedModule': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMountedModule,
                    request_deserializer=amplifier__module__pb2.GetMountedModuleRequest.FromString,
                    response_serializer=amplifier__module__pb2.GetMountedModuleResponse.SerializeToString,
            ),
            'RegisterCapability': grpc.unary_unary_rpc_method_handler(
                    servicer.RegisterCapability,
                    request_deserializer=amplifier__module__pb2.RegisterCapabilityRequest.FromString,
                    response_serializer=amplifier__module__pb2.Empty.SerializeToString,
            ),
            'GetCapability': grpc.unary_unary_rpc_method_handler(
                    servicer.GetCapability,
                    request_deserializer=amplifier__module__pb2.GetCapabilityRequest.FromString,
                    response_serializer=amplifier__module__pb2.GetCapabilityResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'amplifier.module.KernelService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('amplifier.module.KernelService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class KernelService(object):
    """Missing associated documentation comment in .proto file."""

    @staticmethod
    def CompleteWithProvider(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,
            '/amplifier.module.KernelService/CompleteWithProvider',
            amplifier__module__pb2.CompleteWithProviderRequest.SerializeToString,
            amplifier__module__pb2.ChatResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CompleteWithProviderStreaming(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,
            '/amplifier.module.KernelService/CompleteWithProviderStreaming',
            amplifier__module__pb2.CompleteWithProviderRequest.SerializeToString,
            amplifier__module__pb2.ChatResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ExecuteTool(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,
            '/amplifier.module.KernelService/ExecuteTool',
            amplifier__module__pb2.ExecuteToolRequest.SerializeToString,
            amplifier__module__pb2.ToolResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def EmitHook(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,
            '/amplifier.module.KernelService/EmitHook',
            amplifier__module__pb2.EmitHookRequest.SerializeToString,
            amplifier__module__pb2.HookResult.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def EmitHookAndCollect(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,
            '/amplifier.module.KernelService/EmitHookAndCollect',
            amplifier__module__pb2.EmitHookAndCollectRequest.SerializeToString,
            amplifier__module__pb2.EmitHookAndCollectResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetMessages(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,
            '/amplifier.module.KernelService/GetMessages',
            amplifier__module__pb2.GetMessagesRequest.SerializeToString,
            amplifier__module__pb2.GetMessagesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AddMessage(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,
            '/amplifier.module.KernelService/AddMessage',
            amplifier__module__pb2.KernelAddMessageRequest.SerializeToString,
            amplifier__module__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetMountedModule(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,
            '/amplifier.module.KernelService/GetMountedModule',
            amplifier__module__pb2.GetMountedModuleRequest.SerializeToString,
            amplifier__module__pb2.GetMountedModuleResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RegisterCapability(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,
            '/amplifier.module.KernelService/RegisterCapability',
            amplifier__module__pb2.RegisterCapabilityRequest.SerializeToString,
            amplifier__module__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetCapability(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,
            '/amplifier.module.KernelService/GetCapability',
            amplifier__module__pb2.GetCapabilityRequest.SerializeToString,
            amplifier__module__pb2.GetCapabilityResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


class ModuleLifecycleStub(object):
    """---------------------------------------------------------------------------
    ModuleLifecycle — every gRPC module implements this service
    ---------------------------------------------------------------------------

    Universal lifecycle contract for all out-of-process modules.
    Mount is called once at startup; Cleanup before shutdown.
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.Mount = channel.unary_unary(
                '/amplifier.module.ModuleLifecycle/Mount',
                request_serializer=amplifier__module__pb2.MountRequest.SerializeToString,
                response_deserializer=amplifier__module__pb2.MountResponse.FromString,
                _registered_method=True)
        self.Cleanup = channel.unary_unary(
                '/amplifier.module.ModuleLifecycle/Cleanup',
                request_serializer=amplifier__module__pb2.Empty.SerializeToString,
                response_deserializer=amplifier__module__pb2.Empty.FromString,
                _registered_method=True)
        self.HealthCheck = channel.unary_unary(
                '/amplifier.module.ModuleLifecycle/HealthCheck',
                request_serializer=amplifier__module__pb2.Empty.SerializeToString,
                response_deserializer=amplifier__module__pb2.HealthCheckResponse.FromString,
                _registered_method=True)
        self.GetModuleInfo = channel.unary_unary(
                '/amplifier.module.ModuleLifecycle/GetModuleInfo',
                request_serializer=amplifier__module__pb2.Empty.SerializeToString,
                response_deserializer=amplifier__module__pb2.ModuleInfo.FromString,
                _registered_method=True)


class ModuleLifecycleServicer(object):
    """---------------------------------------------------------------------------
    ModuleLifecycle — every gRPC module implements this service
    ---------------------------------------------------------------------------

    Universal lifecycle contract for all out-of-process modules.
    Mount is called once at startup; Cleanup before shutdown.
    """

    def Mount(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 Cleanup(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 HealthCheck(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 GetModuleInfo(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_ModuleLifecycleServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Mount': grpc.unary_unary_rpc_method_handler(
                    servicer.Mount,
                    request_deserializer=amplifier__module__pb2.MountRequest.FromString,
                    response_serializer=amplifier__module__pb2.MountResponse.SerializeToString,
            ),
            'Cleanup': grpc.unary_unary_rpc_method_handler(
                    servicer.Cleanup,
                    request_deserializer=amplifier__module__pb2.Empty.FromString,
                    response_serializer=amplifier__module__pb2.Empty.SerializeToString,
            ),
            'HealthCheck': grpc.unary_unary_rpc_method_handler(
                    servicer.HealthCheck,
                    request_deserializer=amplifier__module__pb2.Empty.FromString,
                    response_serializer=amplifier__module__pb2.HealthCheckResponse.SerializeToString,
            ),
            'GetModuleInfo': grpc.unary_unary_rpc_method_handler(
                    servicer.GetModuleInfo,
                    request_deserializer=amplifier__module__pb2.Empty.FromString,
                    response_serializer=amplifier__module__pb2.ModuleInfo.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'amplifier.module.ModuleLifecycle', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('amplifier.module.ModuleLifecycle', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class ModuleLifecycle(object):
    """---------------------------------------------------------------------------
    ModuleLifecycle — every gRPC module implements this service
    ---------------------------------------------------------------------------

    Universal lifecycle contract for all out-of-process modules.
    Mount is called once at startup; Cleanup before shutdown.
    """

    @staticmethod
    def Mount(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,
            '/amplifier.module.ModuleLifecycle/Mount',
            amplifier__module__pb2.MountRequest.SerializeToString,
            amplifier__module__pb2.MountResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Cleanup(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,
            '/amplifier.module.ModuleLifecycle/Cleanup',
            amplifier__module__pb2.Empty.SerializeToString,
            amplifier__module__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def HealthCheck(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,
            '/amplifier.module.ModuleLifecycle/HealthCheck',
            amplifier__module__pb2.Empty.SerializeToString,
            amplifier__module__pb2.HealthCheckResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetModuleInfo(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,
            '/amplifier.module.ModuleLifecycle/GetModuleInfo',
            amplifier__module__pb2.Empty.SerializeToString,
            amplifier__module__pb2.ModuleInfo.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
