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

from collections.abc import AsyncIterator
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


class UserType(betterproto.Enum):
    """
    Справочник типов пользователей.
     # Тип: byte
    """

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

    OWNER = 1
    """Владелец УК"""

    EMPLOYEE = 2
    """Сотрудник УК"""

    MASTER = 3
    """Мастер житель"""

    SLAVE = 4
    """Подчиненный житель"""

    ADMIN = 5
    """Администратор"""

    SELLER = 6
    """Сотрудники ГАП"""

    MRF = 7
    """МРФ"""

    BACKOFFICE = 8
    """ГРЗУК"""

    SERVICE = 9
    """Сервис"""

    ROOT = 10
    """Супер админ"""

    BTI = 11
    """Сотрудник БТИ"""

    LTP_FIRST = 12
    """Сотрудник 1 ЛТП"""

    EXTERNAL_SELLER = 13
    """Сотрудник ГАП"""

    APPLICATION = 14
    """Приложение"""

    MANAGER = 15
    """Администратор точек продаж"""

    DEVICE_ADMIN = 16
    """Администратор устройств"""

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

        return core_schema.int_schema(ge=0)


class UserStatusType(betterproto.Enum):
    """
    Справочник типов статусов пользователей.
     # Тип: byte
    """

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

    NEW = 1
    """Не активный пользователь"""

    DEMO = 2
    """Демо пользователь"""

    ACTIVE = 3
    """Активный пользователь"""

    BLOCKED = 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 UserPagingOrderByType(betterproto.Enum):
    """
    Справочник типов значений сортировки.
     # Тип: byte
    """

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

    ID = 1
    """По идентификатору"""

    CREATED_AT = 2
    """По времени создания"""

    CHANGED_AT = 3
    """По времени изменения"""

    EMAIL = 4
    """По электронной почте"""

    RANK = 5
    """
    По рангу для поиска по тексту.
     Применяется когда передано поле для поиска по тексту.
     В случае если текстовое поле не передано, применяется значение по умолчанию
    """

    DESCRIPTION = 6
    """По описанию (collate-agnostic ordering)"""

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

        return core_schema.int_schema(ge=0)


class UserPagingDirectionType(betterproto.Enum):
    """
    Справочник типов направлений сортировки.
     # Тип: byte
    """

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

    DESC = 1
    """От большего к меньшему"""

    ASC = 2
    """От меньшего к большему"""

    @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 DeleteUserSessionsRequest(betterproto.Message):
    """Запрос удаления всех пользовательских сессий"""

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


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

    error: "DeleteUserSessionsResponseError | None" = betterproto.message_field(
        1, 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 DeleteUserSessionsResponseError(betterproto.Message):
    """Ошибка запроса"""

    validation: "ValidationError | 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 User(betterproto.Message):
    """Пользователь"""

    id: int = betterproto.int32_field(1)
    """
    Идентификатор.
     # Диапазон: 0..2147483647
    """

    type: "UserType" = betterproto.enum_field(2)
    """Тип пользователя"""

    status_type: "UserStatusType" = betterproto.enum_field(3)
    """Статус пользователя"""

    login: "str | None" = betterproto.message_field(4, wraps=betterproto.TYPE_STRING)
    """
    Логин.
     # Диапазон: 3..64
    """

    email: "str | None" = betterproto.message_field(5, wraps=betterproto.TYPE_STRING)
    """
    Электронная почта.
     # Диапазон: 4..256
    """

    phone_number: "str | None" = betterproto.message_field(
        6, wraps=betterproto.TYPE_STRING
    )
    """
    Номер телефона.
     # Диапазон: 5..14
    """

    company_id: "int | None" = betterproto.message_field(
        7, wraps=betterproto.TYPE_INT32
    )
    """
    Идентификатор компании.
     # Диапазон: 1..2147483647
    """

    mrf_id: "int | None" = betterproto.message_field(8, wraps=betterproto.TYPE_INT32)
    """Идентификатор МРФ"""

    rf_id: "int | None" = betterproto.message_field(9, wraps=betterproto.TYPE_INT32)
    """Идентификатор РФ"""

    created_at: datetime = betterproto.message_field(10)
    """
    Дата создания.
     # Тип: DateTime
    """

    changed_at: datetime = betterproto.message_field(11)
    """
    Дата изменения.
     # Тип: DateTime
    """

    activated_at: datetime = betterproto.message_field(12)
    """
    Дата активации.
     # Тип: DateTime
    """

    blocked_at: datetime = betterproto.message_field(13)
    """
    Дата активации.
     # Тип: DateTime
    """

    creator_user_id: "int | None" = betterproto.message_field(
        14, wraps=betterproto.TYPE_INT32
    )
    """
    Идентификатор создавшего пользователя.
     Берется из токена.
     # Диапазон: 1..2147483647
    """

    owner_user_id: "int | None" = betterproto.message_field(
        15, wraps=betterproto.TYPE_INT32
    )
    """
    Идентификатор пользователя-владельца.
     # Диапазон: 1..2147483647
    """

    invoice_email: "str | None" = betterproto.message_field(
        16, wraps=betterproto.TYPE_STRING
    )
    """
    Электронная почта для чеков.
     # Диапазон: 4..256
    """

    vc_user_id: "int | None" = betterproto.message_field(
        17, wraps=betterproto.TYPE_INT32
    )
    """
    Идентификатор пользователя в Видеонаблюдении.
     Вычисляется на стороне сервера при создании пользователя
    """

    description: "str | None" = betterproto.message_field(
        18, wraps=betterproto.TYPE_STRING
    )
    """Описание"""

    ustore_user_id: "int | None" = betterproto.message_field(
        19, wraps=betterproto.TYPE_INT32
    )
    """
    Идентификатор пользователя в сервисе ustore.
     Вычисляется на стороне сервера при создании пользователя
    """

    env_url: "str | None" = betterproto.message_field(20, wraps=betterproto.TYPE_STRING)
    """Адрес окружения для внутренних пользователей"""


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

    conflict: "UserSavingErrorConflict | None" = betterproto.message_field(
        1, optional=True, group="reason"
    )
    """Конфликт версий"""

    user_type_forbidden: "UserSavingErrorUserTypeForbidden | None" = (
        betterproto.message_field(2, optional=True, group="reason")
    )
    """Нельзя удалять пользователя с данным типом"""

    user_status_forbidden: "UserSavingErrorUserStatusForbidden | None" = (
        betterproto.message_field(3, optional=True, group="reason")
    )
    """Нельзя удалять пользователя в текущем статусе"""

    mrf_id_is_required_for_user_type: (
        "UserSavingErrorMrfIdRequiredForUserType | None"
    ) = betterproto.message_field(4, optional=True, group="reason")
    """Идентификатор МРФ обязателен"""

    creator_must_be_admin: "UserSavingErrorCreatorMustBeAdmin | None" = (
        betterproto.message_field(5, optional=True, group="reason")
    )
    """Создатель пользователя должен иметь роль Admin"""

    rf_id_does_not_match_mrf_id: "UserSavingErrorRfIdDoesNotMatchMrfId | None" = (
        betterproto.message_field(6, optional=True, group="reason")
    )
    """Идентификатор РФ не соответствует идентификатору МРФ"""

    email_is_already_taken: "UserSavingErrorEmailIsAlreadyTaken | None" = (
        betterproto.message_field(7, optional=True, group="reason")
    )
    """Email уже занят"""

    entity_not_found: "UserSavingErrorEntityNotFound | None" = (
        betterproto.message_field(8, 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 UserSavingErrorConflict(betterproto.Message):
    """
    Конфликт версий.
     Причины:
     - В базе хранится другая версия строки, значения changed_at отличаются
    """

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class UserSavingErrorUserTypeForbidden(betterproto.Message):
    """
    Нельзя удалять пользователя с данным типом.
     Доступные типы:
     - Жилец (мастер)
    """

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class UserSavingErrorUserStatusForbidden(betterproto.Message):
    """
    Нельзя удалять пользователя в текущем статусе.
     В каких статусах можно удалить пользователя:
     - demo
    """

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class UserSavingErrorMrfIdRequiredForUserType(betterproto.Message):
    """Для данного типа пользователя идентификатор МРФ обязателен"""

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class UserSavingErrorCreatorMustBeAdmin(betterproto.Message):
    """Создатель пользователя должен иметь роль Admin"""

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class UserSavingErrorRfIdDoesNotMatchMrfId(betterproto.Message):
    """Идентификатор РФ не соответствует идентификатору МРФ"""

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class UserSavingErrorEmailIsAlreadyTaken(betterproto.Message):
    """Email уже занят"""

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class UserSavingErrorEntityNotFound(betterproto.Message):
    """
    Связанная с пользователем сущность не найдена.
     Например: компания по company_id, пользователь по owner_user_id
    """

    field: str = betterproto.string_field(1)
    """Поле"""


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

    code: int = betterproto.int32_field(1)
    """
    Идентификационный код.
     Если поле не заполнено, генерируется автоматически.
     # Диапазон: 10000..99999
    """

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

    created_at: datetime = betterproto.message_field(3)
    """
    Дата создания.
     # Тип: DateTime
    """

    creator_user_id: int = betterproto.int32_field(4)
    """Идентификатор создателя кода"""

    creator_user_type: "UserType" = betterproto.enum_field(5)
    """Тип создателя кода"""


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

    id: int = betterproto.int32_field(1)
    """Идентификатор"""


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

    data: "User | None" = betterproto.message_field(1, optional=True, group="type")
    """Пользователь"""

    error: "GetUserResponseError | 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 GetUserResponseError(betterproto.Message):
    """Ошибка запроса получения пользователя"""

    validation: "ValidationError | 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 GetUserListRequest(betterproto.Message):
    """Запрос на получение списка пользователей"""

    filter: "UserFilter" = betterproto.message_field(1)
    """Фильтр"""

    paging: "UserPaging | None" = betterproto.message_field(
        2, optional=True, group="pagination"
    )
    """Стандартный постраничный вывод"""

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


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

    data: "User | None" = betterproto.message_field(1, optional=True, group="type")
    """Пользователь"""

    error: "GetUserListResponseError | 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 GetUserListResponseError(betterproto.Message):
    """Ошибка запроса получения списка пользователей"""

    validation: "ValidationError | 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 GetUserCountRequest(betterproto.Message):
    """Запрос получения количества пользователей"""

    filter: "UserFilter" = betterproto.message_field(1)
    """Фильтр"""


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

    data: "int | None" = betterproto.int32_field(1, optional=True, group="type")
    """Всего пользователей"""

    error: "GetUserCountResponseError | 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 GetUserCountResponseError(betterproto.Message):
    """Ошибка запроса получения количества пользователей"""

    validation: "ValidationError | 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 DeleteUserRequest(betterproto.Message):
    """Запрос удаления пользователя"""

    id: int = betterproto.int32_field(1)
    """Идентификатор"""


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

    error: "DeleteUserResponseError | None" = betterproto.message_field(
        1, 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 DeleteUserResponseError(betterproto.Message):
    """Ошибка запроса удаления пользователя"""

    validation: "ValidationError | None" = betterproto.message_field(
        1, optional=True, group="reason"
    )
    """Ошибка валидации"""

    saving: "UserSavingError | 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 GetUserCodeRequest(betterproto.Message):
    """Запрос получения идентификационного кода пользователя"""

    id: int = betterproto.int32_field(1)
    """
    Идентификатор.
     # Диапазон: 0..2147483647
    """


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

    data: "UserCode | None" = betterproto.message_field(1, optional=True, group="type")
    """Идентификационный код"""

    error: "GetUserCodeResponseError | 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 GetUserCodeResponseError(betterproto.Message):
    """Ошибка запроса получения идентификационного кода пользователя"""

    validation: "ValidationError | None" = betterproto.message_field(
        1, optional=True, group="reason"
    )
    """Ошибка валидации"""

    user_code_not_found: "GetUserCodeResponseErrorUserCodeNotFound | 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 GetUserCodeResponseErrorUserCodeNotFound(betterproto.Message):
    """У пользователя отсутствует идентификационный код"""

    pass


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

    user_code: "UserCode" = betterproto.message_field(1)
    """Идентификационный код пользователя"""


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

    data: "UserCode | None" = betterproto.message_field(1, optional=True, group="type")
    """Идентификационный код пользователя"""

    error: "PostUserCodeCreateResponseError | 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 PostUserCodeCreateResponseError(betterproto.Message):
    """Ошибка запроса создания идентификационного кода пользователя"""

    validation: "ValidationError | 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 UserFilter(betterproto.Message):
    """Фильтр по пользователям"""

    company_ids: "list[int]" = betterproto.int32_field(1)
    """По идентификаторам компаний"""

    user_types: "list[UserType]" = betterproto.enum_field(2)
    """По типам"""

    user_status_types: "list[UserStatusType]" = betterproto.enum_field(3)
    """По статусам"""

    emails: "list[str]" = betterproto.string_field(4)
    """По электронной почте"""

    phone_numbers: "list[str]" = betterproto.string_field(5)
    """По номеру телефона"""

    logins: "list[str]" = betterproto.string_field(6)
    """По логину"""

    text: "str | None" = betterproto.message_field(7, wraps=betterproto.TYPE_STRING)
    """
    Поиск по тексту.
     Если значение не передано то поиск по нему не производится.
     # Диапазон: 3..64.
     # Поиск производится по полям:
     # - Описание
    """

    contacts: "str | None" = betterproto.message_field(8, wraps=betterproto.TYPE_STRING)
    """
    Поиск по контактным данным пользователя (электронная почта или номер телефона).
     Если значение не передано то поиск по нему не производится.
     # Диапазон: 3..64.
     # Поиск производится по полям:
     # - Электронная почта;
     # - Номер телефона
    """


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class UserPaging(betterproto.Message):
    """Постраничный вывод"""

    order_by_type: "UserPagingOrderByType" = betterproto.enum_field(1)
    """
    Тип значения сортировки.
     Если значение не передано, то будет взято значение по умолчанию.
     # По умолчанию: CHANGED_AT
    """

    direction_type: "UserPagingDirectionType" = betterproto.enum_field(2)
    """
    Тип направления сортировки.
     # По умолчанию: DESC
    """

    limit: int = betterproto.int32_field(3)
    """
    Количество записей на страницу.
     Если значение 0 (не передано), то будет взято значение по умолчанию.
     # Диапазон: 0..100.
     # По умолчанию: 20
    """

    offset: int = betterproto.int32_field(4)
    """
    Сдвиг.
     # Диапазон: 0..2147483647
    """


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

    data: "User" = betterproto.message_field(1)
    """Пользователь"""


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

    data: "User | None" = betterproto.message_field(1, optional=True, group="type")
    """Пользователь"""

    error: "PostUserResponseError | 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 PostUserResponseError(betterproto.Message):
    """Ошибка запроса сохранения пользователя"""

    validation: "ValidationError | None" = betterproto.message_field(
        1, optional=True, group="reason"
    )
    """Ошибка валидации"""

    saving: "UserSavingError | 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 ValidationError(betterproto.Message):
    """
    Ошибки валидации.
     Эти проверки выполняются до обращения в базу данных
    """

    path: str = betterproto.string_field(1)
    """Путь к полю в формате наименования прото"""

    message: str = betterproto.string_field(2)
    """Валидационное сообщение"""


@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


class UserServiceStub(betterproto.ServiceStub):
    async def get_user(
        self,
        get_user_request: "GetUserRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "GetUserResponse":
        return await self._unary_unary(
            "/keyapis.user.v1.UserService/GetUser",
            get_user_request,
            GetUserResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_user_list(
        self,
        get_user_list_request: "GetUserListRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "AsyncIterator[GetUserListResponse]":
        async for response in self._unary_stream(
            "/keyapis.user.v1.UserService/GetUserList",
            get_user_list_request,
            GetUserListResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def get_user_count(
        self,
        get_user_count_request: "GetUserCountRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "GetUserCountResponse":
        return await self._unary_unary(
            "/keyapis.user.v1.UserService/GetUserCount",
            get_user_count_request,
            GetUserCountResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def delete_user(
        self,
        delete_user_request: "DeleteUserRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "DeleteUserResponse":
        return await self._unary_unary(
            "/keyapis.user.v1.UserService/DeleteUser",
            delete_user_request,
            DeleteUserResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def delete_user_sessions(
        self,
        delete_user_sessions_request: "DeleteUserSessionsRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "DeleteUserSessionsResponse":
        return await self._unary_unary(
            "/keyapis.user.v1.UserService/DeleteUserSessions",
            delete_user_sessions_request,
            DeleteUserSessionsResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_user_code(
        self,
        get_user_code_request: "GetUserCodeRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "GetUserCodeResponse":
        return await self._unary_unary(
            "/keyapis.user.v1.UserService/GetUserCode",
            get_user_code_request,
            GetUserCodeResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_user_code_create(
        self,
        post_user_code_create_request: "PostUserCodeCreateRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "PostUserCodeCreateResponse":
        return await self._unary_unary(
            "/keyapis.user.v1.UserService/PostUserCodeCreate",
            post_user_code_create_request,
            PostUserCodeCreateResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_user(
        self,
        post_user_request: "PostUserRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "PostUserResponse":
        return await self._unary_unary(
            "/keyapis.user.v1.UserService/PostUser",
            post_user_request,
            PostUserResponse,
            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.user.v1.SystemService/GetSystemStatus",
            get_system_status_request,
            GetSystemStatusResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )


class UserServiceBase(ServiceBase):

    async def get_user(self, get_user_request: "GetUserRequest") -> "GetUserResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_user_list(
        self, get_user_list_request: "GetUserListRequest"
    ) -> "AsyncIterator[GetUserListResponse]":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetUserListResponse()

    async def get_user_count(
        self, get_user_count_request: "GetUserCountRequest"
    ) -> "GetUserCountResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def delete_user(
        self, delete_user_request: "DeleteUserRequest"
    ) -> "DeleteUserResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def delete_user_sessions(
        self, delete_user_sessions_request: "DeleteUserSessionsRequest"
    ) -> "DeleteUserSessionsResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_user_code(
        self, get_user_code_request: "GetUserCodeRequest"
    ) -> "GetUserCodeResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_user_code_create(
        self, post_user_code_create_request: "PostUserCodeCreateRequest"
    ) -> "PostUserCodeCreateResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_user(
        self, post_user_request: "PostUserRequest"
    ) -> "PostUserResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def __rpc_get_user(
        self, stream: "grpclib.server.Stream[GetUserRequest, GetUserResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_user(request)
        await stream.send_message(response)

    async def __rpc_get_user_list(
        self, stream: "grpclib.server.Stream[GetUserListRequest, GetUserListResponse]"
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_user_list,
            stream,
            request,
        )

    async def __rpc_get_user_count(
        self, stream: "grpclib.server.Stream[GetUserCountRequest, GetUserCountResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_user_count(request)
        await stream.send_message(response)

    async def __rpc_delete_user(
        self, stream: "grpclib.server.Stream[DeleteUserRequest, DeleteUserResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.delete_user(request)
        await stream.send_message(response)

    async def __rpc_delete_user_sessions(
        self,
        stream: "grpclib.server.Stream[DeleteUserSessionsRequest, DeleteUserSessionsResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.delete_user_sessions(request)
        await stream.send_message(response)

    async def __rpc_get_user_code(
        self, stream: "grpclib.server.Stream[GetUserCodeRequest, GetUserCodeResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_user_code(request)
        await stream.send_message(response)

    async def __rpc_post_user_code_create(
        self,
        stream: "grpclib.server.Stream[PostUserCodeCreateRequest, PostUserCodeCreateResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_user_code_create(request)
        await stream.send_message(response)

    async def __rpc_post_user(
        self, stream: "grpclib.server.Stream[PostUserRequest, PostUserResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_user(request)
        await stream.send_message(response)

    def __mapping__(self) -> "dict[str, grpclib.const.Handler]":
        return {
            "/keyapis.user.v1.UserService/GetUser": grpclib.const.Handler(
                self.__rpc_get_user,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetUserRequest,
                GetUserResponse,
            ),
            "/keyapis.user.v1.UserService/GetUserList": grpclib.const.Handler(
                self.__rpc_get_user_list,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetUserListRequest,
                GetUserListResponse,
            ),
            "/keyapis.user.v1.UserService/GetUserCount": grpclib.const.Handler(
                self.__rpc_get_user_count,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetUserCountRequest,
                GetUserCountResponse,
            ),
            "/keyapis.user.v1.UserService/DeleteUser": grpclib.const.Handler(
                self.__rpc_delete_user,
                grpclib.const.Cardinality.UNARY_UNARY,
                DeleteUserRequest,
                DeleteUserResponse,
            ),
            "/keyapis.user.v1.UserService/DeleteUserSessions": grpclib.const.Handler(
                self.__rpc_delete_user_sessions,
                grpclib.const.Cardinality.UNARY_UNARY,
                DeleteUserSessionsRequest,
                DeleteUserSessionsResponse,
            ),
            "/keyapis.user.v1.UserService/GetUserCode": grpclib.const.Handler(
                self.__rpc_get_user_code,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetUserCodeRequest,
                GetUserCodeResponse,
            ),
            "/keyapis.user.v1.UserService/PostUserCodeCreate": grpclib.const.Handler(
                self.__rpc_post_user_code_create,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostUserCodeCreateRequest,
                PostUserCodeCreateResponse,
            ),
            "/keyapis.user.v1.UserService/PostUser": grpclib.const.Handler(
                self.__rpc_post_user,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostUserRequest,
                PostUserResponse,
            ),
        }


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.user.v1.SystemService/GetSystemStatus": grpclib.const.Handler(
                self.__rpc_get_system_status,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetSystemStatusRequest,
                GetSystemStatusResponse,
            ),
        }


rebuild_dataclass(DeleteUserSessionsResponse)  # type: ignore
rebuild_dataclass(DeleteUserSessionsResponseError)  # type: ignore
rebuild_dataclass(User)  # type: ignore
rebuild_dataclass(UserSavingError)  # type: ignore
rebuild_dataclass(UserCode)  # type: ignore
rebuild_dataclass(GetUserResponse)  # type: ignore
rebuild_dataclass(GetUserResponseError)  # type: ignore
rebuild_dataclass(GetUserListRequest)  # type: ignore
rebuild_dataclass(GetUserListResponse)  # type: ignore
rebuild_dataclass(GetUserListResponseError)  # type: ignore
rebuild_dataclass(GetUserCountRequest)  # type: ignore
rebuild_dataclass(GetUserCountResponse)  # type: ignore
rebuild_dataclass(GetUserCountResponseError)  # type: ignore
rebuild_dataclass(DeleteUserResponse)  # type: ignore
rebuild_dataclass(DeleteUserResponseError)  # type: ignore
rebuild_dataclass(GetUserCodeResponse)  # type: ignore
rebuild_dataclass(GetUserCodeResponseError)  # type: ignore
rebuild_dataclass(PostUserCodeCreateRequest)  # type: ignore
rebuild_dataclass(PostUserCodeCreateResponse)  # type: ignore
rebuild_dataclass(PostUserCodeCreateResponseError)  # type: ignore
rebuild_dataclass(UserFilter)  # type: ignore
rebuild_dataclass(UserPaging)  # type: ignore
rebuild_dataclass(PostUserRequest)  # type: ignore
rebuild_dataclass(PostUserResponse)  # type: ignore
rebuild_dataclass(PostUserResponseError)  # type: ignore