# 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 . import neo4j_service_pb2 as neo4j__service__pb2

GRPC_GENERATED_VERSION = '1.75.1'
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},'
        + f' but the generated code in neo4j_service_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 Neo4jServiceStub(object):
    """========================================
    Neo4j Graph Database Service
    ========================================
    Provides centralized graph database access with:
    - Cypher query language support
    - Node and relationship management
    - Graph algorithms (shortest path, PageRank, etc.)
    - Transaction support
    - Full-text and spatial search

    ========== Cypher Query Operations ==========
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.RunCypher = channel.unary_unary(
                '/isa.neo4j.Neo4jService/RunCypher',
                request_serializer=neo4j__service__pb2.RunCypherRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.RunCypherResponse.FromString,
                _registered_method=True)
        self.RunCypherRead = channel.unary_unary(
                '/isa.neo4j.Neo4jService/RunCypherRead',
                request_serializer=neo4j__service__pb2.RunCypherReadRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.RunCypherReadResponse.FromString,
                _registered_method=True)
        self.RunCypherWrite = channel.unary_unary(
                '/isa.neo4j.Neo4jService/RunCypherWrite',
                request_serializer=neo4j__service__pb2.RunCypherWriteRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.RunCypherWriteResponse.FromString,
                _registered_method=True)
        self.RunCypherBatch = channel.unary_unary(
                '/isa.neo4j.Neo4jService/RunCypherBatch',
                request_serializer=neo4j__service__pb2.RunCypherBatchRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.RunCypherBatchResponse.FromString,
                _registered_method=True)
        self.CreateNode = channel.unary_unary(
                '/isa.neo4j.Neo4jService/CreateNode',
                request_serializer=neo4j__service__pb2.CreateNodeRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.CreateNodeResponse.FromString,
                _registered_method=True)
        self.GetNode = channel.unary_unary(
                '/isa.neo4j.Neo4jService/GetNode',
                request_serializer=neo4j__service__pb2.GetNodeRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.GetNodeResponse.FromString,
                _registered_method=True)
        self.UpdateNode = channel.unary_unary(
                '/isa.neo4j.Neo4jService/UpdateNode',
                request_serializer=neo4j__service__pb2.UpdateNodeRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.UpdateNodeResponse.FromString,
                _registered_method=True)
        self.DeleteNode = channel.unary_unary(
                '/isa.neo4j.Neo4jService/DeleteNode',
                request_serializer=neo4j__service__pb2.DeleteNodeRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.DeleteNodeResponse.FromString,
                _registered_method=True)
        self.MergeNode = channel.unary_unary(
                '/isa.neo4j.Neo4jService/MergeNode',
                request_serializer=neo4j__service__pb2.MergeNodeRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.MergeNodeResponse.FromString,
                _registered_method=True)
        self.FindNodes = channel.unary_unary(
                '/isa.neo4j.Neo4jService/FindNodes',
                request_serializer=neo4j__service__pb2.FindNodesRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.FindNodesResponse.FromString,
                _registered_method=True)
        self.CreateRelationship = channel.unary_unary(
                '/isa.neo4j.Neo4jService/CreateRelationship',
                request_serializer=neo4j__service__pb2.CreateRelationshipRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.CreateRelationshipResponse.FromString,
                _registered_method=True)
        self.GetRelationship = channel.unary_unary(
                '/isa.neo4j.Neo4jService/GetRelationship',
                request_serializer=neo4j__service__pb2.GetRelationshipRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.GetRelationshipResponse.FromString,
                _registered_method=True)
        self.UpdateRelationship = channel.unary_unary(
                '/isa.neo4j.Neo4jService/UpdateRelationship',
                request_serializer=neo4j__service__pb2.UpdateRelationshipRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.UpdateRelationshipResponse.FromString,
                _registered_method=True)
        self.DeleteRelationship = channel.unary_unary(
                '/isa.neo4j.Neo4jService/DeleteRelationship',
                request_serializer=neo4j__service__pb2.DeleteRelationshipRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.DeleteRelationshipResponse.FromString,
                _registered_method=True)
        self.FindRelationships = channel.unary_unary(
                '/isa.neo4j.Neo4jService/FindRelationships',
                request_serializer=neo4j__service__pb2.FindRelationshipsRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.FindRelationshipsResponse.FromString,
                _registered_method=True)
        self.GetNeighbors = channel.unary_unary(
                '/isa.neo4j.Neo4jService/GetNeighbors',
                request_serializer=neo4j__service__pb2.GetNeighborsRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.GetNeighborsResponse.FromString,
                _registered_method=True)
        self.GetPath = channel.unary_unary(
                '/isa.neo4j.Neo4jService/GetPath',
                request_serializer=neo4j__service__pb2.GetPathRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.GetPathResponse.FromString,
                _registered_method=True)
        self.GetShortestPath = channel.unary_unary(
                '/isa.neo4j.Neo4jService/GetShortestPath',
                request_serializer=neo4j__service__pb2.GetShortestPathRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.GetShortestPathResponse.FromString,
                _registered_method=True)
        self.GetAllPaths = channel.unary_unary(
                '/isa.neo4j.Neo4jService/GetAllPaths',
                request_serializer=neo4j__service__pb2.GetAllPathsRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.GetAllPathsResponse.FromString,
                _registered_method=True)
        self.PageRank = channel.unary_unary(
                '/isa.neo4j.Neo4jService/PageRank',
                request_serializer=neo4j__service__pb2.PageRankRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.PageRankResponse.FromString,
                _registered_method=True)
        self.BetweennessCentrality = channel.unary_unary(
                '/isa.neo4j.Neo4jService/BetweennessCentrality',
                request_serializer=neo4j__service__pb2.BetweennessCentralityRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.BetweennessCentralityResponse.FromString,
                _registered_method=True)
        self.CommunityDetection = channel.unary_unary(
                '/isa.neo4j.Neo4jService/CommunityDetection',
                request_serializer=neo4j__service__pb2.CommunityDetectionRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.CommunityDetectionResponse.FromString,
                _registered_method=True)
        self.CreateIndex = channel.unary_unary(
                '/isa.neo4j.Neo4jService/CreateIndex',
                request_serializer=neo4j__service__pb2.CreateIndexRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.CreateIndexResponse.FromString,
                _registered_method=True)
        self.DropIndex = channel.unary_unary(
                '/isa.neo4j.Neo4jService/DropIndex',
                request_serializer=neo4j__service__pb2.DropIndexRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.DropIndexResponse.FromString,
                _registered_method=True)
        self.ListIndexes = channel.unary_unary(
                '/isa.neo4j.Neo4jService/ListIndexes',
                request_serializer=neo4j__service__pb2.ListIndexesRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.ListIndexesResponse.FromString,
                _registered_method=True)
        self.CreateConstraint = channel.unary_unary(
                '/isa.neo4j.Neo4jService/CreateConstraint',
                request_serializer=neo4j__service__pb2.CreateConstraintRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.CreateConstraintResponse.FromString,
                _registered_method=True)
        self.DropConstraint = channel.unary_unary(
                '/isa.neo4j.Neo4jService/DropConstraint',
                request_serializer=neo4j__service__pb2.DropConstraintRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.DropConstraintResponse.FromString,
                _registered_method=True)
        self.ListConstraints = channel.unary_unary(
                '/isa.neo4j.Neo4jService/ListConstraints',
                request_serializer=neo4j__service__pb2.ListConstraintsRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.ListConstraintsResponse.FromString,
                _registered_method=True)
        self.BeginTransaction = channel.unary_unary(
                '/isa.neo4j.Neo4jService/BeginTransaction',
                request_serializer=neo4j__service__pb2.BeginTransactionRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.BeginTransactionResponse.FromString,
                _registered_method=True)
        self.CommitTransaction = channel.unary_unary(
                '/isa.neo4j.Neo4jService/CommitTransaction',
                request_serializer=neo4j__service__pb2.CommitTransactionRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.CommitTransactionResponse.FromString,
                _registered_method=True)
        self.RollbackTransaction = channel.unary_unary(
                '/isa.neo4j.Neo4jService/RollbackTransaction',
                request_serializer=neo4j__service__pb2.RollbackTransactionRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.RollbackTransactionResponse.FromString,
                _registered_method=True)
        self.GetDatabaseInfo = channel.unary_unary(
                '/isa.neo4j.Neo4jService/GetDatabaseInfo',
                request_serializer=neo4j__service__pb2.GetDatabaseInfoRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.GetDatabaseInfoResponse.FromString,
                _registered_method=True)
        self.ListDatabases = channel.unary_unary(
                '/isa.neo4j.Neo4jService/ListDatabases',
                request_serializer=neo4j__service__pb2.ListDatabasesRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.ListDatabasesResponse.FromString,
                _registered_method=True)
        self.GetStatistics = channel.unary_unary(
                '/isa.neo4j.Neo4jService/GetStatistics',
                request_serializer=neo4j__service__pb2.GetStatisticsRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.GetStatisticsResponse.FromString,
                _registered_method=True)
        self.HealthCheck = channel.unary_unary(
                '/isa.neo4j.Neo4jService/HealthCheck',
                request_serializer=neo4j__service__pb2.Neo4jHealthCheckRequest.SerializeToString,
                response_deserializer=neo4j__service__pb2.Neo4jHealthCheckResponse.FromString,
                _registered_method=True)


class Neo4jServiceServicer(object):
    """========================================
    Neo4j Graph Database Service
    ========================================
    Provides centralized graph database access with:
    - Cypher query language support
    - Node and relationship management
    - Graph algorithms (shortest path, PageRank, etc.)
    - Transaction support
    - Full-text and spatial search

    ========== Cypher Query Operations ==========
    """

    def RunCypher(self, request, context):
        """RunCypher - Execute Cypher query
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RunCypherRead(self, request, context):
        """RunCypherRead - Execute read-only Cypher query
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RunCypherWrite(self, request, context):
        """RunCypherWrite - Execute write Cypher query
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RunCypherBatch(self, request, context):
        """RunCypherBatch - Execute multiple Cypher queries in batch
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateNode(self, request, context):
        """========== Node Operations ==========

        CreateNode - Create a new node
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetNode(self, request, context):
        """GetNode - Retrieve node by ID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UpdateNode(self, request, context):
        """UpdateNode - Update node properties
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DeleteNode(self, request, context):
        """DeleteNode - Delete node
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MergeNode(self, request, context):
        """MergeNode - Create or update node (MERGE)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FindNodes(self, request, context):
        """FindNodes - Find nodes by label and properties
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateRelationship(self, request, context):
        """========== Relationship Operations ==========

        CreateRelationship - Create relationship between nodes
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetRelationship(self, request, context):
        """GetRelationship - Retrieve relationship by ID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UpdateRelationship(self, request, context):
        """UpdateRelationship - Update relationship properties
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DeleteRelationship(self, request, context):
        """DeleteRelationship - Delete relationship
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FindRelationships(self, request, context):
        """FindRelationships - Find relationships by type and properties
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetNeighbors(self, request, context):
        """========== Graph Traversal ==========

        GetNeighbors - Get neighboring nodes
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetPath(self, request, context):
        """GetPath - Find path between two nodes
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetShortestPath(self, request, context):
        """GetShortestPath - Find shortest path between nodes
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetAllPaths(self, request, context):
        """GetAllPaths - Find all paths between nodes
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PageRank(self, request, context):
        """========== Graph Algorithms ==========

        PageRank - Run PageRank algorithm
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def BetweennessCentrality(self, request, context):
        """BetweennessCentrality - Calculate betweenness centrality
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CommunityDetection(self, request, context):
        """CommunityDetection - Detect communities in graph
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateIndex(self, request, context):
        """========== Schema Management ==========

        CreateIndex - Create index on label/property
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DropIndex(self, request, context):
        """DropIndex - Drop an index
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ListIndexes(self, request, context):
        """ListIndexes - List all indexes
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateConstraint(self, request, context):
        """CreateConstraint - Create uniqueness or existence constraint
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DropConstraint(self, request, context):
        """DropConstraint - Drop a constraint
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ListConstraints(self, request, context):
        """ListConstraints - List all constraints
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def BeginTransaction(self, request, context):
        """========== Transaction Support ==========

        BeginTransaction - Start a new transaction
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CommitTransaction(self, request, context):
        """CommitTransaction - Commit transaction
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RollbackTransaction(self, request, context):
        """RollbackTransaction - Rollback transaction
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetDatabaseInfo(self, request, context):
        """========== Database Operations ==========

        GetDatabaseInfo - Get database information
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ListDatabases(self, request, context):
        """ListDatabases - List all databases
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetStatistics(self, request, context):
        """GetStatistics - Get database statistics
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def HealthCheck(self, request, context):
        """========== Health Check ==========

        HealthCheck - Service health check
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_Neo4jServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'RunCypher': grpc.unary_unary_rpc_method_handler(
                    servicer.RunCypher,
                    request_deserializer=neo4j__service__pb2.RunCypherRequest.FromString,
                    response_serializer=neo4j__service__pb2.RunCypherResponse.SerializeToString,
            ),
            'RunCypherRead': grpc.unary_unary_rpc_method_handler(
                    servicer.RunCypherRead,
                    request_deserializer=neo4j__service__pb2.RunCypherReadRequest.FromString,
                    response_serializer=neo4j__service__pb2.RunCypherReadResponse.SerializeToString,
            ),
            'RunCypherWrite': grpc.unary_unary_rpc_method_handler(
                    servicer.RunCypherWrite,
                    request_deserializer=neo4j__service__pb2.RunCypherWriteRequest.FromString,
                    response_serializer=neo4j__service__pb2.RunCypherWriteResponse.SerializeToString,
            ),
            'RunCypherBatch': grpc.unary_unary_rpc_method_handler(
                    servicer.RunCypherBatch,
                    request_deserializer=neo4j__service__pb2.RunCypherBatchRequest.FromString,
                    response_serializer=neo4j__service__pb2.RunCypherBatchResponse.SerializeToString,
            ),
            'CreateNode': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateNode,
                    request_deserializer=neo4j__service__pb2.CreateNodeRequest.FromString,
                    response_serializer=neo4j__service__pb2.CreateNodeResponse.SerializeToString,
            ),
            'GetNode': grpc.unary_unary_rpc_method_handler(
                    servicer.GetNode,
                    request_deserializer=neo4j__service__pb2.GetNodeRequest.FromString,
                    response_serializer=neo4j__service__pb2.GetNodeResponse.SerializeToString,
            ),
            'UpdateNode': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateNode,
                    request_deserializer=neo4j__service__pb2.UpdateNodeRequest.FromString,
                    response_serializer=neo4j__service__pb2.UpdateNodeResponse.SerializeToString,
            ),
            'DeleteNode': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteNode,
                    request_deserializer=neo4j__service__pb2.DeleteNodeRequest.FromString,
                    response_serializer=neo4j__service__pb2.DeleteNodeResponse.SerializeToString,
            ),
            'MergeNode': grpc.unary_unary_rpc_method_handler(
                    servicer.MergeNode,
                    request_deserializer=neo4j__service__pb2.MergeNodeRequest.FromString,
                    response_serializer=neo4j__service__pb2.MergeNodeResponse.SerializeToString,
            ),
            'FindNodes': grpc.unary_unary_rpc_method_handler(
                    servicer.FindNodes,
                    request_deserializer=neo4j__service__pb2.FindNodesRequest.FromString,
                    response_serializer=neo4j__service__pb2.FindNodesResponse.SerializeToString,
            ),
            'CreateRelationship': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateRelationship,
                    request_deserializer=neo4j__service__pb2.CreateRelationshipRequest.FromString,
                    response_serializer=neo4j__service__pb2.CreateRelationshipResponse.SerializeToString,
            ),
            'GetRelationship': grpc.unary_unary_rpc_method_handler(
                    servicer.GetRelationship,
                    request_deserializer=neo4j__service__pb2.GetRelationshipRequest.FromString,
                    response_serializer=neo4j__service__pb2.GetRelationshipResponse.SerializeToString,
            ),
            'UpdateRelationship': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateRelationship,
                    request_deserializer=neo4j__service__pb2.UpdateRelationshipRequest.FromString,
                    response_serializer=neo4j__service__pb2.UpdateRelationshipResponse.SerializeToString,
            ),
            'DeleteRelationship': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteRelationship,
                    request_deserializer=neo4j__service__pb2.DeleteRelationshipRequest.FromString,
                    response_serializer=neo4j__service__pb2.DeleteRelationshipResponse.SerializeToString,
            ),
            'FindRelationships': grpc.unary_unary_rpc_method_handler(
                    servicer.FindRelationships,
                    request_deserializer=neo4j__service__pb2.FindRelationshipsRequest.FromString,
                    response_serializer=neo4j__service__pb2.FindRelationshipsResponse.SerializeToString,
            ),
            'GetNeighbors': grpc.unary_unary_rpc_method_handler(
                    servicer.GetNeighbors,
                    request_deserializer=neo4j__service__pb2.GetNeighborsRequest.FromString,
                    response_serializer=neo4j__service__pb2.GetNeighborsResponse.SerializeToString,
            ),
            'GetPath': grpc.unary_unary_rpc_method_handler(
                    servicer.GetPath,
                    request_deserializer=neo4j__service__pb2.GetPathRequest.FromString,
                    response_serializer=neo4j__service__pb2.GetPathResponse.SerializeToString,
            ),
            'GetShortestPath': grpc.unary_unary_rpc_method_handler(
                    servicer.GetShortestPath,
                    request_deserializer=neo4j__service__pb2.GetShortestPathRequest.FromString,
                    response_serializer=neo4j__service__pb2.GetShortestPathResponse.SerializeToString,
            ),
            'GetAllPaths': grpc.unary_unary_rpc_method_handler(
                    servicer.GetAllPaths,
                    request_deserializer=neo4j__service__pb2.GetAllPathsRequest.FromString,
                    response_serializer=neo4j__service__pb2.GetAllPathsResponse.SerializeToString,
            ),
            'PageRank': grpc.unary_unary_rpc_method_handler(
                    servicer.PageRank,
                    request_deserializer=neo4j__service__pb2.PageRankRequest.FromString,
                    response_serializer=neo4j__service__pb2.PageRankResponse.SerializeToString,
            ),
            'BetweennessCentrality': grpc.unary_unary_rpc_method_handler(
                    servicer.BetweennessCentrality,
                    request_deserializer=neo4j__service__pb2.BetweennessCentralityRequest.FromString,
                    response_serializer=neo4j__service__pb2.BetweennessCentralityResponse.SerializeToString,
            ),
            'CommunityDetection': grpc.unary_unary_rpc_method_handler(
                    servicer.CommunityDetection,
                    request_deserializer=neo4j__service__pb2.CommunityDetectionRequest.FromString,
                    response_serializer=neo4j__service__pb2.CommunityDetectionResponse.SerializeToString,
            ),
            'CreateIndex': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateIndex,
                    request_deserializer=neo4j__service__pb2.CreateIndexRequest.FromString,
                    response_serializer=neo4j__service__pb2.CreateIndexResponse.SerializeToString,
            ),
            'DropIndex': grpc.unary_unary_rpc_method_handler(
                    servicer.DropIndex,
                    request_deserializer=neo4j__service__pb2.DropIndexRequest.FromString,
                    response_serializer=neo4j__service__pb2.DropIndexResponse.SerializeToString,
            ),
            'ListIndexes': grpc.unary_unary_rpc_method_handler(
                    servicer.ListIndexes,
                    request_deserializer=neo4j__service__pb2.ListIndexesRequest.FromString,
                    response_serializer=neo4j__service__pb2.ListIndexesResponse.SerializeToString,
            ),
            'CreateConstraint': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateConstraint,
                    request_deserializer=neo4j__service__pb2.CreateConstraintRequest.FromString,
                    response_serializer=neo4j__service__pb2.CreateConstraintResponse.SerializeToString,
            ),
            'DropConstraint': grpc.unary_unary_rpc_method_handler(
                    servicer.DropConstraint,
                    request_deserializer=neo4j__service__pb2.DropConstraintRequest.FromString,
                    response_serializer=neo4j__service__pb2.DropConstraintResponse.SerializeToString,
            ),
            'ListConstraints': grpc.unary_unary_rpc_method_handler(
                    servicer.ListConstraints,
                    request_deserializer=neo4j__service__pb2.ListConstraintsRequest.FromString,
                    response_serializer=neo4j__service__pb2.ListConstraintsResponse.SerializeToString,
            ),
            'BeginTransaction': grpc.unary_unary_rpc_method_handler(
                    servicer.BeginTransaction,
                    request_deserializer=neo4j__service__pb2.BeginTransactionRequest.FromString,
                    response_serializer=neo4j__service__pb2.BeginTransactionResponse.SerializeToString,
            ),
            'CommitTransaction': grpc.unary_unary_rpc_method_handler(
                    servicer.CommitTransaction,
                    request_deserializer=neo4j__service__pb2.CommitTransactionRequest.FromString,
                    response_serializer=neo4j__service__pb2.CommitTransactionResponse.SerializeToString,
            ),
            'RollbackTransaction': grpc.unary_unary_rpc_method_handler(
                    servicer.RollbackTransaction,
                    request_deserializer=neo4j__service__pb2.RollbackTransactionRequest.FromString,
                    response_serializer=neo4j__service__pb2.RollbackTransactionResponse.SerializeToString,
            ),
            'GetDatabaseInfo': grpc.unary_unary_rpc_method_handler(
                    servicer.GetDatabaseInfo,
                    request_deserializer=neo4j__service__pb2.GetDatabaseInfoRequest.FromString,
                    response_serializer=neo4j__service__pb2.GetDatabaseInfoResponse.SerializeToString,
            ),
            'ListDatabases': grpc.unary_unary_rpc_method_handler(
                    servicer.ListDatabases,
                    request_deserializer=neo4j__service__pb2.ListDatabasesRequest.FromString,
                    response_serializer=neo4j__service__pb2.ListDatabasesResponse.SerializeToString,
            ),
            'GetStatistics': grpc.unary_unary_rpc_method_handler(
                    servicer.GetStatistics,
                    request_deserializer=neo4j__service__pb2.GetStatisticsRequest.FromString,
                    response_serializer=neo4j__service__pb2.GetStatisticsResponse.SerializeToString,
            ),
            'HealthCheck': grpc.unary_unary_rpc_method_handler(
                    servicer.HealthCheck,
                    request_deserializer=neo4j__service__pb2.Neo4jHealthCheckRequest.FromString,
                    response_serializer=neo4j__service__pb2.Neo4jHealthCheckResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'isa.neo4j.Neo4jService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('isa.neo4j.Neo4jService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class Neo4jService(object):
    """========================================
    Neo4j Graph Database Service
    ========================================
    Provides centralized graph database access with:
    - Cypher query language support
    - Node and relationship management
    - Graph algorithms (shortest path, PageRank, etc.)
    - Transaction support
    - Full-text and spatial search

    ========== Cypher Query Operations ==========
    """

    @staticmethod
    def RunCypher(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,
            '/isa.neo4j.Neo4jService/RunCypher',
            neo4j__service__pb2.RunCypherRequest.SerializeToString,
            neo4j__service__pb2.RunCypherResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RunCypherRead(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,
            '/isa.neo4j.Neo4jService/RunCypherRead',
            neo4j__service__pb2.RunCypherReadRequest.SerializeToString,
            neo4j__service__pb2.RunCypherReadResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RunCypherWrite(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,
            '/isa.neo4j.Neo4jService/RunCypherWrite',
            neo4j__service__pb2.RunCypherWriteRequest.SerializeToString,
            neo4j__service__pb2.RunCypherWriteResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RunCypherBatch(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,
            '/isa.neo4j.Neo4jService/RunCypherBatch',
            neo4j__service__pb2.RunCypherBatchRequest.SerializeToString,
            neo4j__service__pb2.RunCypherBatchResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateNode(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,
            '/isa.neo4j.Neo4jService/CreateNode',
            neo4j__service__pb2.CreateNodeRequest.SerializeToString,
            neo4j__service__pb2.CreateNodeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetNode(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,
            '/isa.neo4j.Neo4jService/GetNode',
            neo4j__service__pb2.GetNodeRequest.SerializeToString,
            neo4j__service__pb2.GetNodeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateNode(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,
            '/isa.neo4j.Neo4jService/UpdateNode',
            neo4j__service__pb2.UpdateNodeRequest.SerializeToString,
            neo4j__service__pb2.UpdateNodeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteNode(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,
            '/isa.neo4j.Neo4jService/DeleteNode',
            neo4j__service__pb2.DeleteNodeRequest.SerializeToString,
            neo4j__service__pb2.DeleteNodeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def MergeNode(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,
            '/isa.neo4j.Neo4jService/MergeNode',
            neo4j__service__pb2.MergeNodeRequest.SerializeToString,
            neo4j__service__pb2.MergeNodeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FindNodes(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,
            '/isa.neo4j.Neo4jService/FindNodes',
            neo4j__service__pb2.FindNodesRequest.SerializeToString,
            neo4j__service__pb2.FindNodesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateRelationship(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,
            '/isa.neo4j.Neo4jService/CreateRelationship',
            neo4j__service__pb2.CreateRelationshipRequest.SerializeToString,
            neo4j__service__pb2.CreateRelationshipResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetRelationship(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,
            '/isa.neo4j.Neo4jService/GetRelationship',
            neo4j__service__pb2.GetRelationshipRequest.SerializeToString,
            neo4j__service__pb2.GetRelationshipResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateRelationship(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,
            '/isa.neo4j.Neo4jService/UpdateRelationship',
            neo4j__service__pb2.UpdateRelationshipRequest.SerializeToString,
            neo4j__service__pb2.UpdateRelationshipResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteRelationship(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,
            '/isa.neo4j.Neo4jService/DeleteRelationship',
            neo4j__service__pb2.DeleteRelationshipRequest.SerializeToString,
            neo4j__service__pb2.DeleteRelationshipResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FindRelationships(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,
            '/isa.neo4j.Neo4jService/FindRelationships',
            neo4j__service__pb2.FindRelationshipsRequest.SerializeToString,
            neo4j__service__pb2.FindRelationshipsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetNeighbors(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,
            '/isa.neo4j.Neo4jService/GetNeighbors',
            neo4j__service__pb2.GetNeighborsRequest.SerializeToString,
            neo4j__service__pb2.GetNeighborsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetPath(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,
            '/isa.neo4j.Neo4jService/GetPath',
            neo4j__service__pb2.GetPathRequest.SerializeToString,
            neo4j__service__pb2.GetPathResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetShortestPath(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,
            '/isa.neo4j.Neo4jService/GetShortestPath',
            neo4j__service__pb2.GetShortestPathRequest.SerializeToString,
            neo4j__service__pb2.GetShortestPathResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetAllPaths(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,
            '/isa.neo4j.Neo4jService/GetAllPaths',
            neo4j__service__pb2.GetAllPathsRequest.SerializeToString,
            neo4j__service__pb2.GetAllPathsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def PageRank(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,
            '/isa.neo4j.Neo4jService/PageRank',
            neo4j__service__pb2.PageRankRequest.SerializeToString,
            neo4j__service__pb2.PageRankResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def BetweennessCentrality(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,
            '/isa.neo4j.Neo4jService/BetweennessCentrality',
            neo4j__service__pb2.BetweennessCentralityRequest.SerializeToString,
            neo4j__service__pb2.BetweennessCentralityResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CommunityDetection(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,
            '/isa.neo4j.Neo4jService/CommunityDetection',
            neo4j__service__pb2.CommunityDetectionRequest.SerializeToString,
            neo4j__service__pb2.CommunityDetectionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateIndex(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,
            '/isa.neo4j.Neo4jService/CreateIndex',
            neo4j__service__pb2.CreateIndexRequest.SerializeToString,
            neo4j__service__pb2.CreateIndexResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DropIndex(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,
            '/isa.neo4j.Neo4jService/DropIndex',
            neo4j__service__pb2.DropIndexRequest.SerializeToString,
            neo4j__service__pb2.DropIndexResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListIndexes(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,
            '/isa.neo4j.Neo4jService/ListIndexes',
            neo4j__service__pb2.ListIndexesRequest.SerializeToString,
            neo4j__service__pb2.ListIndexesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateConstraint(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,
            '/isa.neo4j.Neo4jService/CreateConstraint',
            neo4j__service__pb2.CreateConstraintRequest.SerializeToString,
            neo4j__service__pb2.CreateConstraintResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DropConstraint(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,
            '/isa.neo4j.Neo4jService/DropConstraint',
            neo4j__service__pb2.DropConstraintRequest.SerializeToString,
            neo4j__service__pb2.DropConstraintResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListConstraints(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,
            '/isa.neo4j.Neo4jService/ListConstraints',
            neo4j__service__pb2.ListConstraintsRequest.SerializeToString,
            neo4j__service__pb2.ListConstraintsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def BeginTransaction(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,
            '/isa.neo4j.Neo4jService/BeginTransaction',
            neo4j__service__pb2.BeginTransactionRequest.SerializeToString,
            neo4j__service__pb2.BeginTransactionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CommitTransaction(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,
            '/isa.neo4j.Neo4jService/CommitTransaction',
            neo4j__service__pb2.CommitTransactionRequest.SerializeToString,
            neo4j__service__pb2.CommitTransactionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RollbackTransaction(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,
            '/isa.neo4j.Neo4jService/RollbackTransaction',
            neo4j__service__pb2.RollbackTransactionRequest.SerializeToString,
            neo4j__service__pb2.RollbackTransactionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetDatabaseInfo(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,
            '/isa.neo4j.Neo4jService/GetDatabaseInfo',
            neo4j__service__pb2.GetDatabaseInfoRequest.SerializeToString,
            neo4j__service__pb2.GetDatabaseInfoResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListDatabases(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,
            '/isa.neo4j.Neo4jService/ListDatabases',
            neo4j__service__pb2.ListDatabasesRequest.SerializeToString,
            neo4j__service__pb2.ListDatabasesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetStatistics(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,
            '/isa.neo4j.Neo4jService/GetStatistics',
            neo4j__service__pb2.GetStatisticsRequest.SerializeToString,
            neo4j__service__pb2.GetStatisticsResponse.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,
            '/isa.neo4j.Neo4jService/HealthCheck',
            neo4j__service__pb2.Neo4jHealthCheckRequest.SerializeToString,
            neo4j__service__pb2.Neo4jHealthCheckResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
