# 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 servicebridge_pb2 as servicebridge__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 servicebridge_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 ServiceBridgeStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.RegisterFunction = channel.unary_unary(
                '/servicebridge.ServiceBridge/RegisterFunction',
                request_serializer=servicebridge__pb2.RegisterFunctionRequest.SerializeToString,
                response_deserializer=servicebridge__pb2.RegisterFunctionResponse.FromString,
                _registered_method=True)
        self.RegisterConsumerGroup = channel.unary_unary(
                '/servicebridge.ServiceBridge/RegisterConsumerGroup',
                request_serializer=servicebridge__pb2.RegisterConsumerGroupRequest.SerializeToString,
                response_deserializer=servicebridge__pb2.RegisterConsumerGroupResponse.FromString,
                _registered_method=True)
        self.RegisterGroupMember = channel.unary_unary(
                '/servicebridge.ServiceBridge/RegisterGroupMember',
                request_serializer=servicebridge__pb2.RegisterGroupMemberRequest.SerializeToString,
                response_deserializer=servicebridge__pb2.RegisterGroupMemberResponse.FromString,
                _registered_method=True)
        self.Heartbeat = channel.unary_unary(
                '/servicebridge.ServiceBridge/Heartbeat',
                request_serializer=servicebridge__pb2.HeartbeatRequest.SerializeToString,
                response_deserializer=servicebridge__pb2.HeartbeatResponse.FromString,
                _registered_method=True)
        self.RegisterWorkflow = channel.unary_unary(
                '/servicebridge.ServiceBridge/RegisterWorkflow',
                request_serializer=servicebridge__pb2.RegisterWorkflowRequest.SerializeToString,
                response_deserializer=servicebridge__pb2.RegisterWorkflowResponse.FromString,
                _registered_method=True)
        self.RegisterJob = channel.unary_unary(
                '/servicebridge.ServiceBridge/RegisterJob',
                request_serializer=servicebridge__pb2.RegisterJobRequest.SerializeToString,
                response_deserializer=servicebridge__pb2.RegisterJobResponse.FromString,
                _registered_method=True)
        self.WatchRegistry = channel.unary_stream(
                '/servicebridge.ServiceBridge/WatchRegistry',
                request_serializer=servicebridge__pb2.WatchRegistryRequest.SerializeToString,
                response_deserializer=servicebridge__pb2.RegistryMessage.FromString,
                _registered_method=True)
        self.LookupFunction = channel.unary_unary(
                '/servicebridge.ServiceBridge/LookupFunction',
                request_serializer=servicebridge__pb2.LookupFunctionRequest.SerializeToString,
                response_deserializer=servicebridge__pb2.LookupFunctionResponse.FromString,
                _registered_method=True)
        self.ReportCallStart = channel.unary_unary(
                '/servicebridge.ServiceBridge/ReportCallStart',
                request_serializer=servicebridge__pb2.ReportCallStartRequest.SerializeToString,
                response_deserializer=servicebridge__pb2.ReportCallResponse.FromString,
                _registered_method=True)
        self.ReportCall = channel.unary_unary(
                '/servicebridge.ServiceBridge/ReportCall',
                request_serializer=servicebridge__pb2.ReportCallRequest.SerializeToString,
                response_deserializer=servicebridge__pb2.ReportCallResponse.FromString,
                _registered_method=True)
        self.ReportLog = channel.unary_unary(
                '/servicebridge.ServiceBridge/ReportLog',
                request_serializer=servicebridge__pb2.ReportLogRequest.SerializeToString,
                response_deserializer=servicebridge__pb2.ReportLogResponse.FromString,
                _registered_method=True)
        self.Publish = channel.unary_unary(
                '/servicebridge.ServiceBridge/Publish',
                request_serializer=servicebridge__pb2.PublishRequest.SerializeToString,
                response_deserializer=servicebridge__pb2.PublishResponse.FromString,
                _registered_method=True)
        self.AppendStream = channel.unary_unary(
                '/servicebridge.ServiceBridge/AppendStream',
                request_serializer=servicebridge__pb2.AppendStreamRequest.SerializeToString,
                response_deserializer=servicebridge__pb2.AppendStreamResponse.FromString,
                _registered_method=True)
        self.WatchRun = channel.unary_stream(
                '/servicebridge.ServiceBridge/WatchRun',
                request_serializer=servicebridge__pb2.WatchRunRequest.SerializeToString,
                response_deserializer=servicebridge__pb2.RunStreamChunk.FromString,
                _registered_method=True)


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

    def RegisterFunction(self, request, context):
        """Control plane
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RegisterConsumerGroup(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 RegisterGroupMember(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 RegisterWorkflow(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 RegisterJob(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 WatchRegistry(self, request, context):
        """Service discovery
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def LookupFunction(self, request, context):
        """On-demand lookup for a single function — no streaming, no full registry push.
        Use this for lazy endpoint resolution when the function is not pre-subscribed.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ReportCallStart(self, request, context):
        """Telemetry (internal path kept for SDK-compatible spans)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ReportCall(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 ReportLog(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 Publish(self, request, context):
        """Queue publish
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AppendStream(self, request, context):
        """Realtime streams
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def WatchRun(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_ServiceBridgeServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'RegisterFunction': grpc.unary_unary_rpc_method_handler(
                    servicer.RegisterFunction,
                    request_deserializer=servicebridge__pb2.RegisterFunctionRequest.FromString,
                    response_serializer=servicebridge__pb2.RegisterFunctionResponse.SerializeToString,
            ),
            'RegisterConsumerGroup': grpc.unary_unary_rpc_method_handler(
                    servicer.RegisterConsumerGroup,
                    request_deserializer=servicebridge__pb2.RegisterConsumerGroupRequest.FromString,
                    response_serializer=servicebridge__pb2.RegisterConsumerGroupResponse.SerializeToString,
            ),
            'RegisterGroupMember': grpc.unary_unary_rpc_method_handler(
                    servicer.RegisterGroupMember,
                    request_deserializer=servicebridge__pb2.RegisterGroupMemberRequest.FromString,
                    response_serializer=servicebridge__pb2.RegisterGroupMemberResponse.SerializeToString,
            ),
            'Heartbeat': grpc.unary_unary_rpc_method_handler(
                    servicer.Heartbeat,
                    request_deserializer=servicebridge__pb2.HeartbeatRequest.FromString,
                    response_serializer=servicebridge__pb2.HeartbeatResponse.SerializeToString,
            ),
            'RegisterWorkflow': grpc.unary_unary_rpc_method_handler(
                    servicer.RegisterWorkflow,
                    request_deserializer=servicebridge__pb2.RegisterWorkflowRequest.FromString,
                    response_serializer=servicebridge__pb2.RegisterWorkflowResponse.SerializeToString,
            ),
            'RegisterJob': grpc.unary_unary_rpc_method_handler(
                    servicer.RegisterJob,
                    request_deserializer=servicebridge__pb2.RegisterJobRequest.FromString,
                    response_serializer=servicebridge__pb2.RegisterJobResponse.SerializeToString,
            ),
            'WatchRegistry': grpc.unary_stream_rpc_method_handler(
                    servicer.WatchRegistry,
                    request_deserializer=servicebridge__pb2.WatchRegistryRequest.FromString,
                    response_serializer=servicebridge__pb2.RegistryMessage.SerializeToString,
            ),
            'LookupFunction': grpc.unary_unary_rpc_method_handler(
                    servicer.LookupFunction,
                    request_deserializer=servicebridge__pb2.LookupFunctionRequest.FromString,
                    response_serializer=servicebridge__pb2.LookupFunctionResponse.SerializeToString,
            ),
            'ReportCallStart': grpc.unary_unary_rpc_method_handler(
                    servicer.ReportCallStart,
                    request_deserializer=servicebridge__pb2.ReportCallStartRequest.FromString,
                    response_serializer=servicebridge__pb2.ReportCallResponse.SerializeToString,
            ),
            'ReportCall': grpc.unary_unary_rpc_method_handler(
                    servicer.ReportCall,
                    request_deserializer=servicebridge__pb2.ReportCallRequest.FromString,
                    response_serializer=servicebridge__pb2.ReportCallResponse.SerializeToString,
            ),
            'ReportLog': grpc.unary_unary_rpc_method_handler(
                    servicer.ReportLog,
                    request_deserializer=servicebridge__pb2.ReportLogRequest.FromString,
                    response_serializer=servicebridge__pb2.ReportLogResponse.SerializeToString,
            ),
            'Publish': grpc.unary_unary_rpc_method_handler(
                    servicer.Publish,
                    request_deserializer=servicebridge__pb2.PublishRequest.FromString,
                    response_serializer=servicebridge__pb2.PublishResponse.SerializeToString,
            ),
            'AppendStream': grpc.unary_unary_rpc_method_handler(
                    servicer.AppendStream,
                    request_deserializer=servicebridge__pb2.AppendStreamRequest.FromString,
                    response_serializer=servicebridge__pb2.AppendStreamResponse.SerializeToString,
            ),
            'WatchRun': grpc.unary_stream_rpc_method_handler(
                    servicer.WatchRun,
                    request_deserializer=servicebridge__pb2.WatchRunRequest.FromString,
                    response_serializer=servicebridge__pb2.RunStreamChunk.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'servicebridge.ServiceBridge', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('servicebridge.ServiceBridge', rpc_method_handlers)


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

    @staticmethod
    def RegisterFunction(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,
            '/servicebridge.ServiceBridge/RegisterFunction',
            servicebridge__pb2.RegisterFunctionRequest.SerializeToString,
            servicebridge__pb2.RegisterFunctionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RegisterConsumerGroup(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,
            '/servicebridge.ServiceBridge/RegisterConsumerGroup',
            servicebridge__pb2.RegisterConsumerGroupRequest.SerializeToString,
            servicebridge__pb2.RegisterConsumerGroupResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RegisterGroupMember(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,
            '/servicebridge.ServiceBridge/RegisterGroupMember',
            servicebridge__pb2.RegisterGroupMemberRequest.SerializeToString,
            servicebridge__pb2.RegisterGroupMemberResponse.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,
            '/servicebridge.ServiceBridge/Heartbeat',
            servicebridge__pb2.HeartbeatRequest.SerializeToString,
            servicebridge__pb2.HeartbeatResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RegisterWorkflow(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,
            '/servicebridge.ServiceBridge/RegisterWorkflow',
            servicebridge__pb2.RegisterWorkflowRequest.SerializeToString,
            servicebridge__pb2.RegisterWorkflowResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RegisterJob(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,
            '/servicebridge.ServiceBridge/RegisterJob',
            servicebridge__pb2.RegisterJobRequest.SerializeToString,
            servicebridge__pb2.RegisterJobResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def WatchRegistry(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,
            '/servicebridge.ServiceBridge/WatchRegistry',
            servicebridge__pb2.WatchRegistryRequest.SerializeToString,
            servicebridge__pb2.RegistryMessage.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def LookupFunction(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,
            '/servicebridge.ServiceBridge/LookupFunction',
            servicebridge__pb2.LookupFunctionRequest.SerializeToString,
            servicebridge__pb2.LookupFunctionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ReportCallStart(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,
            '/servicebridge.ServiceBridge/ReportCallStart',
            servicebridge__pb2.ReportCallStartRequest.SerializeToString,
            servicebridge__pb2.ReportCallResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ReportCall(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,
            '/servicebridge.ServiceBridge/ReportCall',
            servicebridge__pb2.ReportCallRequest.SerializeToString,
            servicebridge__pb2.ReportCallResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ReportLog(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,
            '/servicebridge.ServiceBridge/ReportLog',
            servicebridge__pb2.ReportLogRequest.SerializeToString,
            servicebridge__pb2.ReportLogResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Publish(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,
            '/servicebridge.ServiceBridge/Publish',
            servicebridge__pb2.PublishRequest.SerializeToString,
            servicebridge__pb2.PublishResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AppendStream(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,
            '/servicebridge.ServiceBridge/AppendStream',
            servicebridge__pb2.AppendStreamRequest.SerializeToString,
            servicebridge__pb2.AppendStreamResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def WatchRun(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,
            '/servicebridge.ServiceBridge/WatchRun',
            servicebridge__pb2.WatchRunRequest.SerializeToString,
            servicebridge__pb2.RunStreamChunk.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.Handle = channel.unary_unary(
                '/servicebridge.ServiceBridgeWorker/Handle',
                request_serializer=servicebridge__pb2.HandleRequest.SerializeToString,
                response_deserializer=servicebridge__pb2.HandleResponse.FromString,
                _registered_method=True)
        self.DeliverMessage = channel.unary_unary(
                '/servicebridge.ServiceBridgeWorker/DeliverMessage',
                request_serializer=servicebridge__pb2.DeliverMessageRequest.SerializeToString,
                response_deserializer=servicebridge__pb2.DeliveryAck.FromString,
                _registered_method=True)


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

    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 DeliverMessage(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_ServiceBridgeWorkerServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Handle': grpc.unary_unary_rpc_method_handler(
                    servicer.Handle,
                    request_deserializer=servicebridge__pb2.HandleRequest.FromString,
                    response_serializer=servicebridge__pb2.HandleResponse.SerializeToString,
            ),
            'DeliverMessage': grpc.unary_unary_rpc_method_handler(
                    servicer.DeliverMessage,
                    request_deserializer=servicebridge__pb2.DeliverMessageRequest.FromString,
                    response_serializer=servicebridge__pb2.DeliveryAck.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'servicebridge.ServiceBridgeWorker', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('servicebridge.ServiceBridgeWorker', rpc_method_handlers)


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

    @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,
            '/servicebridge.ServiceBridgeWorker/Handle',
            servicebridge__pb2.HandleRequest.SerializeToString,
            servicebridge__pb2.HandleResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeliverMessage(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,
            '/servicebridge.ServiceBridgeWorker/DeliverMessage',
            servicebridge__pb2.DeliverMessageRequest.SerializeToString,
            servicebridge__pb2.DeliveryAck.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
