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

from collections.abc import (
    AsyncIterable,
    AsyncIterator,
    Iterable,
)
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 MeasurementPagingOrderByType(betterproto.Enum):
    """Справочник типов значений сортировки"""

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

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

    SYNCED_AT = 2
    """По дате synced_at"""

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

        return core_schema.int_schema(ge=0)


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

    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)


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

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

    HUB = 1
    """Коммуникационный модуль"""

    PULSE_COUNTER_RECORDER = 2
    """Счетчик импульсов - регистратор"""

    PULSE_COUNTER_RECORDER_LR = 3
    """Счетчик импульсов - регистратор LoRaWAN"""

    METERING_DEVICE = 4
    """Прибор учета расхода коммунальных услуг"""

    INTERFACE_CONVERTER = 5
    """Конвертер интерфейсов"""

    M_BUS_HUB = 6
    """M-BUS концентратор"""

    COMMUNICATION_MODULE_LR = 7
    """Модуль связи LoRaWAN"""

    BASE_LR = 8
    """Базовая станция LoRaWAN"""

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

        return core_schema.int_schema(ge=0)


class MeasurementMetricType(betterproto.Enum):
    """Справочние типов энергоресурсов"""

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

    HOT_WATER = 1
    """Горячая вода"""

    COLD_WATER = 2
    """Холодная вода"""

    HEAT = 3
    """Теплоэнергия"""

    GAS = 4
    """Газ"""

    ELECTRICITY = 5
    """Электроэнергия"""

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

        return core_schema.int_schema(ge=0)


class MeasurementUnitType(betterproto.Enum):
    """Справочник типов единиц измерений"""

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

    PERCENT = 1
    """Процент"""

    C = 2
    """Градус по Цельсию"""

    WT = 3
    """Ватт"""

    GKAL = 4
    """Гигакалория"""

    VALUE = 5
    """Количество"""

    KWH = 6
    """Киловaтт-час"""

    KG_CM2 = 7
    """Килограмм на квадратный сантиметр"""

    KGF_CM2 = 8
    """Килограмм-сила на квадратный сантиметр"""

    M3 = 9
    """Кубический метр"""

    M3_H = 10
    """Кубический метр в час"""

    MPA = 11
    """Мегапаскаль"""

    MS = 12
    """Миллисекунда"""

    BOOLEAN = 13
    """Флаг состояния"""

    T = 14
    """Тонна"""

    T_H = 15
    """Тонна в час"""

    H = 16
    """Час"""

    NON_MEASURABLE = 17
    """Безразмерная величина"""

    IMP = 18
    """Импульс"""

    J = 19
    """Джоуль"""

    KJ = 20
    """Килоджоуль"""

    GJ = 21
    """Гигаджоуль"""

    WTH = 22
    """Ватт-час"""

    KWT = 23
    """Киловатт"""

    MIN = 24
    """Минута"""

    S = 25
    """Секунда"""

    @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 IndicatorsMetadataStartTask(betterproto.Message):
    """
    Сигнал на старт обогащения метаданных индикаторов.
     Очередь key.telemetry_metric.indicators_metadata_start_task
    """

    pass


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

    filter: "MeasurementFilter" = betterproto.message_field(1)
    """Параметры фильтрации измерений"""

    paging: "MeasurementPaging | 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 GetMeasurementConvertedListRequest(betterproto.Message):
    """Запрос получения списка преобразованных измерений"""

    filter: "MeasurementFilter" = betterproto.message_field(1)
    """Параметры фильтрации измерений"""

    paging: "MeasurementPaging | 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 GetMeasurementListResponse(betterproto.Message):
    """Ответ на запрос получения списка измерений"""

    data: "Measurement | 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 GetMeasurementConvertedListResponse(betterproto.Message):
    """Ответ на запрос получения списка преобразованных измерений"""

    data: "Measurement | 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 MeasurementFilter(betterproto.Message):
    """
    Фильтр измерений.
     При передаче массива в параметр фильтра элементы массива работают в выборке через ИЛИ.
     При передаче нескольких разных параметров фильтра они работают в выборке через И
    """

    fias_ids: "list[str]" = betterproto.string_field(1)
    """По ФИАСам"""

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

    indicator_ids: "list[int]" = betterproto.int32_field(3)
    """По идентификаторам индикаторов"""

    begin_synced_at: datetime = betterproto.message_field(4)
    """От даты синхронизации включительно (>=)"""

    end_synced_at: datetime = betterproto.message_field(5)
    """До даты синхронизации (<)"""

    device_models: "list[str]" = betterproto.string_field(6)
    """По моделям устройств"""

    device_types: "list[MeasurementDeviceType]" = betterproto.enum_field(7)
    """По типам устройств"""

    metric_types: "list[MeasurementMetricType]" = betterproto.enum_field(8)
    """По типам измерений"""

    is_border_measurements_only: "bool | None" = betterproto.message_field(
        9, wraps=betterproto.TYPE_BOOL
    )
    """
    Ограничение результатов только пограничными значениями для периода.
     Если border_measurements_only=null возвращаем измерения по условиям фильтра, уникальные по (indicator_id, synced_at).
     Если border_measurements_only=falsе возвращаем измерения по условиям фильтра, уникальные по (indicator_id, synced_at).
     Если заданы border_measurements_only=true, begin_synced_at, end_synced_at возвращаем два измерения ближайшие к границам периода.
     Если заданы border_measurements_only=true, и не задана end_synced_at возвращаем одно измерение ближайшее к begin_synced_at.
     Если заданы border_measurements_only=true, и не задана begin_synced_at возвращаем одно измерение ближайшее к end_synced_at.
     Если заданы border_measurements_only=true и не заданы begin_synced_at и end_synced_at возвращаем ошибку валидации параметров
    """


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

    filter: "MeasurementFilter" = betterproto.message_field(1)
    """Параметры фильтрации измерений"""


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

    filter: "MeasurementFilter" = betterproto.message_field(1)
    """Параметры фильтрации измерений"""


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

    data: "int | None" = betterproto.int32_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 GetMeasurementConvertedCountResponse(betterproto.Message):
    """Ответ на запрос получения количества преобразованных измерений"""

    data: "int | None" = betterproto.int32_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 MeasurementPaging(betterproto.Message):
    """Параметры пагинации измерений"""

    order_by_type: "MeasurementPagingOrderByType" = betterproto.enum_field(1)
    """
    Тип значения сортировки.
     По умолчанию: SYNCED_AT
    """

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

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

    offset: int = betterproto.int32_field(4)
    """
    Сдвиг.
     По умолчанию: 0
    """


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class PostMeasurementRequest(betterproto.Message):
    """Запрос сохранения измерения"""

    data: "Measurement" = betterproto.message_field(1)
    """Измерение"""


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

    pass


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

    data: "Measurement" = betterproto.message_field(1)
    """Измерение"""


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

    pass


@dataclass(eq=False, repr=False, config={"extra": "forbid"})
class Measurement(betterproto.Message):
    """
    Измерение.
     Очередь key.telemetry_consumer.measurement_stream_request.v1
    """

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

    value: float = betterproto.float_field(2)
    """Значение"""

    synced_at: datetime = betterproto.message_field(3)
    """
    Временная метка сбора счётчиком.
     Если не передано берётся серверное время
    """

    fias_id: "str | None" = betterproto.message_field(4, wraps=betterproto.TYPE_STRING)
    """ФИАС"""

    device_id: "int | None" = betterproto.message_field(5, wraps=betterproto.TYPE_INT32)
    """Идентификатор устройства"""

    device_parent_id: "int | None" = betterproto.message_field(
        6, wraps=betterproto.TYPE_INT32
    )
    """Идентификатор родительского устройства"""

    device_model: "str | None" = betterproto.message_field(
        7, wraps=betterproto.TYPE_STRING
    )
    """Модель устройства"""

    device_type: "MeasurementDeviceType" = betterproto.enum_field(8)
    """Тип устройства"""

    metric_type: "MeasurementMetricType" = betterproto.enum_field(9)
    """Тип энергоресурса"""

    changed_at: datetime = betterproto.message_field(10)
    """
    Дата последнего изменения.
     Заполняется и обновляется сервером.
     Заполняется при создании и изменении.
     Является версией объекта
    """

    utc_offset: int = betterproto.int32_field(11)
    """Сдвиг таймзоны относительно UTC для даты synced_at"""

    unit_type: "MeasurementUnitType" = betterproto.enum_field(12)
    """Тип единицы измерения, в которой представлено, получаемое измерение"""


@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 MeasurementServiceStub(betterproto.ServiceStub):
    async def post_measurement(
        self,
        post_measurement_request: "PostMeasurementRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "PostMeasurementResponse":
        return await self._unary_unary(
            "/keyapis.telemetry_metric.v1.MeasurementService/PostMeasurement",
            post_measurement_request,
            PostMeasurementResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_measurement_half_duplex(
        self,
        post_measurement_half_duplex_request_iterator: "AsyncIterable[PostMeasurementHalfDuplexRequest] | Iterable[PostMeasurementHalfDuplexRequest]",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "PostMeasurementHalfDuplexResponse":
        return await self._stream_unary(
            "/keyapis.telemetry_metric.v1.MeasurementService/PostMeasurementHalfDuplex",
            post_measurement_half_duplex_request_iterator,
            PostMeasurementHalfDuplexRequest,
            PostMeasurementHalfDuplexResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_measurement_list(
        self,
        get_measurement_list_request: "GetMeasurementListRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "AsyncIterator[GetMeasurementListResponse]":
        async for response in self._unary_stream(
            "/keyapis.telemetry_metric.v1.MeasurementService/GetMeasurementList",
            get_measurement_list_request,
            GetMeasurementListResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def get_measurement_count(
        self,
        get_measurement_count_request: "GetMeasurementCountRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "GetMeasurementCountResponse":
        return await self._unary_unary(
            "/keyapis.telemetry_metric.v1.MeasurementService/GetMeasurementCount",
            get_measurement_count_request,
            GetMeasurementCountResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_measurement_converted_list(
        self,
        get_measurement_converted_list_request: "GetMeasurementConvertedListRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "AsyncIterator[GetMeasurementConvertedListResponse]":
        async for response in self._unary_stream(
            "/keyapis.telemetry_metric.v1.MeasurementService/GetMeasurementConvertedList",
            get_measurement_converted_list_request,
            GetMeasurementConvertedListResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def get_measurement_converted_count(
        self,
        get_measurement_converted_count_request: "GetMeasurementConvertedCountRequest",
        *,
        timeout: "float | None" = None,
        deadline: "Deadline | None" = None,
        metadata: "MetadataLike | None" = None
    ) -> "GetMeasurementConvertedCountResponse":
        return await self._unary_unary(
            "/keyapis.telemetry_metric.v1.MeasurementService/GetMeasurementConvertedCount",
            get_measurement_converted_count_request,
            GetMeasurementConvertedCountResponse,
            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.telemetry_metric.v1.SystemService/GetSystemStatus",
            get_system_status_request,
            GetSystemStatusResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )


class MeasurementServiceBase(ServiceBase):

    async def post_measurement(
        self, post_measurement_request: "PostMeasurementRequest"
    ) -> "PostMeasurementResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_measurement_half_duplex(
        self,
        post_measurement_half_duplex_request_iterator: "AsyncIterator[PostMeasurementHalfDuplexRequest]",
    ) -> "PostMeasurementHalfDuplexResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_measurement_list(
        self, get_measurement_list_request: "GetMeasurementListRequest"
    ) -> "AsyncIterator[GetMeasurementListResponse]":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetMeasurementListResponse()

    async def get_measurement_count(
        self, get_measurement_count_request: "GetMeasurementCountRequest"
    ) -> "GetMeasurementCountResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_measurement_converted_list(
        self,
        get_measurement_converted_list_request: "GetMeasurementConvertedListRequest",
    ) -> "AsyncIterator[GetMeasurementConvertedListResponse]":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetMeasurementConvertedListResponse()

    async def get_measurement_converted_count(
        self,
        get_measurement_converted_count_request: "GetMeasurementConvertedCountRequest",
    ) -> "GetMeasurementConvertedCountResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def __rpc_post_measurement(
        self,
        stream: "grpclib.server.Stream[PostMeasurementRequest, PostMeasurementResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_measurement(request)
        await stream.send_message(response)

    async def __rpc_post_measurement_half_duplex(
        self,
        stream: "grpclib.server.Stream[PostMeasurementHalfDuplexRequest, PostMeasurementHalfDuplexResponse]",
    ) -> None:
        request = stream.__aiter__()
        response = await self.post_measurement_half_duplex(request)
        await stream.send_message(response)

    async def __rpc_get_measurement_list(
        self,
        stream: "grpclib.server.Stream[GetMeasurementListRequest, GetMeasurementListResponse]",
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_measurement_list,
            stream,
            request,
        )

    async def __rpc_get_measurement_count(
        self,
        stream: "grpclib.server.Stream[GetMeasurementCountRequest, GetMeasurementCountResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_measurement_count(request)
        await stream.send_message(response)

    async def __rpc_get_measurement_converted_list(
        self,
        stream: "grpclib.server.Stream[GetMeasurementConvertedListRequest, GetMeasurementConvertedListResponse]",
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_measurement_converted_list,
            stream,
            request,
        )

    async def __rpc_get_measurement_converted_count(
        self,
        stream: "grpclib.server.Stream[GetMeasurementConvertedCountRequest, GetMeasurementConvertedCountResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_measurement_converted_count(request)
        await stream.send_message(response)

    def __mapping__(self) -> "dict[str, grpclib.const.Handler]":
        return {
            "/keyapis.telemetry_metric.v1.MeasurementService/PostMeasurement": grpclib.const.Handler(
                self.__rpc_post_measurement,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostMeasurementRequest,
                PostMeasurementResponse,
            ),
            "/keyapis.telemetry_metric.v1.MeasurementService/PostMeasurementHalfDuplex": grpclib.const.Handler(
                self.__rpc_post_measurement_half_duplex,
                grpclib.const.Cardinality.STREAM_UNARY,
                PostMeasurementHalfDuplexRequest,
                PostMeasurementHalfDuplexResponse,
            ),
            "/keyapis.telemetry_metric.v1.MeasurementService/GetMeasurementList": grpclib.const.Handler(
                self.__rpc_get_measurement_list,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetMeasurementListRequest,
                GetMeasurementListResponse,
            ),
            "/keyapis.telemetry_metric.v1.MeasurementService/GetMeasurementCount": grpclib.const.Handler(
                self.__rpc_get_measurement_count,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetMeasurementCountRequest,
                GetMeasurementCountResponse,
            ),
            "/keyapis.telemetry_metric.v1.MeasurementService/GetMeasurementConvertedList": grpclib.const.Handler(
                self.__rpc_get_measurement_converted_list,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetMeasurementConvertedListRequest,
                GetMeasurementConvertedListResponse,
            ),
            "/keyapis.telemetry_metric.v1.MeasurementService/GetMeasurementConvertedCount": grpclib.const.Handler(
                self.__rpc_get_measurement_converted_count,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetMeasurementConvertedCountRequest,
                GetMeasurementConvertedCountResponse,
            ),
        }


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


rebuild_dataclass(GetMeasurementListRequest)  # type: ignore
rebuild_dataclass(GetMeasurementConvertedListRequest)  # type: ignore
rebuild_dataclass(GetMeasurementListResponse)  # type: ignore
rebuild_dataclass(GetMeasurementConvertedListResponse)  # type: ignore
rebuild_dataclass(MeasurementFilter)  # type: ignore
rebuild_dataclass(GetMeasurementCountRequest)  # type: ignore
rebuild_dataclass(GetMeasurementConvertedCountRequest)  # type: ignore
rebuild_dataclass(MeasurementPaging)  # type: ignore
rebuild_dataclass(PostMeasurementRequest)  # type: ignore
rebuild_dataclass(PostMeasurementHalfDuplexRequest)  # type: ignore
rebuild_dataclass(Measurement)  # type: ignore