# Copyright (c) 2017-2024 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
# SPDX-License-Identifier: Apache-2.0
# fmt: off
# isort: skip_file
# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
"""Client and server classes corresponding to protobuf-defined services."""
import grpc

from . import sequencer_service_pb2 as com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2
from ....protocol.v0 import sequencing_pb2 as com_dot_digitalasset_dot_canton_dot_protocol_dot_v0_dot_sequencing__pb2
from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2


class SequencerServiceStub(object):
    """The service that a member can use to send messages to the domain and
    receive events from the domain
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.SendAsync = channel.unary_unary(
                '/com.digitalasset.canton.domain.api.v0.SequencerService/SendAsync',
                request_serializer=com_dot_digitalasset_dot_canton_dot_protocol_dot_v0_dot_sequencing__pb2.SubmissionRequest.SerializeToString,
                response_deserializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SendAsyncResponse.FromString,
                )
        self.SendAsyncSigned = channel.unary_unary(
                '/com.digitalasset.canton.domain.api.v0.SequencerService/SendAsyncSigned',
                request_serializer=com_dot_digitalasset_dot_canton_dot_protocol_dot_v0_dot_sequencing__pb2.SignedContent.SerializeToString,
                response_deserializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SendAsyncSignedResponse.FromString,
                )
        self.SendAsyncUnauthenticated = channel.unary_unary(
                '/com.digitalasset.canton.domain.api.v0.SequencerService/SendAsyncUnauthenticated',
                request_serializer=com_dot_digitalasset_dot_canton_dot_protocol_dot_v0_dot_sequencing__pb2.SubmissionRequest.SerializeToString,
                response_deserializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SendAsyncResponse.FromString,
                )
        self.SendAsyncVersioned = channel.unary_unary(
                '/com.digitalasset.canton.domain.api.v0.SequencerService/SendAsyncVersioned',
                request_serializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SendAsyncVersionedRequest.SerializeToString,
                response_deserializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SendAsyncSignedResponse.FromString,
                )
        self.SendAsyncUnauthenticatedVersioned = channel.unary_unary(
                '/com.digitalasset.canton.domain.api.v0.SequencerService/SendAsyncUnauthenticatedVersioned',
                request_serializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SendAsyncUnauthenticatedVersionedRequest.SerializeToString,
                response_deserializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SendAsyncResponse.FromString,
                )
        self.Subscribe = channel.unary_stream(
                '/com.digitalasset.canton.domain.api.v0.SequencerService/Subscribe',
                request_serializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SubscriptionRequest.SerializeToString,
                response_deserializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SubscriptionResponse.FromString,
                )
        self.SubscribeVersioned = channel.unary_stream(
                '/com.digitalasset.canton.domain.api.v0.SequencerService/SubscribeVersioned',
                request_serializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SubscriptionRequest.SerializeToString,
                response_deserializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.VersionedSubscriptionResponse.FromString,
                )
        self.SubscribeUnauthenticated = channel.unary_stream(
                '/com.digitalasset.canton.domain.api.v0.SequencerService/SubscribeUnauthenticated',
                request_serializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SubscriptionRequest.SerializeToString,
                response_deserializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SubscriptionResponse.FromString,
                )
        self.SubscribeUnauthenticatedVersioned = channel.unary_stream(
                '/com.digitalasset.canton.domain.api.v0.SequencerService/SubscribeUnauthenticatedVersioned',
                request_serializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SubscriptionRequest.SerializeToString,
                response_deserializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.VersionedSubscriptionResponse.FromString,
                )
        self.Acknowledge = channel.unary_unary(
                '/com.digitalasset.canton.domain.api.v0.SequencerService/Acknowledge',
                request_serializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.AcknowledgeRequest.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.AcknowledgeSigned = channel.unary_unary(
                '/com.digitalasset.canton.domain.api.v0.SequencerService/AcknowledgeSigned',
                request_serializer=com_dot_digitalasset_dot_canton_dot_protocol_dot_v0_dot_sequencing__pb2.SignedContent.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.DownloadTopologyStateForInit = channel.unary_unary(
                '/com.digitalasset.canton.domain.api.v0.SequencerService/DownloadTopologyStateForInit',
                request_serializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.TopologyStateForInitRequest.SerializeToString,
                response_deserializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.TopologyStateForInitResponse.FromString,
                )


class SequencerServiceServicer(object):
    """The service that a member can use to send messages to the domain and
    receive events from the domain
    """

    def SendAsync(self, request, context):
        """Submit a send request to the sequencer for sequencing asynchronously.
        The rpc request may return an error if the request cannot be processed at all - see SendAsyncResponse for these scenarios.
        The sequencer may emit a Deliver or DeliverError event from this send,
        if the subscriber witnesses an event greater or equal to the supplied maxSequencingTime, the sequencer
        guarantees not to publish a future Deliver event for this send.
        The sequencer implementation may however publish a future DeliverError (typically used to indicate maxSequencingTime exceeded).
        Used in protocol version 3
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SendAsyncSigned(self, request, context):
        """Newer version of request submission (for authenticated members).
        To be active for protocol versions 4.
        The argument here is a SubmissionRequest wrapped in SignedContent.
        The signature is checked on the server side to avoid that malicious sequencers create fake
        submission requests in multi-writer architectures where writers don't fully trust each other.

        Submit a send request to the sequencer for sequencing asynchronously.
        The rpc request may return an error if the request cannot be processed at all - see SendAsyncResponse for these scenarios.
        The sequencer may emit a Deliver or DeliverError event from this send,
        if the subscriber witnesses an event greater or equal to the supplied maxSequencingTime, the sequencer
        guarantees not to publish a future Deliver event for this send.
        The sequencer implementation may however publish a future DeliverError (typically used to indicate maxSequencingTime exceeded).
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SendAsyncUnauthenticated(self, request, context):
        """Submit a send request to the sequencer for sequencing asynchronously exactly like SendAsync, except that this
        meant to be used only by unauthenticated members for very specific operations that do not require authentication
        such as requesting that a participant's topology data gets accepted by the topology manager
        Used in protocol versions 3 and 4
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SendAsyncVersioned(self, request, context):
        """Submit a send request to the sequencer for sequencing asynchronously.
        The rpc request may return an error if the request cannot be processed at all - see SendAsyncResponse for these scenarios.
        The sequencer may emit a Deliver or DeliverError event from this send.
        If the subscriber witnesses an event greater or equal to the supplied maxSequencingTime, the sequencer
        guarantees not to publish a future Deliver event for this send.
        The sequencer implementation may however publish a future DeliverError (typically used to indicate maxSequencingTime exceeded).


        The signature is checked on the server side to avoid that malicious sequencers create fake
        submission requests in multi-writer architectures where writers don't fully trust each other.

        Used in protocol version 5 or higher
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SendAsyncUnauthenticatedVersioned(self, request, context):
        """Submit a send request to the sequencer for sequencing asynchronously exactly like SendAsyncVersioned, except that this
        meant to be used only by unauthenticated members for very specific operations that do not require authentication
        such as requesting that a participant's topology data gets accepted by the topology manager

        Used in protocol version 5 or higher
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Subscribe(self, request, context):
        """Establishes a stream with the server to receive sequenced events from the domain after the given
        counter. The delivered events will have a sequential counter and monotonically increasing timestamp.
        TBD: Message TTL - How far back should it go when the participant initiate a subscription ?
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SubscribeVersioned(self, request, context):
        """Same as `Subscribe(SubscriptionRequest)` but delivers byte array rather than typed
        message to support multiple versions.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SubscribeUnauthenticated(self, request, context):
        """Establishes a stream with the server to receive sequenced events exactly like Subscribe, except that this is
        supposed to be used only by unauthenticated members similarly to SendAsyncUnauthenticated
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SubscribeUnauthenticatedVersioned(self, request, context):
        """Same as `SubscribeUnauthenticated(SubscriptionRequest)` but delivers byte array rather than typed
        message to support multiple versions.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Acknowledge(self, request, context):
        """Allows a member to acknowledge that they have read all events up to and including the provided timestamp,
        and that they will never re-read these events again. This information is currently only used for informational
        purposes and to provide a watermark for which it is safe to prune earlier events from the sequencer data stores.
        There is no requirement for every event to be individually acknowledged, and in fact callers are encouraged to
        only periodically record acknowledgements (at an interval of minutes is expected to be more than sufficient for
        pruning).
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AcknowledgeSigned(self, request, context):
        """Newer version of acknowledgements.
        To be active for protocol versions >= 4.
        The argument here is an AcknowledgeRequest wrapped in SignedContent.
        The signature is checked on the server side to avoid that malicious sequencers create fake
        acknowledgements in multi-writer architectures where writers don't fully trust each other.

        Allows a member to acknowledge that they have read all events up to and including the provided timestamp,
        and that they will never re-read these events again. This information is currently only used for informational
        purposes and to provide a watermark for which it is safe to prune earlier events from the sequencer data stores.
        There is no requirement for every event to be individually acknowledged, and in fact callers are encouraged to
        only periodically record acknowledgements (at an interval of minutes is expected to be more than sufficient for
        pruning).
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DownloadTopologyStateForInit(self, request, context):
        """TODO(#11255) use a streaming response to avoid running into the grpc message size limit
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_SequencerServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'SendAsync': grpc.unary_unary_rpc_method_handler(
                    servicer.SendAsync,
                    request_deserializer=com_dot_digitalasset_dot_canton_dot_protocol_dot_v0_dot_sequencing__pb2.SubmissionRequest.FromString,
                    response_serializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SendAsyncResponse.SerializeToString,
            ),
            'SendAsyncSigned': grpc.unary_unary_rpc_method_handler(
                    servicer.SendAsyncSigned,
                    request_deserializer=com_dot_digitalasset_dot_canton_dot_protocol_dot_v0_dot_sequencing__pb2.SignedContent.FromString,
                    response_serializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SendAsyncSignedResponse.SerializeToString,
            ),
            'SendAsyncUnauthenticated': grpc.unary_unary_rpc_method_handler(
                    servicer.SendAsyncUnauthenticated,
                    request_deserializer=com_dot_digitalasset_dot_canton_dot_protocol_dot_v0_dot_sequencing__pb2.SubmissionRequest.FromString,
                    response_serializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SendAsyncResponse.SerializeToString,
            ),
            'SendAsyncVersioned': grpc.unary_unary_rpc_method_handler(
                    servicer.SendAsyncVersioned,
                    request_deserializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SendAsyncVersionedRequest.FromString,
                    response_serializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SendAsyncSignedResponse.SerializeToString,
            ),
            'SendAsyncUnauthenticatedVersioned': grpc.unary_unary_rpc_method_handler(
                    servicer.SendAsyncUnauthenticatedVersioned,
                    request_deserializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SendAsyncUnauthenticatedVersionedRequest.FromString,
                    response_serializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SendAsyncResponse.SerializeToString,
            ),
            'Subscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.Subscribe,
                    request_deserializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SubscriptionRequest.FromString,
                    response_serializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SubscriptionResponse.SerializeToString,
            ),
            'SubscribeVersioned': grpc.unary_stream_rpc_method_handler(
                    servicer.SubscribeVersioned,
                    request_deserializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SubscriptionRequest.FromString,
                    response_serializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.VersionedSubscriptionResponse.SerializeToString,
            ),
            'SubscribeUnauthenticated': grpc.unary_stream_rpc_method_handler(
                    servicer.SubscribeUnauthenticated,
                    request_deserializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SubscriptionRequest.FromString,
                    response_serializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SubscriptionResponse.SerializeToString,
            ),
            'SubscribeUnauthenticatedVersioned': grpc.unary_stream_rpc_method_handler(
                    servicer.SubscribeUnauthenticatedVersioned,
                    request_deserializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SubscriptionRequest.FromString,
                    response_serializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.VersionedSubscriptionResponse.SerializeToString,
            ),
            'Acknowledge': grpc.unary_unary_rpc_method_handler(
                    servicer.Acknowledge,
                    request_deserializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.AcknowledgeRequest.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'AcknowledgeSigned': grpc.unary_unary_rpc_method_handler(
                    servicer.AcknowledgeSigned,
                    request_deserializer=com_dot_digitalasset_dot_canton_dot_protocol_dot_v0_dot_sequencing__pb2.SignedContent.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'DownloadTopologyStateForInit': grpc.unary_unary_rpc_method_handler(
                    servicer.DownloadTopologyStateForInit,
                    request_deserializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.TopologyStateForInitRequest.FromString,
                    response_serializer=com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.TopologyStateForInitResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'com.digitalasset.canton.domain.api.v0.SequencerService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class SequencerService(object):
    """The service that a member can use to send messages to the domain and
    receive events from the domain
    """

    @staticmethod
    def SendAsync(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, '/com.digitalasset.canton.domain.api.v0.SequencerService/SendAsync',
            com_dot_digitalasset_dot_canton_dot_protocol_dot_v0_dot_sequencing__pb2.SubmissionRequest.SerializeToString,
            com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SendAsyncResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SendAsyncSigned(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, '/com.digitalasset.canton.domain.api.v0.SequencerService/SendAsyncSigned',
            com_dot_digitalasset_dot_canton_dot_protocol_dot_v0_dot_sequencing__pb2.SignedContent.SerializeToString,
            com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SendAsyncSignedResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SendAsyncUnauthenticated(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, '/com.digitalasset.canton.domain.api.v0.SequencerService/SendAsyncUnauthenticated',
            com_dot_digitalasset_dot_canton_dot_protocol_dot_v0_dot_sequencing__pb2.SubmissionRequest.SerializeToString,
            com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SendAsyncResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SendAsyncVersioned(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, '/com.digitalasset.canton.domain.api.v0.SequencerService/SendAsyncVersioned',
            com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SendAsyncVersionedRequest.SerializeToString,
            com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SendAsyncSignedResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SendAsyncUnauthenticatedVersioned(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, '/com.digitalasset.canton.domain.api.v0.SequencerService/SendAsyncUnauthenticatedVersioned',
            com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SendAsyncUnauthenticatedVersionedRequest.SerializeToString,
            com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SendAsyncResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Subscribe(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, '/com.digitalasset.canton.domain.api.v0.SequencerService/Subscribe',
            com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SubscriptionRequest.SerializeToString,
            com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SubscriptionResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SubscribeVersioned(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, '/com.digitalasset.canton.domain.api.v0.SequencerService/SubscribeVersioned',
            com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SubscriptionRequest.SerializeToString,
            com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.VersionedSubscriptionResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SubscribeUnauthenticated(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, '/com.digitalasset.canton.domain.api.v0.SequencerService/SubscribeUnauthenticated',
            com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SubscriptionRequest.SerializeToString,
            com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SubscriptionResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SubscribeUnauthenticatedVersioned(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, '/com.digitalasset.canton.domain.api.v0.SequencerService/SubscribeUnauthenticatedVersioned',
            com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.SubscriptionRequest.SerializeToString,
            com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.VersionedSubscriptionResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Acknowledge(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, '/com.digitalasset.canton.domain.api.v0.SequencerService/Acknowledge',
            com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.AcknowledgeRequest.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def AcknowledgeSigned(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, '/com.digitalasset.canton.domain.api.v0.SequencerService/AcknowledgeSigned',
            com_dot_digitalasset_dot_canton_dot_protocol_dot_v0_dot_sequencing__pb2.SignedContent.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def DownloadTopologyStateForInit(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, '/com.digitalasset.canton.domain.api.v0.SequencerService/DownloadTopologyStateForInit',
            com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.TopologyStateForInitRequest.SerializeToString,
            com_dot_digitalasset_dot_canton_dot_domain_dot_api_dot_v0_dot_sequencer__service__pb2.TopologyStateForInitResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
