# 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 placebrain_contracts import devices_pb2 as devices__pb2

GRPC_GENERATED_VERSION = '1.76.0'
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},'
        + ' but the generated code in devices_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 DevicesServiceStub(object):
    """Missing associated documentation comment in .proto file."""

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

        Args:
            channel: A grpc.Channel.
        """
        self.CreateDevice = channel.unary_unary(
                '/devices.DevicesService/CreateDevice',
                request_serializer=devices__pb2.CreateDeviceRequest.SerializeToString,
                response_deserializer=devices__pb2.CreateDeviceResponse.FromString,
                _registered_method=True)
        self.GetDevice = channel.unary_unary(
                '/devices.DevicesService/GetDevice',
                request_serializer=devices__pb2.GetDeviceRequest.SerializeToString,
                response_deserializer=devices__pb2.GetDeviceResponse.FromString,
                _registered_method=True)
        self.ListDevices = channel.unary_unary(
                '/devices.DevicesService/ListDevices',
                request_serializer=devices__pb2.ListDevicesRequest.SerializeToString,
                response_deserializer=devices__pb2.ListDevicesResponse.FromString,
                _registered_method=True)
        self.UpdateDevice = channel.unary_unary(
                '/devices.DevicesService/UpdateDevice',
                request_serializer=devices__pb2.UpdateDeviceRequest.SerializeToString,
                response_deserializer=devices__pb2.UpdateDeviceResponse.FromString,
                _registered_method=True)
        self.DeleteDevice = channel.unary_unary(
                '/devices.DevicesService/DeleteDevice',
                request_serializer=devices__pb2.DeleteDeviceRequest.SerializeToString,
                response_deserializer=devices__pb2.DeleteDeviceResponse.FromString,
                _registered_method=True)
        self.RegenerateDeviceToken = channel.unary_unary(
                '/devices.DevicesService/RegenerateDeviceToken',
                request_serializer=devices__pb2.RegenerateDeviceTokenRequest.SerializeToString,
                response_deserializer=devices__pb2.RegenerateDeviceTokenResponse.FromString,
                _registered_method=True)
        self.CreateSensor = channel.unary_unary(
                '/devices.DevicesService/CreateSensor',
                request_serializer=devices__pb2.CreateSensorRequest.SerializeToString,
                response_deserializer=devices__pb2.CreateSensorResponse.FromString,
                _registered_method=True)
        self.ListSensors = channel.unary_unary(
                '/devices.DevicesService/ListSensors',
                request_serializer=devices__pb2.ListSensorsRequest.SerializeToString,
                response_deserializer=devices__pb2.ListSensorsResponse.FromString,
                _registered_method=True)
        self.UpdateSensor = channel.unary_unary(
                '/devices.DevicesService/UpdateSensor',
                request_serializer=devices__pb2.UpdateSensorRequest.SerializeToString,
                response_deserializer=devices__pb2.UpdateSensorResponse.FromString,
                _registered_method=True)
        self.DeleteSensor = channel.unary_unary(
                '/devices.DevicesService/DeleteSensor',
                request_serializer=devices__pb2.DeleteSensorRequest.SerializeToString,
                response_deserializer=devices__pb2.DeleteSensorResponse.FromString,
                _registered_method=True)
        self.SetThreshold = channel.unary_unary(
                '/devices.DevicesService/SetThreshold',
                request_serializer=devices__pb2.SetThresholdRequest.SerializeToString,
                response_deserializer=devices__pb2.SetThresholdResponse.FromString,
                _registered_method=True)
        self.ListThresholds = channel.unary_unary(
                '/devices.DevicesService/ListThresholds',
                request_serializer=devices__pb2.ListThresholdsRequest.SerializeToString,
                response_deserializer=devices__pb2.ListThresholdsResponse.FromString,
                _registered_method=True)
        self.DeleteThreshold = channel.unary_unary(
                '/devices.DevicesService/DeleteThreshold',
                request_serializer=devices__pb2.DeleteThresholdRequest.SerializeToString,
                response_deserializer=devices__pb2.DeleteThresholdResponse.FromString,
                _registered_method=True)
        self.GetSensorThresholds = channel.unary_unary(
                '/devices.DevicesService/GetSensorThresholds',
                request_serializer=devices__pb2.GetSensorThresholdsRequest.SerializeToString,
                response_deserializer=devices__pb2.GetSensorThresholdsResponse.FromString,
                _registered_method=True)
        self.CreateActuator = channel.unary_unary(
                '/devices.DevicesService/CreateActuator',
                request_serializer=devices__pb2.CreateActuatorRequest.SerializeToString,
                response_deserializer=devices__pb2.CreateActuatorResponse.FromString,
                _registered_method=True)
        self.ListActuators = channel.unary_unary(
                '/devices.DevicesService/ListActuators',
                request_serializer=devices__pb2.ListActuatorsRequest.SerializeToString,
                response_deserializer=devices__pb2.ListActuatorsResponse.FromString,
                _registered_method=True)
        self.UpdateActuator = channel.unary_unary(
                '/devices.DevicesService/UpdateActuator',
                request_serializer=devices__pb2.UpdateActuatorRequest.SerializeToString,
                response_deserializer=devices__pb2.UpdateActuatorResponse.FromString,
                _registered_method=True)
        self.DeleteActuator = channel.unary_unary(
                '/devices.DevicesService/DeleteActuator',
                request_serializer=devices__pb2.DeleteActuatorRequest.SerializeToString,
                response_deserializer=devices__pb2.DeleteActuatorResponse.FromString,
                _registered_method=True)
        self.SendCommand = channel.unary_unary(
                '/devices.DevicesService/SendCommand',
                request_serializer=devices__pb2.SendCommandRequest.SerializeToString,
                response_deserializer=devices__pb2.SendCommandResponse.FromString,
                _registered_method=True)
        self.AuthenticateDevice = channel.unary_unary(
                '/devices.DevicesService/AuthenticateDevice',
                request_serializer=devices__pb2.AuthenticateDeviceRequest.SerializeToString,
                response_deserializer=devices__pb2.AuthenticateDeviceResponse.FromString,
                _registered_method=True)
        self.CheckDeviceAcl = channel.unary_unary(
                '/devices.DevicesService/CheckDeviceAcl',
                request_serializer=devices__pb2.CheckDeviceAclRequest.SerializeToString,
                response_deserializer=devices__pb2.CheckDeviceAclResponse.FromString,
                _registered_method=True)
        self.GenerateMqttCredentials = channel.unary_unary(
                '/devices.DevicesService/GenerateMqttCredentials',
                request_serializer=devices__pb2.GenerateMqttCredentialsRequest.SerializeToString,
                response_deserializer=devices__pb2.GenerateMqttCredentialsResponse.FromString,
                _registered_method=True)
        self.UpdateDeviceStatus = channel.unary_unary(
                '/devices.DevicesService/UpdateDeviceStatus',
                request_serializer=devices__pb2.UpdateDeviceStatusRequest.SerializeToString,
                response_deserializer=devices__pb2.UpdateDeviceStatusResponse.FromString,
                _registered_method=True)
        self.DeleteDevicesByPlace = channel.unary_unary(
                '/devices.DevicesService/DeleteDevicesByPlace',
                request_serializer=devices__pb2.DeleteDevicesByPlaceRequest.SerializeToString,
                response_deserializer=devices__pb2.DeleteDevicesByPlaceResponse.FromString,
                _registered_method=True)
        self.InvalidateMqttCredentials = channel.unary_unary(
                '/devices.DevicesService/InvalidateMqttCredentials',
                request_serializer=devices__pb2.InvalidateMqttCredentialsRequest.SerializeToString,
                response_deserializer=devices__pb2.InvalidateMqttCredentialsResponse.FromString,
                _registered_method=True)
        self.GetAllThresholds = channel.unary_unary(
                '/devices.DevicesService/GetAllThresholds',
                request_serializer=devices__pb2.GetAllThresholdsRequest.SerializeToString,
                response_deserializer=devices__pb2.GetAllThresholdsResponse.FromString,
                _registered_method=True)


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

    def CreateDevice(self, request, context):
        """Devices CRUD
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetDevice(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 ListDevices(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 UpdateDevice(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 DeleteDevice(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 RegenerateDeviceToken(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 CreateSensor(self, request, context):
        """Sensors CRUD
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ListSensors(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 UpdateSensor(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 DeleteSensor(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 SetThreshold(self, request, context):
        """Sensor Thresholds
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ListThresholds(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 DeleteThreshold(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 GetSensorThresholds(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 CreateActuator(self, request, context):
        """Actuators CRUD
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ListActuators(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 UpdateActuator(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 DeleteActuator(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 SendCommand(self, request, context):
        """Commands
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AuthenticateDevice(self, request, context):
        """MQTT auth (internal, for gateway webhook)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CheckDeviceAcl(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 GenerateMqttCredentials(self, request, context):
        """MQTT credentials for frontend users
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def UpdateDeviceStatus(self, request, context):
        """Device status (for collector)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def DeleteDevicesByPlace(self, request, context):
        """Internal: delete all devices by place (for gateway cascade)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def InvalidateMqttCredentials(self, request, context):
        """Internal: invalidate cached MQTT credentials (for gateway)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetAllThresholds(self, request, context):
        """Internal: all thresholds for collector cache
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_DevicesServiceServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'CreateDevice': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateDevice,
                    request_deserializer=devices__pb2.CreateDeviceRequest.FromString,
                    response_serializer=devices__pb2.CreateDeviceResponse.SerializeToString,
            ),
            'GetDevice': grpc.unary_unary_rpc_method_handler(
                    servicer.GetDevice,
                    request_deserializer=devices__pb2.GetDeviceRequest.FromString,
                    response_serializer=devices__pb2.GetDeviceResponse.SerializeToString,
            ),
            'ListDevices': grpc.unary_unary_rpc_method_handler(
                    servicer.ListDevices,
                    request_deserializer=devices__pb2.ListDevicesRequest.FromString,
                    response_serializer=devices__pb2.ListDevicesResponse.SerializeToString,
            ),
            'UpdateDevice': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateDevice,
                    request_deserializer=devices__pb2.UpdateDeviceRequest.FromString,
                    response_serializer=devices__pb2.UpdateDeviceResponse.SerializeToString,
            ),
            'DeleteDevice': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteDevice,
                    request_deserializer=devices__pb2.DeleteDeviceRequest.FromString,
                    response_serializer=devices__pb2.DeleteDeviceResponse.SerializeToString,
            ),
            'RegenerateDeviceToken': grpc.unary_unary_rpc_method_handler(
                    servicer.RegenerateDeviceToken,
                    request_deserializer=devices__pb2.RegenerateDeviceTokenRequest.FromString,
                    response_serializer=devices__pb2.RegenerateDeviceTokenResponse.SerializeToString,
            ),
            'CreateSensor': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateSensor,
                    request_deserializer=devices__pb2.CreateSensorRequest.FromString,
                    response_serializer=devices__pb2.CreateSensorResponse.SerializeToString,
            ),
            'ListSensors': grpc.unary_unary_rpc_method_handler(
                    servicer.ListSensors,
                    request_deserializer=devices__pb2.ListSensorsRequest.FromString,
                    response_serializer=devices__pb2.ListSensorsResponse.SerializeToString,
            ),
            'UpdateSensor': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateSensor,
                    request_deserializer=devices__pb2.UpdateSensorRequest.FromString,
                    response_serializer=devices__pb2.UpdateSensorResponse.SerializeToString,
            ),
            'DeleteSensor': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteSensor,
                    request_deserializer=devices__pb2.DeleteSensorRequest.FromString,
                    response_serializer=devices__pb2.DeleteSensorResponse.SerializeToString,
            ),
            'SetThreshold': grpc.unary_unary_rpc_method_handler(
                    servicer.SetThreshold,
                    request_deserializer=devices__pb2.SetThresholdRequest.FromString,
                    response_serializer=devices__pb2.SetThresholdResponse.SerializeToString,
            ),
            'ListThresholds': grpc.unary_unary_rpc_method_handler(
                    servicer.ListThresholds,
                    request_deserializer=devices__pb2.ListThresholdsRequest.FromString,
                    response_serializer=devices__pb2.ListThresholdsResponse.SerializeToString,
            ),
            'DeleteThreshold': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteThreshold,
                    request_deserializer=devices__pb2.DeleteThresholdRequest.FromString,
                    response_serializer=devices__pb2.DeleteThresholdResponse.SerializeToString,
            ),
            'GetSensorThresholds': grpc.unary_unary_rpc_method_handler(
                    servicer.GetSensorThresholds,
                    request_deserializer=devices__pb2.GetSensorThresholdsRequest.FromString,
                    response_serializer=devices__pb2.GetSensorThresholdsResponse.SerializeToString,
            ),
            'CreateActuator': grpc.unary_unary_rpc_method_handler(
                    servicer.CreateActuator,
                    request_deserializer=devices__pb2.CreateActuatorRequest.FromString,
                    response_serializer=devices__pb2.CreateActuatorResponse.SerializeToString,
            ),
            'ListActuators': grpc.unary_unary_rpc_method_handler(
                    servicer.ListActuators,
                    request_deserializer=devices__pb2.ListActuatorsRequest.FromString,
                    response_serializer=devices__pb2.ListActuatorsResponse.SerializeToString,
            ),
            'UpdateActuator': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateActuator,
                    request_deserializer=devices__pb2.UpdateActuatorRequest.FromString,
                    response_serializer=devices__pb2.UpdateActuatorResponse.SerializeToString,
            ),
            'DeleteActuator': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteActuator,
                    request_deserializer=devices__pb2.DeleteActuatorRequest.FromString,
                    response_serializer=devices__pb2.DeleteActuatorResponse.SerializeToString,
            ),
            'SendCommand': grpc.unary_unary_rpc_method_handler(
                    servicer.SendCommand,
                    request_deserializer=devices__pb2.SendCommandRequest.FromString,
                    response_serializer=devices__pb2.SendCommandResponse.SerializeToString,
            ),
            'AuthenticateDevice': grpc.unary_unary_rpc_method_handler(
                    servicer.AuthenticateDevice,
                    request_deserializer=devices__pb2.AuthenticateDeviceRequest.FromString,
                    response_serializer=devices__pb2.AuthenticateDeviceResponse.SerializeToString,
            ),
            'CheckDeviceAcl': grpc.unary_unary_rpc_method_handler(
                    servicer.CheckDeviceAcl,
                    request_deserializer=devices__pb2.CheckDeviceAclRequest.FromString,
                    response_serializer=devices__pb2.CheckDeviceAclResponse.SerializeToString,
            ),
            'GenerateMqttCredentials': grpc.unary_unary_rpc_method_handler(
                    servicer.GenerateMqttCredentials,
                    request_deserializer=devices__pb2.GenerateMqttCredentialsRequest.FromString,
                    response_serializer=devices__pb2.GenerateMqttCredentialsResponse.SerializeToString,
            ),
            'UpdateDeviceStatus': grpc.unary_unary_rpc_method_handler(
                    servicer.UpdateDeviceStatus,
                    request_deserializer=devices__pb2.UpdateDeviceStatusRequest.FromString,
                    response_serializer=devices__pb2.UpdateDeviceStatusResponse.SerializeToString,
            ),
            'DeleteDevicesByPlace': grpc.unary_unary_rpc_method_handler(
                    servicer.DeleteDevicesByPlace,
                    request_deserializer=devices__pb2.DeleteDevicesByPlaceRequest.FromString,
                    response_serializer=devices__pb2.DeleteDevicesByPlaceResponse.SerializeToString,
            ),
            'InvalidateMqttCredentials': grpc.unary_unary_rpc_method_handler(
                    servicer.InvalidateMqttCredentials,
                    request_deserializer=devices__pb2.InvalidateMqttCredentialsRequest.FromString,
                    response_serializer=devices__pb2.InvalidateMqttCredentialsResponse.SerializeToString,
            ),
            'GetAllThresholds': grpc.unary_unary_rpc_method_handler(
                    servicer.GetAllThresholds,
                    request_deserializer=devices__pb2.GetAllThresholdsRequest.FromString,
                    response_serializer=devices__pb2.GetAllThresholdsResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'devices.DevicesService', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))
    server.add_registered_method_handlers('devices.DevicesService', rpc_method_handlers)


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

    @staticmethod
    def CreateDevice(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,
            '/devices.DevicesService/CreateDevice',
            devices__pb2.CreateDeviceRequest.SerializeToString,
            devices__pb2.CreateDeviceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetDevice(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,
            '/devices.DevicesService/GetDevice',
            devices__pb2.GetDeviceRequest.SerializeToString,
            devices__pb2.GetDeviceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListDevices(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,
            '/devices.DevicesService/ListDevices',
            devices__pb2.ListDevicesRequest.SerializeToString,
            devices__pb2.ListDevicesResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateDevice(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,
            '/devices.DevicesService/UpdateDevice',
            devices__pb2.UpdateDeviceRequest.SerializeToString,
            devices__pb2.UpdateDeviceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteDevice(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,
            '/devices.DevicesService/DeleteDevice',
            devices__pb2.DeleteDeviceRequest.SerializeToString,
            devices__pb2.DeleteDeviceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def RegenerateDeviceToken(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,
            '/devices.DevicesService/RegenerateDeviceToken',
            devices__pb2.RegenerateDeviceTokenRequest.SerializeToString,
            devices__pb2.RegenerateDeviceTokenResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateSensor(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,
            '/devices.DevicesService/CreateSensor',
            devices__pb2.CreateSensorRequest.SerializeToString,
            devices__pb2.CreateSensorResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListSensors(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,
            '/devices.DevicesService/ListSensors',
            devices__pb2.ListSensorsRequest.SerializeToString,
            devices__pb2.ListSensorsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateSensor(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,
            '/devices.DevicesService/UpdateSensor',
            devices__pb2.UpdateSensorRequest.SerializeToString,
            devices__pb2.UpdateSensorResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteSensor(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,
            '/devices.DevicesService/DeleteSensor',
            devices__pb2.DeleteSensorRequest.SerializeToString,
            devices__pb2.DeleteSensorResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SetThreshold(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,
            '/devices.DevicesService/SetThreshold',
            devices__pb2.SetThresholdRequest.SerializeToString,
            devices__pb2.SetThresholdResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListThresholds(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,
            '/devices.DevicesService/ListThresholds',
            devices__pb2.ListThresholdsRequest.SerializeToString,
            devices__pb2.ListThresholdsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteThreshold(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,
            '/devices.DevicesService/DeleteThreshold',
            devices__pb2.DeleteThresholdRequest.SerializeToString,
            devices__pb2.DeleteThresholdResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetSensorThresholds(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,
            '/devices.DevicesService/GetSensorThresholds',
            devices__pb2.GetSensorThresholdsRequest.SerializeToString,
            devices__pb2.GetSensorThresholdsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CreateActuator(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,
            '/devices.DevicesService/CreateActuator',
            devices__pb2.CreateActuatorRequest.SerializeToString,
            devices__pb2.CreateActuatorResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def ListActuators(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,
            '/devices.DevicesService/ListActuators',
            devices__pb2.ListActuatorsRequest.SerializeToString,
            devices__pb2.ListActuatorsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateActuator(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,
            '/devices.DevicesService/UpdateActuator',
            devices__pb2.UpdateActuatorRequest.SerializeToString,
            devices__pb2.UpdateActuatorResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteActuator(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,
            '/devices.DevicesService/DeleteActuator',
            devices__pb2.DeleteActuatorRequest.SerializeToString,
            devices__pb2.DeleteActuatorResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def SendCommand(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,
            '/devices.DevicesService/SendCommand',
            devices__pb2.SendCommandRequest.SerializeToString,
            devices__pb2.SendCommandResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def AuthenticateDevice(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,
            '/devices.DevicesService/AuthenticateDevice',
            devices__pb2.AuthenticateDeviceRequest.SerializeToString,
            devices__pb2.AuthenticateDeviceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def CheckDeviceAcl(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,
            '/devices.DevicesService/CheckDeviceAcl',
            devices__pb2.CheckDeviceAclRequest.SerializeToString,
            devices__pb2.CheckDeviceAclResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GenerateMqttCredentials(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,
            '/devices.DevicesService/GenerateMqttCredentials',
            devices__pb2.GenerateMqttCredentialsRequest.SerializeToString,
            devices__pb2.GenerateMqttCredentialsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def UpdateDeviceStatus(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,
            '/devices.DevicesService/UpdateDeviceStatus',
            devices__pb2.UpdateDeviceStatusRequest.SerializeToString,
            devices__pb2.UpdateDeviceStatusResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def DeleteDevicesByPlace(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,
            '/devices.DevicesService/DeleteDevicesByPlace',
            devices__pb2.DeleteDevicesByPlaceRequest.SerializeToString,
            devices__pb2.DeleteDevicesByPlaceResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def InvalidateMqttCredentials(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,
            '/devices.DevicesService/InvalidateMqttCredentials',
            devices__pb2.InvalidateMqttCredentialsRequest.SerializeToString,
            devices__pb2.InvalidateMqttCredentialsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)

    @staticmethod
    def GetAllThresholds(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,
            '/devices.DevicesService/GetAllThresholds',
            devices__pb2.GetAllThresholdsRequest.SerializeToString,
            devices__pb2.GetAllThresholdsResponse.FromString,
            options,
            channel_credentials,
            insecure,
            call_credentials,
            compression,
            wait_for_ready,
            timeout,
            metadata,
            _registered_method=True)
