# 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 kumiho_pb2 as kumiho__pb2

GRPC_GENERATED_VERSION = '1.76.0'
GRPC_VERSION = grpc.__version__
_version_not_supported = False

try:
    from grpc._utilities import first_version_is_lower
    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
except ImportError:
    _version_not_supported = True

if _version_not_supported:
    raise RuntimeError(
        f'The grpc package installed is at version {GRPC_VERSION},'
        + ' but the generated code in kumiho_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 KumihoServiceStub(object):
    """The Kumiho service definition.
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.CreateProject = channel.unary_unary(
                '/kumiho.KumihoService/CreateProject',
                request_serializer=kumiho__pb2.CreateProjectRequest.SerializeToString,
                response_deserializer=kumiho__pb2.ProjectResponse.FromString,
                _registered_method=True)
        self.GetProjects = channel.unary_unary(
                '/kumiho.KumihoService/GetProjects',
                request_serializer=kumiho__pb2.GetProjectsRequest.SerializeToString,
                response_deserializer=kumiho__pb2.GetProjectsResponse.FromString,
                _registered_method=True)
        self.UpdateProject = channel.unary_unary(
                '/kumiho.KumihoService/UpdateProject',
                request_serializer=kumiho__pb2.UpdateProjectRequest.SerializeToString,
                response_deserializer=kumiho__pb2.ProjectResponse.FromString,
                _registered_method=True)
        self.DeleteProject = channel.unary_unary(
                '/kumiho.KumihoService/DeleteProject',
                request_serializer=kumiho__pb2.DeleteProjectRequest.SerializeToString,
                response_deserializer=kumiho__pb2.StatusResponse.FromString,
                _registered_method=True)
        self.CreateSpace = channel.unary_unary(
                '/kumiho.KumihoService/CreateSpace',
                request_serializer=kumiho__pb2.CreateSpaceRequest.SerializeToString,
                response_deserializer=kumiho__pb2.SpaceResponse.FromString,
                _registered_method=True)
        self.GetSpace = channel.unary_unary(
                '/kumiho.KumihoService/GetSpace',
                request_serializer=kumiho__pb2.GetSpaceRequest.SerializeToString,
                response_deserializer=kumiho__pb2.SpaceResponse.FromString,
                _registered_method=True)
        self.GetChildSpaces = channel.unary_unary(
                '/kumiho.KumihoService/GetChildSpaces',
                request_serializer=kumiho__pb2.GetChildSpacesRequest.SerializeToString,
                response_deserializer=kumiho__pb2.GetChildSpacesResponse.FromString,
                _registered_method=True)
        self.DeleteSpace = channel.unary_unary(
                '/kumiho.KumihoService/DeleteSpace',
                request_serializer=kumiho__pb2.DeleteSpaceRequest.SerializeToString,
                response_deserializer=kumiho__pb2.StatusResponse.FromString,
                _registered_method=True)
        self.UpdateSpaceMetadata = channel.unary_unary(
                '/kumiho.KumihoService/UpdateSpaceMetadata',
                request_serializer=kumiho__pb2.UpdateMetadataRequest.SerializeToString,
                response_deserializer=kumiho__pb2.SpaceResponse.FromString,
                _registered_method=True)
        self.CreateItem = channel.unary_unary(
                '/kumiho.KumihoService/CreateItem',
                request_serializer=kumiho__pb2.CreateItemRequest.SerializeToString,
                response_deserializer=kumiho__pb2.ItemResponse.FromString,
                _registered_method=True)
        self.GetItem = channel.unary_unary(
                '/kumiho.KumihoService/GetItem',
                request_serializer=kumiho__pb2.GetItemRequest.SerializeToString,
                response_deserializer=kumiho__pb2.ItemResponse.FromString,
                _registered_method=True)
        self.GetItems = channel.unary_unary(
                '/kumiho.KumihoService/GetItems',
                request_serializer=kumiho__pb2.GetItemsRequest.SerializeToString,
                response_deserializer=kumiho__pb2.GetItemsResponse.FromString,
                _registered_method=True)
        self.ItemSearch = channel.unary_unary(
                '/kumiho.KumihoService/ItemSearch',
                request_serializer=kumiho__pb2.ItemSearchRequest.SerializeToString,
                response_deserializer=kumiho__pb2.GetItemsResponse.FromString,
                _registered_method=True)
        self.DeleteItem = channel.unary_unary(
                '/kumiho.KumihoService/DeleteItem',
                request_serializer=kumiho__pb2.DeleteItemRequest.SerializeToString,
                response_deserializer=kumiho__pb2.StatusResponse.FromString,
                _registered_method=True)
        self.UpdateItemMetadata = channel.unary_unary(
                '/kumiho.KumihoService/UpdateItemMetadata',
                request_serializer=kumiho__pb2.UpdateMetadataRequest.SerializeToString,
                response_deserializer=kumiho__pb2.ItemResponse.FromString,
                _registered_method=True)
        self.Search = channel.unary_unary(
                '/kumiho.KumihoService/Search',
                request_serializer=kumiho__pb2.SearchRequest.SerializeToString,
                response_deserializer=kumiho__pb2.SearchResponse.FromString,
                _registered_method=True)
        self.ResolveKref = channel.unary_unary(
                '/kumiho.KumihoService/ResolveKref',
                request_serializer=kumiho__pb2.ResolveKrefRequest.SerializeToString,
                response_deserializer=kumiho__pb2.RevisionResponse.FromString,
                _registered_method=True)
        self.ResolveLocation = channel.unary_unary(
                '/kumiho.KumihoService/ResolveLocation',
                request_serializer=kumiho__pb2.ResolveLocationRequest.SerializeToString,
                response_deserializer=kumiho__pb2.ResolveLocationResponse.FromString,
                _registered_method=True)
        self.CreateRevision = channel.unary_unary(
                '/kumiho.KumihoService/CreateRevision',
                request_serializer=kumiho__pb2.CreateRevisionRequest.SerializeToString,
                response_deserializer=kumiho__pb2.RevisionResponse.FromString,
                _registered_method=True)
        self.GetRevision = channel.unary_unary(
                '/kumiho.KumihoService/GetRevision',
                request_serializer=kumiho__pb2.KrefRequest.SerializeToString,
                response_deserializer=kumiho__pb2.RevisionResponse.FromString,
                _registered_method=True)
        self.GetRevisions = channel.unary_unary(
                '/kumiho.KumihoService/GetRevisions',
                request_serializer=kumiho__pb2.GetRevisionsRequest.SerializeToString,
                response_deserializer=kumiho__pb2.GetRevisionsResponse.FromString,
                _registered_method=True)
        self.DeleteRevision = channel.unary_unary(
                '/kumiho.KumihoService/DeleteRevision',
                request_serializer=kumiho__pb2.DeleteRevisionRequest.SerializeToString,
                response_deserializer=kumiho__pb2.StatusResponse.FromString,
                _registered_method=True)
        self.PeekNextRevision = channel.unary_unary(
                '/kumiho.KumihoService/PeekNextRevision',
                request_serializer=kumiho__pb2.PeekNextRevisionRequest.SerializeToString,
                response_deserializer=kumiho__pb2.PeekNextRevisionResponse.FromString,
                _registered_method=True)
        self.UpdateRevisionMetadata = channel.unary_unary(
                '/kumiho.KumihoService/UpdateRevisionMetadata',
                request_serializer=kumiho__pb2.UpdateMetadataRequest.SerializeToString,
                response_deserializer=kumiho__pb2.RevisionResponse.FromString,
                _registered_method=True)
        self.TagRevision = channel.unary_unary(
                '/kumiho.KumihoService/TagRevision',
                request_serializer=kumiho__pb2.TagRevisionRequest.SerializeToString,
                response_deserializer=kumiho__pb2.StatusResponse.FromString,
                _registered_method=True)
        self.UnTagRevision = channel.unary_unary(
                '/kumiho.KumihoService/UnTagRevision',
                request_serializer=kumiho__pb2.UnTagRevisionRequest.SerializeToString,
                response_deserializer=kumiho__pb2.StatusResponse.FromString,
                _registered_method=True)
        self.HasTag = channel.unary_unary(
                '/kumiho.KumihoService/HasTag',
                request_serializer=kumiho__pb2.HasTagRequest.SerializeToString,
                response_deserializer=kumiho__pb2.HasTagResponse.FromString,
                _registered_method=True)
        self.WasTagged = channel.unary_unary(
                '/kumiho.KumihoService/WasTagged',
                request_serializer=kumiho__pb2.WasTaggedRequest.SerializeToString,
                response_deserializer=kumiho__pb2.WasTaggedResponse.FromString,
                _registered_method=True)
        self.SetDefaultArtifact = channel.unary_unary(
                '/kumiho.KumihoService/SetDefaultArtifact',
                request_serializer=kumiho__pb2.SetDefaultArtifactRequest.SerializeToString,
                response_deserializer=kumiho__pb2.StatusResponse.FromString,
                _registered_method=True)
        self.CreateArtifact = channel.unary_unary(
                '/kumiho.KumihoService/CreateArtifact',
                request_serializer=kumiho__pb2.CreateArtifactRequest.SerializeToString,
                response_deserializer=kumiho__pb2.ArtifactResponse.FromString,
                _registered_method=True)
        self.GetArtifact = channel.unary_unary(
                '/kumiho.KumihoService/GetArtifact',
                request_serializer=kumiho__pb2.GetArtifactRequest.SerializeToString,
                response_deserializer=kumiho__pb2.ArtifactResponse.FromString,
                _registered_method=True)
        self.GetArtifacts = channel.unary_unary(
                '/kumiho.KumihoService/GetArtifacts',
                request_serializer=kumiho__pb2.GetArtifactsRequest.SerializeToString,
                response_deserializer=kumiho__pb2.GetArtifactsResponse.FromString,
                _registered_method=True)
        self.GetArtifactsByLocation = channel.unary_unary(
                '/kumiho.KumihoService/GetArtifactsByLocation',
                request_serializer=kumiho__pb2.GetArtifactsByLocationRequest.SerializeToString,
                response_deserializer=kumiho__pb2.GetArtifactsByLocationResponse.FromString,
                _registered_method=True)
        self.DeleteArtifact = channel.unary_unary(
                '/kumiho.KumihoService/DeleteArtifact',
                request_serializer=kumiho__pb2.DeleteArtifactRequest.SerializeToString,
                response_deserializer=kumiho__pb2.StatusResponse.FromString,
                _registered_method=True)
        self.UpdateArtifactMetadata = channel.unary_unary(
                '/kumiho.KumihoService/UpdateArtifactMetadata',
                request_serializer=kumiho__pb2.UpdateMetadataRequest.SerializeToString,
                response_deserializer=kumiho__pb2.ArtifactResponse.FromString,
                _registered_method=True)
        self.SetAttribute = channel.unary_unary(
                '/kumiho.KumihoService/SetAttribute',
                request_serializer=kumiho__pb2.SetAttributeRequest.SerializeToString,
                response_deserializer=kumiho__pb2.StatusResponse.FromString,
                _registered_method=True)
        self.GetAttribute = channel.unary_unary(
                '/kumiho.KumihoService/GetAttribute',
                request_serializer=kumiho__pb2.GetAttributeRequest.SerializeToString,
                response_deserializer=kumiho__pb2.GetAttributeResponse.FromString,
                _registered_method=True)
        self.DeleteAttribute = channel.unary_unary(
                '/kumiho.KumihoService/DeleteAttribute',
                request_serializer=kumiho__pb2.DeleteAttributeRequest.SerializeToString,
                response_deserializer=kumiho__pb2.StatusResponse.FromString,
                _registered_method=True)
        self.CreateEdge = channel.unary_unary(
                '/kumiho.KumihoService/CreateEdge',
                request_serializer=kumiho__pb2.CreateEdgeRequest.SerializeToString,
                response_deserializer=kumiho__pb2.StatusResponse.FromString,
                _registered_method=True)
        self.GetEdges = channel.unary_unary(
                '/kumiho.KumihoService/GetEdges',
                request_serializer=kumiho__pb2.GetEdgesRequest.SerializeToString,
                response_deserializer=kumiho__pb2.GetEdgesResponse.FromString,
                _registered_method=True)
        self.DeleteEdge = channel.unary_unary(
                '/kumiho.KumihoService/DeleteEdge',
                request_serializer=kumiho__pb2.DeleteEdgeRequest.SerializeToString,
                response_deserializer=kumiho__pb2.StatusResponse.FromString,
                _registered_method=True)
        self.TraverseEdges = channel.unary_unary(
                '/kumiho.KumihoService/TraverseEdges',
                request_serializer=kumiho__pb2.TraverseEdgesRequest.SerializeToString,
                response_deserializer=kumiho__pb2.TraverseEdgesResponse.FromString,
                _registered_method=True)
        self.FindShortestPath = channel.unary_unary(
                '/kumiho.KumihoService/FindShortestPath',
                request_serializer=kumiho__pb2.ShortestPathRequest.SerializeToString,
                response_deserializer=kumiho__pb2.ShortestPathResponse.FromString,
                _registered_method=True)
        self.AnalyzeImpact = channel.unary_unary(
                '/kumiho.KumihoService/AnalyzeImpact',
                request_serializer=kumiho__pb2.ImpactAnalysisRequest.SerializeToString,
                response_deserializer=kumiho__pb2.ImpactAnalysisResponse.FromString,
                _registered_method=True)
        self.CreateBundle = channel.unary_unary(
                '/kumiho.KumihoService/CreateBundle',
                request_serializer=kumiho__pb2.CreateBundleRequest.SerializeToString,
                response_deserializer=kumiho__pb2.ItemResponse.FromString,
                _registered_method=True)
        self.AddBundleMember = channel.unary_unary(
                '/kumiho.KumihoService/AddBundleMember',
                request_serializer=kumiho__pb2.AddBundleMemberRequest.SerializeToString,
                response_deserializer=kumiho__pb2.AddBundleMemberResponse.FromString,
                _registered_method=True)
        self.RemoveBundleMember = channel.unary_unary(
                '/kumiho.KumihoService/RemoveBundleMember',
                request_serializer=kumiho__pb2.RemoveBundleMemberRequest.SerializeToString,
                response_deserializer=kumiho__pb2.RemoveBundleMemberResponse.FromString,
                _registered_method=True)
        self.GetBundleMembers = channel.unary_unary(
                '/kumiho.KumihoService/GetBundleMembers',
                request_serializer=kumiho__pb2.GetBundleMembersRequest.SerializeToString,
                response_deserializer=kumiho__pb2.GetBundleMembersResponse.FromString,
                _registered_method=True)
        self.GetBundleHistory = channel.unary_unary(
                '/kumiho.KumihoService/GetBundleHistory',
                request_serializer=kumiho__pb2.GetBundleHistoryRequest.SerializeToString,
                response_deserializer=kumiho__pb2.GetBundleHistoryResponse.FromString,
                _registered_method=True)
        self.GetTenantUsage = channel.unary_unary(
                '/kumiho.KumihoService/GetTenantUsage',
                request_serializer=kumiho__pb2.GetTenantUsageRequest.SerializeToString,
                response_deserializer=kumiho__pb2.TenantUsageResponse.FromString,
                _registered_method=True)
        self.EventStream = channel.unary_stream(
                '/kumiho.KumihoService/EventStream',
                request_serializer=kumiho__pb2.EventStreamRequest.SerializeToString,
                response_deserializer=kumiho__pb2.Event.FromString,
                _registered_method=True)
        self.GetEventCapabilities = channel.unary_unary(
                '/kumiho.KumihoService/GetEventCapabilities',
                request_serializer=kumiho__pb2.GetEventCapabilitiesRequest.SerializeToString,
                response_deserializer=kumiho__pb2.EventCapabilities.FromString,
                _registered_method=True)
        self.SetDeprecated = channel.unary_unary(
                '/kumiho.KumihoService/SetDeprecated',
                request_serializer=kumiho__pb2.SetDeprecatedRequest.SerializeToString,
                response_deserializer=kumiho__pb2.StatusResponse.FromString,
                _registered_method=True)


class KumihoServiceServicer(object):
    """The Kumiho service definition.
    """

    def CreateProject(self, request, context):
        """Project methods
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetProjects(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 UpdateProject(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 DeleteProject(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 CreateSpace(self, request, context):
        """Space methods
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetSpace(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 GetChildSpaces(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 DeleteSpace(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 UpdateSpaceMetadata(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 CreateItem(self, request, context):
        """Item methods
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetItem(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 GetItems(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 ItemSearch(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 DeleteItem(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 UpdateItemMetadata(self, request, context):
        """Missing associated documentation comment in .proto file."""
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Search(self, request, context):
        """Full-text search (Google-like fuzzy search across items)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ResolveKref(self, request, context):
        """Revision methods
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ResolveLocation(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 CreateRevision(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 GetRevision(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 GetRevisions(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 DeleteRevision(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 PeekNextRevision(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 UpdateRevisionMetadata(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 TagRevision(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 UnTagRevision(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 HasTag(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 WasTagged(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 SetDefaultArtifact(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 CreateArtifact(self, request, context):
        """Artifact methods
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetArtifact(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 GetArtifacts(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 GetArtifactsByLocation(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 DeleteArtifact(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 UpdateArtifactMetadata(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 SetAttribute(self, request, context):
        """Attribute methods (granular metadata operations)
        These work on any entity type (Revision, Item, Artifact, Space) identified by kref
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetAttribute(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 DeleteAttribute(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 CreateEdge(self, request, context):
        """Edge methods
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetEdges(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 DeleteEdge(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 TraverseEdges(self, request, context):
        """Graph Traversal methods
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FindShortestPath(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 AnalyzeImpact(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 CreateBundle(self, request, context):
        """Bundle methods
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AddBundleMember(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 RemoveBundleMember(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 GetBundleMembers(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 GetBundleHistory(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 GetTenantUsage(self, request, context):
        """Tenant methods
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def EventStream(self, request, context):
        """Event Streaming
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetEventCapabilities(self, request, context):
        """Get event streaming capabilities for the authenticated tenant's tier
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetDeprecated(self, request, context):
        """Deprecation methods
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_KumihoServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'CreateProject': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateProject,
                    request_deserializer=kumiho__pb2.CreateProjectRequest.FromString,
                    response_serializer=kumiho__pb2.ProjectResponse.SerializeToString,
            ),
            'GetProjects': grpc.unary_unary_rpc_method_handler(
                    servicer.GetProjects,
                    request_deserializer=kumiho__pb2.GetProjectsRequest.FromString,
                    response_serializer=kumiho__pb2.GetProjectsResponse.SerializeToString,
            ),
            'UpdateProject': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateProject,
                    request_deserializer=kumiho__pb2.UpdateProjectRequest.FromString,
                    response_serializer=kumiho__pb2.ProjectResponse.SerializeToString,
            ),
            'DeleteProject': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteProject,
                    request_deserializer=kumiho__pb2.DeleteProjectRequest.FromString,
                    response_serializer=kumiho__pb2.StatusResponse.SerializeToString,
            ),
            'CreateSpace': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateSpace,
                    request_deserializer=kumiho__pb2.CreateSpaceRequest.FromString,
                    response_serializer=kumiho__pb2.SpaceResponse.SerializeToString,
            ),
            'GetSpace': grpc.unary_unary_rpc_method_handler(
                    servicer.GetSpace,
                    request_deserializer=kumiho__pb2.GetSpaceRequest.FromString,
                    response_serializer=kumiho__pb2.SpaceResponse.SerializeToString,
            ),
            'GetChildSpaces': grpc.unary_unary_rpc_method_handler(
                    servicer.GetChildSpaces,
                    request_deserializer=kumiho__pb2.GetChildSpacesRequest.FromString,
                    response_serializer=kumiho__pb2.GetChildSpacesResponse.SerializeToString,
            ),
            'DeleteSpace': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteSpace,
                    request_deserializer=kumiho__pb2.DeleteSpaceRequest.FromString,
                    response_serializer=kumiho__pb2.StatusResponse.SerializeToString,
            ),
            'UpdateSpaceMetadata': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateSpaceMetadata,
                    request_deserializer=kumiho__pb2.UpdateMetadataRequest.FromString,
                    response_serializer=kumiho__pb2.SpaceResponse.SerializeToString,
            ),
            'CreateItem': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateItem,
                    request_deserializer=kumiho__pb2.CreateItemRequest.FromString,
                    response_serializer=kumiho__pb2.ItemResponse.SerializeToString,
            ),
            'GetItem': grpc.unary_unary_rpc_method_handler(
                    servicer.GetItem,
                    request_deserializer=kumiho__pb2.GetItemRequest.FromString,
                    response_serializer=kumiho__pb2.ItemResponse.SerializeToString,
            ),
            'GetItems': grpc.unary_unary_rpc_method_handler(
                    servicer.GetItems,
                    request_deserializer=kumiho__pb2.GetItemsRequest.FromString,
                    response_serializer=kumiho__pb2.GetItemsResponse.SerializeToString,
            ),
            'ItemSearch': grpc.unary_unary_rpc_method_handler(
                    servicer.ItemSearch,
                    request_deserializer=kumiho__pb2.ItemSearchRequest.FromString,
                    response_serializer=kumiho__pb2.GetItemsResponse.SerializeToString,
            ),
            'DeleteItem': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteItem,
                    request_deserializer=kumiho__pb2.DeleteItemRequest.FromString,
                    response_serializer=kumiho__pb2.StatusResponse.SerializeToString,
            ),
            'UpdateItemMetadata': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateItemMetadata,
                    request_deserializer=kumiho__pb2.UpdateMetadataRequest.FromString,
                    response_serializer=kumiho__pb2.ItemResponse.SerializeToString,
            ),
            'Search': grpc.unary_unary_rpc_method_handler(
                    servicer.Search,
                    request_deserializer=kumiho__pb2.SearchRequest.FromString,
                    response_serializer=kumiho__pb2.SearchResponse.SerializeToString,
            ),
            'ResolveKref': grpc.unary_unary_rpc_method_handler(
                    servicer.ResolveKref,
                    request_deserializer=kumiho__pb2.ResolveKrefRequest.FromString,
                    response_serializer=kumiho__pb2.RevisionResponse.SerializeToString,
            ),
            'ResolveLocation': grpc.unary_unary_rpc_method_handler(
                    servicer.ResolveLocation,
                    request_deserializer=kumiho__pb2.ResolveLocationRequest.FromString,
                    response_serializer=kumiho__pb2.ResolveLocationResponse.SerializeToString,
            ),
            'CreateRevision': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateRevision,
                    request_deserializer=kumiho__pb2.CreateRevisionRequest.FromString,
                    response_serializer=kumiho__pb2.RevisionResponse.SerializeToString,
            ),
            'GetRevision': grpc.unary_unary_rpc_method_handler(
                    servicer.GetRevision,
                    request_deserializer=kumiho__pb2.KrefRequest.FromString,
                    response_serializer=kumiho__pb2.RevisionResponse.SerializeToString,
            ),
            'GetRevisions': grpc.unary_unary_rpc_method_handler(
                    servicer.GetRevisions,
                    request_deserializer=kumiho__pb2.GetRevisionsRequest.FromString,
                    response_serializer=kumiho__pb2.GetRevisionsResponse.SerializeToString,
            ),
            'DeleteRevision': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteRevision,
                    request_deserializer=kumiho__pb2.DeleteRevisionRequest.FromString,
                    response_serializer=kumiho__pb2.StatusResponse.SerializeToString,
            ),
            'PeekNextRevision': grpc.unary_unary_rpc_method_handler(
                    servicer.PeekNextRevision,
                    request_deserializer=kumiho__pb2.PeekNextRevisionRequest.FromString,
                    response_serializer=kumiho__pb2.PeekNextRevisionResponse.SerializeToString,
            ),
            'UpdateRevisionMetadata': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateRevisionMetadata,
                    request_deserializer=kumiho__pb2.UpdateMetadataRequest.FromString,
                    response_serializer=kumiho__pb2.RevisionResponse.SerializeToString,
            ),
            'TagRevision': grpc.unary_unary_rpc_method_handler(
                    servicer.TagRevision,
                    request_deserializer=kumiho__pb2.TagRevisionRequest.FromString,
                    response_serializer=kumiho__pb2.StatusResponse.SerializeToString,
            ),
            'UnTagRevision': grpc.unary_unary_rpc_method_handler(
                    servicer.UnTagRevision,
                    request_deserializer=kumiho__pb2.UnTagRevisionRequest.FromString,
                    response_serializer=kumiho__pb2.StatusResponse.SerializeToString,
            ),
            'HasTag': grpc.unary_unary_rpc_method_handler(
                    servicer.HasTag,
                    request_deserializer=kumiho__pb2.HasTagRequest.FromString,
                    response_serializer=kumiho__pb2.HasTagResponse.SerializeToString,
            ),
            'WasTagged': grpc.unary_unary_rpc_method_handler(
                    servicer.WasTagged,
                    request_deserializer=kumiho__pb2.WasTaggedRequest.FromString,
                    response_serializer=kumiho__pb2.WasTaggedResponse.SerializeToString,
            ),
            'SetDefaultArtifact': grpc.unary_unary_rpc_method_handler(
                    servicer.SetDefaultArtifact,
                    request_deserializer=kumiho__pb2.SetDefaultArtifactRequest.FromString,
                    response_serializer=kumiho__pb2.StatusResponse.SerializeToString,
            ),
            'CreateArtifact': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateArtifact,
                    request_deserializer=kumiho__pb2.CreateArtifactRequest.FromString,
                    response_serializer=kumiho__pb2.ArtifactResponse.SerializeToString,
            ),
            'GetArtifact': grpc.unary_unary_rpc_method_handler(
                    servicer.GetArtifact,
                    request_deserializer=kumiho__pb2.GetArtifactRequest.FromString,
                    response_serializer=kumiho__pb2.ArtifactResponse.SerializeToString,
            ),
            'GetArtifacts': grpc.unary_unary_rpc_method_handler(
                    servicer.GetArtifacts,
                    request_deserializer=kumiho__pb2.GetArtifactsRequest.FromString,
                    response_serializer=kumiho__pb2.GetArtifactsResponse.SerializeToString,
            ),
            'GetArtifactsByLocation': grpc.unary_unary_rpc_method_handler(
                    servicer.GetArtifactsByLocation,
                    request_deserializer=kumiho__pb2.GetArtifactsByLocationRequest.FromString,
                    response_serializer=kumiho__pb2.GetArtifactsByLocationResponse.SerializeToString,
            ),
            'DeleteArtifact': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteArtifact,
                    request_deserializer=kumiho__pb2.DeleteArtifactRequest.FromString,
                    response_serializer=kumiho__pb2.StatusResponse.SerializeToString,
            ),
            'UpdateArtifactMetadata': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateArtifactMetadata,
                    request_deserializer=kumiho__pb2.UpdateMetadataRequest.FromString,
                    response_serializer=kumiho__pb2.ArtifactResponse.SerializeToString,
            ),
            'SetAttribute': grpc.unary_unary_rpc_method_handler(
                    servicer.SetAttribute,
                    request_deserializer=kumiho__pb2.SetAttributeRequest.FromString,
                    response_serializer=kumiho__pb2.StatusResponse.SerializeToString,
            ),
            'GetAttribute': grpc.unary_unary_rpc_method_handler(
                    servicer.GetAttribute,
                    request_deserializer=kumiho__pb2.GetAttributeRequest.FromString,
                    response_serializer=kumiho__pb2.GetAttributeResponse.SerializeToString,
            ),
            'DeleteAttribute': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteAttribute,
                    request_deserializer=kumiho__pb2.DeleteAttributeRequest.FromString,
                    response_serializer=kumiho__pb2.StatusResponse.SerializeToString,
            ),
            'CreateEdge': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateEdge,
                    request_deserializer=kumiho__pb2.CreateEdgeRequest.FromString,
                    response_serializer=kumiho__pb2.StatusResponse.SerializeToString,
            ),
            'GetEdges': grpc.unary_unary_rpc_method_handler(
                    servicer.GetEdges,
                    request_deserializer=kumiho__pb2.GetEdgesRequest.FromString,
                    response_serializer=kumiho__pb2.GetEdgesResponse.SerializeToString,
            ),
            'DeleteEdge': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteEdge,
                    request_deserializer=kumiho__pb2.DeleteEdgeRequest.FromString,
                    response_serializer=kumiho__pb2.StatusResponse.SerializeToString,
            ),
            'TraverseEdges': grpc.unary_unary_rpc_method_handler(
                    servicer.TraverseEdges,
                    request_deserializer=kumiho__pb2.TraverseEdgesRequest.FromString,
                    response_serializer=kumiho__pb2.TraverseEdgesResponse.SerializeToString,
            ),
            'FindShortestPath': grpc.unary_unary_rpc_method_handler(
                    servicer.FindShortestPath,
                    request_deserializer=kumiho__pb2.ShortestPathRequest.FromString,
                    response_serializer=kumiho__pb2.ShortestPathResponse.SerializeToString,
            ),
            'AnalyzeImpact': grpc.unary_unary_rpc_method_handler(
                    servicer.AnalyzeImpact,
                    request_deserializer=kumiho__pb2.ImpactAnalysisRequest.FromString,
                    response_serializer=kumiho__pb2.ImpactAnalysisResponse.SerializeToString,
            ),
            'CreateBundle': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateBundle,
                    request_deserializer=kumiho__pb2.CreateBundleRequest.FromString,
                    response_serializer=kumiho__pb2.ItemResponse.SerializeToString,
            ),
            'AddBundleMember': grpc.unary_unary_rpc_method_handler(
                    servicer.AddBundleMember,
                    request_deserializer=kumiho__pb2.AddBundleMemberRequest.FromString,
                    response_serializer=kumiho__pb2.AddBundleMemberResponse.SerializeToString,
            ),
            'RemoveBundleMember': grpc.unary_unary_rpc_method_handler(
                    servicer.RemoveBundleMember,
                    request_deserializer=kumiho__pb2.RemoveBundleMemberRequest.FromString,
                    response_serializer=kumiho__pb2.RemoveBundleMemberResponse.SerializeToString,
            ),
            'GetBundleMembers': grpc.unary_unary_rpc_method_handler(
                    servicer.GetBundleMembers,
                    request_deserializer=kumiho__pb2.GetBundleMembersRequest.FromString,
                    response_serializer=kumiho__pb2.GetBundleMembersResponse.SerializeToString,
            ),
            'GetBundleHistory': grpc.unary_unary_rpc_method_handler(
                    servicer.GetBundleHistory,
                    request_deserializer=kumiho__pb2.GetBundleHistoryRequest.FromString,
                    response_serializer=kumiho__pb2.GetBundleHistoryResponse.SerializeToString,
            ),
            'GetTenantUsage': grpc.unary_unary_rpc_method_handler(
                    servicer.GetTenantUsage,
                    request_deserializer=kumiho__pb2.GetTenantUsageRequest.FromString,
                    response_serializer=kumiho__pb2.TenantUsageResponse.SerializeToString,
            ),
            'EventStream': grpc.unary_stream_rpc_method_handler(
                    servicer.EventStream,
                    request_deserializer=kumiho__pb2.EventStreamRequest.FromString,
                    response_serializer=kumiho__pb2.Event.SerializeToString,
            ),
            'GetEventCapabilities': grpc.unary_unary_rpc_method_handler(
                    servicer.GetEventCapabilities,
                    request_deserializer=kumiho__pb2.GetEventCapabilitiesRequest.FromString,
                    response_serializer=kumiho__pb2.EventCapabilities.SerializeToString,
            ),
            'SetDeprecated': grpc.unary_unary_rpc_method_handler(
                    servicer.SetDeprecated,
                    request_deserializer=kumiho__pb2.SetDeprecatedRequest.FromString,
                    response_serializer=kumiho__pb2.StatusResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'kumiho.KumihoService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('kumiho.KumihoService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class KumihoService(object):
    """The Kumiho service definition.
    """

    @staticmethod
    def CreateProject(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,
            '/kumiho.KumihoService/CreateProject',
            kumiho__pb2.CreateProjectRequest.SerializeToString,
            kumiho__pb2.ProjectResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetProjects(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,
            '/kumiho.KumihoService/GetProjects',
            kumiho__pb2.GetProjectsRequest.SerializeToString,
            kumiho__pb2.GetProjectsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateProject(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,
            '/kumiho.KumihoService/UpdateProject',
            kumiho__pb2.UpdateProjectRequest.SerializeToString,
            kumiho__pb2.ProjectResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteProject(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,
            '/kumiho.KumihoService/DeleteProject',
            kumiho__pb2.DeleteProjectRequest.SerializeToString,
            kumiho__pb2.StatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateSpace(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,
            '/kumiho.KumihoService/CreateSpace',
            kumiho__pb2.CreateSpaceRequest.SerializeToString,
            kumiho__pb2.SpaceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetSpace(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,
            '/kumiho.KumihoService/GetSpace',
            kumiho__pb2.GetSpaceRequest.SerializeToString,
            kumiho__pb2.SpaceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetChildSpaces(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,
            '/kumiho.KumihoService/GetChildSpaces',
            kumiho__pb2.GetChildSpacesRequest.SerializeToString,
            kumiho__pb2.GetChildSpacesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteSpace(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,
            '/kumiho.KumihoService/DeleteSpace',
            kumiho__pb2.DeleteSpaceRequest.SerializeToString,
            kumiho__pb2.StatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateSpaceMetadata(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,
            '/kumiho.KumihoService/UpdateSpaceMetadata',
            kumiho__pb2.UpdateMetadataRequest.SerializeToString,
            kumiho__pb2.SpaceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateItem(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,
            '/kumiho.KumihoService/CreateItem',
            kumiho__pb2.CreateItemRequest.SerializeToString,
            kumiho__pb2.ItemResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetItem(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,
            '/kumiho.KumihoService/GetItem',
            kumiho__pb2.GetItemRequest.SerializeToString,
            kumiho__pb2.ItemResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetItems(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,
            '/kumiho.KumihoService/GetItems',
            kumiho__pb2.GetItemsRequest.SerializeToString,
            kumiho__pb2.GetItemsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ItemSearch(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,
            '/kumiho.KumihoService/ItemSearch',
            kumiho__pb2.ItemSearchRequest.SerializeToString,
            kumiho__pb2.GetItemsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteItem(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,
            '/kumiho.KumihoService/DeleteItem',
            kumiho__pb2.DeleteItemRequest.SerializeToString,
            kumiho__pb2.StatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateItemMetadata(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,
            '/kumiho.KumihoService/UpdateItemMetadata',
            kumiho__pb2.UpdateMetadataRequest.SerializeToString,
            kumiho__pb2.ItemResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def Search(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(
            request,
            target,
            '/kumiho.KumihoService/Search',
            kumiho__pb2.SearchRequest.SerializeToString,
            kumiho__pb2.SearchResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ResolveKref(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,
            '/kumiho.KumihoService/ResolveKref',
            kumiho__pb2.ResolveKrefRequest.SerializeToString,
            kumiho__pb2.RevisionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ResolveLocation(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,
            '/kumiho.KumihoService/ResolveLocation',
            kumiho__pb2.ResolveLocationRequest.SerializeToString,
            kumiho__pb2.ResolveLocationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateRevision(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,
            '/kumiho.KumihoService/CreateRevision',
            kumiho__pb2.CreateRevisionRequest.SerializeToString,
            kumiho__pb2.RevisionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetRevision(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,
            '/kumiho.KumihoService/GetRevision',
            kumiho__pb2.KrefRequest.SerializeToString,
            kumiho__pb2.RevisionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetRevisions(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,
            '/kumiho.KumihoService/GetRevisions',
            kumiho__pb2.GetRevisionsRequest.SerializeToString,
            kumiho__pb2.GetRevisionsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteRevision(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,
            '/kumiho.KumihoService/DeleteRevision',
            kumiho__pb2.DeleteRevisionRequest.SerializeToString,
            kumiho__pb2.StatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def PeekNextRevision(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,
            '/kumiho.KumihoService/PeekNextRevision',
            kumiho__pb2.PeekNextRevisionRequest.SerializeToString,
            kumiho__pb2.PeekNextRevisionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateRevisionMetadata(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,
            '/kumiho.KumihoService/UpdateRevisionMetadata',
            kumiho__pb2.UpdateMetadataRequest.SerializeToString,
            kumiho__pb2.RevisionResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def TagRevision(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,
            '/kumiho.KumihoService/TagRevision',
            kumiho__pb2.TagRevisionRequest.SerializeToString,
            kumiho__pb2.StatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UnTagRevision(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,
            '/kumiho.KumihoService/UnTagRevision',
            kumiho__pb2.UnTagRevisionRequest.SerializeToString,
            kumiho__pb2.StatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def HasTag(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,
            '/kumiho.KumihoService/HasTag',
            kumiho__pb2.HasTagRequest.SerializeToString,
            kumiho__pb2.HasTagResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def WasTagged(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,
            '/kumiho.KumihoService/WasTagged',
            kumiho__pb2.WasTaggedRequest.SerializeToString,
            kumiho__pb2.WasTaggedResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetDefaultArtifact(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,
            '/kumiho.KumihoService/SetDefaultArtifact',
            kumiho__pb2.SetDefaultArtifactRequest.SerializeToString,
            kumiho__pb2.StatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateArtifact(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,
            '/kumiho.KumihoService/CreateArtifact',
            kumiho__pb2.CreateArtifactRequest.SerializeToString,
            kumiho__pb2.ArtifactResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetArtifact(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,
            '/kumiho.KumihoService/GetArtifact',
            kumiho__pb2.GetArtifactRequest.SerializeToString,
            kumiho__pb2.ArtifactResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetArtifacts(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,
            '/kumiho.KumihoService/GetArtifacts',
            kumiho__pb2.GetArtifactsRequest.SerializeToString,
            kumiho__pb2.GetArtifactsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetArtifactsByLocation(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,
            '/kumiho.KumihoService/GetArtifactsByLocation',
            kumiho__pb2.GetArtifactsByLocationRequest.SerializeToString,
            kumiho__pb2.GetArtifactsByLocationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteArtifact(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,
            '/kumiho.KumihoService/DeleteArtifact',
            kumiho__pb2.DeleteArtifactRequest.SerializeToString,
            kumiho__pb2.StatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateArtifactMetadata(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,
            '/kumiho.KumihoService/UpdateArtifactMetadata',
            kumiho__pb2.UpdateMetadataRequest.SerializeToString,
            kumiho__pb2.ArtifactResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetAttribute(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,
            '/kumiho.KumihoService/SetAttribute',
            kumiho__pb2.SetAttributeRequest.SerializeToString,
            kumiho__pb2.StatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetAttribute(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,
            '/kumiho.KumihoService/GetAttribute',
            kumiho__pb2.GetAttributeRequest.SerializeToString,
            kumiho__pb2.GetAttributeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteAttribute(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,
            '/kumiho.KumihoService/DeleteAttribute',
            kumiho__pb2.DeleteAttributeRequest.SerializeToString,
            kumiho__pb2.StatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateEdge(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,
            '/kumiho.KumihoService/CreateEdge',
            kumiho__pb2.CreateEdgeRequest.SerializeToString,
            kumiho__pb2.StatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetEdges(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,
            '/kumiho.KumihoService/GetEdges',
            kumiho__pb2.GetEdgesRequest.SerializeToString,
            kumiho__pb2.GetEdgesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteEdge(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,
            '/kumiho.KumihoService/DeleteEdge',
            kumiho__pb2.DeleteEdgeRequest.SerializeToString,
            kumiho__pb2.StatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def TraverseEdges(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,
            '/kumiho.KumihoService/TraverseEdges',
            kumiho__pb2.TraverseEdgesRequest.SerializeToString,
            kumiho__pb2.TraverseEdgesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FindShortestPath(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,
            '/kumiho.KumihoService/FindShortestPath',
            kumiho__pb2.ShortestPathRequest.SerializeToString,
            kumiho__pb2.ShortestPathResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AnalyzeImpact(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,
            '/kumiho.KumihoService/AnalyzeImpact',
            kumiho__pb2.ImpactAnalysisRequest.SerializeToString,
            kumiho__pb2.ImpactAnalysisResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateBundle(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,
            '/kumiho.KumihoService/CreateBundle',
            kumiho__pb2.CreateBundleRequest.SerializeToString,
            kumiho__pb2.ItemResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AddBundleMember(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,
            '/kumiho.KumihoService/AddBundleMember',
            kumiho__pb2.AddBundleMemberRequest.SerializeToString,
            kumiho__pb2.AddBundleMemberResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RemoveBundleMember(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,
            '/kumiho.KumihoService/RemoveBundleMember',
            kumiho__pb2.RemoveBundleMemberRequest.SerializeToString,
            kumiho__pb2.RemoveBundleMemberResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetBundleMembers(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,
            '/kumiho.KumihoService/GetBundleMembers',
            kumiho__pb2.GetBundleMembersRequest.SerializeToString,
            kumiho__pb2.GetBundleMembersResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetBundleHistory(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,
            '/kumiho.KumihoService/GetBundleHistory',
            kumiho__pb2.GetBundleHistoryRequest.SerializeToString,
            kumiho__pb2.GetBundleHistoryResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetTenantUsage(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,
            '/kumiho.KumihoService/GetTenantUsage',
            kumiho__pb2.GetTenantUsageRequest.SerializeToString,
            kumiho__pb2.TenantUsageResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def EventStream(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/kumiho.KumihoService/EventStream',
            kumiho__pb2.EventStreamRequest.SerializeToString,
            kumiho__pb2.Event.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetEventCapabilities(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,
            '/kumiho.KumihoService/GetEventCapabilities',
            kumiho__pb2.GetEventCapabilitiesRequest.SerializeToString,
            kumiho__pb2.EventCapabilities.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetDeprecated(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,
            '/kumiho.KumihoService/SetDeprecated',
            kumiho__pb2.SetDeprecatedRequest.SerializeToString,
            kumiho__pb2.StatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
