# Generated by the protocol buffer compiler.  DO NOT EDIT!
# sources: keyapis/iot_connect/v1/keyapis_iot_connect_callback_v1.proto, keyapis/iot_connect/v1/keyapis_iot_connect_manage_v1.proto, keyapis/iot_connect/v1/keyapis_iot_connect_system_v1.proto
# plugin: python-betterproto
# This file has been @generated

from typing import TYPE_CHECKING

import betterproto
import grpclib
from betterproto.grpc.grpclib_server import ServiceBase
from pydantic import model_validator
from pydantic.dataclasses import (
    dataclass,
    rebuild_dataclass,
)

if TYPE_CHECKING:
    import grpclib.server
    from betterproto.grpc.grpclib_client import MetadataLike
    from grpclib.metadata import Deadline


class ModelFeatureType(betterproto.Enum):
    """Список функций устройства"""

    FEATURE_TYPE_UNKNOWN = 0
    """Значение не указано"""

    INCOMING_CALL = 1
    """Сигнализация о поступившем звонке"""

    ONLINE = 2
    """Сигнализация о доступности устройства"""

    REJECT_CALL = 3
    """Отклонение звонка"""

    UNLOCK = 4
    """Открытие замка"""

    @classmethod
    def __get_pydantic_core_schema__(cls, _source_type, _handler):
        from pydantic_core import core_schema

        return core_schema.int_schema(ge=0)


class DeviceCommandKeyType(betterproto.Enum):
    """Список ключей команд на изменение статуса устройства"""

    KEY_TYPE_UNKNOWN = 0
    """Значение не указано"""

    REJECT_CALL = 1
    """Отклонение звонка"""

    UNLOCK = 2
    """Открытие замка"""

    @classmethod
    def __get_pydantic_core_schema__(cls, _source_type, _handler):
        from pydantic_core import core_schema

        return core_schema.int_schema(ge=0)


class DeviceCommandValueType(betterproto.Enum):
    """Тип значения команд на изменение статуса устройства"""

    TYPE_UNKNOWN = 0
    """Значение не указано"""

    ENUM = 1
    """Перечисление"""

    @classmethod
    def __get_pydantic_core_schema__(cls, _source_type, _handler):
        from pydantic_core import core_schema

        return core_schema.int_schema(ge=0)


class DeviceCommandValueValueEnumType(betterproto.Enum):
    """Значения команд на изменение статуса устройства типа перечисление"""

    VALUE_ENUM_TYPE_UNKNOWN = 0
    """Значение не указано"""

    REJECT = 1
    """Отклонение звонка"""

    UNLOCK = 2
    """Открытие замка"""

    @classmethod
    def __get_pydantic_core_schema__(cls, _source_type, _handler):
        from pydantic_core import core_schema

        return core_schema.int_schema(ge=0)


class DeviceStateKeyType(betterproto.Enum):
    """Список ключей статусов устройства"""

    KEY_TYPE_UNKNOWN = 0
    """Значение не указано"""

    ONLINE = 1
    """Статус доступности устройства"""

    @classmethod
    def __get_pydantic_core_schema__(cls, _source_type, _handler):
        from pydantic_core import core_schema

        return core_schema.int_schema(ge=0)


class DeviceStateValueType(betterproto.Enum):
    """Тип значения статуса устройства"""

    TYPE_UNKNOWN = 0
    """Значение не указано"""

    BOOL = 1
    """Логический тип"""

    @classmethod
    def __get_pydantic_core_schema__(cls, _source_type, _handler):
        from pydantic_core import core_schema

        return core_schema.int_schema(ge=0)


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class GetCallbackUserRequest(betterproto.Message):
    """Запрос метода получения пользователя для соединения аккаунтов"""

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class GetCallbackUserResponse(betterproto.Message):
    """
    Ответ на запрос метода получения пользователя для соединения аккаунтов
    """

    data: int = betterproto.int32_field(1)
    """Идентификатор пользователя"""


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class Model(betterproto.Message):
    """Объект Модель устройства"""

    id: str = betterproto.string_field(1)
    """Идентификатор модели"""

    manufacturer: str = betterproto.string_field(2)
    """Производитель"""

    model: str = betterproto.string_field(3)
    """Название модели"""

    hw_version: str = betterproto.string_field(4)
    """Версия оборудования"""

    sw_version: str = betterproto.string_field(5)
    """Версия прошивки"""

    description: str = betterproto.string_field(6)
    """Описание"""

    category: str = betterproto.string_field(7)
    """Категория устройства"""

    feature_types: "list[ModelFeatureType]" = betterproto.enum_field(8)
    """Список функций"""


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class Device(betterproto.Message):
    """Объект устройства"""

    id: str = betterproto.string_field(1)
    """
    Идентификатор устройства на платформе Ключ.
     Конкатенация user_id и device_id плафтормы Ключ
    """

    name: str = betterproto.string_field(2)
    """Название устройства на платформе Ключ"""

    default_name: str = betterproto.string_field(3)
    """Название устройства от производителя"""

    home: str = betterproto.string_field(4)
    """Адрес дома, где установлено устройство"""

    room: str = betterproto.string_field(5)
    """Название или номер подъезда"""

    model: "Model" = betterproto.message_field(6)
    """Тип устройства"""

    hw_version: str = betterproto.string_field(7)
    """HW версия устройства"""

    sw_version: str = betterproto.string_field(8)
    """SW версия устройства"""


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class DeviceStateArray(betterproto.Message):
    """Массив статусов устройства"""

    states: "list[DeviceState]" = betterproto.message_field(1)
    """Статусы устройства"""


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class DeviceCommandArray(betterproto.Message):
    """Массив команд на изменение статуса устройства"""

    states: "list[DeviceCommand]" = betterproto.message_field(1)
    """Команды на изменение статуса устройства"""


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class DeviceCommand(betterproto.Message):
    """Команды на изменение статуса устройства"""

    command_key_type: "DeviceCommandKeyType" = betterproto.enum_field(1)
    """Тип команды на изменение статуса устройства"""

    value: "DeviceCommandValue" = betterproto.message_field(2)
    """Значение команды на изменение статуса устройства"""


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class DeviceCommandValue(betterproto.Message):
    """Значение команды на изменение статуса устройства"""

    type: "DeviceCommandValueType" = betterproto.enum_field(1)
    """Тип значения команды на изменение статуса устройства"""

    value_enum_type: "DeviceCommandValueValueEnumType | None" = betterproto.enum_field(
        2, optional=True, group="value"
    )
    """Значения команды на изменение статуса устройства типа перечисление"""

    @model_validator(mode="after")
    def check_oneof(cls, values):
        return cls._validate_field_groups(values)


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class DeviceState(betterproto.Message):
    """Статус устройства"""

    state_key_type: "DeviceStateKeyType" = betterproto.enum_field(1)
    """Тип статуса устройства"""

    value: "DeviceStateValue" = betterproto.message_field(2)
    """Значение статуса устройства"""


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class DeviceStateValue(betterproto.Message):
    """Значение статуса устройства"""

    type: "DeviceStateValueType" = betterproto.enum_field(1)
    """Тип значения статуса устройства"""

    is_value: "bool | None" = betterproto.bool_field(2, optional=True, group="value")
    """Значение логического типа"""

    @model_validator(mode="after")
    def check_oneof(cls, values):
        return cls._validate_field_groups(values)


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class GetCallbackDevicesRequest(betterproto.Message):
    """Запрос метода получения устройств, доступных пользователю"""

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class GetCallbackDevicesResponse(betterproto.Message):
    """Ответ на запрос метода получения устройств, доступных пользователю"""

    data: "list[Device]" = betterproto.message_field(1)
    """Домофоны, доступные пользователю"""


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class PostCallbackQueryRequest(betterproto.Message):
    """Запрос статуса домофонов пользователя"""

    devices: "list[str]" = betterproto.string_field(1)
    """Массив идентификаторов домофонов пользователя"""


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class PostCallbackQueryResponse(betterproto.Message):
    """Ответ на запрос статуса домофонов пользователя"""

    data: "dict[str, DeviceStateArray]" = betterproto.map_field(
        1, betterproto.TYPE_STRING, betterproto.TYPE_MESSAGE
    )
    """Массив домофонов со статусами"""


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class PostCallbackCommandRequest(betterproto.Message):
    """Запрос на изменение статуса домофона"""

    devices: "dict[str, DeviceCommandArray]" = betterproto.map_field(
        1, betterproto.TYPE_STRING, betterproto.TYPE_MESSAGE
    )
    """Массив домофонов со статусами"""


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class PostCallbackCommandResponse(betterproto.Message):
    """Ответ на запрос на изменение статуса домофона"""

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class PostCallbackUnlinkRequest(betterproto.Message):
    """Запрос метода разъединения аккаунтов"""

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class PostCallbackUnlinkResponse(betterproto.Message):
    """Ответ на запрос метода разъединения аккаунтов"""

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class PostManageStateRequest(betterproto.Message):
    """Сообщение об изменении состояния устройства (домофона)"""

    key: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class PostManageStateResponse(betterproto.Message):
    """Ответ"""

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class PutManageUserDetachRequest(betterproto.Message):
    """Запрос метода разъединения аккаунтов"""

    user_id: int = betterproto.int32_field(1)
    """Идентификатор пользователя"""


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class PutManageUserDetachResponse(betterproto.Message):
    """Ответ на запрос метода разъединения аккаунтов"""

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class GetPingRequest(betterproto.Message):
    """Запрос доступности сервиса"""

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class GetPingResponse(betterproto.Message):
    """Ответ на запрос доступности сервиса"""

    pass


class IotConnectCallbackServiceStub(betterproto.ServiceStub):
    async def get_callback_user(
        self,
        get_callback_user_request: "GetCallbackUserRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "GetCallbackUserResponse":
        return await self._unary_unary(
            "/keyapis.iot_connect.v1.IotConnectCallbackService/GetCallbackUser",
            get_callback_user_request,
            GetCallbackUserResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_callback_unlink(
        self,
        post_callback_unlink_request: "PostCallbackUnlinkRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "PostCallbackUnlinkResponse":
        return await self._unary_unary(
            "/keyapis.iot_connect.v1.IotConnectCallbackService/PostCallbackUnlink",
            post_callback_unlink_request,
            PostCallbackUnlinkResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_callback_devices(
        self,
        get_callback_devices_request: "GetCallbackDevicesRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "GetCallbackDevicesResponse":
        return await self._unary_unary(
            "/keyapis.iot_connect.v1.IotConnectCallbackService/GetCallbackDevices",
            get_callback_devices_request,
            GetCallbackDevicesResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_callback_query(
        self,
        post_callback_query_request: "PostCallbackQueryRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "PostCallbackQueryResponse":
        return await self._unary_unary(
            "/keyapis.iot_connect.v1.IotConnectCallbackService/PostCallbackQuery",
            post_callback_query_request,
            PostCallbackQueryResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_callback_command(
        self,
        post_callback_command_request: "PostCallbackCommandRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "PostCallbackCommandResponse":
        return await self._unary_unary(
            "/keyapis.iot_connect.v1.IotConnectCallbackService/PostCallbackCommand",
            post_callback_command_request,
            PostCallbackCommandResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )


class IotConnectManageServiceStub(betterproto.ServiceStub):
    async def post_manage_state(
        self,
        post_manage_state_request: "PostManageStateRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "PostManageStateResponse":
        return await self._unary_unary(
            "/keyapis.iot_connect.v1.IotConnectManageService/PostManageState",
            post_manage_state_request,
            PostManageStateResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def put_manage_user_detach(
        self,
        put_manage_user_detach_request: "PutManageUserDetachRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "PutManageUserDetachResponse":
        return await self._unary_unary(
            "/keyapis.iot_connect.v1.IotConnectManageService/PutManageUserDetach",
            put_manage_user_detach_request,
            PutManageUserDetachResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )


class SystemServiceStub(betterproto.ServiceStub):
    async def get_ping(
        self,
        get_ping_request: "GetPingRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "GetPingResponse":
        return await self._unary_unary(
            "/keyapis.iot_connect.v1.SystemService/GetPing",
            get_ping_request,
            GetPingResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )


class IotConnectCallbackServiceBase(ServiceBase):

    async def get_callback_user(
        self, get_callback_user_request: "GetCallbackUserRequest"
    ) -> "GetCallbackUserResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_callback_unlink(
        self, post_callback_unlink_request: "PostCallbackUnlinkRequest"
    ) -> "PostCallbackUnlinkResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_callback_devices(
        self, get_callback_devices_request: "GetCallbackDevicesRequest"
    ) -> "GetCallbackDevicesResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_callback_query(
        self, post_callback_query_request: "PostCallbackQueryRequest"
    ) -> "PostCallbackQueryResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_callback_command(
        self, post_callback_command_request: "PostCallbackCommandRequest"
    ) -> "PostCallbackCommandResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def __rpc_get_callback_user(
        self,
        stream: "grpclib.server.Stream[GetCallbackUserRequest, GetCallbackUserResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_callback_user(request)
        await stream.send_message(response)

    async def __rpc_post_callback_unlink(
        self,
        stream: "grpclib.server.Stream[PostCallbackUnlinkRequest, PostCallbackUnlinkResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_callback_unlink(request)
        await stream.send_message(response)

    async def __rpc_get_callback_devices(
        self,
        stream: "grpclib.server.Stream[GetCallbackDevicesRequest, GetCallbackDevicesResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_callback_devices(request)
        await stream.send_message(response)

    async def __rpc_post_callback_query(
        self,
        stream: "grpclib.server.Stream[PostCallbackQueryRequest, PostCallbackQueryResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_callback_query(request)
        await stream.send_message(response)

    async def __rpc_post_callback_command(
        self,
        stream: "grpclib.server.Stream[PostCallbackCommandRequest, PostCallbackCommandResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_callback_command(request)
        await stream.send_message(response)

    def __mapping__(self) -> "dict[str, grpclib.const.Handler]":
        return {
            "/keyapis.iot_connect.v1.IotConnectCallbackService/GetCallbackUser": grpclib.const.Handler(
                self.__rpc_get_callback_user,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetCallbackUserRequest,
                GetCallbackUserResponse,
            ),
            "/keyapis.iot_connect.v1.IotConnectCallbackService/PostCallbackUnlink": grpclib.const.Handler(
                self.__rpc_post_callback_unlink,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostCallbackUnlinkRequest,
                PostCallbackUnlinkResponse,
            ),
            "/keyapis.iot_connect.v1.IotConnectCallbackService/GetCallbackDevices": grpclib.const.Handler(
                self.__rpc_get_callback_devices,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetCallbackDevicesRequest,
                GetCallbackDevicesResponse,
            ),
            "/keyapis.iot_connect.v1.IotConnectCallbackService/PostCallbackQuery": grpclib.const.Handler(
                self.__rpc_post_callback_query,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostCallbackQueryRequest,
                PostCallbackQueryResponse,
            ),
            "/keyapis.iot_connect.v1.IotConnectCallbackService/PostCallbackCommand": grpclib.const.Handler(
                self.__rpc_post_callback_command,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostCallbackCommandRequest,
                PostCallbackCommandResponse,
            ),
        }


class IotConnectManageServiceBase(ServiceBase):

    async def post_manage_state(
        self, post_manage_state_request: "PostManageStateRequest"
    ) -> "PostManageStateResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def put_manage_user_detach(
        self, put_manage_user_detach_request: "PutManageUserDetachRequest"
    ) -> "PutManageUserDetachResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def __rpc_post_manage_state(
        self,
        stream: "grpclib.server.Stream[PostManageStateRequest, PostManageStateResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_manage_state(request)
        await stream.send_message(response)

    async def __rpc_put_manage_user_detach(
        self,
        stream: "grpclib.server.Stream[PutManageUserDetachRequest, PutManageUserDetachResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.put_manage_user_detach(request)
        await stream.send_message(response)

    def __mapping__(self) -> "dict[str, grpclib.const.Handler]":
        return {
            "/keyapis.iot_connect.v1.IotConnectManageService/PostManageState": grpclib.const.Handler(
                self.__rpc_post_manage_state,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostManageStateRequest,
                PostManageStateResponse,
            ),
            "/keyapis.iot_connect.v1.IotConnectManageService/PutManageUserDetach": grpclib.const.Handler(
                self.__rpc_put_manage_user_detach,
                grpclib.const.Cardinality.UNARY_UNARY,
                PutManageUserDetachRequest,
                PutManageUserDetachResponse,
            ),
        }


class SystemServiceBase(ServiceBase):

    async def get_ping(self, get_ping_request: "GetPingRequest") -> "GetPingResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def __rpc_get_ping(
        self, stream: "grpclib.server.Stream[GetPingRequest, GetPingResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_ping(request)
        await stream.send_message(response)

    def __mapping__(self) -> "dict[str, grpclib.const.Handler]":
        return {
            "/keyapis.iot_connect.v1.SystemService/GetPing": grpclib.const.Handler(
                self.__rpc_get_ping,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetPingRequest,
                GetPingResponse,
            ),
        }


rebuild_dataclass(Model)  # type: ignore
rebuild_dataclass(Device)  # type: ignore
rebuild_dataclass(DeviceStateArray)  # type: ignore
rebuild_dataclass(DeviceCommandArray)  # type: ignore
rebuild_dataclass(DeviceCommand)  # type: ignore
rebuild_dataclass(DeviceCommandValue)  # type: ignore
rebuild_dataclass(DeviceState)  # type: ignore
rebuild_dataclass(DeviceStateValue)  # type: ignore
rebuild_dataclass(GetCallbackDevicesResponse)  # type: ignore
rebuild_dataclass(PostCallbackQueryResponse)  # type: ignore
rebuild_dataclass(PostCallbackCommandRequest)  # type: ignore