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

import grpc
import warnings

import noteflow_pb2 as noteflow__pb2

GRPC_VERSION = grpc.__version__
_version_not_supported = False

GRPC_GENERATED_VERSION = '1.76.0'
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 noteflow_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 NoteFlowServiceStub(object):
    """=============================================================================
    Core Service
    =============================================================================

    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.StreamTranscription = channel.stream_stream(
                '/noteflow.NoteFlowService/StreamTranscription',
                request_serializer=noteflow__pb2.AudioChunk.SerializeToString,
                response_deserializer=noteflow__pb2.TranscriptUpdate.FromString,
                _registered_method=True)
        self.CreateMeeting = channel.unary_unary(
                '/noteflow.NoteFlowService/CreateMeeting',
                request_serializer=noteflow__pb2.CreateMeetingRequest.SerializeToString,
                response_deserializer=noteflow__pb2.Meeting.FromString,
                _registered_method=True)
        self.StopMeeting = channel.unary_unary(
                '/noteflow.NoteFlowService/StopMeeting',
                request_serializer=noteflow__pb2.StopMeetingRequest.SerializeToString,
                response_deserializer=noteflow__pb2.Meeting.FromString,
                _registered_method=True)
        self.ListMeetings = channel.unary_unary(
                '/noteflow.NoteFlowService/ListMeetings',
                request_serializer=noteflow__pb2.ListMeetingsRequest.SerializeToString,
                response_deserializer=noteflow__pb2.ListMeetingsResponse.FromString,
                _registered_method=True)
        self.GetMeeting = channel.unary_unary(
                '/noteflow.NoteFlowService/GetMeeting',
                request_serializer=noteflow__pb2.GetMeetingRequest.SerializeToString,
                response_deserializer=noteflow__pb2.Meeting.FromString,
                _registered_method=True)
        self.DeleteMeeting = channel.unary_unary(
                '/noteflow.NoteFlowService/DeleteMeeting',
                request_serializer=noteflow__pb2.DeleteMeetingRequest.SerializeToString,
                response_deserializer=noteflow__pb2.DeleteMeetingResponse.FromString,
                _registered_method=True)
        self.GenerateSummary = channel.unary_unary(
                '/noteflow.NoteFlowService/GenerateSummary',
                request_serializer=noteflow__pb2.GenerateSummaryRequest.SerializeToString,
                response_deserializer=noteflow__pb2.Summary.FromString,
                _registered_method=True)
        self.AddAnnotation = channel.unary_unary(
                '/noteflow.NoteFlowService/AddAnnotation',
                request_serializer=noteflow__pb2.AddAnnotationRequest.SerializeToString,
                response_deserializer=noteflow__pb2.Annotation.FromString,
                _registered_method=True)
        self.GetAnnotation = channel.unary_unary(
                '/noteflow.NoteFlowService/GetAnnotation',
                request_serializer=noteflow__pb2.GetAnnotationRequest.SerializeToString,
                response_deserializer=noteflow__pb2.Annotation.FromString,
                _registered_method=True)
        self.ListAnnotations = channel.unary_unary(
                '/noteflow.NoteFlowService/ListAnnotations',
                request_serializer=noteflow__pb2.ListAnnotationsRequest.SerializeToString,
                response_deserializer=noteflow__pb2.ListAnnotationsResponse.FromString,
                _registered_method=True)
        self.UpdateAnnotation = channel.unary_unary(
                '/noteflow.NoteFlowService/UpdateAnnotation',
                request_serializer=noteflow__pb2.UpdateAnnotationRequest.SerializeToString,
                response_deserializer=noteflow__pb2.Annotation.FromString,
                _registered_method=True)
        self.DeleteAnnotation = channel.unary_unary(
                '/noteflow.NoteFlowService/DeleteAnnotation',
                request_serializer=noteflow__pb2.DeleteAnnotationRequest.SerializeToString,
                response_deserializer=noteflow__pb2.DeleteAnnotationResponse.FromString,
                _registered_method=True)
        self.ExportTranscript = channel.unary_unary(
                '/noteflow.NoteFlowService/ExportTranscript',
                request_serializer=noteflow__pb2.ExportTranscriptRequest.SerializeToString,
                response_deserializer=noteflow__pb2.ExportTranscriptResponse.FromString,
                _registered_method=True)
        self.RefineSpeakerDiarization = channel.unary_unary(
                '/noteflow.NoteFlowService/RefineSpeakerDiarization',
                request_serializer=noteflow__pb2.RefineSpeakerDiarizationRequest.SerializeToString,
                response_deserializer=noteflow__pb2.RefineSpeakerDiarizationResponse.FromString,
                _registered_method=True)
        self.RenameSpeaker = channel.unary_unary(
                '/noteflow.NoteFlowService/RenameSpeaker',
                request_serializer=noteflow__pb2.RenameSpeakerRequest.SerializeToString,
                response_deserializer=noteflow__pb2.RenameSpeakerResponse.FromString,
                _registered_method=True)
        self.GetDiarizationJobStatus = channel.unary_unary(
                '/noteflow.NoteFlowService/GetDiarizationJobStatus',
                request_serializer=noteflow__pb2.GetDiarizationJobStatusRequest.SerializeToString,
                response_deserializer=noteflow__pb2.DiarizationJobStatus.FromString,
                _registered_method=True)
        self.CancelDiarizationJob = channel.unary_unary(
                '/noteflow.NoteFlowService/CancelDiarizationJob',
                request_serializer=noteflow__pb2.CancelDiarizationJobRequest.SerializeToString,
                response_deserializer=noteflow__pb2.CancelDiarizationJobResponse.FromString,
                _registered_method=True)
        self.GetActiveDiarizationJobs = channel.unary_unary(
                '/noteflow.NoteFlowService/GetActiveDiarizationJobs',
                request_serializer=noteflow__pb2.GetActiveDiarizationJobsRequest.SerializeToString,
                response_deserializer=noteflow__pb2.GetActiveDiarizationJobsResponse.FromString,
                _registered_method=True)
        self.GetServerInfo = channel.unary_unary(
                '/noteflow.NoteFlowService/GetServerInfo',
                request_serializer=noteflow__pb2.ServerInfoRequest.SerializeToString,
                response_deserializer=noteflow__pb2.ServerInfo.FromString,
                _registered_method=True)
        self.ExtractEntities = channel.unary_unary(
                '/noteflow.NoteFlowService/ExtractEntities',
                request_serializer=noteflow__pb2.ExtractEntitiesRequest.SerializeToString,
                response_deserializer=noteflow__pb2.ExtractEntitiesResponse.FromString,
                _registered_method=True)
        self.UpdateEntity = channel.unary_unary(
                '/noteflow.NoteFlowService/UpdateEntity',
                request_serializer=noteflow__pb2.UpdateEntityRequest.SerializeToString,
                response_deserializer=noteflow__pb2.UpdateEntityResponse.FromString,
                _registered_method=True)
        self.DeleteEntity = channel.unary_unary(
                '/noteflow.NoteFlowService/DeleteEntity',
                request_serializer=noteflow__pb2.DeleteEntityRequest.SerializeToString,
                response_deserializer=noteflow__pb2.DeleteEntityResponse.FromString,
                _registered_method=True)
        self.ListCalendarEvents = channel.unary_unary(
                '/noteflow.NoteFlowService/ListCalendarEvents',
                request_serializer=noteflow__pb2.ListCalendarEventsRequest.SerializeToString,
                response_deserializer=noteflow__pb2.ListCalendarEventsResponse.FromString,
                _registered_method=True)
        self.GetCalendarProviders = channel.unary_unary(
                '/noteflow.NoteFlowService/GetCalendarProviders',
                request_serializer=noteflow__pb2.GetCalendarProvidersRequest.SerializeToString,
                response_deserializer=noteflow__pb2.GetCalendarProvidersResponse.FromString,
                _registered_method=True)
        self.InitiateOAuth = channel.unary_unary(
                '/noteflow.NoteFlowService/InitiateOAuth',
                request_serializer=noteflow__pb2.InitiateOAuthRequest.SerializeToString,
                response_deserializer=noteflow__pb2.InitiateOAuthResponse.FromString,
                _registered_method=True)
        self.CompleteOAuth = channel.unary_unary(
                '/noteflow.NoteFlowService/CompleteOAuth',
                request_serializer=noteflow__pb2.CompleteOAuthRequest.SerializeToString,
                response_deserializer=noteflow__pb2.CompleteOAuthResponse.FromString,
                _registered_method=True)
        self.GetOAuthConnectionStatus = channel.unary_unary(
                '/noteflow.NoteFlowService/GetOAuthConnectionStatus',
                request_serializer=noteflow__pb2.GetOAuthConnectionStatusRequest.SerializeToString,
                response_deserializer=noteflow__pb2.GetOAuthConnectionStatusResponse.FromString,
                _registered_method=True)
        self.DisconnectOAuth = channel.unary_unary(
                '/noteflow.NoteFlowService/DisconnectOAuth',
                request_serializer=noteflow__pb2.DisconnectOAuthRequest.SerializeToString,
                response_deserializer=noteflow__pb2.DisconnectOAuthResponse.FromString,
                _registered_method=True)
        self.RegisterWebhook = channel.unary_unary(
                '/noteflow.NoteFlowService/RegisterWebhook',
                request_serializer=noteflow__pb2.RegisterWebhookRequest.SerializeToString,
                response_deserializer=noteflow__pb2.WebhookConfigProto.FromString,
                _registered_method=True)
        self.ListWebhooks = channel.unary_unary(
                '/noteflow.NoteFlowService/ListWebhooks',
                request_serializer=noteflow__pb2.ListWebhooksRequest.SerializeToString,
                response_deserializer=noteflow__pb2.ListWebhooksResponse.FromString,
                _registered_method=True)
        self.UpdateWebhook = channel.unary_unary(
                '/noteflow.NoteFlowService/UpdateWebhook',
                request_serializer=noteflow__pb2.UpdateWebhookRequest.SerializeToString,
                response_deserializer=noteflow__pb2.WebhookConfigProto.FromString,
                _registered_method=True)
        self.DeleteWebhook = channel.unary_unary(
                '/noteflow.NoteFlowService/DeleteWebhook',
                request_serializer=noteflow__pb2.DeleteWebhookRequest.SerializeToString,
                response_deserializer=noteflow__pb2.DeleteWebhookResponse.FromString,
                _registered_method=True)
        self.GetWebhookDeliveries = channel.unary_unary(
                '/noteflow.NoteFlowService/GetWebhookDeliveries',
                request_serializer=noteflow__pb2.GetWebhookDeliveriesRequest.SerializeToString,
                response_deserializer=noteflow__pb2.GetWebhookDeliveriesResponse.FromString,
                _registered_method=True)
        self.GrantCloudConsent = channel.unary_unary(
                '/noteflow.NoteFlowService/GrantCloudConsent',
                request_serializer=noteflow__pb2.GrantCloudConsentRequest.SerializeToString,
                response_deserializer=noteflow__pb2.GrantCloudConsentResponse.FromString,
                _registered_method=True)
        self.RevokeCloudConsent = channel.unary_unary(
                '/noteflow.NoteFlowService/RevokeCloudConsent',
                request_serializer=noteflow__pb2.RevokeCloudConsentRequest.SerializeToString,
                response_deserializer=noteflow__pb2.RevokeCloudConsentResponse.FromString,
                _registered_method=True)
        self.GetCloudConsentStatus = channel.unary_unary(
                '/noteflow.NoteFlowService/GetCloudConsentStatus',
                request_serializer=noteflow__pb2.GetCloudConsentStatusRequest.SerializeToString,
                response_deserializer=noteflow__pb2.GetCloudConsentStatusResponse.FromString,
                _registered_method=True)
        self.GetPreferences = channel.unary_unary(
                '/noteflow.NoteFlowService/GetPreferences',
                request_serializer=noteflow__pb2.GetPreferencesRequest.SerializeToString,
                response_deserializer=noteflow__pb2.GetPreferencesResponse.FromString,
                _registered_method=True)
        self.SetPreferences = channel.unary_unary(
                '/noteflow.NoteFlowService/SetPreferences',
                request_serializer=noteflow__pb2.SetPreferencesRequest.SerializeToString,
                response_deserializer=noteflow__pb2.SetPreferencesResponse.FromString,
                _registered_method=True)
        self.StartIntegrationSync = channel.unary_unary(
                '/noteflow.NoteFlowService/StartIntegrationSync',
                request_serializer=noteflow__pb2.StartIntegrationSyncRequest.SerializeToString,
                response_deserializer=noteflow__pb2.StartIntegrationSyncResponse.FromString,
                _registered_method=True)
        self.GetSyncStatus = channel.unary_unary(
                '/noteflow.NoteFlowService/GetSyncStatus',
                request_serializer=noteflow__pb2.GetSyncStatusRequest.SerializeToString,
                response_deserializer=noteflow__pb2.GetSyncStatusResponse.FromString,
                _registered_method=True)
        self.ListSyncHistory = channel.unary_unary(
                '/noteflow.NoteFlowService/ListSyncHistory',
                request_serializer=noteflow__pb2.ListSyncHistoryRequest.SerializeToString,
                response_deserializer=noteflow__pb2.ListSyncHistoryResponse.FromString,
                _registered_method=True)
        self.GetUserIntegrations = channel.unary_unary(
                '/noteflow.NoteFlowService/GetUserIntegrations',
                request_serializer=noteflow__pb2.GetUserIntegrationsRequest.SerializeToString,
                response_deserializer=noteflow__pb2.GetUserIntegrationsResponse.FromString,
                _registered_method=True)
        self.GetRecentLogs = channel.unary_unary(
                '/noteflow.NoteFlowService/GetRecentLogs',
                request_serializer=noteflow__pb2.GetRecentLogsRequest.SerializeToString,
                response_deserializer=noteflow__pb2.GetRecentLogsResponse.FromString,
                _registered_method=True)
        self.GetPerformanceMetrics = channel.unary_unary(
                '/noteflow.NoteFlowService/GetPerformanceMetrics',
                request_serializer=noteflow__pb2.GetPerformanceMetricsRequest.SerializeToString,
                response_deserializer=noteflow__pb2.GetPerformanceMetricsResponse.FromString,
                _registered_method=True)
        self.RegisterOidcProvider = channel.unary_unary(
                '/noteflow.NoteFlowService/RegisterOidcProvider',
                request_serializer=noteflow__pb2.RegisterOidcProviderRequest.SerializeToString,
                response_deserializer=noteflow__pb2.OidcProviderProto.FromString,
                _registered_method=True)
        self.ListOidcProviders = channel.unary_unary(
                '/noteflow.NoteFlowService/ListOidcProviders',
                request_serializer=noteflow__pb2.ListOidcProvidersRequest.SerializeToString,
                response_deserializer=noteflow__pb2.ListOidcProvidersResponse.FromString,
                _registered_method=True)
        self.GetOidcProvider = channel.unary_unary(
                '/noteflow.NoteFlowService/GetOidcProvider',
                request_serializer=noteflow__pb2.GetOidcProviderRequest.SerializeToString,
                response_deserializer=noteflow__pb2.OidcProviderProto.FromString,
                _registered_method=True)
        self.UpdateOidcProvider = channel.unary_unary(
                '/noteflow.NoteFlowService/UpdateOidcProvider',
                request_serializer=noteflow__pb2.UpdateOidcProviderRequest.SerializeToString,
                response_deserializer=noteflow__pb2.OidcProviderProto.FromString,
                _registered_method=True)
        self.DeleteOidcProvider = channel.unary_unary(
                '/noteflow.NoteFlowService/DeleteOidcProvider',
                request_serializer=noteflow__pb2.DeleteOidcProviderRequest.SerializeToString,
                response_deserializer=noteflow__pb2.DeleteOidcProviderResponse.FromString,
                _registered_method=True)
        self.RefreshOidcDiscovery = channel.unary_unary(
                '/noteflow.NoteFlowService/RefreshOidcDiscovery',
                request_serializer=noteflow__pb2.RefreshOidcDiscoveryRequest.SerializeToString,
                response_deserializer=noteflow__pb2.RefreshOidcDiscoveryResponse.FromString,
                _registered_method=True)
        self.ListOidcPresets = channel.unary_unary(
                '/noteflow.NoteFlowService/ListOidcPresets',
                request_serializer=noteflow__pb2.ListOidcPresetsRequest.SerializeToString,
                response_deserializer=noteflow__pb2.ListOidcPresetsResponse.FromString,
                _registered_method=True)
        self.CreateProject = channel.unary_unary(
                '/noteflow.NoteFlowService/CreateProject',
                request_serializer=noteflow__pb2.CreateProjectRequest.SerializeToString,
                response_deserializer=noteflow__pb2.ProjectProto.FromString,
                _registered_method=True)
        self.GetProject = channel.unary_unary(
                '/noteflow.NoteFlowService/GetProject',
                request_serializer=noteflow__pb2.GetProjectRequest.SerializeToString,
                response_deserializer=noteflow__pb2.ProjectProto.FromString,
                _registered_method=True)
        self.GetProjectBySlug = channel.unary_unary(
                '/noteflow.NoteFlowService/GetProjectBySlug',
                request_serializer=noteflow__pb2.GetProjectBySlugRequest.SerializeToString,
                response_deserializer=noteflow__pb2.ProjectProto.FromString,
                _registered_method=True)
        self.ListProjects = channel.unary_unary(
                '/noteflow.NoteFlowService/ListProjects',
                request_serializer=noteflow__pb2.ListProjectsRequest.SerializeToString,
                response_deserializer=noteflow__pb2.ListProjectsResponse.FromString,
                _registered_method=True)
        self.UpdateProject = channel.unary_unary(
                '/noteflow.NoteFlowService/UpdateProject',
                request_serializer=noteflow__pb2.UpdateProjectRequest.SerializeToString,
                response_deserializer=noteflow__pb2.ProjectProto.FromString,
                _registered_method=True)
        self.ArchiveProject = channel.unary_unary(
                '/noteflow.NoteFlowService/ArchiveProject',
                request_serializer=noteflow__pb2.ArchiveProjectRequest.SerializeToString,
                response_deserializer=noteflow__pb2.ProjectProto.FromString,
                _registered_method=True)
        self.RestoreProject = channel.unary_unary(
                '/noteflow.NoteFlowService/RestoreProject',
                request_serializer=noteflow__pb2.RestoreProjectRequest.SerializeToString,
                response_deserializer=noteflow__pb2.ProjectProto.FromString,
                _registered_method=True)
        self.DeleteProject = channel.unary_unary(
                '/noteflow.NoteFlowService/DeleteProject',
                request_serializer=noteflow__pb2.DeleteProjectRequest.SerializeToString,
                response_deserializer=noteflow__pb2.DeleteProjectResponse.FromString,
                _registered_method=True)
        self.SetActiveProject = channel.unary_unary(
                '/noteflow.NoteFlowService/SetActiveProject',
                request_serializer=noteflow__pb2.SetActiveProjectRequest.SerializeToString,
                response_deserializer=noteflow__pb2.SetActiveProjectResponse.FromString,
                _registered_method=True)
        self.GetActiveProject = channel.unary_unary(
                '/noteflow.NoteFlowService/GetActiveProject',
                request_serializer=noteflow__pb2.GetActiveProjectRequest.SerializeToString,
                response_deserializer=noteflow__pb2.GetActiveProjectResponse.FromString,
                _registered_method=True)
        self.AddProjectMember = channel.unary_unary(
                '/noteflow.NoteFlowService/AddProjectMember',
                request_serializer=noteflow__pb2.AddProjectMemberRequest.SerializeToString,
                response_deserializer=noteflow__pb2.ProjectMembershipProto.FromString,
                _registered_method=True)
        self.UpdateProjectMemberRole = channel.unary_unary(
                '/noteflow.NoteFlowService/UpdateProjectMemberRole',
                request_serializer=noteflow__pb2.UpdateProjectMemberRoleRequest.SerializeToString,
                response_deserializer=noteflow__pb2.ProjectMembershipProto.FromString,
                _registered_method=True)
        self.RemoveProjectMember = channel.unary_unary(
                '/noteflow.NoteFlowService/RemoveProjectMember',
                request_serializer=noteflow__pb2.RemoveProjectMemberRequest.SerializeToString,
                response_deserializer=noteflow__pb2.RemoveProjectMemberResponse.FromString,
                _registered_method=True)
        self.ListProjectMembers = channel.unary_unary(
                '/noteflow.NoteFlowService/ListProjectMembers',
                request_serializer=noteflow__pb2.ListProjectMembersRequest.SerializeToString,
                response_deserializer=noteflow__pb2.ListProjectMembersResponse.FromString,
                _registered_method=True)


class NoteFlowServiceServicer(object):
    """=============================================================================
    Core Service
    =============================================================================

    """

    def StreamTranscription(self, request_iterator, context):
        """Bidirectional streaming: client sends audio chunks, server returns transcripts
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateMeeting(self, request, context):
        """Meeting lifecycle management
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StopMeeting(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 ListMeetings(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 GetMeeting(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 DeleteMeeting(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 GenerateSummary(self, request, context):
        """Summary generation
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AddAnnotation(self, request, context):
        """Annotation management
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetAnnotation(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 ListAnnotations(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 UpdateAnnotation(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 DeleteAnnotation(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 ExportTranscript(self, request, context):
        """Export functionality
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RefineSpeakerDiarization(self, request, context):
        """Speaker diarization
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RenameSpeaker(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 GetDiarizationJobStatus(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 CancelDiarizationJob(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 GetActiveDiarizationJobs(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 GetServerInfo(self, request, context):
        """Server health and capabilities
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ExtractEntities(self, request, context):
        """Named entity extraction (Sprint 4) + mutations (Sprint 8)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UpdateEntity(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 DeleteEntity(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 ListCalendarEvents(self, request, context):
        """Calendar integration (Sprint 5)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetCalendarProviders(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 InitiateOAuth(self, request, context):
        """OAuth integration (generic for calendar, email, PKM, etc.)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CompleteOAuth(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 GetOAuthConnectionStatus(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 DisconnectOAuth(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 RegisterWebhook(self, request, context):
        """Webhook management (Sprint 6)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ListWebhooks(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 UpdateWebhook(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 DeleteWebhook(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 GetWebhookDeliveries(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 GrantCloudConsent(self, request, context):
        """Cloud consent management (Sprint 7)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RevokeCloudConsent(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 GetCloudConsentStatus(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 GetPreferences(self, request, context):
        """User preferences sync (Sprint 14)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SetPreferences(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 StartIntegrationSync(self, request, context):
        """Integration sync orchestration (Sprint 9)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetSyncStatus(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 ListSyncHistory(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 GetUserIntegrations(self, request, context):
        """Integration cache validation (Sprint 18.1)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetRecentLogs(self, request, context):
        """Observability (Sprint 9)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetPerformanceMetrics(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 RegisterOidcProvider(self, request, context):
        """OIDC Provider Management (Sprint 17)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ListOidcProviders(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 GetOidcProvider(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 UpdateOidcProvider(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 DeleteOidcProvider(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 RefreshOidcDiscovery(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 ListOidcPresets(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 CreateProject(self, request, context):
        """Project management (Sprint 18)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetProject(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 GetProjectBySlug(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 ListProjects(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 ArchiveProject(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 RestoreProject(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 SetActiveProject(self, request, context):
        """Active project (Sprint 18)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetActiveProject(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 AddProjectMember(self, request, context):
        """Project membership management (Sprint 18)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

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


def add_NoteFlowServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'StreamTranscription': grpc.stream_stream_rpc_method_handler(
                    servicer.StreamTranscription,
                    request_deserializer=noteflow__pb2.AudioChunk.FromString,
                    response_serializer=noteflow__pb2.TranscriptUpdate.SerializeToString,
            ),
            'CreateMeeting': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateMeeting,
                    request_deserializer=noteflow__pb2.CreateMeetingRequest.FromString,
                    response_serializer=noteflow__pb2.Meeting.SerializeToString,
            ),
            'StopMeeting': grpc.unary_unary_rpc_method_handler(
                    servicer.StopMeeting,
                    request_deserializer=noteflow__pb2.StopMeetingRequest.FromString,
                    response_serializer=noteflow__pb2.Meeting.SerializeToString,
            ),
            'ListMeetings': grpc.unary_unary_rpc_method_handler(
                    servicer.ListMeetings,
                    request_deserializer=noteflow__pb2.ListMeetingsRequest.FromString,
                    response_serializer=noteflow__pb2.ListMeetingsResponse.SerializeToString,
            ),
            'GetMeeting': grpc.unary_unary_rpc_method_handler(
                    servicer.GetMeeting,
                    request_deserializer=noteflow__pb2.GetMeetingRequest.FromString,
                    response_serializer=noteflow__pb2.Meeting.SerializeToString,
            ),
            'DeleteMeeting': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteMeeting,
                    request_deserializer=noteflow__pb2.DeleteMeetingRequest.FromString,
                    response_serializer=noteflow__pb2.DeleteMeetingResponse.SerializeToString,
            ),
            'GenerateSummary': grpc.unary_unary_rpc_method_handler(
                    servicer.GenerateSummary,
                    request_deserializer=noteflow__pb2.GenerateSummaryRequest.FromString,
                    response_serializer=noteflow__pb2.Summary.SerializeToString,
            ),
            'AddAnnotation': grpc.unary_unary_rpc_method_handler(
                    servicer.AddAnnotation,
                    request_deserializer=noteflow__pb2.AddAnnotationRequest.FromString,
                    response_serializer=noteflow__pb2.Annotation.SerializeToString,
            ),
            'GetAnnotation': grpc.unary_unary_rpc_method_handler(
                    servicer.GetAnnotation,
                    request_deserializer=noteflow__pb2.GetAnnotationRequest.FromString,
                    response_serializer=noteflow__pb2.Annotation.SerializeToString,
            ),
            'ListAnnotations': grpc.unary_unary_rpc_method_handler(
                    servicer.ListAnnotations,
                    request_deserializer=noteflow__pb2.ListAnnotationsRequest.FromString,
                    response_serializer=noteflow__pb2.ListAnnotationsResponse.SerializeToString,
            ),
            'UpdateAnnotation': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateAnnotation,
                    request_deserializer=noteflow__pb2.UpdateAnnotationRequest.FromString,
                    response_serializer=noteflow__pb2.Annotation.SerializeToString,
            ),
            'DeleteAnnotation': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteAnnotation,
                    request_deserializer=noteflow__pb2.DeleteAnnotationRequest.FromString,
                    response_serializer=noteflow__pb2.DeleteAnnotationResponse.SerializeToString,
            ),
            'ExportTranscript': grpc.unary_unary_rpc_method_handler(
                    servicer.ExportTranscript,
                    request_deserializer=noteflow__pb2.ExportTranscriptRequest.FromString,
                    response_serializer=noteflow__pb2.ExportTranscriptResponse.SerializeToString,
            ),
            'RefineSpeakerDiarization': grpc.unary_unary_rpc_method_handler(
                    servicer.RefineSpeakerDiarization,
                    request_deserializer=noteflow__pb2.RefineSpeakerDiarizationRequest.FromString,
                    response_serializer=noteflow__pb2.RefineSpeakerDiarizationResponse.SerializeToString,
            ),
            'RenameSpeaker': grpc.unary_unary_rpc_method_handler(
                    servicer.RenameSpeaker,
                    request_deserializer=noteflow__pb2.RenameSpeakerRequest.FromString,
                    response_serializer=noteflow__pb2.RenameSpeakerResponse.SerializeToString,
            ),
            'GetDiarizationJobStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.GetDiarizationJobStatus,
                    request_deserializer=noteflow__pb2.GetDiarizationJobStatusRequest.FromString,
                    response_serializer=noteflow__pb2.DiarizationJobStatus.SerializeToString,
            ),
            'CancelDiarizationJob': grpc.unary_unary_rpc_method_handler(
                    servicer.CancelDiarizationJob,
                    request_deserializer=noteflow__pb2.CancelDiarizationJobRequest.FromString,
                    response_serializer=noteflow__pb2.CancelDiarizationJobResponse.SerializeToString,
            ),
            'GetActiveDiarizationJobs': grpc.unary_unary_rpc_method_handler(
                    servicer.GetActiveDiarizationJobs,
                    request_deserializer=noteflow__pb2.GetActiveDiarizationJobsRequest.FromString,
                    response_serializer=noteflow__pb2.GetActiveDiarizationJobsResponse.SerializeToString,
            ),
            'GetServerInfo': grpc.unary_unary_rpc_method_handler(
                    servicer.GetServerInfo,
                    request_deserializer=noteflow__pb2.ServerInfoRequest.FromString,
                    response_serializer=noteflow__pb2.ServerInfo.SerializeToString,
            ),
            'ExtractEntities': grpc.unary_unary_rpc_method_handler(
                    servicer.ExtractEntities,
                    request_deserializer=noteflow__pb2.ExtractEntitiesRequest.FromString,
                    response_serializer=noteflow__pb2.ExtractEntitiesResponse.SerializeToString,
            ),
            'UpdateEntity': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateEntity,
                    request_deserializer=noteflow__pb2.UpdateEntityRequest.FromString,
                    response_serializer=noteflow__pb2.UpdateEntityResponse.SerializeToString,
            ),
            'DeleteEntity': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteEntity,
                    request_deserializer=noteflow__pb2.DeleteEntityRequest.FromString,
                    response_serializer=noteflow__pb2.DeleteEntityResponse.SerializeToString,
            ),
            'ListCalendarEvents': grpc.unary_unary_rpc_method_handler(
                    servicer.ListCalendarEvents,
                    request_deserializer=noteflow__pb2.ListCalendarEventsRequest.FromString,
                    response_serializer=noteflow__pb2.ListCalendarEventsResponse.SerializeToString,
            ),
            'GetCalendarProviders': grpc.unary_unary_rpc_method_handler(
                    servicer.GetCalendarProviders,
                    request_deserializer=noteflow__pb2.GetCalendarProvidersRequest.FromString,
                    response_serializer=noteflow__pb2.GetCalendarProvidersResponse.SerializeToString,
            ),
            'InitiateOAuth': grpc.unary_unary_rpc_method_handler(
                    servicer.InitiateOAuth,
                    request_deserializer=noteflow__pb2.InitiateOAuthRequest.FromString,
                    response_serializer=noteflow__pb2.InitiateOAuthResponse.SerializeToString,
            ),
            'CompleteOAuth': grpc.unary_unary_rpc_method_handler(
                    servicer.CompleteOAuth,
                    request_deserializer=noteflow__pb2.CompleteOAuthRequest.FromString,
                    response_serializer=noteflow__pb2.CompleteOAuthResponse.SerializeToString,
            ),
            'GetOAuthConnectionStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.GetOAuthConnectionStatus,
                    request_deserializer=noteflow__pb2.GetOAuthConnectionStatusRequest.FromString,
                    response_serializer=noteflow__pb2.GetOAuthConnectionStatusResponse.SerializeToString,
            ),
            'DisconnectOAuth': grpc.unary_unary_rpc_method_handler(
                    servicer.DisconnectOAuth,
                    request_deserializer=noteflow__pb2.DisconnectOAuthRequest.FromString,
                    response_serializer=noteflow__pb2.DisconnectOAuthResponse.SerializeToString,
            ),
            'RegisterWebhook': grpc.unary_unary_rpc_method_handler(
                    servicer.RegisterWebhook,
                    request_deserializer=noteflow__pb2.RegisterWebhookRequest.FromString,
                    response_serializer=noteflow__pb2.WebhookConfigProto.SerializeToString,
            ),
            'ListWebhooks': grpc.unary_unary_rpc_method_handler(
                    servicer.ListWebhooks,
                    request_deserializer=noteflow__pb2.ListWebhooksRequest.FromString,
                    response_serializer=noteflow__pb2.ListWebhooksResponse.SerializeToString,
            ),
            'UpdateWebhook': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateWebhook,
                    request_deserializer=noteflow__pb2.UpdateWebhookRequest.FromString,
                    response_serializer=noteflow__pb2.WebhookConfigProto.SerializeToString,
            ),
            'DeleteWebhook': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteWebhook,
                    request_deserializer=noteflow__pb2.DeleteWebhookRequest.FromString,
                    response_serializer=noteflow__pb2.DeleteWebhookResponse.SerializeToString,
            ),
            'GetWebhookDeliveries': grpc.unary_unary_rpc_method_handler(
                    servicer.GetWebhookDeliveries,
                    request_deserializer=noteflow__pb2.GetWebhookDeliveriesRequest.FromString,
                    response_serializer=noteflow__pb2.GetWebhookDeliveriesResponse.SerializeToString,
            ),
            'GrantCloudConsent': grpc.unary_unary_rpc_method_handler(
                    servicer.GrantCloudConsent,
                    request_deserializer=noteflow__pb2.GrantCloudConsentRequest.FromString,
                    response_serializer=noteflow__pb2.GrantCloudConsentResponse.SerializeToString,
            ),
            'RevokeCloudConsent': grpc.unary_unary_rpc_method_handler(
                    servicer.RevokeCloudConsent,
                    request_deserializer=noteflow__pb2.RevokeCloudConsentRequest.FromString,
                    response_serializer=noteflow__pb2.RevokeCloudConsentResponse.SerializeToString,
            ),
            'GetCloudConsentStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.GetCloudConsentStatus,
                    request_deserializer=noteflow__pb2.GetCloudConsentStatusRequest.FromString,
                    response_serializer=noteflow__pb2.GetCloudConsentStatusResponse.SerializeToString,
            ),
            'GetPreferences': grpc.unary_unary_rpc_method_handler(
                    servicer.GetPreferences,
                    request_deserializer=noteflow__pb2.GetPreferencesRequest.FromString,
                    response_serializer=noteflow__pb2.GetPreferencesResponse.SerializeToString,
            ),
            'SetPreferences': grpc.unary_unary_rpc_method_handler(
                    servicer.SetPreferences,
                    request_deserializer=noteflow__pb2.SetPreferencesRequest.FromString,
                    response_serializer=noteflow__pb2.SetPreferencesResponse.SerializeToString,
            ),
            'StartIntegrationSync': grpc.unary_unary_rpc_method_handler(
                    servicer.StartIntegrationSync,
                    request_deserializer=noteflow__pb2.StartIntegrationSyncRequest.FromString,
                    response_serializer=noteflow__pb2.StartIntegrationSyncResponse.SerializeToString,
            ),
            'GetSyncStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.GetSyncStatus,
                    request_deserializer=noteflow__pb2.GetSyncStatusRequest.FromString,
                    response_serializer=noteflow__pb2.GetSyncStatusResponse.SerializeToString,
            ),
            'ListSyncHistory': grpc.unary_unary_rpc_method_handler(
                    servicer.ListSyncHistory,
                    request_deserializer=noteflow__pb2.ListSyncHistoryRequest.FromString,
                    response_serializer=noteflow__pb2.ListSyncHistoryResponse.SerializeToString,
            ),
            'GetUserIntegrations': grpc.unary_unary_rpc_method_handler(
                    servicer.GetUserIntegrations,
                    request_deserializer=noteflow__pb2.GetUserIntegrationsRequest.FromString,
                    response_serializer=noteflow__pb2.GetUserIntegrationsResponse.SerializeToString,
            ),
            'GetRecentLogs': grpc.unary_unary_rpc_method_handler(
                    servicer.GetRecentLogs,
                    request_deserializer=noteflow__pb2.GetRecentLogsRequest.FromString,
                    response_serializer=noteflow__pb2.GetRecentLogsResponse.SerializeToString,
            ),
            'GetPerformanceMetrics': grpc.unary_unary_rpc_method_handler(
                    servicer.GetPerformanceMetrics,
                    request_deserializer=noteflow__pb2.GetPerformanceMetricsRequest.FromString,
                    response_serializer=noteflow__pb2.GetPerformanceMetricsResponse.SerializeToString,
            ),
            'RegisterOidcProvider': grpc.unary_unary_rpc_method_handler(
                    servicer.RegisterOidcProvider,
                    request_deserializer=noteflow__pb2.RegisterOidcProviderRequest.FromString,
                    response_serializer=noteflow__pb2.OidcProviderProto.SerializeToString,
            ),
            'ListOidcProviders': grpc.unary_unary_rpc_method_handler(
                    servicer.ListOidcProviders,
                    request_deserializer=noteflow__pb2.ListOidcProvidersRequest.FromString,
                    response_serializer=noteflow__pb2.ListOidcProvidersResponse.SerializeToString,
            ),
            'GetOidcProvider': grpc.unary_unary_rpc_method_handler(
                    servicer.GetOidcProvider,
                    request_deserializer=noteflow__pb2.GetOidcProviderRequest.FromString,
                    response_serializer=noteflow__pb2.OidcProviderProto.SerializeToString,
            ),
            'UpdateOidcProvider': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateOidcProvider,
                    request_deserializer=noteflow__pb2.UpdateOidcProviderRequest.FromString,
                    response_serializer=noteflow__pb2.OidcProviderProto.SerializeToString,
            ),
            'DeleteOidcProvider': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteOidcProvider,
                    request_deserializer=noteflow__pb2.DeleteOidcProviderRequest.FromString,
                    response_serializer=noteflow__pb2.DeleteOidcProviderResponse.SerializeToString,
            ),
            'RefreshOidcDiscovery': grpc.unary_unary_rpc_method_handler(
                    servicer.RefreshOidcDiscovery,
                    request_deserializer=noteflow__pb2.RefreshOidcDiscoveryRequest.FromString,
                    response_serializer=noteflow__pb2.RefreshOidcDiscoveryResponse.SerializeToString,
            ),
            'ListOidcPresets': grpc.unary_unary_rpc_method_handler(
                    servicer.ListOidcPresets,
                    request_deserializer=noteflow__pb2.ListOidcPresetsRequest.FromString,
                    response_serializer=noteflow__pb2.ListOidcPresetsResponse.SerializeToString,
            ),
            'CreateProject': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateProject,
                    request_deserializer=noteflow__pb2.CreateProjectRequest.FromString,
                    response_serializer=noteflow__pb2.ProjectProto.SerializeToString,
            ),
            'GetProject': grpc.unary_unary_rpc_method_handler(
                    servicer.GetProject,
                    request_deserializer=noteflow__pb2.GetProjectRequest.FromString,
                    response_serializer=noteflow__pb2.ProjectProto.SerializeToString,
            ),
            'GetProjectBySlug': grpc.unary_unary_rpc_method_handler(
                    servicer.GetProjectBySlug,
                    request_deserializer=noteflow__pb2.GetProjectBySlugRequest.FromString,
                    response_serializer=noteflow__pb2.ProjectProto.SerializeToString,
            ),
            'ListProjects': grpc.unary_unary_rpc_method_handler(
                    servicer.ListProjects,
                    request_deserializer=noteflow__pb2.ListProjectsRequest.FromString,
                    response_serializer=noteflow__pb2.ListProjectsResponse.SerializeToString,
            ),
            'UpdateProject': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateProject,
                    request_deserializer=noteflow__pb2.UpdateProjectRequest.FromString,
                    response_serializer=noteflow__pb2.ProjectProto.SerializeToString,
            ),
            'ArchiveProject': grpc.unary_unary_rpc_method_handler(
                    servicer.ArchiveProject,
                    request_deserializer=noteflow__pb2.ArchiveProjectRequest.FromString,
                    response_serializer=noteflow__pb2.ProjectProto.SerializeToString,
            ),
            'RestoreProject': grpc.unary_unary_rpc_method_handler(
                    servicer.RestoreProject,
                    request_deserializer=noteflow__pb2.RestoreProjectRequest.FromString,
                    response_serializer=noteflow__pb2.ProjectProto.SerializeToString,
            ),
            'DeleteProject': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteProject,
                    request_deserializer=noteflow__pb2.DeleteProjectRequest.FromString,
                    response_serializer=noteflow__pb2.DeleteProjectResponse.SerializeToString,
            ),
            'SetActiveProject': grpc.unary_unary_rpc_method_handler(
                    servicer.SetActiveProject,
                    request_deserializer=noteflow__pb2.SetActiveProjectRequest.FromString,
                    response_serializer=noteflow__pb2.SetActiveProjectResponse.SerializeToString,
            ),
            'GetActiveProject': grpc.unary_unary_rpc_method_handler(
                    servicer.GetActiveProject,
                    request_deserializer=noteflow__pb2.GetActiveProjectRequest.FromString,
                    response_serializer=noteflow__pb2.GetActiveProjectResponse.SerializeToString,
            ),
            'AddProjectMember': grpc.unary_unary_rpc_method_handler(
                    servicer.AddProjectMember,
                    request_deserializer=noteflow__pb2.AddProjectMemberRequest.FromString,
                    response_serializer=noteflow__pb2.ProjectMembershipProto.SerializeToString,
            ),
            'UpdateProjectMemberRole': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateProjectMemberRole,
                    request_deserializer=noteflow__pb2.UpdateProjectMemberRoleRequest.FromString,
                    response_serializer=noteflow__pb2.ProjectMembershipProto.SerializeToString,
            ),
            'RemoveProjectMember': grpc.unary_unary_rpc_method_handler(
                    servicer.RemoveProjectMember,
                    request_deserializer=noteflow__pb2.RemoveProjectMemberRequest.FromString,
                    response_serializer=noteflow__pb2.RemoveProjectMemberResponse.SerializeToString,
            ),
            'ListProjectMembers': grpc.unary_unary_rpc_method_handler(
                    servicer.ListProjectMembers,
                    request_deserializer=noteflow__pb2.ListProjectMembersRequest.FromString,
                    response_serializer=noteflow__pb2.ListProjectMembersResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'noteflow.NoteFlowService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('noteflow.NoteFlowService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class NoteFlowService(object):
    """=============================================================================
    Core Service
    =============================================================================

    """

    @staticmethod
    def StreamTranscription(request_iterator,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.stream_stream(
            request_iterator,
            target,
            '/noteflow.NoteFlowService/StreamTranscription',
            noteflow__pb2.AudioChunk.SerializeToString,
            noteflow__pb2.TranscriptUpdate.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateMeeting(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,
            '/noteflow.NoteFlowService/CreateMeeting',
            noteflow__pb2.CreateMeetingRequest.SerializeToString,
            noteflow__pb2.Meeting.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StopMeeting(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,
            '/noteflow.NoteFlowService/StopMeeting',
            noteflow__pb2.StopMeetingRequest.SerializeToString,
            noteflow__pb2.Meeting.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListMeetings(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,
            '/noteflow.NoteFlowService/ListMeetings',
            noteflow__pb2.ListMeetingsRequest.SerializeToString,
            noteflow__pb2.ListMeetingsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetMeeting(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,
            '/noteflow.NoteFlowService/GetMeeting',
            noteflow__pb2.GetMeetingRequest.SerializeToString,
            noteflow__pb2.Meeting.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteMeeting(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,
            '/noteflow.NoteFlowService/DeleteMeeting',
            noteflow__pb2.DeleteMeetingRequest.SerializeToString,
            noteflow__pb2.DeleteMeetingResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GenerateSummary(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,
            '/noteflow.NoteFlowService/GenerateSummary',
            noteflow__pb2.GenerateSummaryRequest.SerializeToString,
            noteflow__pb2.Summary.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AddAnnotation(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,
            '/noteflow.NoteFlowService/AddAnnotation',
            noteflow__pb2.AddAnnotationRequest.SerializeToString,
            noteflow__pb2.Annotation.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetAnnotation(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,
            '/noteflow.NoteFlowService/GetAnnotation',
            noteflow__pb2.GetAnnotationRequest.SerializeToString,
            noteflow__pb2.Annotation.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListAnnotations(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,
            '/noteflow.NoteFlowService/ListAnnotations',
            noteflow__pb2.ListAnnotationsRequest.SerializeToString,
            noteflow__pb2.ListAnnotationsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateAnnotation(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,
            '/noteflow.NoteFlowService/UpdateAnnotation',
            noteflow__pb2.UpdateAnnotationRequest.SerializeToString,
            noteflow__pb2.Annotation.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteAnnotation(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,
            '/noteflow.NoteFlowService/DeleteAnnotation',
            noteflow__pb2.DeleteAnnotationRequest.SerializeToString,
            noteflow__pb2.DeleteAnnotationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ExportTranscript(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,
            '/noteflow.NoteFlowService/ExportTranscript',
            noteflow__pb2.ExportTranscriptRequest.SerializeToString,
            noteflow__pb2.ExportTranscriptResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RefineSpeakerDiarization(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,
            '/noteflow.NoteFlowService/RefineSpeakerDiarization',
            noteflow__pb2.RefineSpeakerDiarizationRequest.SerializeToString,
            noteflow__pb2.RefineSpeakerDiarizationResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RenameSpeaker(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,
            '/noteflow.NoteFlowService/RenameSpeaker',
            noteflow__pb2.RenameSpeakerRequest.SerializeToString,
            noteflow__pb2.RenameSpeakerResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetDiarizationJobStatus(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,
            '/noteflow.NoteFlowService/GetDiarizationJobStatus',
            noteflow__pb2.GetDiarizationJobStatusRequest.SerializeToString,
            noteflow__pb2.DiarizationJobStatus.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CancelDiarizationJob(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,
            '/noteflow.NoteFlowService/CancelDiarizationJob',
            noteflow__pb2.CancelDiarizationJobRequest.SerializeToString,
            noteflow__pb2.CancelDiarizationJobResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetActiveDiarizationJobs(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,
            '/noteflow.NoteFlowService/GetActiveDiarizationJobs',
            noteflow__pb2.GetActiveDiarizationJobsRequest.SerializeToString,
            noteflow__pb2.GetActiveDiarizationJobsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetServerInfo(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,
            '/noteflow.NoteFlowService/GetServerInfo',
            noteflow__pb2.ServerInfoRequest.SerializeToString,
            noteflow__pb2.ServerInfo.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ExtractEntities(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,
            '/noteflow.NoteFlowService/ExtractEntities',
            noteflow__pb2.ExtractEntitiesRequest.SerializeToString,
            noteflow__pb2.ExtractEntitiesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateEntity(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,
            '/noteflow.NoteFlowService/UpdateEntity',
            noteflow__pb2.UpdateEntityRequest.SerializeToString,
            noteflow__pb2.UpdateEntityResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteEntity(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,
            '/noteflow.NoteFlowService/DeleteEntity',
            noteflow__pb2.DeleteEntityRequest.SerializeToString,
            noteflow__pb2.DeleteEntityResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListCalendarEvents(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,
            '/noteflow.NoteFlowService/ListCalendarEvents',
            noteflow__pb2.ListCalendarEventsRequest.SerializeToString,
            noteflow__pb2.ListCalendarEventsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetCalendarProviders(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,
            '/noteflow.NoteFlowService/GetCalendarProviders',
            noteflow__pb2.GetCalendarProvidersRequest.SerializeToString,
            noteflow__pb2.GetCalendarProvidersResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def InitiateOAuth(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,
            '/noteflow.NoteFlowService/InitiateOAuth',
            noteflow__pb2.InitiateOAuthRequest.SerializeToString,
            noteflow__pb2.InitiateOAuthResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CompleteOAuth(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,
            '/noteflow.NoteFlowService/CompleteOAuth',
            noteflow__pb2.CompleteOAuthRequest.SerializeToString,
            noteflow__pb2.CompleteOAuthResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetOAuthConnectionStatus(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,
            '/noteflow.NoteFlowService/GetOAuthConnectionStatus',
            noteflow__pb2.GetOAuthConnectionStatusRequest.SerializeToString,
            noteflow__pb2.GetOAuthConnectionStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DisconnectOAuth(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,
            '/noteflow.NoteFlowService/DisconnectOAuth',
            noteflow__pb2.DisconnectOAuthRequest.SerializeToString,
            noteflow__pb2.DisconnectOAuthResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RegisterWebhook(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,
            '/noteflow.NoteFlowService/RegisterWebhook',
            noteflow__pb2.RegisterWebhookRequest.SerializeToString,
            noteflow__pb2.WebhookConfigProto.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListWebhooks(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,
            '/noteflow.NoteFlowService/ListWebhooks',
            noteflow__pb2.ListWebhooksRequest.SerializeToString,
            noteflow__pb2.ListWebhooksResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateWebhook(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,
            '/noteflow.NoteFlowService/UpdateWebhook',
            noteflow__pb2.UpdateWebhookRequest.SerializeToString,
            noteflow__pb2.WebhookConfigProto.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteWebhook(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,
            '/noteflow.NoteFlowService/DeleteWebhook',
            noteflow__pb2.DeleteWebhookRequest.SerializeToString,
            noteflow__pb2.DeleteWebhookResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetWebhookDeliveries(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,
            '/noteflow.NoteFlowService/GetWebhookDeliveries',
            noteflow__pb2.GetWebhookDeliveriesRequest.SerializeToString,
            noteflow__pb2.GetWebhookDeliveriesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GrantCloudConsent(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,
            '/noteflow.NoteFlowService/GrantCloudConsent',
            noteflow__pb2.GrantCloudConsentRequest.SerializeToString,
            noteflow__pb2.GrantCloudConsentResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RevokeCloudConsent(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,
            '/noteflow.NoteFlowService/RevokeCloudConsent',
            noteflow__pb2.RevokeCloudConsentRequest.SerializeToString,
            noteflow__pb2.RevokeCloudConsentResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetCloudConsentStatus(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,
            '/noteflow.NoteFlowService/GetCloudConsentStatus',
            noteflow__pb2.GetCloudConsentStatusRequest.SerializeToString,
            noteflow__pb2.GetCloudConsentStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetPreferences(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,
            '/noteflow.NoteFlowService/GetPreferences',
            noteflow__pb2.GetPreferencesRequest.SerializeToString,
            noteflow__pb2.GetPreferencesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetPreferences(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,
            '/noteflow.NoteFlowService/SetPreferences',
            noteflow__pb2.SetPreferencesRequest.SerializeToString,
            noteflow__pb2.SetPreferencesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StartIntegrationSync(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,
            '/noteflow.NoteFlowService/StartIntegrationSync',
            noteflow__pb2.StartIntegrationSyncRequest.SerializeToString,
            noteflow__pb2.StartIntegrationSyncResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetSyncStatus(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,
            '/noteflow.NoteFlowService/GetSyncStatus',
            noteflow__pb2.GetSyncStatusRequest.SerializeToString,
            noteflow__pb2.GetSyncStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListSyncHistory(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,
            '/noteflow.NoteFlowService/ListSyncHistory',
            noteflow__pb2.ListSyncHistoryRequest.SerializeToString,
            noteflow__pb2.ListSyncHistoryResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetUserIntegrations(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,
            '/noteflow.NoteFlowService/GetUserIntegrations',
            noteflow__pb2.GetUserIntegrationsRequest.SerializeToString,
            noteflow__pb2.GetUserIntegrationsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetRecentLogs(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,
            '/noteflow.NoteFlowService/GetRecentLogs',
            noteflow__pb2.GetRecentLogsRequest.SerializeToString,
            noteflow__pb2.GetRecentLogsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetPerformanceMetrics(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,
            '/noteflow.NoteFlowService/GetPerformanceMetrics',
            noteflow__pb2.GetPerformanceMetricsRequest.SerializeToString,
            noteflow__pb2.GetPerformanceMetricsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RegisterOidcProvider(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,
            '/noteflow.NoteFlowService/RegisterOidcProvider',
            noteflow__pb2.RegisterOidcProviderRequest.SerializeToString,
            noteflow__pb2.OidcProviderProto.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListOidcProviders(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,
            '/noteflow.NoteFlowService/ListOidcProviders',
            noteflow__pb2.ListOidcProvidersRequest.SerializeToString,
            noteflow__pb2.ListOidcProvidersResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetOidcProvider(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,
            '/noteflow.NoteFlowService/GetOidcProvider',
            noteflow__pb2.GetOidcProviderRequest.SerializeToString,
            noteflow__pb2.OidcProviderProto.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateOidcProvider(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,
            '/noteflow.NoteFlowService/UpdateOidcProvider',
            noteflow__pb2.UpdateOidcProviderRequest.SerializeToString,
            noteflow__pb2.OidcProviderProto.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteOidcProvider(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,
            '/noteflow.NoteFlowService/DeleteOidcProvider',
            noteflow__pb2.DeleteOidcProviderRequest.SerializeToString,
            noteflow__pb2.DeleteOidcProviderResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RefreshOidcDiscovery(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,
            '/noteflow.NoteFlowService/RefreshOidcDiscovery',
            noteflow__pb2.RefreshOidcDiscoveryRequest.SerializeToString,
            noteflow__pb2.RefreshOidcDiscoveryResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListOidcPresets(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,
            '/noteflow.NoteFlowService/ListOidcPresets',
            noteflow__pb2.ListOidcPresetsRequest.SerializeToString,
            noteflow__pb2.ListOidcPresetsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @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,
            '/noteflow.NoteFlowService/CreateProject',
            noteflow__pb2.CreateProjectRequest.SerializeToString,
            noteflow__pb2.ProjectProto.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetProject(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,
            '/noteflow.NoteFlowService/GetProject',
            noteflow__pb2.GetProjectRequest.SerializeToString,
            noteflow__pb2.ProjectProto.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetProjectBySlug(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,
            '/noteflow.NoteFlowService/GetProjectBySlug',
            noteflow__pb2.GetProjectBySlugRequest.SerializeToString,
            noteflow__pb2.ProjectProto.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListProjects(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,
            '/noteflow.NoteFlowService/ListProjects',
            noteflow__pb2.ListProjectsRequest.SerializeToString,
            noteflow__pb2.ListProjectsResponse.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,
            '/noteflow.NoteFlowService/UpdateProject',
            noteflow__pb2.UpdateProjectRequest.SerializeToString,
            noteflow__pb2.ProjectProto.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ArchiveProject(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,
            '/noteflow.NoteFlowService/ArchiveProject',
            noteflow__pb2.ArchiveProjectRequest.SerializeToString,
            noteflow__pb2.ProjectProto.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RestoreProject(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,
            '/noteflow.NoteFlowService/RestoreProject',
            noteflow__pb2.RestoreProjectRequest.SerializeToString,
            noteflow__pb2.ProjectProto.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,
            '/noteflow.NoteFlowService/DeleteProject',
            noteflow__pb2.DeleteProjectRequest.SerializeToString,
            noteflow__pb2.DeleteProjectResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetActiveProject(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,
            '/noteflow.NoteFlowService/SetActiveProject',
            noteflow__pb2.SetActiveProjectRequest.SerializeToString,
            noteflow__pb2.SetActiveProjectResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetActiveProject(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,
            '/noteflow.NoteFlowService/GetActiveProject',
            noteflow__pb2.GetActiveProjectRequest.SerializeToString,
            noteflow__pb2.GetActiveProjectResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AddProjectMember(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,
            '/noteflow.NoteFlowService/AddProjectMember',
            noteflow__pb2.AddProjectMemberRequest.SerializeToString,
            noteflow__pb2.ProjectMembershipProto.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateProjectMemberRole(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,
            '/noteflow.NoteFlowService/UpdateProjectMemberRole',
            noteflow__pb2.UpdateProjectMemberRoleRequest.SerializeToString,
            noteflow__pb2.ProjectMembershipProto.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RemoveProjectMember(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,
            '/noteflow.NoteFlowService/RemoveProjectMember',
            noteflow__pb2.RemoveProjectMemberRequest.SerializeToString,
            noteflow__pb2.RemoveProjectMemberResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListProjectMembers(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,
            '/noteflow.NoteFlowService/ListProjectMembers',
            noteflow__pb2.ListProjectMembersRequest.SerializeToString,
            noteflow__pb2.ListProjectMembersResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
