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

from . import base_pb2 as base__pb2
from . import querys_pb2 as querys__pb2
from . import queues_pb2 as queues__pb2
from . import watch_pb2 as watch__pb2
from . import workitems_pb2 as workitems__pb2


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.SetupStream = channel.stream_stream(
                '/openiap.FlowService/SetupStream',
                request_serializer=base__pb2.Envelope.SerializeToString,
                response_deserializer=base__pb2.Envelope.FromString,
                )
        self.Signin = channel.unary_unary(
                '/openiap.FlowService/Signin',
                request_serializer=base__pb2.SigninRequest.SerializeToString,
                response_deserializer=base__pb2.SigninResponse.FromString,
                )
        self.Download = channel.unary_unary(
                '/openiap.FlowService/Download',
                request_serializer=base__pb2.DownloadRequest.SerializeToString,
                response_deserializer=base__pb2.DownloadResponse.FromString,
                )
        self.Upload = channel.unary_unary(
                '/openiap.FlowService/Upload',
                request_serializer=base__pb2.UploadRequest.SerializeToString,
                response_deserializer=base__pb2.UploadResponse.FromString,
                )
        self.CustomCommand = channel.unary_unary(
                '/openiap.FlowService/CustomCommand',
                request_serializer=base__pb2.CustomCommandRequest.SerializeToString,
                response_deserializer=base__pb2.CustomCommandResponse.FromString,
                )
        self.ListCollections = channel.unary_unary(
                '/openiap.FlowService/ListCollections',
                request_serializer=querys__pb2.ListCollectionsRequest.SerializeToString,
                response_deserializer=querys__pb2.ListCollectionsResponse.FromString,
                )
        self.DropCollection = channel.unary_unary(
                '/openiap.FlowService/DropCollection',
                request_serializer=querys__pb2.DropCollectionRequest.SerializeToString,
                response_deserializer=querys__pb2.DropCollectionResponse.FromString,
                )
        self.Query = channel.unary_unary(
                '/openiap.FlowService/Query',
                request_serializer=querys__pb2.QueryRequest.SerializeToString,
                response_deserializer=querys__pb2.QueryResponse.FromString,
                )
        self.GetDocumentVersion = channel.unary_unary(
                '/openiap.FlowService/GetDocumentVersion',
                request_serializer=querys__pb2.GetDocumentVersionRequest.SerializeToString,
                response_deserializer=querys__pb2.GetDocumentVersionResponse.FromString,
                )
        self.Aggregate = channel.unary_unary(
                '/openiap.FlowService/Aggregate',
                request_serializer=querys__pb2.AggregateRequest.SerializeToString,
                response_deserializer=querys__pb2.AggregateResponse.FromString,
                )
        self.Count = channel.unary_unary(
                '/openiap.FlowService/Count',
                request_serializer=querys__pb2.CountRequest.SerializeToString,
                response_deserializer=querys__pb2.CountResponse.FromString,
                )
        self.InsertOne = channel.unary_unary(
                '/openiap.FlowService/InsertOne',
                request_serializer=querys__pb2.InsertOneRequest.SerializeToString,
                response_deserializer=querys__pb2.InsertOneResponse.FromString,
                )
        self.InsertMany = channel.unary_unary(
                '/openiap.FlowService/InsertMany',
                request_serializer=querys__pb2.InsertManyRequest.SerializeToString,
                response_deserializer=querys__pb2.InsertManyResponse.FromString,
                )
        self.UpdateOne = channel.unary_unary(
                '/openiap.FlowService/UpdateOne',
                request_serializer=querys__pb2.UpdateOneRequest.SerializeToString,
                response_deserializer=querys__pb2.UpdateOneResponse.FromString,
                )
        self.UpdateDocument = channel.unary_unary(
                '/openiap.FlowService/UpdateDocument',
                request_serializer=querys__pb2.UpdateDocumentRequest.SerializeToString,
                response_deserializer=querys__pb2.UpdateDocumentResponse.FromString,
                )
        self.InsertOrUpdateOne = channel.unary_unary(
                '/openiap.FlowService/InsertOrUpdateOne',
                request_serializer=querys__pb2.InsertOrUpdateOneRequest.SerializeToString,
                response_deserializer=querys__pb2.InsertOrUpdateOneResponse.FromString,
                )
        self.InsertOrUpdateMany = channel.unary_unary(
                '/openiap.FlowService/InsertOrUpdateMany',
                request_serializer=querys__pb2.InsertOrUpdateManyRequest.SerializeToString,
                response_deserializer=querys__pb2.InsertOrUpdateManyResponse.FromString,
                )
        self.DeleteOne = channel.unary_unary(
                '/openiap.FlowService/DeleteOne',
                request_serializer=querys__pb2.DeleteOneRequest.SerializeToString,
                response_deserializer=querys__pb2.DeleteOneResponse.FromString,
                )
        self.DeleteMany = channel.unary_unary(
                '/openiap.FlowService/DeleteMany',
                request_serializer=querys__pb2.DeleteManyRequest.SerializeToString,
                response_deserializer=querys__pb2.DeleteManyResponse.FromString,
                )
        self.RegisterQueue = channel.unary_unary(
                '/openiap.FlowService/RegisterQueue',
                request_serializer=queues__pb2.RegisterQueueRequest.SerializeToString,
                response_deserializer=queues__pb2.RegisterQueueResponse.FromString,
                )
        self.RegisterExchange = channel.unary_unary(
                '/openiap.FlowService/RegisterExchange',
                request_serializer=queues__pb2.RegisterExchangeRequest.SerializeToString,
                response_deserializer=queues__pb2.RegisterExchangeResponse.FromString,
                )
        self.QueueMessage = channel.unary_unary(
                '/openiap.FlowService/QueueMessage',
                request_serializer=queues__pb2.QueueMessageRequest.SerializeToString,
                response_deserializer=queues__pb2.QueueMessageResponse.FromString,
                )
        self.UnRegisterQueue = channel.unary_unary(
                '/openiap.FlowService/UnRegisterQueue',
                request_serializer=queues__pb2.UnRegisterQueueRequest.SerializeToString,
                response_deserializer=queues__pb2.UnRegisterQueueResponse.FromString,
                )
        self.Watch = channel.unary_unary(
                '/openiap.FlowService/Watch',
                request_serializer=watch__pb2.WatchRequest.SerializeToString,
                response_deserializer=watch__pb2.WatchResponse.FromString,
                )
        self.UnWatch = channel.unary_unary(
                '/openiap.FlowService/UnWatch',
                request_serializer=watch__pb2.UnWatchRequest.SerializeToString,
                response_deserializer=watch__pb2.UnWatchResponse.FromString,
                )
        self.PushWorkitem = channel.unary_unary(
                '/openiap.FlowService/PushWorkitem',
                request_serializer=workitems__pb2.PushWorkitemRequest.SerializeToString,
                response_deserializer=workitems__pb2.PushWorkitemResponse.FromString,
                )
        self.PushWorkitems = channel.unary_unary(
                '/openiap.FlowService/PushWorkitems',
                request_serializer=workitems__pb2.PushWorkitemsRequest.SerializeToString,
                response_deserializer=workitems__pb2.PushWorkitemsResponse.FromString,
                )
        self.UpdateWorkitem = channel.unary_unary(
                '/openiap.FlowService/UpdateWorkitem',
                request_serializer=workitems__pb2.UpdateWorkitemRequest.SerializeToString,
                response_deserializer=workitems__pb2.UpdateWorkitemResponse.FromString,
                )
        self.PopWorkitem = channel.unary_unary(
                '/openiap.FlowService/PopWorkitem',
                request_serializer=workitems__pb2.PopWorkitemRequest.SerializeToString,
                response_deserializer=workitems__pb2.PopWorkitemResponse.FromString,
                )
        self.DeleteWorkitem = channel.unary_unary(
                '/openiap.FlowService/DeleteWorkitem',
                request_serializer=workitems__pb2.DeleteWorkitemRequest.SerializeToString,
                response_deserializer=workitems__pb2.DeleteWorkitemResponse.FromString,
                )
        self.AddWorkItemQueue = channel.unary_unary(
                '/openiap.FlowService/AddWorkItemQueue',
                request_serializer=workitems__pb2.AddWorkItemQueueRequest.SerializeToString,
                response_deserializer=workitems__pb2.AddWorkItemQueueResponse.FromString,
                )


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

    def SetupStream(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 Signin(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 Download(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 Upload(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 CustomCommand(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 ListCollections(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 DropCollection(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 Query(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 GetDocumentVersion(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 Aggregate(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 Count(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 InsertOne(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 InsertMany(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 UpdateOne(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 UpdateDocument(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 InsertOrUpdateOne(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 InsertOrUpdateMany(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 DeleteOne(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 DeleteMany(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 RegisterQueue(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 RegisterExchange(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 QueueMessage(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 UnRegisterQueue(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 UnWatch(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 PushWorkitem(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 PushWorkitems(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 UpdateWorkitem(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 PopWorkitem(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 DeleteWorkitem(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 AddWorkItemQueue(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_FlowServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'SetupStream': grpc.stream_stream_rpc_method_handler(
                    servicer.SetupStream,
                    request_deserializer=base__pb2.Envelope.FromString,
                    response_serializer=base__pb2.Envelope.SerializeToString,
            ),
            'Signin': grpc.unary_unary_rpc_method_handler(
                    servicer.Signin,
                    request_deserializer=base__pb2.SigninRequest.FromString,
                    response_serializer=base__pb2.SigninResponse.SerializeToString,
            ),
            'Download': grpc.unary_unary_rpc_method_handler(
                    servicer.Download,
                    request_deserializer=base__pb2.DownloadRequest.FromString,
                    response_serializer=base__pb2.DownloadResponse.SerializeToString,
            ),
            'Upload': grpc.unary_unary_rpc_method_handler(
                    servicer.Upload,
                    request_deserializer=base__pb2.UploadRequest.FromString,
                    response_serializer=base__pb2.UploadResponse.SerializeToString,
            ),
            'CustomCommand': grpc.unary_unary_rpc_method_handler(
                    servicer.CustomCommand,
                    request_deserializer=base__pb2.CustomCommandRequest.FromString,
                    response_serializer=base__pb2.CustomCommandResponse.SerializeToString,
            ),
            'ListCollections': grpc.unary_unary_rpc_method_handler(
                    servicer.ListCollections,
                    request_deserializer=querys__pb2.ListCollectionsRequest.FromString,
                    response_serializer=querys__pb2.ListCollectionsResponse.SerializeToString,
            ),
            'DropCollection': grpc.unary_unary_rpc_method_handler(
                    servicer.DropCollection,
                    request_deserializer=querys__pb2.DropCollectionRequest.FromString,
                    response_serializer=querys__pb2.DropCollectionResponse.SerializeToString,
            ),
            'Query': grpc.unary_unary_rpc_method_handler(
                    servicer.Query,
                    request_deserializer=querys__pb2.QueryRequest.FromString,
                    response_serializer=querys__pb2.QueryResponse.SerializeToString,
            ),
            'GetDocumentVersion': grpc.unary_unary_rpc_method_handler(
                    servicer.GetDocumentVersion,
                    request_deserializer=querys__pb2.GetDocumentVersionRequest.FromString,
                    response_serializer=querys__pb2.GetDocumentVersionResponse.SerializeToString,
            ),
            'Aggregate': grpc.unary_unary_rpc_method_handler(
                    servicer.Aggregate,
                    request_deserializer=querys__pb2.AggregateRequest.FromString,
                    response_serializer=querys__pb2.AggregateResponse.SerializeToString,
            ),
            'Count': grpc.unary_unary_rpc_method_handler(
                    servicer.Count,
                    request_deserializer=querys__pb2.CountRequest.FromString,
                    response_serializer=querys__pb2.CountResponse.SerializeToString,
            ),
            'InsertOne': grpc.unary_unary_rpc_method_handler(
                    servicer.InsertOne,
                    request_deserializer=querys__pb2.InsertOneRequest.FromString,
                    response_serializer=querys__pb2.InsertOneResponse.SerializeToString,
            ),
            'InsertMany': grpc.unary_unary_rpc_method_handler(
                    servicer.InsertMany,
                    request_deserializer=querys__pb2.InsertManyRequest.FromString,
                    response_serializer=querys__pb2.InsertManyResponse.SerializeToString,
            ),
            'UpdateOne': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateOne,
                    request_deserializer=querys__pb2.UpdateOneRequest.FromString,
                    response_serializer=querys__pb2.UpdateOneResponse.SerializeToString,
            ),
            'UpdateDocument': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateDocument,
                    request_deserializer=querys__pb2.UpdateDocumentRequest.FromString,
                    response_serializer=querys__pb2.UpdateDocumentResponse.SerializeToString,
            ),
            'InsertOrUpdateOne': grpc.unary_unary_rpc_method_handler(
                    servicer.InsertOrUpdateOne,
                    request_deserializer=querys__pb2.InsertOrUpdateOneRequest.FromString,
                    response_serializer=querys__pb2.InsertOrUpdateOneResponse.SerializeToString,
            ),
            'InsertOrUpdateMany': grpc.unary_unary_rpc_method_handler(
                    servicer.InsertOrUpdateMany,
                    request_deserializer=querys__pb2.InsertOrUpdateManyRequest.FromString,
                    response_serializer=querys__pb2.InsertOrUpdateManyResponse.SerializeToString,
            ),
            'DeleteOne': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteOne,
                    request_deserializer=querys__pb2.DeleteOneRequest.FromString,
                    response_serializer=querys__pb2.DeleteOneResponse.SerializeToString,
            ),
            'DeleteMany': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteMany,
                    request_deserializer=querys__pb2.DeleteManyRequest.FromString,
                    response_serializer=querys__pb2.DeleteManyResponse.SerializeToString,
            ),
            'RegisterQueue': grpc.unary_unary_rpc_method_handler(
                    servicer.RegisterQueue,
                    request_deserializer=queues__pb2.RegisterQueueRequest.FromString,
                    response_serializer=queues__pb2.RegisterQueueResponse.SerializeToString,
            ),
            'RegisterExchange': grpc.unary_unary_rpc_method_handler(
                    servicer.RegisterExchange,
                    request_deserializer=queues__pb2.RegisterExchangeRequest.FromString,
                    response_serializer=queues__pb2.RegisterExchangeResponse.SerializeToString,
            ),
            'QueueMessage': grpc.unary_unary_rpc_method_handler(
                    servicer.QueueMessage,
                    request_deserializer=queues__pb2.QueueMessageRequest.FromString,
                    response_serializer=queues__pb2.QueueMessageResponse.SerializeToString,
            ),
            'UnRegisterQueue': grpc.unary_unary_rpc_method_handler(
                    servicer.UnRegisterQueue,
                    request_deserializer=queues__pb2.UnRegisterQueueRequest.FromString,
                    response_serializer=queues__pb2.UnRegisterQueueResponse.SerializeToString,
            ),
            'Watch': grpc.unary_unary_rpc_method_handler(
                    servicer.Watch,
                    request_deserializer=watch__pb2.WatchRequest.FromString,
                    response_serializer=watch__pb2.WatchResponse.SerializeToString,
            ),
            'UnWatch': grpc.unary_unary_rpc_method_handler(
                    servicer.UnWatch,
                    request_deserializer=watch__pb2.UnWatchRequest.FromString,
                    response_serializer=watch__pb2.UnWatchResponse.SerializeToString,
            ),
            'PushWorkitem': grpc.unary_unary_rpc_method_handler(
                    servicer.PushWorkitem,
                    request_deserializer=workitems__pb2.PushWorkitemRequest.FromString,
                    response_serializer=workitems__pb2.PushWorkitemResponse.SerializeToString,
            ),
            'PushWorkitems': grpc.unary_unary_rpc_method_handler(
                    servicer.PushWorkitems,
                    request_deserializer=workitems__pb2.PushWorkitemsRequest.FromString,
                    response_serializer=workitems__pb2.PushWorkitemsResponse.SerializeToString,
            ),
            'UpdateWorkitem': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateWorkitem,
                    request_deserializer=workitems__pb2.UpdateWorkitemRequest.FromString,
                    response_serializer=workitems__pb2.UpdateWorkitemResponse.SerializeToString,
            ),
            'PopWorkitem': grpc.unary_unary_rpc_method_handler(
                    servicer.PopWorkitem,
                    request_deserializer=workitems__pb2.PopWorkitemRequest.FromString,
                    response_serializer=workitems__pb2.PopWorkitemResponse.SerializeToString,
            ),
            'DeleteWorkitem': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteWorkitem,
                    request_deserializer=workitems__pb2.DeleteWorkitemRequest.FromString,
                    response_serializer=workitems__pb2.DeleteWorkitemResponse.SerializeToString,
            ),
            'AddWorkItemQueue': grpc.unary_unary_rpc_method_handler(
                    servicer.AddWorkItemQueue,
                    request_deserializer=workitems__pb2.AddWorkItemQueueRequest.FromString,
                    response_serializer=workitems__pb2.AddWorkItemQueueResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'openiap.FlowService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


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

    @staticmethod
    def SetupStream(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_stream(request_iterator, target, '/openiap.FlowService/SetupStream',
            base__pb2.Envelope.SerializeToString,
            base__pb2.Envelope.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Signin(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, '/openiap.FlowService/Signin',
            base__pb2.SigninRequest.SerializeToString,
            base__pb2.SigninResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Download(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, '/openiap.FlowService/Download',
            base__pb2.DownloadRequest.SerializeToString,
            base__pb2.DownloadResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Upload(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, '/openiap.FlowService/Upload',
            base__pb2.UploadRequest.SerializeToString,
            base__pb2.UploadResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def CustomCommand(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, '/openiap.FlowService/CustomCommand',
            base__pb2.CustomCommandRequest.SerializeToString,
            base__pb2.CustomCommandResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ListCollections(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, '/openiap.FlowService/ListCollections',
            querys__pb2.ListCollectionsRequest.SerializeToString,
            querys__pb2.ListCollectionsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def DropCollection(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, '/openiap.FlowService/DropCollection',
            querys__pb2.DropCollectionRequest.SerializeToString,
            querys__pb2.DropCollectionResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Query(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, '/openiap.FlowService/Query',
            querys__pb2.QueryRequest.SerializeToString,
            querys__pb2.QueryResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetDocumentVersion(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, '/openiap.FlowService/GetDocumentVersion',
            querys__pb2.GetDocumentVersionRequest.SerializeToString,
            querys__pb2.GetDocumentVersionResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Aggregate(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, '/openiap.FlowService/Aggregate',
            querys__pb2.AggregateRequest.SerializeToString,
            querys__pb2.AggregateResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Count(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, '/openiap.FlowService/Count',
            querys__pb2.CountRequest.SerializeToString,
            querys__pb2.CountResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def InsertOne(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, '/openiap.FlowService/InsertOne',
            querys__pb2.InsertOneRequest.SerializeToString,
            querys__pb2.InsertOneResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def InsertMany(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, '/openiap.FlowService/InsertMany',
            querys__pb2.InsertManyRequest.SerializeToString,
            querys__pb2.InsertManyResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def UpdateOne(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, '/openiap.FlowService/UpdateOne',
            querys__pb2.UpdateOneRequest.SerializeToString,
            querys__pb2.UpdateOneResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def UpdateDocument(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, '/openiap.FlowService/UpdateDocument',
            querys__pb2.UpdateDocumentRequest.SerializeToString,
            querys__pb2.UpdateDocumentResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def InsertOrUpdateOne(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, '/openiap.FlowService/InsertOrUpdateOne',
            querys__pb2.InsertOrUpdateOneRequest.SerializeToString,
            querys__pb2.InsertOrUpdateOneResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def InsertOrUpdateMany(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, '/openiap.FlowService/InsertOrUpdateMany',
            querys__pb2.InsertOrUpdateManyRequest.SerializeToString,
            querys__pb2.InsertOrUpdateManyResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def DeleteOne(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, '/openiap.FlowService/DeleteOne',
            querys__pb2.DeleteOneRequest.SerializeToString,
            querys__pb2.DeleteOneResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def DeleteMany(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, '/openiap.FlowService/DeleteMany',
            querys__pb2.DeleteManyRequest.SerializeToString,
            querys__pb2.DeleteManyResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RegisterQueue(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, '/openiap.FlowService/RegisterQueue',
            queues__pb2.RegisterQueueRequest.SerializeToString,
            queues__pb2.RegisterQueueResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RegisterExchange(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, '/openiap.FlowService/RegisterExchange',
            queues__pb2.RegisterExchangeRequest.SerializeToString,
            queues__pb2.RegisterExchangeResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def QueueMessage(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, '/openiap.FlowService/QueueMessage',
            queues__pb2.QueueMessageRequest.SerializeToString,
            queues__pb2.QueueMessageResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def UnRegisterQueue(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, '/openiap.FlowService/UnRegisterQueue',
            queues__pb2.UnRegisterQueueRequest.SerializeToString,
            queues__pb2.UnRegisterQueueResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @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_unary(request, target, '/openiap.FlowService/Watch',
            watch__pb2.WatchRequest.SerializeToString,
            watch__pb2.WatchResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def UnWatch(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, '/openiap.FlowService/UnWatch',
            watch__pb2.UnWatchRequest.SerializeToString,
            watch__pb2.UnWatchResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PushWorkitem(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, '/openiap.FlowService/PushWorkitem',
            workitems__pb2.PushWorkitemRequest.SerializeToString,
            workitems__pb2.PushWorkitemResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PushWorkitems(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, '/openiap.FlowService/PushWorkitems',
            workitems__pb2.PushWorkitemsRequest.SerializeToString,
            workitems__pb2.PushWorkitemsResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def UpdateWorkitem(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, '/openiap.FlowService/UpdateWorkitem',
            workitems__pb2.UpdateWorkitemRequest.SerializeToString,
            workitems__pb2.UpdateWorkitemResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PopWorkitem(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, '/openiap.FlowService/PopWorkitem',
            workitems__pb2.PopWorkitemRequest.SerializeToString,
            workitems__pb2.PopWorkitemResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def DeleteWorkitem(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, '/openiap.FlowService/DeleteWorkitem',
            workitems__pb2.DeleteWorkitemRequest.SerializeToString,
            workitems__pb2.DeleteWorkitemResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def AddWorkItemQueue(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, '/openiap.FlowService/AddWorkItemQueue',
            workitems__pb2.AddWorkItemQueueRequest.SerializeToString,
            workitems__pb2.AddWorkItemQueueResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
