# 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 vault_service_pb2 as com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2
from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2


class VaultServiceStub(object):
    """*
    Vault service providing programmatic access to locally stored keys and certificates

    We have two key-stores: a private key store where we are storing our pairs of
    public and private keys and a public key store where we are storing other
    public keys that we learned.

    We learn public key stores in different ways: either by importing them or
    by picking them up from internal sources (such as identity management updates).

    The only purpose of the public key store (where we import foreign keys) is convenience for
    identity management such that when we add identity management transactions, we can refer to
    fingerprints in commands while building them rather than having to attach public-key files.

    In addition, we also provide access to the locally stored certificates which are used
    either by the HTTP/1.1 sequencer client or for legal identity claims.
    """

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

        Args:
            channel: A grpc.Channel.
        """
        self.ListMyKeys = channel.unary_unary(
                '/com.digitalasset.canton.crypto.admin.v0.VaultService/ListMyKeys',
                request_serializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ListKeysRequest.SerializeToString,
                response_deserializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ListMyKeysResponse.FromString,
                )
        self.GenerateSigningKey = channel.unary_unary(
                '/com.digitalasset.canton.crypto.admin.v0.VaultService/GenerateSigningKey',
                request_serializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.GenerateSigningKeyRequest.SerializeToString,
                response_deserializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.GenerateSigningKeyResponse.FromString,
                )
        self.GenerateEncryptionKey = channel.unary_unary(
                '/com.digitalasset.canton.crypto.admin.v0.VaultService/GenerateEncryptionKey',
                request_serializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.GenerateEncryptionKeyRequest.SerializeToString,
                response_deserializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.GenerateEncryptionKeyResponse.FromString,
                )
        self.RegisterKmsEncryptionKey = channel.unary_unary(
                '/com.digitalasset.canton.crypto.admin.v0.VaultService/RegisterKmsEncryptionKey',
                request_serializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.RegisterKmsEncryptionKeyRequest.SerializeToString,
                response_deserializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.RegisterKmsEncryptionKeyResponse.FromString,
                )
        self.RegisterKmsSigningKey = channel.unary_unary(
                '/com.digitalasset.canton.crypto.admin.v0.VaultService/RegisterKmsSigningKey',
                request_serializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.RegisterKmsSigningKeyRequest.SerializeToString,
                response_deserializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.RegisterKmsSigningKeyResponse.FromString,
                )
        self.ImportPublicKey = channel.unary_unary(
                '/com.digitalasset.canton.crypto.admin.v0.VaultService/ImportPublicKey',
                request_serializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ImportPublicKeyRequest.SerializeToString,
                response_deserializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ImportPublicKeyResponse.FromString,
                )
        self.ListPublicKeys = channel.unary_unary(
                '/com.digitalasset.canton.crypto.admin.v0.VaultService/ListPublicKeys',
                request_serializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ListKeysRequest.SerializeToString,
                response_deserializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ListKeysResponse.FromString,
                )
        self.RotateWrapperKey = channel.unary_unary(
                '/com.digitalasset.canton.crypto.admin.v0.VaultService/RotateWrapperKey',
                request_serializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.RotateWrapperKeyRequest.SerializeToString,
                response_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                )
        self.GetWrapperKeyId = channel.unary_unary(
                '/com.digitalasset.canton.crypto.admin.v0.VaultService/GetWrapperKeyId',
                request_serializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.GetWrapperKeyIdRequest.SerializeToString,
                response_deserializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.GetWrapperKeyIdResponse.FromString,
                )
        self.ExportKeyPair = channel.unary_unary(
                '/com.digitalasset.canton.crypto.admin.v0.VaultService/ExportKeyPair',
                request_serializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ExportKeyPairRequest.SerializeToString,
                response_deserializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ExportKeyPairResponse.FromString,
                )
        self.ImportKeyPair = channel.unary_unary(
                '/com.digitalasset.canton.crypto.admin.v0.VaultService/ImportKeyPair',
                request_serializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ImportKeyPairRequest.SerializeToString,
                response_deserializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ImportKeyPairResponse.FromString,
                )
        self.DeleteKeyPair = channel.unary_unary(
                '/com.digitalasset.canton.crypto.admin.v0.VaultService/DeleteKeyPair',
                request_serializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.DeleteKeyPairRequest.SerializeToString,
                response_deserializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.DeleteKeyPairResponse.FromString,
                )


class VaultServiceServicer(object):
    """*
    Vault service providing programmatic access to locally stored keys and certificates

    We have two key-stores: a private key store where we are storing our pairs of
    public and private keys and a public key store where we are storing other
    public keys that we learned.

    We learn public key stores in different ways: either by importing them or
    by picking them up from internal sources (such as identity management updates).

    The only purpose of the public key store (where we import foreign keys) is convenience for
    identity management such that when we add identity management transactions, we can refer to
    fingerprints in commands while building them rather than having to attach public-key files.

    In addition, we also provide access to the locally stored certificates which are used
    either by the HTTP/1.1 sequencer client or for legal identity claims.
    """

    def ListMyKeys(self, request, context):
        """*
        List public keys according to request filter for which we have a private key in our key vault.

        The request includes a filter for fingerprints which can be used for lookups.

        @param ListMyKeysRequest: request with optional fingerprint filter
        @return: all serialized keys and metadata that have the fingerprint filter as a substring in their fingerprint
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GenerateSigningKey(self, request, context):
        """*
        Generates a new public / private key pair for signing.

        Stores the private key in the vault, and returns the public key
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GenerateEncryptionKey(self, request, context):
        """*
        Generates a new public / private key pair for hybrid encryption.

        Stores the private key in the vault, and returns the public key
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RegisterKmsEncryptionKey(self, request, context):
        """*
        Registers a KMS key for asymmetric/hybrid encryption.

        Stores the corresponding public key in the vault, and returns it
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RegisterKmsSigningKey(self, request, context):
        """*
        Registers a KMS key for signing.

        Stores the corresponding public key in the vault, and returns it
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ImportPublicKey(self, request, context):
        """*
        Import a public key into the registry in order to provide that Fingerprint -> PublicKey lookups

        @param: ImportPublicKeyRequest serialized public key to be imported
        @return: fingerprint and serialized public key of imported public key
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ListPublicKeys(self, request, context):
        """*
        Lists all public keys matching the supplied filter which are internally cached

        Any public key returned here can be referenced in topology transaction building
        by fingerprint.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def RotateWrapperKey(self, request, context):
        """*
        Changes the wrapper key that is used to encrypt private keys when stored
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetWrapperKeyId(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 ExportKeyPair(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 ImportKeyPair(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 DeleteKeyPair(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_VaultServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'ListMyKeys': grpc.unary_unary_rpc_method_handler(
                    servicer.ListMyKeys,
                    request_deserializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ListKeysRequest.FromString,
                    response_serializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ListMyKeysResponse.SerializeToString,
            ),
            'GenerateSigningKey': grpc.unary_unary_rpc_method_handler(
                    servicer.GenerateSigningKey,
                    request_deserializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.GenerateSigningKeyRequest.FromString,
                    response_serializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.GenerateSigningKeyResponse.SerializeToString,
            ),
            'GenerateEncryptionKey': grpc.unary_unary_rpc_method_handler(
                    servicer.GenerateEncryptionKey,
                    request_deserializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.GenerateEncryptionKeyRequest.FromString,
                    response_serializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.GenerateEncryptionKeyResponse.SerializeToString,
            ),
            'RegisterKmsEncryptionKey': grpc.unary_unary_rpc_method_handler(
                    servicer.RegisterKmsEncryptionKey,
                    request_deserializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.RegisterKmsEncryptionKeyRequest.FromString,
                    response_serializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.RegisterKmsEncryptionKeyResponse.SerializeToString,
            ),
            'RegisterKmsSigningKey': grpc.unary_unary_rpc_method_handler(
                    servicer.RegisterKmsSigningKey,
                    request_deserializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.RegisterKmsSigningKeyRequest.FromString,
                    response_serializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.RegisterKmsSigningKeyResponse.SerializeToString,
            ),
            'ImportPublicKey': grpc.unary_unary_rpc_method_handler(
                    servicer.ImportPublicKey,
                    request_deserializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ImportPublicKeyRequest.FromString,
                    response_serializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ImportPublicKeyResponse.SerializeToString,
            ),
            'ListPublicKeys': grpc.unary_unary_rpc_method_handler(
                    servicer.ListPublicKeys,
                    request_deserializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ListKeysRequest.FromString,
                    response_serializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ListKeysResponse.SerializeToString,
            ),
            'RotateWrapperKey': grpc.unary_unary_rpc_method_handler(
                    servicer.RotateWrapperKey,
                    request_deserializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.RotateWrapperKeyRequest.FromString,
                    response_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            ),
            'GetWrapperKeyId': grpc.unary_unary_rpc_method_handler(
                    servicer.GetWrapperKeyId,
                    request_deserializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.GetWrapperKeyIdRequest.FromString,
                    response_serializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.GetWrapperKeyIdResponse.SerializeToString,
            ),
            'ExportKeyPair': grpc.unary_unary_rpc_method_handler(
                    servicer.ExportKeyPair,
                    request_deserializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ExportKeyPairRequest.FromString,
                    response_serializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ExportKeyPairResponse.SerializeToString,
            ),
            'ImportKeyPair': grpc.unary_unary_rpc_method_handler(
                    servicer.ImportKeyPair,
                    request_deserializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ImportKeyPairRequest.FromString,
                    response_serializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ImportKeyPairResponse.SerializeToString,
            ),
            'DeleteKeyPair': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteKeyPair,
                    request_deserializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.DeleteKeyPairRequest.FromString,
                    response_serializer=com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.DeleteKeyPairResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'com.digitalasset.canton.crypto.admin.v0.VaultService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class VaultService(object):
    """*
    Vault service providing programmatic access to locally stored keys and certificates

    We have two key-stores: a private key store where we are storing our pairs of
    public and private keys and a public key store where we are storing other
    public keys that we learned.

    We learn public key stores in different ways: either by importing them or
    by picking them up from internal sources (such as identity management updates).

    The only purpose of the public key store (where we import foreign keys) is convenience for
    identity management such that when we add identity management transactions, we can refer to
    fingerprints in commands while building them rather than having to attach public-key files.

    In addition, we also provide access to the locally stored certificates which are used
    either by the HTTP/1.1 sequencer client or for legal identity claims.
    """

    @staticmethod
    def ListMyKeys(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.crypto.admin.v0.VaultService/ListMyKeys',
            com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ListKeysRequest.SerializeToString,
            com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ListMyKeysResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GenerateSigningKey(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.crypto.admin.v0.VaultService/GenerateSigningKey',
            com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.GenerateSigningKeyRequest.SerializeToString,
            com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.GenerateSigningKeyResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GenerateEncryptionKey(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.crypto.admin.v0.VaultService/GenerateEncryptionKey',
            com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.GenerateEncryptionKeyRequest.SerializeToString,
            com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.GenerateEncryptionKeyResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RegisterKmsEncryptionKey(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.crypto.admin.v0.VaultService/RegisterKmsEncryptionKey',
            com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.RegisterKmsEncryptionKeyRequest.SerializeToString,
            com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.RegisterKmsEncryptionKeyResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RegisterKmsSigningKey(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.crypto.admin.v0.VaultService/RegisterKmsSigningKey',
            com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.RegisterKmsSigningKeyRequest.SerializeToString,
            com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.RegisterKmsSigningKeyResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ImportPublicKey(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.crypto.admin.v0.VaultService/ImportPublicKey',
            com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ImportPublicKeyRequest.SerializeToString,
            com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ImportPublicKeyResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ListPublicKeys(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.crypto.admin.v0.VaultService/ListPublicKeys',
            com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ListKeysRequest.SerializeToString,
            com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ListKeysResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def RotateWrapperKey(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.crypto.admin.v0.VaultService/RotateWrapperKey',
            com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.RotateWrapperKeyRequest.SerializeToString,
            google_dot_protobuf_dot_empty__pb2.Empty.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetWrapperKeyId(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.crypto.admin.v0.VaultService/GetWrapperKeyId',
            com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.GetWrapperKeyIdRequest.SerializeToString,
            com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.GetWrapperKeyIdResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ExportKeyPair(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.crypto.admin.v0.VaultService/ExportKeyPair',
            com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ExportKeyPairRequest.SerializeToString,
            com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ExportKeyPairResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ImportKeyPair(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.crypto.admin.v0.VaultService/ImportKeyPair',
            com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ImportKeyPairRequest.SerializeToString,
            com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.ImportKeyPairResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def DeleteKeyPair(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.crypto.admin.v0.VaultService/DeleteKeyPair',
            com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.DeleteKeyPairRequest.SerializeToString,
            com_dot_digitalasset_dot_canton_dot_crypto_dot_admin_dot_v0_dot_vault__service__pb2.DeleteKeyPairResponse.FromString,
            options, channel_credentials,
            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
