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

import qiclib.packages.grpc.datatypes_pb2 as datatypes__pb2
import qiclib.packages.grpc.qic_storage_pb2 as qic__storage__pb2

GRPC_GENERATED_VERSION = '1.66.1'
GRPC_VERSION = grpc.__version__
_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:
    raise RuntimeError(
        f'The grpc package installed is at version {GRPC_VERSION},'
        + f' but the generated code in qic_storage_pb2_grpc.py depends on'
        + f' grpcio>={GRPC_GENERATED_VERSION}.'
        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
    )


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

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

        Args:
            channel: A grpc.Channel.
        """
        self.Reset = channel.unary_unary(
                '/qic_storage.Storage/Reset',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.SetStateHandling = channel.unary_unary(
                '/qic_storage.Storage/SetStateHandling',
                request_serializer=qic__storage__pb2.StateHandling.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetStateHandling = channel.unary_unary(
                '/qic_storage.Storage/GetStateHandling',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=qic__storage__pb2.StateHandling.FromString,
                _registered_method=True)
        self.GetStateAccumulation = channel.unary_unary(
                '/qic_storage.Storage/GetStateAccumulation',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=qic__storage__pb2.StateAccumulation.FromString,
                _registered_method=True)
        self.SetResultHandling = channel.unary_unary(
                '/qic_storage.Storage/SetResultHandling',
                request_serializer=qic__storage__pb2.ResultHandling.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetResultHandling = channel.unary_unary(
                '/qic_storage.Storage/GetResultHandling',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=qic__storage__pb2.ResultHandling.FromString,
                _registered_method=True)
        self.SetAveragedHandling = channel.unary_unary(
                '/qic_storage.Storage/SetAveragedHandling',
                request_serializer=qic__storage__pb2.AveragedHandling.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetAveragedHandling = channel.unary_unary(
                '/qic_storage.Storage/GetAveragedHandling',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=qic__storage__pb2.AveragedHandling.FromString,
                _registered_method=True)
        self.SetBramControl = channel.unary_unary(
                '/qic_storage.Storage/SetBramControl',
                request_serializer=qic__storage__pb2.BramControl.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetBramStatus = channel.unary_unary(
                '/qic_storage.Storage/GetBramStatus',
                request_serializer=qic__storage__pb2.BramIndex.SerializeToString,
                response_deserializer=qic__storage__pb2.BramStatus.FromString,
                _registered_method=True)
        self.ResetBramData = channel.unary_unary(
                '/qic_storage.Storage/ResetBramData',
                request_serializer=qic__storage__pb2.BramIndex.SerializeToString,
                response_deserializer=datatypes__pb2.Empty.FromString,
                _registered_method=True)
        self.GetBramResultData = channel.unary_unary(
                '/qic_storage.Storage/GetBramResultData',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=qic__storage__pb2.ResultData.FromString,
                _registered_method=True)
        self.GetBramAveragedData = channel.unary_unary(
                '/qic_storage.Storage/GetBramAveragedData',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=qic__storage__pb2.AveragedData.FromString,
                _registered_method=True)
        self.GetBramStateData = channel.unary_unary(
                '/qic_storage.Storage/GetBramStateData',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=qic__storage__pb2.StateData.FromString,
                _registered_method=True)
        self.GetBramDataUInt32 = channel.unary_unary(
                '/qic_storage.Storage/GetBramDataUInt32',
                request_serializer=qic__storage__pb2.BramIndex.SerializeToString,
                response_deserializer=qic__storage__pb2.BramDataUInt32.FromString,
                _registered_method=True)
        self.GetBramDataInt32 = channel.unary_unary(
                '/qic_storage.Storage/GetBramDataInt32',
                request_serializer=qic__storage__pb2.BramIndex.SerializeToString,
                response_deserializer=qic__storage__pb2.BramDataInt32.FromString,
                _registered_method=True)
        self.GetBramLatestData = channel.unary_unary(
                '/qic_storage.Storage/GetBramLatestData',
                request_serializer=qic__storage__pb2.BramIndex.SerializeToString,
                response_deserializer=qic__storage__pb2.LatestData.FromString,
                _registered_method=True)
        self.IsDataLost = channel.unary_unary(
                '/qic_storage.Storage/IsDataLost',
                request_serializer=datatypes__pb2.EndpointIndex.SerializeToString,
                response_deserializer=qic__storage__pb2.DataLost.FromString,
                _registered_method=True)


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

    def Reset(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 SetStateHandling(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 GetStateHandling(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 GetStateAccumulation(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 SetResultHandling(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 GetResultHandling(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 SetAveragedHandling(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 GetAveragedHandling(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 SetBramControl(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 GetBramStatus(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 ResetBramData(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 GetBramResultData(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 GetBramAveragedData(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 GetBramStateData(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 GetBramDataUInt32(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 GetBramDataInt32(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 GetBramLatestData(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 IsDataLost(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_StorageServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'Reset': grpc.unary_unary_rpc_method_handler(
                    servicer.Reset,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'SetStateHandling': grpc.unary_unary_rpc_method_handler(
                    servicer.SetStateHandling,
                    request_deserializer=qic__storage__pb2.StateHandling.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetStateHandling': grpc.unary_unary_rpc_method_handler(
                    servicer.GetStateHandling,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=qic__storage__pb2.StateHandling.SerializeToString,
            ),
            'GetStateAccumulation': grpc.unary_unary_rpc_method_handler(
                    servicer.GetStateAccumulation,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=qic__storage__pb2.StateAccumulation.SerializeToString,
            ),
            'SetResultHandling': grpc.unary_unary_rpc_method_handler(
                    servicer.SetResultHandling,
                    request_deserializer=qic__storage__pb2.ResultHandling.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetResultHandling': grpc.unary_unary_rpc_method_handler(
                    servicer.GetResultHandling,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=qic__storage__pb2.ResultHandling.SerializeToString,
            ),
            'SetAveragedHandling': grpc.unary_unary_rpc_method_handler(
                    servicer.SetAveragedHandling,
                    request_deserializer=qic__storage__pb2.AveragedHandling.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetAveragedHandling': grpc.unary_unary_rpc_method_handler(
                    servicer.GetAveragedHandling,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=qic__storage__pb2.AveragedHandling.SerializeToString,
            ),
            'SetBramControl': grpc.unary_unary_rpc_method_handler(
                    servicer.SetBramControl,
                    request_deserializer=qic__storage__pb2.BramControl.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetBramStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.GetBramStatus,
                    request_deserializer=qic__storage__pb2.BramIndex.FromString,
                    response_serializer=qic__storage__pb2.BramStatus.SerializeToString,
            ),
            'ResetBramData': grpc.unary_unary_rpc_method_handler(
                    servicer.ResetBramData,
                    request_deserializer=qic__storage__pb2.BramIndex.FromString,
                    response_serializer=datatypes__pb2.Empty.SerializeToString,
            ),
            'GetBramResultData': grpc.unary_unary_rpc_method_handler(
                    servicer.GetBramResultData,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=qic__storage__pb2.ResultData.SerializeToString,
            ),
            'GetBramAveragedData': grpc.unary_unary_rpc_method_handler(
                    servicer.GetBramAveragedData,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=qic__storage__pb2.AveragedData.SerializeToString,
            ),
            'GetBramStateData': grpc.unary_unary_rpc_method_handler(
                    servicer.GetBramStateData,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=qic__storage__pb2.StateData.SerializeToString,
            ),
            'GetBramDataUInt32': grpc.unary_unary_rpc_method_handler(
                    servicer.GetBramDataUInt32,
                    request_deserializer=qic__storage__pb2.BramIndex.FromString,
                    response_serializer=qic__storage__pb2.BramDataUInt32.SerializeToString,
            ),
            'GetBramDataInt32': grpc.unary_unary_rpc_method_handler(
                    servicer.GetBramDataInt32,
                    request_deserializer=qic__storage__pb2.BramIndex.FromString,
                    response_serializer=qic__storage__pb2.BramDataInt32.SerializeToString,
            ),
            'GetBramLatestData': grpc.unary_unary_rpc_method_handler(
                    servicer.GetBramLatestData,
                    request_deserializer=qic__storage__pb2.BramIndex.FromString,
                    response_serializer=qic__storage__pb2.LatestData.SerializeToString,
            ),
            'IsDataLost': grpc.unary_unary_rpc_method_handler(
                    servicer.IsDataLost,
                    request_deserializer=datatypes__pb2.EndpointIndex.FromString,
                    response_serializer=qic__storage__pb2.DataLost.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'qic_storage.Storage', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('qic_storage.Storage', rpc_method_handlers)


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

    @staticmethod
    def Reset(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,
            '/qic_storage.Storage/Reset',
            datatypes__pb2.EndpointIndex.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetStateHandling(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,
            '/qic_storage.Storage/SetStateHandling',
            qic__storage__pb2.StateHandling.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetStateHandling(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,
            '/qic_storage.Storage/GetStateHandling',
            datatypes__pb2.EndpointIndex.SerializeToString,
            qic__storage__pb2.StateHandling.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetStateAccumulation(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,
            '/qic_storage.Storage/GetStateAccumulation',
            datatypes__pb2.EndpointIndex.SerializeToString,
            qic__storage__pb2.StateAccumulation.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetResultHandling(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,
            '/qic_storage.Storage/SetResultHandling',
            qic__storage__pb2.ResultHandling.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetResultHandling(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,
            '/qic_storage.Storage/GetResultHandling',
            datatypes__pb2.EndpointIndex.SerializeToString,
            qic__storage__pb2.ResultHandling.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetAveragedHandling(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,
            '/qic_storage.Storage/SetAveragedHandling',
            qic__storage__pb2.AveragedHandling.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetAveragedHandling(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,
            '/qic_storage.Storage/GetAveragedHandling',
            datatypes__pb2.EndpointIndex.SerializeToString,
            qic__storage__pb2.AveragedHandling.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetBramControl(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,
            '/qic_storage.Storage/SetBramControl',
            qic__storage__pb2.BramControl.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetBramStatus(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,
            '/qic_storage.Storage/GetBramStatus',
            qic__storage__pb2.BramIndex.SerializeToString,
            qic__storage__pb2.BramStatus.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ResetBramData(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,
            '/qic_storage.Storage/ResetBramData',
            qic__storage__pb2.BramIndex.SerializeToString,
            datatypes__pb2.Empty.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetBramResultData(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,
            '/qic_storage.Storage/GetBramResultData',
            datatypes__pb2.EndpointIndex.SerializeToString,
            qic__storage__pb2.ResultData.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetBramAveragedData(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,
            '/qic_storage.Storage/GetBramAveragedData',
            datatypes__pb2.EndpointIndex.SerializeToString,
            qic__storage__pb2.AveragedData.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetBramStateData(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,
            '/qic_storage.Storage/GetBramStateData',
            datatypes__pb2.EndpointIndex.SerializeToString,
            qic__storage__pb2.StateData.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetBramDataUInt32(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,
            '/qic_storage.Storage/GetBramDataUInt32',
            qic__storage__pb2.BramIndex.SerializeToString,
            qic__storage__pb2.BramDataUInt32.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetBramDataInt32(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,
            '/qic_storage.Storage/GetBramDataInt32',
            qic__storage__pb2.BramIndex.SerializeToString,
            qic__storage__pb2.BramDataInt32.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetBramLatestData(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,
            '/qic_storage.Storage/GetBramLatestData',
            qic__storage__pb2.BramIndex.SerializeToString,
            qic__storage__pb2.LatestData.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def IsDataLost(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,
            '/qic_storage.Storage/IsDataLost',
            datatypes__pb2.EndpointIndex.SerializeToString,
            qic__storage__pb2.DataLost.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
