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

from capiscio_mcp._proto.gen.capiscio.v1 import badge_pb2 as capiscio_dot_v1_dot_badge__pb2


class BadgeServiceStub(object):
    """BadgeService handles Trust Badge operations
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.SignBadge = channel.unary_unary(
                '/capiscio.v1.BadgeService/SignBadge',
                request_serializer=capiscio_dot_v1_dot_badge__pb2.SignBadgeRequest.SerializeToString,
                response_deserializer=capiscio_dot_v1_dot_badge__pb2.SignBadgeResponse.FromString,
                _registered_method=True)
        self.VerifyBadge = channel.unary_unary(
                '/capiscio.v1.BadgeService/VerifyBadge',
                request_serializer=capiscio_dot_v1_dot_badge__pb2.VerifyBadgeRequest.SerializeToString,
                response_deserializer=capiscio_dot_v1_dot_badge__pb2.VerifyBadgeResponse.FromString,
                _registered_method=True)
        self.VerifyBadgeWithOptions = channel.unary_unary(
                '/capiscio.v1.BadgeService/VerifyBadgeWithOptions',
                request_serializer=capiscio_dot_v1_dot_badge__pb2.VerifyBadgeWithOptionsRequest.SerializeToString,
                response_deserializer=capiscio_dot_v1_dot_badge__pb2.VerifyBadgeResponse.FromString,
                _registered_method=True)
        self.ParseBadge = channel.unary_unary(
                '/capiscio.v1.BadgeService/ParseBadge',
                request_serializer=capiscio_dot_v1_dot_badge__pb2.ParseBadgeRequest.SerializeToString,
                response_deserializer=capiscio_dot_v1_dot_badge__pb2.ParseBadgeResponse.FromString,
                _registered_method=True)
        self.RequestBadge = channel.unary_unary(
                '/capiscio.v1.BadgeService/RequestBadge',
                request_serializer=capiscio_dot_v1_dot_badge__pb2.RequestBadgeRequest.SerializeToString,
                response_deserializer=capiscio_dot_v1_dot_badge__pb2.RequestBadgeResponse.FromString,
                _registered_method=True)
        self.RequestPoPBadge = channel.unary_unary(
                '/capiscio.v1.BadgeService/RequestPoPBadge',
                request_serializer=capiscio_dot_v1_dot_badge__pb2.RequestPoPBadgeRequest.SerializeToString,
                response_deserializer=capiscio_dot_v1_dot_badge__pb2.RequestPoPBadgeResponse.FromString,
                _registered_method=True)
        self.CreateDVOrder = channel.unary_unary(
                '/capiscio.v1.BadgeService/CreateDVOrder',
                request_serializer=capiscio_dot_v1_dot_badge__pb2.CreateDVOrderRequest.SerializeToString,
                response_deserializer=capiscio_dot_v1_dot_badge__pb2.CreateDVOrderResponse.FromString,
                _registered_method=True)
        self.GetDVOrder = channel.unary_unary(
                '/capiscio.v1.BadgeService/GetDVOrder',
                request_serializer=capiscio_dot_v1_dot_badge__pb2.GetDVOrderRequest.SerializeToString,
                response_deserializer=capiscio_dot_v1_dot_badge__pb2.GetDVOrderResponse.FromString,
                _registered_method=True)
        self.FinalizeDVOrder = channel.unary_unary(
                '/capiscio.v1.BadgeService/FinalizeDVOrder',
                request_serializer=capiscio_dot_v1_dot_badge__pb2.FinalizeDVOrderRequest.SerializeToString,
                response_deserializer=capiscio_dot_v1_dot_badge__pb2.FinalizeDVOrderResponse.FromString,
                _registered_method=True)
        self.StartKeeper = channel.unary_stream(
                '/capiscio.v1.BadgeService/StartKeeper',
                request_serializer=capiscio_dot_v1_dot_badge__pb2.StartKeeperRequest.SerializeToString,
                response_deserializer=capiscio_dot_v1_dot_badge__pb2.KeeperEvent.FromString,
                _registered_method=True)


class BadgeServiceServicer(object):
    """BadgeService handles Trust Badge operations
    """

    def SignBadge(self, request, context):
        """Sign a new badge with the provided claims
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def VerifyBadge(self, request, context):
        """Verify a badge token (basic verification)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def VerifyBadgeWithOptions(self, request, context):
        """Verify a badge with full options (online checks, etc.)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ParseBadge(self, request, context):
        """Parse badge claims without verification
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RequestBadge(self, request, context):
        """Request a badge from a Certificate Authority (RFC-002 §12.1)
        This is for production use where badges are issued by CapiscIO registry
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RequestPoPBadge(self, request, context):
        """Request a badge using Proof of Possession (RFC-003)
        This provides IAL-1 assurance with cryptographic key binding
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CreateDVOrder(self, request, context):
        """Create a Domain Validated (DV) badge order (RFC-002 v1.2)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetDVOrder(self, request, context):
        """Get DV order status
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def FinalizeDVOrder(self, request, context):
        """Finalize DV order and receive grant
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def StartKeeper(self, request, context):
        """Start a badge keeper that automatically renews badges (RFC-002 §7.3)
        Returns a stream of keeper events (started, renewed, error, stopped)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_BadgeServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'SignBadge': grpc.unary_unary_rpc_method_handler(
                    servicer.SignBadge,
                    request_deserializer=capiscio_dot_v1_dot_badge__pb2.SignBadgeRequest.FromString,
                    response_serializer=capiscio_dot_v1_dot_badge__pb2.SignBadgeResponse.SerializeToString,
            ),
            'VerifyBadge': grpc.unary_unary_rpc_method_handler(
                    servicer.VerifyBadge,
                    request_deserializer=capiscio_dot_v1_dot_badge__pb2.VerifyBadgeRequest.FromString,
                    response_serializer=capiscio_dot_v1_dot_badge__pb2.VerifyBadgeResponse.SerializeToString,
            ),
            'VerifyBadgeWithOptions': grpc.unary_unary_rpc_method_handler(
                    servicer.VerifyBadgeWithOptions,
                    request_deserializer=capiscio_dot_v1_dot_badge__pb2.VerifyBadgeWithOptionsRequest.FromString,
                    response_serializer=capiscio_dot_v1_dot_badge__pb2.VerifyBadgeResponse.SerializeToString,
            ),
            'ParseBadge': grpc.unary_unary_rpc_method_handler(
                    servicer.ParseBadge,
                    request_deserializer=capiscio_dot_v1_dot_badge__pb2.ParseBadgeRequest.FromString,
                    response_serializer=capiscio_dot_v1_dot_badge__pb2.ParseBadgeResponse.SerializeToString,
            ),
            'RequestBadge': grpc.unary_unary_rpc_method_handler(
                    servicer.RequestBadge,
                    request_deserializer=capiscio_dot_v1_dot_badge__pb2.RequestBadgeRequest.FromString,
                    response_serializer=capiscio_dot_v1_dot_badge__pb2.RequestBadgeResponse.SerializeToString,
            ),
            'RequestPoPBadge': grpc.unary_unary_rpc_method_handler(
                    servicer.RequestPoPBadge,
                    request_deserializer=capiscio_dot_v1_dot_badge__pb2.RequestPoPBadgeRequest.FromString,
                    response_serializer=capiscio_dot_v1_dot_badge__pb2.RequestPoPBadgeResponse.SerializeToString,
            ),
            'CreateDVOrder': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateDVOrder,
                    request_deserializer=capiscio_dot_v1_dot_badge__pb2.CreateDVOrderRequest.FromString,
                    response_serializer=capiscio_dot_v1_dot_badge__pb2.CreateDVOrderResponse.SerializeToString,
            ),
            'GetDVOrder': grpc.unary_unary_rpc_method_handler(
                    servicer.GetDVOrder,
                    request_deserializer=capiscio_dot_v1_dot_badge__pb2.GetDVOrderRequest.FromString,
                    response_serializer=capiscio_dot_v1_dot_badge__pb2.GetDVOrderResponse.SerializeToString,
            ),
            'FinalizeDVOrder': grpc.unary_unary_rpc_method_handler(
                    servicer.FinalizeDVOrder,
                    request_deserializer=capiscio_dot_v1_dot_badge__pb2.FinalizeDVOrderRequest.FromString,
                    response_serializer=capiscio_dot_v1_dot_badge__pb2.FinalizeDVOrderResponse.SerializeToString,
            ),
            'StartKeeper': grpc.unary_stream_rpc_method_handler(
                    servicer.StartKeeper,
                    request_deserializer=capiscio_dot_v1_dot_badge__pb2.StartKeeperRequest.FromString,
                    response_serializer=capiscio_dot_v1_dot_badge__pb2.KeeperEvent.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'capiscio.v1.BadgeService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('capiscio.v1.BadgeService', rpc_method_handlers)


 # This class is part of an EXPERIMENTAL API.
class BadgeService(object):
    """BadgeService handles Trust Badge operations
    """

    @staticmethod
    def SignBadge(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,
            '/capiscio.v1.BadgeService/SignBadge',
            capiscio_dot_v1_dot_badge__pb2.SignBadgeRequest.SerializeToString,
            capiscio_dot_v1_dot_badge__pb2.SignBadgeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def VerifyBadge(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,
            '/capiscio.v1.BadgeService/VerifyBadge',
            capiscio_dot_v1_dot_badge__pb2.VerifyBadgeRequest.SerializeToString,
            capiscio_dot_v1_dot_badge__pb2.VerifyBadgeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def VerifyBadgeWithOptions(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,
            '/capiscio.v1.BadgeService/VerifyBadgeWithOptions',
            capiscio_dot_v1_dot_badge__pb2.VerifyBadgeWithOptionsRequest.SerializeToString,
            capiscio_dot_v1_dot_badge__pb2.VerifyBadgeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ParseBadge(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,
            '/capiscio.v1.BadgeService/ParseBadge',
            capiscio_dot_v1_dot_badge__pb2.ParseBadgeRequest.SerializeToString,
            capiscio_dot_v1_dot_badge__pb2.ParseBadgeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RequestBadge(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,
            '/capiscio.v1.BadgeService/RequestBadge',
            capiscio_dot_v1_dot_badge__pb2.RequestBadgeRequest.SerializeToString,
            capiscio_dot_v1_dot_badge__pb2.RequestBadgeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RequestPoPBadge(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,
            '/capiscio.v1.BadgeService/RequestPoPBadge',
            capiscio_dot_v1_dot_badge__pb2.RequestPoPBadgeRequest.SerializeToString,
            capiscio_dot_v1_dot_badge__pb2.RequestPoPBadgeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateDVOrder(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,
            '/capiscio.v1.BadgeService/CreateDVOrder',
            capiscio_dot_v1_dot_badge__pb2.CreateDVOrderRequest.SerializeToString,
            capiscio_dot_v1_dot_badge__pb2.CreateDVOrderResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetDVOrder(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,
            '/capiscio.v1.BadgeService/GetDVOrder',
            capiscio_dot_v1_dot_badge__pb2.GetDVOrderRequest.SerializeToString,
            capiscio_dot_v1_dot_badge__pb2.GetDVOrderResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def FinalizeDVOrder(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,
            '/capiscio.v1.BadgeService/FinalizeDVOrder',
            capiscio_dot_v1_dot_badge__pb2.FinalizeDVOrderRequest.SerializeToString,
            capiscio_dot_v1_dot_badge__pb2.FinalizeDVOrderResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def StartKeeper(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            insecure=False,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(
            request,
            target,
            '/capiscio.v1.BadgeService/StartKeeper',
            capiscio_dot_v1_dot_badge__pb2.StartKeeperRequest.SerializeToString,
            capiscio_dot_v1_dot_badge__pb2.KeeperEvent.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
