# Generated by the protocol buffer compiler.  DO NOT EDIT!
# sources: keyapis/identity/v1/keyapis_identity_authorization_v1.proto, keyapis/identity/v1/keyapis_identity_system_v1.proto, keyapis/identity/v1/keyapis_identity_token_v1.proto
# plugin: python-betterproto
# This file has been @generated

from datetime import datetime
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


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class UserToken(betterproto.Message):
    """Информация о токене пользователя"""

    access_token: str = betterproto.string_field(1)
    """Токен"""

    expired_at: datetime = betterproto.message_field(2)
    """Окончание действия токена"""


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class Captcha(betterproto.Message):
    """Капча"""

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

    url: str = betterproto.string_field(2)
    """Ссылка на капчу"""


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class CaptchaAnswer(betterproto.Message):
    """Ответ на капчу"""

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

    code: str = betterproto.string_field(2)
    """Ответ на капчу"""


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class CaptchaAnswerError(betterproto.Message):
    """Ошибка ответа на капчу"""

    wrong_answer: "CaptchaAnswerErrorWrongAnswer | None" = betterproto.message_field(
        1, optional=True, group="reason"
    )
    """Некорректный ответ на капчу"""

    captcha: "Captcha" = betterproto.message_field(2)
    """Капча"""

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


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class CaptchaAnswerErrorWrongAnswer(betterproto.Message):
    """Некорректный ответ на капчу"""

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class OtpCode(betterproto.Message):
    """Информация о вводе ОТП-кода"""

    code_id: str = betterproto.string_field(1)
    """Идентификатор ОТП-кода"""

    timeout: int = betterproto.int32_field(2)
    """Время в секундах, оставшееся до возможности отправки следующего кода"""


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class OtpCodeError(betterproto.Message):
    """Ошибка ответа на капчу"""

    life_time_expired: "OtpCodeErrorLifeTimeExpired | None" = betterproto.message_field(
        1, optional=True, group="reason"
    )
    """Код истек"""

    no_attempts: "OtpCodeErrorNoAttempts | None" = betterproto.message_field(
        2, optional=True, group="reason"
    )
    """Попыток больше нет"""

    address_not_found: "OtpCodeErrorAddressNotFound | None" = betterproto.message_field(
        3, optional=True, group="reason"
    )
    """
    Адрес для отправки кода не найден.
     В текущей реализации, эту ошибку невозможно получить
    """

    invalid_code: "OtpCodeErrorInvalidCode | None" = betterproto.message_field(
        4, optional=True, group="reason"
    )
    """Неправильный ОТП-код"""

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


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class OtpCodeErrorLifeTimeExpired(betterproto.Message):
    """Код истек"""

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class OtpCodeErrorNoAttempts(betterproto.Message):
    """Попыток больше нет"""

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class OtpCodeErrorAddressNotFound(betterproto.Message):
    """Адрес для отправки кода не найден"""

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class OtpCodeErrorInvalidCode(betterproto.Message):
    """Неправильный ОТП-код"""

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class SsoError(betterproto.Message):
    """Ошибки из ССО"""

    user_is_temporary_blocked: "SsoErrorUserIsTemporaryBlocked | None" = (
        betterproto.message_field(1, optional=True, group="reason")
    )
    """Пользователь временно заблокирован"""

    user_not_found: "SsoErrorUserNotFound | None" = betterproto.message_field(
        2, optional=True, group="reason"
    )
    """Пользователь не найден"""

    wrong_credentials: "SsoErrorWrongCredentials | None" = betterproto.message_field(
        3, optional=True, group="reason"
    )
    """Неверный пароль"""

    user_is_blocked: "SsoErrorUserIsBlocked | None" = betterproto.message_field(
        4, optional=True, group="reason"
    )
    """Пользователь заблокирован"""

    interval_exceeded: "SsoErrorIntervalExceeded | None" = betterproto.message_field(
        5, optional=True, group="reason"
    )
    """Превышен интервал отправки ОТП-кодов"""

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


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class SsoErrorUserIsTemporaryBlocked(betterproto.Message):
    """Пользователь временно заблокирован"""

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class SsoErrorUserNotFound(betterproto.Message):
    """Пользователь не найден"""

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class SsoErrorWrongCredentials(betterproto.Message):
    """Неверный пароль"""

    captcha: "Captcha" = betterproto.message_field(1)
    """Капча"""


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class SsoErrorUserIsBlocked(betterproto.Message):
    """Пользователь заблокирован"""

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class SsoErrorIntervalExceeded(betterproto.Message):
    """Превышен интервал отправки ОТП-кодов"""

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class KeyError(betterproto.Message):
    """Ошибки сервисов ключа"""

    user_creation: "KeyErrorUserCreation | None" = betterproto.message_field(
        1, optional=True, group="reason"
    )
    """Ошибка создания пользователя"""

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


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

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class PostAuthorizationSendCodeRequest(betterproto.Message):
    """Запрос на отправку ОТП-кода"""

    phone_number: "str | None" = betterproto.string_field(
        1, optional=True, group="otp_text"
    )
    """Номер телефона"""

    captcha_answer: "CaptchaAnswer" = betterproto.message_field(2)
    """Ответ на капчу"""

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


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

    data: "OtpCode | None" = betterproto.message_field(1, optional=True, group="type")
    """Информация об ОТП-коде"""

    error: "PostAuthorizationSendCodeResponseError | None" = betterproto.message_field(
        2, optional=True, group="type"
    )
    """Ошибка"""

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


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class PostAuthorizationSendCodeResponseError(betterproto.Message):
    """Ошибка запроса на отправку ОТП-кода"""

    captcha_answer: "CaptchaAnswerError | None" = betterproto.message_field(
        1, optional=True, group="reason"
    )
    """Ошибка ответа с капчей"""

    sso: "SsoError | None" = betterproto.message_field(2, optional=True, group="reason")
    """Ошибка из ССО"""

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


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class PostAuthorizationLoginRequest(betterproto.Message):
    """Запрос на авторизацию по ОТП-коду"""

    code_id: str = betterproto.string_field(1)
    """Идентификатор ОТП-кода"""

    code: str = betterproto.string_field(2)
    """Значение ОТП-кода"""


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class PostAuthorizationLoginResponse(betterproto.Message):
    """Ответ на запрос об авторизации пользователя"""

    data: "UserToken | None" = betterproto.message_field(1, optional=True, group="type")
    """Токен пользователя"""

    error: "PostAuthorizationLoginResponseError | None" = betterproto.message_field(
        2, optional=True, group="type"
    )
    """Ошибка"""

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


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class PostAuthorizationLoginResponseError(betterproto.Message):
    """Ошибка запроса авторизации пользователя"""

    otp_code: "OtpCodeError | None" = betterproto.message_field(
        1, optional=True, group="reason"
    )
    """Ошибка отп-кода"""

    sso: "SsoError | None" = betterproto.message_field(2, optional=True, group="reason")
    """Ошибка из ССО"""

    key: "KeyError | None" = betterproto.message_field(3, optional=True, group="reason")
    """Ошибка из сервисов ключа"""

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


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class PostAuthorizationLoginByPasswordRequest(betterproto.Message):
    """Запрос на авторизацию по паролю"""

    phone_number: "str | None" = betterproto.string_field(
        1, optional=True, group="type"
    )
    """Номер телефона"""

    email: "str | None" = betterproto.string_field(2, optional=True, group="type")
    """Электронная почта"""

    login: "str | None" = betterproto.string_field(3, optional=True, group="type")
    """Логин"""

    password: str = betterproto.string_field(4)
    """Пароль"""

    captcha_answer: "CaptchaAnswer" = betterproto.message_field(5)
    """Ответ на капчу"""

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


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class PostAuthorizationLoginByPasswordResponse(betterproto.Message):
    """Ответ на запрос об авторизации по паролю пользователя"""

    data: "UserToken | None" = betterproto.message_field(1, optional=True, group="type")
    """Токен пользователя"""

    error: "PostAuthorizationLoginByPasswordResponseError | None" = (
        betterproto.message_field(2, optional=True, group="type")
    )
    """Ошибка"""

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


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class PostAuthorizationLoginByPasswordResponseError(betterproto.Message):
    """Ошибка запроса авторизации пользователя"""

    captcha_answer: "CaptchaAnswerError | None" = betterproto.message_field(
        1, optional=True, group="reason"
    )
    """Ошибка капчи"""

    sso: "SsoError | None" = betterproto.message_field(2, optional=True, group="reason")
    """Ошибка из ССО"""

    key: "KeyError | None" = betterproto.message_field(3, optional=True, group="reason")
    """Ошибка из сервисов ключа"""

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


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

    pass


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

    pass


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

    access_token: str = betterproto.string_field(1)
    """Токен"""

    expires_in: int = betterproto.int32_field(2)
    """Время (в секундах), через которое истечет срок действия Access Token"""


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

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


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

    data: "Token | None" = betterproto.message_field(1, optional=True, group="type")
    """Токен пользователя"""

    error: "PostTokenUserResponseError | None" = betterproto.message_field(
        2, optional=True, group="type"
    )
    """Ошибка"""

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


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

    token: "PostTokenUserResponseErrorTokenError | None" = betterproto.message_field(
        1, optional=True, group="reason"
    )
    """Ошибка получения токена"""

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


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class PostTokenUserResponseErrorTokenError(betterproto.Message):
    """
    Ошибка получения токена.
     Причины:
     - Ошибка в сервисе Household
    """

    pass


class AuthorizationServiceStub(betterproto.ServiceStub):
    async def post_authorization_login(
        self,
        post_authorization_login_request: "PostAuthorizationLoginRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "PostAuthorizationLoginResponse":
        return await self._unary_unary(
            "/keyapis.identity.v1.AuthorizationService/PostAuthorizationLogin",
            post_authorization_login_request,
            PostAuthorizationLoginResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_authorization_send_code(
        self,
        post_authorization_send_code_request: "PostAuthorizationSendCodeRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "PostAuthorizationSendCodeResponse":
        return await self._unary_unary(
            "/keyapis.identity.v1.AuthorizationService/PostAuthorizationSendCode",
            post_authorization_send_code_request,
            PostAuthorizationSendCodeResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_authorization_login_by_password(
        self,
        post_authorization_login_by_password_request: "PostAuthorizationLoginByPasswordRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "PostAuthorizationLoginByPasswordResponse":
        return await self._unary_unary(
            "/keyapis.identity.v1.AuthorizationService/PostAuthorizationLoginByPassword",
            post_authorization_login_by_password_request,
            PostAuthorizationLoginByPasswordResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )


class SystemServiceStub(betterproto.ServiceStub):
    async def get_system_status(
        self,
        get_system_status_request: "GetSystemStatusRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "GetSystemStatusResponse":
        return await self._unary_unary(
            "/keyapis.identity.v1.SystemService/GetSystemStatus",
            get_system_status_request,
            GetSystemStatusResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )


class TokenServiceStub(betterproto.ServiceStub):
    async def post_token_user(
        self,
        post_token_user_request: "PostTokenUserRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "PostTokenUserResponse":
        return await self._unary_unary(
            "/keyapis.identity.v1.TokenService/PostTokenUser",
            post_token_user_request,
            PostTokenUserResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )


class AuthorizationServiceBase(ServiceBase):

    async def post_authorization_login(
        self, post_authorization_login_request: "PostAuthorizationLoginRequest"
    ) -> "PostAuthorizationLoginResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_authorization_send_code(
        self, post_authorization_send_code_request: "PostAuthorizationSendCodeRequest"
    ) -> "PostAuthorizationSendCodeResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_authorization_login_by_password(
        self,
        post_authorization_login_by_password_request: "PostAuthorizationLoginByPasswordRequest",
    ) -> "PostAuthorizationLoginByPasswordResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def __rpc_post_authorization_login(
        self,
        stream: "grpclib.server.Stream[PostAuthorizationLoginRequest, PostAuthorizationLoginResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_authorization_login(request)
        await stream.send_message(response)

    async def __rpc_post_authorization_send_code(
        self,
        stream: "grpclib.server.Stream[PostAuthorizationSendCodeRequest, PostAuthorizationSendCodeResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_authorization_send_code(request)
        await stream.send_message(response)

    async def __rpc_post_authorization_login_by_password(
        self,
        stream: "grpclib.server.Stream[PostAuthorizationLoginByPasswordRequest, PostAuthorizationLoginByPasswordResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_authorization_login_by_password(request)
        await stream.send_message(response)

    def __mapping__(self) -> "dict[str, grpclib.const.Handler]":
        return {
            "/keyapis.identity.v1.AuthorizationService/PostAuthorizationLogin": grpclib.const.Handler(
                self.__rpc_post_authorization_login,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostAuthorizationLoginRequest,
                PostAuthorizationLoginResponse,
            ),
            "/keyapis.identity.v1.AuthorizationService/PostAuthorizationSendCode": grpclib.const.Handler(
                self.__rpc_post_authorization_send_code,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostAuthorizationSendCodeRequest,
                PostAuthorizationSendCodeResponse,
            ),
            "/keyapis.identity.v1.AuthorizationService/PostAuthorizationLoginByPassword": grpclib.const.Handler(
                self.__rpc_post_authorization_login_by_password,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostAuthorizationLoginByPasswordRequest,
                PostAuthorizationLoginByPasswordResponse,
            ),
        }


class SystemServiceBase(ServiceBase):

    async def get_system_status(
        self, get_system_status_request: "GetSystemStatusRequest"
    ) -> "GetSystemStatusResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def __rpc_get_system_status(
        self,
        stream: "grpclib.server.Stream[GetSystemStatusRequest, GetSystemStatusResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_system_status(request)
        await stream.send_message(response)

    def __mapping__(self) -> "dict[str, grpclib.const.Handler]":
        return {
            "/keyapis.identity.v1.SystemService/GetSystemStatus": grpclib.const.Handler(
                self.__rpc_get_system_status,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetSystemStatusRequest,
                GetSystemStatusResponse,
            ),
        }


class TokenServiceBase(ServiceBase):

    async def post_token_user(
        self, post_token_user_request: "PostTokenUserRequest"
    ) -> "PostTokenUserResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def __rpc_post_token_user(
        self,
        stream: "grpclib.server.Stream[PostTokenUserRequest, PostTokenUserResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_token_user(request)
        await stream.send_message(response)

    def __mapping__(self) -> "dict[str, grpclib.const.Handler]":
        return {
            "/keyapis.identity.v1.TokenService/PostTokenUser": grpclib.const.Handler(
                self.__rpc_post_token_user,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostTokenUserRequest,
                PostTokenUserResponse,
            ),
        }


rebuild_dataclass(UserToken)  # type: ignore
rebuild_dataclass(CaptchaAnswerError)  # type: ignore
rebuild_dataclass(OtpCodeError)  # type: ignore
rebuild_dataclass(SsoError)  # type: ignore
rebuild_dataclass(SsoErrorWrongCredentials)  # type: ignore
rebuild_dataclass(KeyError)  # type: ignore
rebuild_dataclass(PostAuthorizationSendCodeRequest)  # type: ignore
rebuild_dataclass(PostAuthorizationSendCodeResponse)  # type: ignore
rebuild_dataclass(PostAuthorizationSendCodeResponseError)  # type: ignore
rebuild_dataclass(PostAuthorizationLoginResponse)  # type: ignore
rebuild_dataclass(PostAuthorizationLoginResponseError)  # type: ignore
rebuild_dataclass(PostAuthorizationLoginByPasswordRequest)  # type: ignore
rebuild_dataclass(PostAuthorizationLoginByPasswordResponse)  # type: ignore
rebuild_dataclass(PostAuthorizationLoginByPasswordResponseError)  # type: ignore
rebuild_dataclass(PostTokenUserResponse)  # type: ignore
rebuild_dataclass(PostTokenUserResponseError)  # type: ignore