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

from deephaven_enterprise.proto import auth_pb2 as deephaven__enterprise_dot_proto_dot_auth__pb2
from deephaven_enterprise.proto import common_pb2 as deephaven__enterprise_dot_proto_dot_common__pb2

GRPC_GENERATED_VERSION = '1.63.0'
GRPC_VERSION = grpc.__version__
EXPECTED_ERROR_RELEASE = '1.65.0'
SCHEDULED_RELEASE_DATE = 'June 25, 2024'
_version_not_supported = False

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

if _version_not_supported:
    warnings.warn(
        f'The grpc package installed is at version {GRPC_VERSION},'
        + f' but the generated code in deephaven_enterprise/proto/auth_service_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}.'
        + f' This warning will become an error in {EXPECTED_ERROR_RELEASE},'
        + f' scheduled for release on {SCHEDULED_RELEASE_DATE}.',
        RuntimeWarning
    )


class AuthApiStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.ping = channel.unary_unary(
                '/io.deephaven.proto.auth.grpc.AuthApi/ping',
                request_serializer=deephaven__enterprise_dot_proto_dot_common__pb2.PingRequest.SerializeToString,
                response_deserializer=deephaven__enterprise_dot_proto_dot_common__pb2.PingResponse.FromString,
                _registered_method=True)
        self.authenticateByPassword = channel.unary_unary(
                '/io.deephaven.proto.auth.grpc.AuthApi/authenticateByPassword',
                request_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByPasswordRequest.SerializeToString,
                response_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByPasswordResponse.FromString,
                _registered_method=True)
        self.authenticateByPublicKey = channel.unary_unary(
                '/io.deephaven.proto.auth.grpc.AuthApi/authenticateByPublicKey',
                request_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByPublicKeyRequest.SerializeToString,
                response_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByPublicKeyResponse.FromString,
                _registered_method=True)
        self.authenticateByDelegateToken = channel.unary_unary(
                '/io.deephaven.proto.auth.grpc.AuthApi/authenticateByDelegateToken',
                request_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByDelegateTokenRequest.SerializeToString,
                response_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByDelegateTokenResponse.FromString,
                _registered_method=True)
        self.authenticateByExternal = channel.unary_unary(
                '/io.deephaven.proto.auth.grpc.AuthApi/authenticateByExternal',
                request_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByExternalRequest.SerializeToString,
                response_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByExternalResponse.FromString,
                _registered_method=True)
        self.authenticateByCookie = channel.unary_unary(
                '/io.deephaven.proto.auth.grpc.AuthApi/authenticateByCookie',
                request_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByCookieRequest.SerializeToString,
                response_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByCookieResponse.FromString,
                _registered_method=True)
        self.refreshCookie = channel.unary_unary(
                '/io.deephaven.proto.auth.grpc.AuthApi/refreshCookie',
                request_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.RefreshCookieRequest.SerializeToString,
                response_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.RefreshCookieResponse.FromString,
                _registered_method=True)
        self.invalidateCookie = channel.unary_unary(
                '/io.deephaven.proto.auth.grpc.AuthApi/invalidateCookie',
                request_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.InvalidateCookieRequest.SerializeToString,
                response_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.InvalidateCookieResponse.FromString,
                _registered_method=True)
        self.getNonce = channel.unary_unary(
                '/io.deephaven.proto.auth.grpc.AuthApi/getNonce',
                request_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.GetNonceRequest.SerializeToString,
                response_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.GetNonceResponse.FromString,
                _registered_method=True)
        self.getToken = channel.unary_unary(
                '/io.deephaven.proto.auth.grpc.AuthApi/getToken',
                request_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.GetTokenRequest.SerializeToString,
                response_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.GetTokenResponse.FromString,
                _registered_method=True)
        self.getTokenAs = channel.unary_unary(
                '/io.deephaven.proto.auth.grpc.AuthApi/getTokenAs',
                request_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.GetTokenAsRequest.SerializeToString,
                response_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.GetTokenAsResponse.FromString,
                _registered_method=True)
        self.verifyToken = channel.unary_unary(
                '/io.deephaven.proto.auth.grpc.AuthApi/verifyToken',
                request_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.VerifyTokenRequest.SerializeToString,
                response_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.VerifyTokenResponse.FromString,
                _registered_method=True)
        self.reload = channel.unary_unary(
                '/io.deephaven.proto.auth.grpc.AuthApi/reload',
                request_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.ReloadRequest.SerializeToString,
                response_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.ReloadResponse.FromString,
                _registered_method=True)
        self.verifyChallenge = channel.unary_unary(
                '/io.deephaven.proto.auth.grpc.AuthApi/verifyChallenge',
                request_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.VerifyChallengeRequest.SerializeToString,
                response_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.VerifyChallengeResponse.FromString,
                _registered_method=True)


class AuthApiServicer(object):
    """Missing associated documentation comment in .proto file."""

    def ping(self, request, context):
        """Simple ping method that allows a client to sample the latency to the server.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def authenticateByPassword(self, request, context):
        """
        Authenticate methods validate credentials and register authentication state (unless asked to verify only)


        Authenticate by password.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def authenticateByPublicKey(self, request, context):
        """Authenticate by public key challenge; should have obtained a nonce earlier via getNonce rpc.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def authenticateByDelegateToken(self, request, context):
        """Authenticate by delegate token; should have obtained a token earlier from another service that
        created it and forwarded it.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def authenticateByExternal(self, request, context):
        """Authenticate by an external method (eg, active directory).
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def authenticateByCookie(self, request, context):
        """Authenticate by providing an already existing cookie and the user context that cookie should be associated with.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def refreshCookie(self, request, context):
        """Refresh a cookie to maintain credentials.  Clients are expected to try to refresh cookies
        with enough time in advance before expiration; a reasonable default is half way through from the time
        the cookie was obtained with its deadline, and the actual deadline time.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def invalidateCookie(self, request, context):
        """Clients that are about to terminate are expected to invalidate their credentials before going away.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def getNonce(self, request, context):
        """Get a nonce for public key authentication.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def getToken(self, request, context):
        """Get a token for a three-way handshake.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def getTokenAs(self, request, context):
        """Get a token for a three-way handshake as a particular user.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def verifyToken(self, request, context):
        """Verify a token provided by another service.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def reload(self, request, context):
        """Request this server to reload its configuration.
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def verifyChallenge(self, request, context):
        """Verify a nonce challenge response for another server (not used directly by clients, only server-server)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_AuthApiServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'ping': grpc.unary_unary_rpc_method_handler(
                    servicer.ping,
                    request_deserializer=deephaven__enterprise_dot_proto_dot_common__pb2.PingRequest.FromString,
                    response_serializer=deephaven__enterprise_dot_proto_dot_common__pb2.PingResponse.SerializeToString,
            ),
            'authenticateByPassword': grpc.unary_unary_rpc_method_handler(
                    servicer.authenticateByPassword,
                    request_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByPasswordRequest.FromString,
                    response_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByPasswordResponse.SerializeToString,
            ),
            'authenticateByPublicKey': grpc.unary_unary_rpc_method_handler(
                    servicer.authenticateByPublicKey,
                    request_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByPublicKeyRequest.FromString,
                    response_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByPublicKeyResponse.SerializeToString,
            ),
            'authenticateByDelegateToken': grpc.unary_unary_rpc_method_handler(
                    servicer.authenticateByDelegateToken,
                    request_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByDelegateTokenRequest.FromString,
                    response_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByDelegateTokenResponse.SerializeToString,
            ),
            'authenticateByExternal': grpc.unary_unary_rpc_method_handler(
                    servicer.authenticateByExternal,
                    request_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByExternalRequest.FromString,
                    response_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByExternalResponse.SerializeToString,
            ),
            'authenticateByCookie': grpc.unary_unary_rpc_method_handler(
                    servicer.authenticateByCookie,
                    request_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByCookieRequest.FromString,
                    response_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByCookieResponse.SerializeToString,
            ),
            'refreshCookie': grpc.unary_unary_rpc_method_handler(
                    servicer.refreshCookie,
                    request_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.RefreshCookieRequest.FromString,
                    response_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.RefreshCookieResponse.SerializeToString,
            ),
            'invalidateCookie': grpc.unary_unary_rpc_method_handler(
                    servicer.invalidateCookie,
                    request_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.InvalidateCookieRequest.FromString,
                    response_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.InvalidateCookieResponse.SerializeToString,
            ),
            'getNonce': grpc.unary_unary_rpc_method_handler(
                    servicer.getNonce,
                    request_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.GetNonceRequest.FromString,
                    response_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.GetNonceResponse.SerializeToString,
            ),
            'getToken': grpc.unary_unary_rpc_method_handler(
                    servicer.getToken,
                    request_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.GetTokenRequest.FromString,
                    response_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.GetTokenResponse.SerializeToString,
            ),
            'getTokenAs': grpc.unary_unary_rpc_method_handler(
                    servicer.getTokenAs,
                    request_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.GetTokenAsRequest.FromString,
                    response_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.GetTokenAsResponse.SerializeToString,
            ),
            'verifyToken': grpc.unary_unary_rpc_method_handler(
                    servicer.verifyToken,
                    request_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.VerifyTokenRequest.FromString,
                    response_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.VerifyTokenResponse.SerializeToString,
            ),
            'reload': grpc.unary_unary_rpc_method_handler(
                    servicer.reload,
                    request_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.ReloadRequest.FromString,
                    response_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.ReloadResponse.SerializeToString,
            ),
            'verifyChallenge': grpc.unary_unary_rpc_method_handler(
                    servicer.verifyChallenge,
                    request_deserializer=deephaven__enterprise_dot_proto_dot_auth__pb2.VerifyChallengeRequest.FromString,
                    response_serializer=deephaven__enterprise_dot_proto_dot_auth__pb2.VerifyChallengeResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'io.deephaven.proto.auth.grpc.AuthApi', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class AuthApi(object):
    """Missing associated documentation comment in .proto file."""

    @staticmethod
    def ping(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,
            '/io.deephaven.proto.auth.grpc.AuthApi/ping',
            deephaven__enterprise_dot_proto_dot_common__pb2.PingRequest.SerializeToString,
            deephaven__enterprise_dot_proto_dot_common__pb2.PingResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def authenticateByPassword(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,
            '/io.deephaven.proto.auth.grpc.AuthApi/authenticateByPassword',
            deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByPasswordRequest.SerializeToString,
            deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByPasswordResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def authenticateByPublicKey(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,
            '/io.deephaven.proto.auth.grpc.AuthApi/authenticateByPublicKey',
            deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByPublicKeyRequest.SerializeToString,
            deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByPublicKeyResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def authenticateByDelegateToken(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,
            '/io.deephaven.proto.auth.grpc.AuthApi/authenticateByDelegateToken',
            deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByDelegateTokenRequest.SerializeToString,
            deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByDelegateTokenResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def authenticateByExternal(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,
            '/io.deephaven.proto.auth.grpc.AuthApi/authenticateByExternal',
            deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByExternalRequest.SerializeToString,
            deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByExternalResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def authenticateByCookie(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,
            '/io.deephaven.proto.auth.grpc.AuthApi/authenticateByCookie',
            deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByCookieRequest.SerializeToString,
            deephaven__enterprise_dot_proto_dot_auth__pb2.AuthenticateByCookieResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def refreshCookie(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,
            '/io.deephaven.proto.auth.grpc.AuthApi/refreshCookie',
            deephaven__enterprise_dot_proto_dot_auth__pb2.RefreshCookieRequest.SerializeToString,
            deephaven__enterprise_dot_proto_dot_auth__pb2.RefreshCookieResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def invalidateCookie(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,
            '/io.deephaven.proto.auth.grpc.AuthApi/invalidateCookie',
            deephaven__enterprise_dot_proto_dot_auth__pb2.InvalidateCookieRequest.SerializeToString,
            deephaven__enterprise_dot_proto_dot_auth__pb2.InvalidateCookieResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def getNonce(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,
            '/io.deephaven.proto.auth.grpc.AuthApi/getNonce',
            deephaven__enterprise_dot_proto_dot_auth__pb2.GetNonceRequest.SerializeToString,
            deephaven__enterprise_dot_proto_dot_auth__pb2.GetNonceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def getToken(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,
            '/io.deephaven.proto.auth.grpc.AuthApi/getToken',
            deephaven__enterprise_dot_proto_dot_auth__pb2.GetTokenRequest.SerializeToString,
            deephaven__enterprise_dot_proto_dot_auth__pb2.GetTokenResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def getTokenAs(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,
            '/io.deephaven.proto.auth.grpc.AuthApi/getTokenAs',
            deephaven__enterprise_dot_proto_dot_auth__pb2.GetTokenAsRequest.SerializeToString,
            deephaven__enterprise_dot_proto_dot_auth__pb2.GetTokenAsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def verifyToken(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,
            '/io.deephaven.proto.auth.grpc.AuthApi/verifyToken',
            deephaven__enterprise_dot_proto_dot_auth__pb2.VerifyTokenRequest.SerializeToString,
            deephaven__enterprise_dot_proto_dot_auth__pb2.VerifyTokenResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def reload(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,
            '/io.deephaven.proto.auth.grpc.AuthApi/reload',
            deephaven__enterprise_dot_proto_dot_auth__pb2.ReloadRequest.SerializeToString,
            deephaven__enterprise_dot_proto_dot_auth__pb2.ReloadResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def verifyChallenge(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,
            '/io.deephaven.proto.auth.grpc.AuthApi/verifyChallenge',
            deephaven__enterprise_dot_proto_dot_auth__pb2.VerifyChallengeRequest.SerializeToString,
            deephaven__enterprise_dot_proto_dot_auth__pb2.VerifyChallengeResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
