// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: keyapis/telemetry_control/v1/keyapis_telemetry_control_dictionary_v1.proto

#include "keyapis/telemetry_control/v1/keyapis_telemetry_control_dictionary_v1.pb.h"

#include <algorithm>
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/extension_set.h"
#include "google/protobuf/wire_format_lite.h"
#include "google/protobuf/io/zero_copy_stream_impl_lite.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"
PROTOBUF_PRAGMA_INIT_SEG
namespace _pb = ::PROTOBUF_NAMESPACE_ID;
namespace _pbi = ::PROTOBUF_NAMESPACE_ID::internal;
namespace keyapis {
namespace telemetry_control {
namespace v1 {
template <typename>
PROTOBUF_CONSTEXPR PostDictionaryDeviceModelRequest::PostDictionaryDeviceModelRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.data_)*/nullptr} {}
struct PostDictionaryDeviceModelRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostDictionaryDeviceModelRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostDictionaryDeviceModelRequestDefaultTypeInternal() {}
  union {
    PostDictionaryDeviceModelRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostDictionaryDeviceModelRequestDefaultTypeInternal _PostDictionaryDeviceModelRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostDictionaryDeviceModelResponse::PostDictionaryDeviceModelResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostDictionaryDeviceModelResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostDictionaryDeviceModelResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostDictionaryDeviceModelResponseDefaultTypeInternal() {}
  union {
    PostDictionaryDeviceModelResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostDictionaryDeviceModelResponseDefaultTypeInternal _PostDictionaryDeviceModelResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR DeleteDictionaryDeviceModelRequest::DeleteDictionaryDeviceModelRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.id_)*/ 0

  , /*decltype(_impl_._cached_size_)*/{}} {}
struct DeleteDictionaryDeviceModelRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR DeleteDictionaryDeviceModelRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~DeleteDictionaryDeviceModelRequestDefaultTypeInternal() {}
  union {
    DeleteDictionaryDeviceModelRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeleteDictionaryDeviceModelRequestDefaultTypeInternal _DeleteDictionaryDeviceModelRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR DeleteDictionaryDeviceModelResponse::DeleteDictionaryDeviceModelResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct DeleteDictionaryDeviceModelResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR DeleteDictionaryDeviceModelResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~DeleteDictionaryDeviceModelResponseDefaultTypeInternal() {}
  union {
    DeleteDictionaryDeviceModelResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeleteDictionaryDeviceModelResponseDefaultTypeInternal _DeleteDictionaryDeviceModelResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetDictionaryDeviceModelRequest::GetDictionaryDeviceModelRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.id_)*/ 0

  , /*decltype(_impl_._cached_size_)*/{}} {}
struct GetDictionaryDeviceModelRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetDictionaryDeviceModelRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetDictionaryDeviceModelRequestDefaultTypeInternal() {}
  union {
    GetDictionaryDeviceModelRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetDictionaryDeviceModelRequestDefaultTypeInternal _GetDictionaryDeviceModelRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetDictionaryDeviceModelResponse::GetDictionaryDeviceModelResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetDictionaryDeviceModelResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetDictionaryDeviceModelResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetDictionaryDeviceModelResponseDefaultTypeInternal() {}
  union {
    GetDictionaryDeviceModelResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetDictionaryDeviceModelResponseDefaultTypeInternal _GetDictionaryDeviceModelResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetDictionaryDeviceModelListRequest::GetDictionaryDeviceModelListRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.filter_)*/nullptr
  , /*decltype(_impl_.pagination_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetDictionaryDeviceModelListRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetDictionaryDeviceModelListRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetDictionaryDeviceModelListRequestDefaultTypeInternal() {}
  union {
    GetDictionaryDeviceModelListRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetDictionaryDeviceModelListRequestDefaultTypeInternal _GetDictionaryDeviceModelListRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetDictionaryMrfListRequest::GetDictionaryMrfListRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct GetDictionaryMrfListRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetDictionaryMrfListRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetDictionaryMrfListRequestDefaultTypeInternal() {}
  union {
    GetDictionaryMrfListRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetDictionaryMrfListRequestDefaultTypeInternal _GetDictionaryMrfListRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetDictionaryRfListRequest::GetDictionaryRfListRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct GetDictionaryRfListRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetDictionaryRfListRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetDictionaryRfListRequestDefaultTypeInternal() {}
  union {
    GetDictionaryRfListRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetDictionaryRfListRequestDefaultTypeInternal _GetDictionaryRfListRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR DictionaryDeviceModelPaging::DictionaryDeviceModelPaging(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.order_by_type_)*/ 0

  , /*decltype(_impl_.direction_type_)*/ 0

  , /*decltype(_impl_.limit_)*/ 0

  , /*decltype(_impl_.offset_)*/ 0

  , /*decltype(_impl_._cached_size_)*/{}} {}
struct DictionaryDeviceModelPagingDefaultTypeInternal {
  PROTOBUF_CONSTEXPR DictionaryDeviceModelPagingDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~DictionaryDeviceModelPagingDefaultTypeInternal() {}
  union {
    DictionaryDeviceModelPaging _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DictionaryDeviceModelPagingDefaultTypeInternal _DictionaryDeviceModelPaging_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR DictionaryDeviceModelFilter::DictionaryDeviceModelFilter(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.titles_)*/{}
  , /*decltype(_impl_.model_kinds_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct DictionaryDeviceModelFilterDefaultTypeInternal {
  PROTOBUF_CONSTEXPR DictionaryDeviceModelFilterDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~DictionaryDeviceModelFilterDefaultTypeInternal() {}
  union {
    DictionaryDeviceModelFilter _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DictionaryDeviceModelFilterDefaultTypeInternal _DictionaryDeviceModelFilter_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetDictionaryDeviceModelListResponse::GetDictionaryDeviceModelListResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetDictionaryDeviceModelListResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetDictionaryDeviceModelListResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetDictionaryDeviceModelListResponseDefaultTypeInternal() {}
  union {
    GetDictionaryDeviceModelListResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetDictionaryDeviceModelListResponseDefaultTypeInternal _GetDictionaryDeviceModelListResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetDictionaryMrfListResponse::GetDictionaryMrfListResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetDictionaryMrfListResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetDictionaryMrfListResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetDictionaryMrfListResponseDefaultTypeInternal() {}
  union {
    GetDictionaryMrfListResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetDictionaryMrfListResponseDefaultTypeInternal _GetDictionaryMrfListResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR DictionaryMrf::DictionaryMrf(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.created_at_)*/nullptr
  , /*decltype(_impl_.changed_at_)*/nullptr
  , /*decltype(_impl_.title_)*/nullptr
  , /*decltype(_impl_.code_)*/nullptr
  , /*decltype(_impl_.id_)*/ 0
} {}
struct DictionaryMrfDefaultTypeInternal {
  PROTOBUF_CONSTEXPR DictionaryMrfDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~DictionaryMrfDefaultTypeInternal() {}
  union {
    DictionaryMrf _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DictionaryMrfDefaultTypeInternal _DictionaryMrf_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetDictionaryRfListResponse::GetDictionaryRfListResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetDictionaryRfListResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetDictionaryRfListResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetDictionaryRfListResponseDefaultTypeInternal() {}
  union {
    GetDictionaryRfListResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetDictionaryRfListResponseDefaultTypeInternal _GetDictionaryRfListResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR DictionaryPermission::DictionaryPermission(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.permission_type_)*/ 0

  , /*decltype(_impl_._cached_size_)*/{}} {}
struct DictionaryPermissionDefaultTypeInternal {
  PROTOBUF_CONSTEXPR DictionaryPermissionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~DictionaryPermissionDefaultTypeInternal() {}
  union {
    DictionaryPermission _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DictionaryPermissionDefaultTypeInternal _DictionaryPermission_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR DictionaryRf::DictionaryRf(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.created_at_)*/nullptr
  , /*decltype(_impl_.changed_at_)*/nullptr
  , /*decltype(_impl_.title_)*/nullptr
  , /*decltype(_impl_.code_)*/nullptr
  , /*decltype(_impl_.id_)*/ 0

  , /*decltype(_impl_.mrf_id_)*/ 0
} {}
struct DictionaryRfDefaultTypeInternal {
  PROTOBUF_CONSTEXPR DictionaryRfDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~DictionaryRfDefaultTypeInternal() {}
  union {
    DictionaryRf _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DictionaryRfDefaultTypeInternal _DictionaryRf_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetDictionaryDeviceModelCountRequest::GetDictionaryDeviceModelCountRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.filter_)*/nullptr} {}
struct GetDictionaryDeviceModelCountRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetDictionaryDeviceModelCountRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetDictionaryDeviceModelCountRequestDefaultTypeInternal() {}
  union {
    GetDictionaryDeviceModelCountRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetDictionaryDeviceModelCountRequestDefaultTypeInternal _GetDictionaryDeviceModelCountRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetDictionaryDeviceModelCountResponse::GetDictionaryDeviceModelCountResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetDictionaryDeviceModelCountResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetDictionaryDeviceModelCountResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetDictionaryDeviceModelCountResponseDefaultTypeInternal() {}
  union {
    GetDictionaryDeviceModelCountResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetDictionaryDeviceModelCountResponseDefaultTypeInternal _GetDictionaryDeviceModelCountResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetDictionaryMrfCountRequest::GetDictionaryMrfCountRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct GetDictionaryMrfCountRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetDictionaryMrfCountRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetDictionaryMrfCountRequestDefaultTypeInternal() {}
  union {
    GetDictionaryMrfCountRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetDictionaryMrfCountRequestDefaultTypeInternal _GetDictionaryMrfCountRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetDictionaryMrfCountResponse::GetDictionaryMrfCountResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetDictionaryMrfCountResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetDictionaryMrfCountResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetDictionaryMrfCountResponseDefaultTypeInternal() {}
  union {
    GetDictionaryMrfCountResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetDictionaryMrfCountResponseDefaultTypeInternal _GetDictionaryMrfCountResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetDictionaryRfCountRequest::GetDictionaryRfCountRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct GetDictionaryRfCountRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetDictionaryRfCountRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetDictionaryRfCountRequestDefaultTypeInternal() {}
  union {
    GetDictionaryRfCountRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetDictionaryRfCountRequestDefaultTypeInternal _GetDictionaryRfCountRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetDictionaryRfCountResponse::GetDictionaryRfCountResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetDictionaryRfCountResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetDictionaryRfCountResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetDictionaryRfCountResponseDefaultTypeInternal() {}
  union {
    GetDictionaryRfCountResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetDictionaryRfCountResponseDefaultTypeInternal _GetDictionaryRfCountResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR DictionaryDeviceModel::DictionaryDeviceModel(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.created_at_)*/nullptr
  , /*decltype(_impl_.changed_at_)*/nullptr
  , /*decltype(_impl_.title_)*/nullptr
  , /*decltype(_impl_.protocol_)*/nullptr
  , /*decltype(_impl_.model_kind_)*/nullptr
  , /*decltype(_impl_.id_)*/ 0
} {}
struct DictionaryDeviceModelDefaultTypeInternal {
  PROTOBUF_CONSTEXPR DictionaryDeviceModelDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~DictionaryDeviceModelDefaultTypeInternal() {}
  union {
    DictionaryDeviceModel _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DictionaryDeviceModelDefaultTypeInternal _DictionaryDeviceModel_default_instance_;
}  // namespace v1
}  // namespace telemetry_control
}  // namespace keyapis
namespace keyapis {
namespace telemetry_control {
namespace v1 {
bool DictionaryDeviceModelPaging_OrderByType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string>
    DictionaryDeviceModelPaging_OrderByType_strings[3] = {};

static const char DictionaryDeviceModelPaging_OrderByType_names[] = {
    "ID"
    "ORDER_BY_TYPE_UNKNOWN"
    "TITLE"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DictionaryDeviceModelPaging_OrderByType_entries[] =
    {
        {{&DictionaryDeviceModelPaging_OrderByType_names[0], 2}, 1},
        {{&DictionaryDeviceModelPaging_OrderByType_names[2], 21}, 0},
        {{&DictionaryDeviceModelPaging_OrderByType_names[23], 5}, 2},
};

static const int DictionaryDeviceModelPaging_OrderByType_entries_by_number[] = {
    1,  // 0 -> ORDER_BY_TYPE_UNKNOWN
    0,  // 1 -> ID
    2,  // 2 -> TITLE
};

const std::string& DictionaryDeviceModelPaging_OrderByType_Name(DictionaryDeviceModelPaging_OrderByType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          DictionaryDeviceModelPaging_OrderByType_entries, DictionaryDeviceModelPaging_OrderByType_entries_by_number,
          3, DictionaryDeviceModelPaging_OrderByType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      DictionaryDeviceModelPaging_OrderByType_entries, DictionaryDeviceModelPaging_OrderByType_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : DictionaryDeviceModelPaging_OrderByType_strings[idx].get();
}

bool DictionaryDeviceModelPaging_OrderByType_Parse(absl::string_view name, DictionaryDeviceModelPaging_OrderByType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      DictionaryDeviceModelPaging_OrderByType_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<DictionaryDeviceModelPaging_OrderByType>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && \
  (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

constexpr DictionaryDeviceModelPaging_OrderByType DictionaryDeviceModelPaging::ORDER_BY_TYPE_UNKNOWN;
constexpr DictionaryDeviceModelPaging_OrderByType DictionaryDeviceModelPaging::ID;
constexpr DictionaryDeviceModelPaging_OrderByType DictionaryDeviceModelPaging::TITLE;
constexpr DictionaryDeviceModelPaging_OrderByType DictionaryDeviceModelPaging::OrderByType_MIN;
constexpr DictionaryDeviceModelPaging_OrderByType DictionaryDeviceModelPaging::OrderByType_MAX;
constexpr int DictionaryDeviceModelPaging::OrderByType_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool DictionaryDeviceModelPaging_DirectionType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string>
    DictionaryDeviceModelPaging_DirectionType_strings[3] = {};

static const char DictionaryDeviceModelPaging_DirectionType_names[] = {
    "ASC"
    "DESC"
    "DIRECTION_TYPE_UNKNOWN"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DictionaryDeviceModelPaging_DirectionType_entries[] =
    {
        {{&DictionaryDeviceModelPaging_DirectionType_names[0], 3}, 2},
        {{&DictionaryDeviceModelPaging_DirectionType_names[3], 4}, 1},
        {{&DictionaryDeviceModelPaging_DirectionType_names[7], 22}, 0},
};

static const int DictionaryDeviceModelPaging_DirectionType_entries_by_number[] = {
    2,  // 0 -> DIRECTION_TYPE_UNKNOWN
    1,  // 1 -> DESC
    0,  // 2 -> ASC
};

const std::string& DictionaryDeviceModelPaging_DirectionType_Name(DictionaryDeviceModelPaging_DirectionType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          DictionaryDeviceModelPaging_DirectionType_entries, DictionaryDeviceModelPaging_DirectionType_entries_by_number,
          3, DictionaryDeviceModelPaging_DirectionType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      DictionaryDeviceModelPaging_DirectionType_entries, DictionaryDeviceModelPaging_DirectionType_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : DictionaryDeviceModelPaging_DirectionType_strings[idx].get();
}

bool DictionaryDeviceModelPaging_DirectionType_Parse(absl::string_view name, DictionaryDeviceModelPaging_DirectionType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      DictionaryDeviceModelPaging_DirectionType_entries, 3, name, &int_value);
  if (success) {
    *value = static_cast<DictionaryDeviceModelPaging_DirectionType>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && \
  (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

constexpr DictionaryDeviceModelPaging_DirectionType DictionaryDeviceModelPaging::DIRECTION_TYPE_UNKNOWN;
constexpr DictionaryDeviceModelPaging_DirectionType DictionaryDeviceModelPaging::DESC;
constexpr DictionaryDeviceModelPaging_DirectionType DictionaryDeviceModelPaging::ASC;
constexpr DictionaryDeviceModelPaging_DirectionType DictionaryDeviceModelPaging::DirectionType_MIN;
constexpr DictionaryDeviceModelPaging_DirectionType DictionaryDeviceModelPaging::DirectionType_MAX;
constexpr int DictionaryDeviceModelPaging::DirectionType_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool DictionaryMrf_MrfType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
      return true;
    default:
      return false;
  }
}
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string>
    DictionaryMrf_MrfType_strings[8] = {};

static const char DictionaryMrf_MrfType_names[] = {
    "DALNIY_VOSTOK"
    "MRF_TYPE_UNKNOWN"
    "SEVERO_ZAPAD"
    "SIBIR"
    "TSENTR"
    "URAL"
    "VOLGA"
    "YUG"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DictionaryMrf_MrfType_entries[] =
    {
        {{&DictionaryMrf_MrfType_names[0], 13}, 6},
        {{&DictionaryMrf_MrfType_names[13], 16}, 0},
        {{&DictionaryMrf_MrfType_names[29], 12}, 5},
        {{&DictionaryMrf_MrfType_names[41], 5}, 4},
        {{&DictionaryMrf_MrfType_names[46], 6}, 1},
        {{&DictionaryMrf_MrfType_names[52], 4}, 3},
        {{&DictionaryMrf_MrfType_names[56], 5}, 7},
        {{&DictionaryMrf_MrfType_names[61], 3}, 2},
};

static const int DictionaryMrf_MrfType_entries_by_number[] = {
    1,  // 0 -> MRF_TYPE_UNKNOWN
    4,  // 1 -> TSENTR
    7,  // 2 -> YUG
    5,  // 3 -> URAL
    3,  // 4 -> SIBIR
    2,  // 5 -> SEVERO_ZAPAD
    0,  // 6 -> DALNIY_VOSTOK
    6,  // 7 -> VOLGA
};

const std::string& DictionaryMrf_MrfType_Name(DictionaryMrf_MrfType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          DictionaryMrf_MrfType_entries, DictionaryMrf_MrfType_entries_by_number,
          8, DictionaryMrf_MrfType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      DictionaryMrf_MrfType_entries, DictionaryMrf_MrfType_entries_by_number, 8,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : DictionaryMrf_MrfType_strings[idx].get();
}

bool DictionaryMrf_MrfType_Parse(absl::string_view name, DictionaryMrf_MrfType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      DictionaryMrf_MrfType_entries, 8, name, &int_value);
  if (success) {
    *value = static_cast<DictionaryMrf_MrfType>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && \
  (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

constexpr DictionaryMrf_MrfType DictionaryMrf::MRF_TYPE_UNKNOWN;
constexpr DictionaryMrf_MrfType DictionaryMrf::TSENTR;
constexpr DictionaryMrf_MrfType DictionaryMrf::YUG;
constexpr DictionaryMrf_MrfType DictionaryMrf::URAL;
constexpr DictionaryMrf_MrfType DictionaryMrf::SIBIR;
constexpr DictionaryMrf_MrfType DictionaryMrf::SEVERO_ZAPAD;
constexpr DictionaryMrf_MrfType DictionaryMrf::DALNIY_VOSTOK;
constexpr DictionaryMrf_MrfType DictionaryMrf::VOLGA;
constexpr DictionaryMrf_MrfType DictionaryMrf::MrfType_MIN;
constexpr DictionaryMrf_MrfType DictionaryMrf::MrfType_MAX;
constexpr int DictionaryMrf::MrfType_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool DictionaryPermission_PermissionType_IsValid(int value) {
  switch (value) {
    case 0:
      return true;
    default:
      return false;
  }
}
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string>
    DictionaryPermission_PermissionType_strings[1] = {};

static const char DictionaryPermission_PermissionType_names[] = {
    "PERMISSION_TYPE_UNKNOWN"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DictionaryPermission_PermissionType_entries[] =
    {
        {{&DictionaryPermission_PermissionType_names[0], 23}, 0},
};

static const int DictionaryPermission_PermissionType_entries_by_number[] = {
    0,  // 0 -> PERMISSION_TYPE_UNKNOWN
};

const std::string& DictionaryPermission_PermissionType_Name(DictionaryPermission_PermissionType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          DictionaryPermission_PermissionType_entries, DictionaryPermission_PermissionType_entries_by_number,
          1, DictionaryPermission_PermissionType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      DictionaryPermission_PermissionType_entries, DictionaryPermission_PermissionType_entries_by_number, 1,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : DictionaryPermission_PermissionType_strings[idx].get();
}

bool DictionaryPermission_PermissionType_Parse(absl::string_view name, DictionaryPermission_PermissionType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      DictionaryPermission_PermissionType_entries, 1, name, &int_value);
  if (success) {
    *value = static_cast<DictionaryPermission_PermissionType>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && \
  (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

constexpr DictionaryPermission_PermissionType DictionaryPermission::PERMISSION_TYPE_UNKNOWN;
constexpr DictionaryPermission_PermissionType DictionaryPermission::PermissionType_MIN;
constexpr DictionaryPermission_PermissionType DictionaryPermission::PermissionType_MAX;
constexpr int DictionaryPermission::PermissionType_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool DictionaryRf_RfType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    case 19:
    case 20:
    case 21:
    case 22:
    case 23:
    case 24:
    case 25:
    case 26:
    case 27:
    case 28:
    case 29:
    case 30:
    case 31:
    case 32:
    case 33:
    case 34:
    case 35:
    case 36:
    case 37:
    case 38:
    case 39:
    case 40:
    case 41:
    case 42:
    case 43:
    case 44:
    case 45:
    case 46:
    case 47:
    case 48:
    case 49:
    case 50:
    case 51:
    case 52:
    case 53:
    case 54:
    case 55:
    case 56:
    case 57:
    case 58:
    case 59:
    case 60:
    case 61:
    case 62:
    case 63:
    case 64:
    case 65:
    case 66:
    case 67:
    case 68:
    case 69:
    case 70:
    case 71:
    case 72:
    case 73:
    case 74:
    case 75:
    case 76:
    case 77:
    case 78:
    case 79:
    case 80:
    case 81:
    case 82:
      return true;
    default:
      return false;
  }
}
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string>
    DictionaryRf_RfType_strings[83] = {};

static const char DictionaryRf_RfType_names[] = {
    "ALTAI"
    "AMUR"
    "ARCHANGELSK"
    "ASTRAKHAN"
    "BELGOROD"
    "BRYANSK"
    "BURYATIYA"
    "CHELYABINSK"
    "CHERKESSK"
    "CHITA"
    "CHUKOTKA"
    "CHUVASHIYA"
    "EAO"
    "EKT"
    "ELISTA"
    "HAKASIYA"
    "HANTY"
    "INGUSHETIA"
    "IRKUTSK"
    "IVANOVO"
    "KALININGRAD"
    "KALUGA"
    "KAMCHATKA"
    "KARELIA"
    "KAZAN"
    "KEMEROVO"
    "KHABAROVSK"
    "KIROV"
    "KOMI"
    "KOSTROMA"
    "KRASNODAR"
    "KRASNOYARSK"
    "KURGAN"
    "KURSK"
    "LENOBLAST"
    "LIPETSK"
    "MAGADAN"
    "MAHACHKALA"
    "MARYEL"
    "MAYKOP"
    "MORDOVIYA"
    "MOSCOW"
    "MOSOBLAST"
    "MURMANSK"
    "NALCHIK"
    "NNOVGOROD"
    "NOVGOROD"
    "NOVOSIBIRSK"
    "OMSK"
    "OREL"
    "ORENBURG"
    "PENZA"
    "PERM"
    "PRIMORYE"
    "PSKOV"
    "RALTAY"
    "RF_TYPE_UNKNOWN"
    "ROSTOV"
    "RYAZAN"
    "SAKHA"
    "SAKHALIN"
    "SAMARA"
    "SARATOV"
    "SMOLENSK"
    "SPB"
    "STAVROPOL"
    "TAMBOV"
    "TEST"
    "TOMSK"
    "TULA"
    "TUMEN"
    "TUVA"
    "TVER"
    "UDMURTIYA"
    "UFA"
    "ULYANOVSK"
    "VLADIKAVKAZ"
    "VLADIMIR"
    "VOLGOGRAD"
    "VOLOGDA"
    "VORONEZH"
    "YAMAL"
    "YAROSLAVL"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DictionaryRf_RfType_entries[] =
    {
        {{&DictionaryRf_RfType_names[0], 5}, 39},
        {{&DictionaryRf_RfType_names[5], 4}, 21},
        {{&DictionaryRf_RfType_names[9], 11}, 29},
        {{&DictionaryRf_RfType_names[20], 9}, 79},
        {{&DictionaryRf_RfType_names[29], 8}, 50},
        {{&DictionaryRf_RfType_names[37], 7}, 72},
        {{&DictionaryRf_RfType_names[44], 9}, 40},
        {{&DictionaryRf_RfType_names[53], 11}, 55},
        {{&DictionaryRf_RfType_names[64], 9}, 77},
        {{&DictionaryRf_RfType_names[73], 5}, 27},
        {{&DictionaryRf_RfType_names[78], 8}, 28},
        {{&DictionaryRf_RfType_names[86], 10}, 70},
        {{&DictionaryRf_RfType_names[96], 3}, 17},
        {{&DictionaryRf_RfType_names[99], 3}, 52},
        {{&DictionaryRf_RfType_names[102], 6}, 61},
        {{&DictionaryRf_RfType_names[108], 8}, 45},
        {{&DictionaryRf_RfType_names[116], 5}, 20},
        {{&DictionaryRf_RfType_names[121], 10}, 59},
        {{&DictionaryRf_RfType_names[131], 7}, 41},
        {{&DictionaryRf_RfType_names[138], 7}, 3},
        {{&DictionaryRf_RfType_names[145], 11}, 31},
        {{&DictionaryRf_RfType_names[156], 6}, 4},
        {{&DictionaryRf_RfType_names[162], 9}, 22},
        {{&DictionaryRf_RfType_names[171], 7}, 32},
        {{&DictionaryRf_RfType_names[178], 5}, 65},
        {{&DictionaryRf_RfType_names[183], 8}, 42},
        {{&DictionaryRf_RfType_names[191], 10}, 26},
        {{&DictionaryRf_RfType_names[201], 5}, 2},
        {{&DictionaryRf_RfType_names[206], 4}, 33},
        {{&DictionaryRf_RfType_names[210], 8}, 5},
        {{&DictionaryRf_RfType_names[218], 9}, 80},
        {{&DictionaryRf_RfType_names[227], 11}, 43},
        {{&DictionaryRf_RfType_names[238], 6}, 18},
        {{&DictionaryRf_RfType_names[244], 5}, 6},
        {{&DictionaryRf_RfType_names[249], 9}, 34},
        {{&DictionaryRf_RfType_names[258], 7}, 7},
        {{&DictionaryRf_RfType_names[265], 7}, 23},
        {{&DictionaryRf_RfType_names[272], 10}, 63},
        {{&DictionaryRf_RfType_names[282], 6}, 57},
        {{&DictionaryRf_RfType_names[288], 6}, 78},
        {{&DictionaryRf_RfType_names[294], 9}, 64},
        {{&DictionaryRf_RfType_names[303], 6}, 16},
        {{&DictionaryRf_RfType_names[309], 9}, 8},
        {{&DictionaryRf_RfType_names[318], 8}, 35},
        {{&DictionaryRf_RfType_names[326], 7}, 60},
        {{&DictionaryRf_RfType_names[333], 9}, 71},
        {{&DictionaryRf_RfType_names[342], 8}, 36},
        {{&DictionaryRf_RfType_names[350], 11}, 82},
        {{&DictionaryRf_RfType_names[361], 4}, 44},
        {{&DictionaryRf_RfType_names[365], 4}, 9},
        {{&DictionaryRf_RfType_names[369], 8}, 49},
        {{&DictionaryRf_RfType_names[377], 5}, 58},
        {{&DictionaryRf_RfType_names[382], 4}, 56},
        {{&DictionaryRf_RfType_names[386], 8}, 24},
        {{&DictionaryRf_RfType_names[394], 5}, 37},
        {{&DictionaryRf_RfType_names[399], 6}, 46},
        {{&DictionaryRf_RfType_names[405], 15}, 0},
        {{&DictionaryRf_RfType_names[420], 6}, 62},
        {{&DictionaryRf_RfType_names[426], 6}, 10},
        {{&DictionaryRf_RfType_names[432], 5}, 51},
        {{&DictionaryRf_RfType_names[437], 8}, 25},
        {{&DictionaryRf_RfType_names[445], 6}, 66},
        {{&DictionaryRf_RfType_names[451], 7}, 67},
        {{&DictionaryRf_RfType_names[458], 8}, 14},
        {{&DictionaryRf_RfType_names[466], 3}, 38},
        {{&DictionaryRf_RfType_names[469], 9}, 76},
        {{&DictionaryRf_RfType_names[478], 6}, 11},
        {{&DictionaryRf_RfType_names[484], 4}, 81},
        {{&DictionaryRf_RfType_names[488], 5}, 48},
        {{&DictionaryRf_RfType_names[493], 4}, 15},
        {{&DictionaryRf_RfType_names[497], 5}, 19},
        {{&DictionaryRf_RfType_names[502], 4}, 47},
        {{&DictionaryRf_RfType_names[506], 4}, 12},
        {{&DictionaryRf_RfType_names[510], 9}, 68},
        {{&DictionaryRf_RfType_names[519], 3}, 1},
        {{&DictionaryRf_RfType_names[522], 9}, 69},
        {{&DictionaryRf_RfType_names[531], 11}, 75},
        {{&DictionaryRf_RfType_names[542], 8}, 73},
        {{&DictionaryRf_RfType_names[550], 9}, 53},
        {{&DictionaryRf_RfType_names[559], 7}, 30},
        {{&DictionaryRf_RfType_names[566], 8}, 74},
        {{&DictionaryRf_RfType_names[574], 5}, 54},
        {{&DictionaryRf_RfType_names[579], 9}, 13},
};

static const int DictionaryRf_RfType_entries_by_number[] = {
    56,  // 0 -> RF_TYPE_UNKNOWN
    74,  // 1 -> UFA
    27,  // 2 -> KIROV
    19,  // 3 -> IVANOVO
    21,  // 4 -> KALUGA
    29,  // 5 -> KOSTROMA
    33,  // 6 -> KURSK
    35,  // 7 -> LIPETSK
    42,  // 8 -> MOSOBLAST
    49,  // 9 -> OREL
    58,  // 10 -> RYAZAN
    66,  // 11 -> TAMBOV
    72,  // 12 -> TVER
    82,  // 13 -> YAROSLAVL
    63,  // 14 -> SMOLENSK
    69,  // 15 -> TULA
    41,  // 16 -> MOSCOW
    12,  // 17 -> EAO
    32,  // 18 -> KURGAN
    70,  // 19 -> TUMEN
    16,  // 20 -> HANTY
    1,  // 21 -> AMUR
    22,  // 22 -> KAMCHATKA
    36,  // 23 -> MAGADAN
    53,  // 24 -> PRIMORYE
    60,  // 25 -> SAKHALIN
    26,  // 26 -> KHABAROVSK
    9,  // 27 -> CHITA
    10,  // 28 -> CHUKOTKA
    2,  // 29 -> ARCHANGELSK
    79,  // 30 -> VOLOGDA
    20,  // 31 -> KALININGRAD
    23,  // 32 -> KARELIA
    28,  // 33 -> KOMI
    34,  // 34 -> LENOBLAST
    43,  // 35 -> MURMANSK
    46,  // 36 -> NOVGOROD
    54,  // 37 -> PSKOV
    64,  // 38 -> SPB
    0,  // 39 -> ALTAI
    6,  // 40 -> BURYATIYA
    18,  // 41 -> IRKUTSK
    25,  // 42 -> KEMEROVO
    31,  // 43 -> KRASNOYARSK
    48,  // 44 -> OMSK
    15,  // 45 -> HAKASIYA
    55,  // 46 -> RALTAY
    71,  // 47 -> TUVA
    68,  // 48 -> TOMSK
    50,  // 49 -> ORENBURG
    4,  // 50 -> BELGOROD
    59,  // 51 -> SAKHA
    13,  // 52 -> EKT
    78,  // 53 -> VOLGOGRAD
    81,  // 54 -> YAMAL
    7,  // 55 -> CHELYABINSK
    52,  // 56 -> PERM
    38,  // 57 -> MARYEL
    51,  // 58 -> PENZA
    17,  // 59 -> INGUSHETIA
    44,  // 60 -> NALCHIK
    14,  // 61 -> ELISTA
    57,  // 62 -> ROSTOV
    37,  // 63 -> MAHACHKALA
    40,  // 64 -> MORDOVIYA
    24,  // 65 -> KAZAN
    61,  // 66 -> SAMARA
    62,  // 67 -> SARATOV
    73,  // 68 -> UDMURTIYA
    75,  // 69 -> ULYANOVSK
    11,  // 70 -> CHUVASHIYA
    45,  // 71 -> NNOVGOROD
    5,  // 72 -> BRYANSK
    77,  // 73 -> VLADIMIR
    80,  // 74 -> VORONEZH
    76,  // 75 -> VLADIKAVKAZ
    65,  // 76 -> STAVROPOL
    8,  // 77 -> CHERKESSK
    39,  // 78 -> MAYKOP
    3,  // 79 -> ASTRAKHAN
    30,  // 80 -> KRASNODAR
    67,  // 81 -> TEST
    47,  // 82 -> NOVOSIBIRSK
};

const std::string& DictionaryRf_RfType_Name(DictionaryRf_RfType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          DictionaryRf_RfType_entries, DictionaryRf_RfType_entries_by_number,
          83, DictionaryRf_RfType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      DictionaryRf_RfType_entries, DictionaryRf_RfType_entries_by_number, 83,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : DictionaryRf_RfType_strings[idx].get();
}

bool DictionaryRf_RfType_Parse(absl::string_view name, DictionaryRf_RfType* value) {
  int int_value;
  bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
      DictionaryRf_RfType_entries, 83, name, &int_value);
  if (success) {
    *value = static_cast<DictionaryRf_RfType>(int_value);
  }
  return success;
}
#if (__cplusplus < 201703) && \
  (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

constexpr DictionaryRf_RfType DictionaryRf::RF_TYPE_UNKNOWN;
constexpr DictionaryRf_RfType DictionaryRf::UFA;
constexpr DictionaryRf_RfType DictionaryRf::KIROV;
constexpr DictionaryRf_RfType DictionaryRf::IVANOVO;
constexpr DictionaryRf_RfType DictionaryRf::KALUGA;
constexpr DictionaryRf_RfType DictionaryRf::KOSTROMA;
constexpr DictionaryRf_RfType DictionaryRf::KURSK;
constexpr DictionaryRf_RfType DictionaryRf::LIPETSK;
constexpr DictionaryRf_RfType DictionaryRf::MOSOBLAST;
constexpr DictionaryRf_RfType DictionaryRf::OREL;
constexpr DictionaryRf_RfType DictionaryRf::RYAZAN;
constexpr DictionaryRf_RfType DictionaryRf::TAMBOV;
constexpr DictionaryRf_RfType DictionaryRf::TVER;
constexpr DictionaryRf_RfType DictionaryRf::YAROSLAVL;
constexpr DictionaryRf_RfType DictionaryRf::SMOLENSK;
constexpr DictionaryRf_RfType DictionaryRf::TULA;
constexpr DictionaryRf_RfType DictionaryRf::MOSCOW;
constexpr DictionaryRf_RfType DictionaryRf::EAO;
constexpr DictionaryRf_RfType DictionaryRf::KURGAN;
constexpr DictionaryRf_RfType DictionaryRf::TUMEN;
constexpr DictionaryRf_RfType DictionaryRf::HANTY;
constexpr DictionaryRf_RfType DictionaryRf::AMUR;
constexpr DictionaryRf_RfType DictionaryRf::KAMCHATKA;
constexpr DictionaryRf_RfType DictionaryRf::MAGADAN;
constexpr DictionaryRf_RfType DictionaryRf::PRIMORYE;
constexpr DictionaryRf_RfType DictionaryRf::SAKHALIN;
constexpr DictionaryRf_RfType DictionaryRf::KHABAROVSK;
constexpr DictionaryRf_RfType DictionaryRf::CHITA;
constexpr DictionaryRf_RfType DictionaryRf::CHUKOTKA;
constexpr DictionaryRf_RfType DictionaryRf::ARCHANGELSK;
constexpr DictionaryRf_RfType DictionaryRf::VOLOGDA;
constexpr DictionaryRf_RfType DictionaryRf::KALININGRAD;
constexpr DictionaryRf_RfType DictionaryRf::KARELIA;
constexpr DictionaryRf_RfType DictionaryRf::KOMI;
constexpr DictionaryRf_RfType DictionaryRf::LENOBLAST;
constexpr DictionaryRf_RfType DictionaryRf::MURMANSK;
constexpr DictionaryRf_RfType DictionaryRf::NOVGOROD;
constexpr DictionaryRf_RfType DictionaryRf::PSKOV;
constexpr DictionaryRf_RfType DictionaryRf::SPB;
constexpr DictionaryRf_RfType DictionaryRf::ALTAI;
constexpr DictionaryRf_RfType DictionaryRf::BURYATIYA;
constexpr DictionaryRf_RfType DictionaryRf::IRKUTSK;
constexpr DictionaryRf_RfType DictionaryRf::KEMEROVO;
constexpr DictionaryRf_RfType DictionaryRf::KRASNOYARSK;
constexpr DictionaryRf_RfType DictionaryRf::OMSK;
constexpr DictionaryRf_RfType DictionaryRf::HAKASIYA;
constexpr DictionaryRf_RfType DictionaryRf::RALTAY;
constexpr DictionaryRf_RfType DictionaryRf::TUVA;
constexpr DictionaryRf_RfType DictionaryRf::TOMSK;
constexpr DictionaryRf_RfType DictionaryRf::ORENBURG;
constexpr DictionaryRf_RfType DictionaryRf::BELGOROD;
constexpr DictionaryRf_RfType DictionaryRf::SAKHA;
constexpr DictionaryRf_RfType DictionaryRf::EKT;
constexpr DictionaryRf_RfType DictionaryRf::VOLGOGRAD;
constexpr DictionaryRf_RfType DictionaryRf::YAMAL;
constexpr DictionaryRf_RfType DictionaryRf::CHELYABINSK;
constexpr DictionaryRf_RfType DictionaryRf::PERM;
constexpr DictionaryRf_RfType DictionaryRf::MARYEL;
constexpr DictionaryRf_RfType DictionaryRf::PENZA;
constexpr DictionaryRf_RfType DictionaryRf::INGUSHETIA;
constexpr DictionaryRf_RfType DictionaryRf::NALCHIK;
constexpr DictionaryRf_RfType DictionaryRf::ELISTA;
constexpr DictionaryRf_RfType DictionaryRf::ROSTOV;
constexpr DictionaryRf_RfType DictionaryRf::MAHACHKALA;
constexpr DictionaryRf_RfType DictionaryRf::MORDOVIYA;
constexpr DictionaryRf_RfType DictionaryRf::KAZAN;
constexpr DictionaryRf_RfType DictionaryRf::SAMARA;
constexpr DictionaryRf_RfType DictionaryRf::SARATOV;
constexpr DictionaryRf_RfType DictionaryRf::UDMURTIYA;
constexpr DictionaryRf_RfType DictionaryRf::ULYANOVSK;
constexpr DictionaryRf_RfType DictionaryRf::CHUVASHIYA;
constexpr DictionaryRf_RfType DictionaryRf::NNOVGOROD;
constexpr DictionaryRf_RfType DictionaryRf::BRYANSK;
constexpr DictionaryRf_RfType DictionaryRf::VLADIMIR;
constexpr DictionaryRf_RfType DictionaryRf::VORONEZH;
constexpr DictionaryRf_RfType DictionaryRf::VLADIKAVKAZ;
constexpr DictionaryRf_RfType DictionaryRf::STAVROPOL;
constexpr DictionaryRf_RfType DictionaryRf::CHERKESSK;
constexpr DictionaryRf_RfType DictionaryRf::MAYKOP;
constexpr DictionaryRf_RfType DictionaryRf::ASTRAKHAN;
constexpr DictionaryRf_RfType DictionaryRf::KRASNODAR;
constexpr DictionaryRf_RfType DictionaryRf::TEST;
constexpr DictionaryRf_RfType DictionaryRf::NOVOSIBIRSK;
constexpr DictionaryRf_RfType DictionaryRf::RfType_MIN;
constexpr DictionaryRf_RfType DictionaryRf::RfType_MAX;
constexpr int DictionaryRf::RfType_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
// ===================================================================

class PostDictionaryDeviceModelRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<PostDictionaryDeviceModelRequest>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(PostDictionaryDeviceModelRequest, _impl_._has_bits_);
  static const ::keyapis::telemetry_control::v1::DictionaryDeviceModel& data(const PostDictionaryDeviceModelRequest* msg);
  static void set_has_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::keyapis::telemetry_control::v1::DictionaryDeviceModel&
PostDictionaryDeviceModelRequest::_Internal::data(const PostDictionaryDeviceModelRequest* msg) {
  return *msg->_impl_.data_;
}
PostDictionaryDeviceModelRequest::PostDictionaryDeviceModelRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.PostDictionaryDeviceModelRequest)
}
PostDictionaryDeviceModelRequest::PostDictionaryDeviceModelRequest(const PostDictionaryDeviceModelRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostDictionaryDeviceModelRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.data_){nullptr}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.data_ = new ::keyapis::telemetry_control::v1::DictionaryDeviceModel(*from._impl_.data_);
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.PostDictionaryDeviceModelRequest)
}

inline void PostDictionaryDeviceModelRequest::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.data_){nullptr}
  };
}

PostDictionaryDeviceModelRequest::~PostDictionaryDeviceModelRequest() {
  // @@protoc_insertion_point(destructor:keyapis.telemetry_control.v1.PostDictionaryDeviceModelRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void PostDictionaryDeviceModelRequest::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.data_;
}

void PostDictionaryDeviceModelRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void PostDictionaryDeviceModelRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.PostDictionaryDeviceModelRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    ABSL_DCHECK(_impl_.data_ != nullptr);
    _impl_.data_->Clear();
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* PostDictionaryDeviceModelRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.telemetry_control.v1.DictionaryDeviceModel data = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_data(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* PostDictionaryDeviceModelRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.PostDictionaryDeviceModelRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.telemetry_control.v1.DictionaryDeviceModel data = 1 [(.google.api.field_behavior) = REQUIRED];
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::data(this),
        _Internal::data(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.PostDictionaryDeviceModelRequest)
  return target;
}

::size_t PostDictionaryDeviceModelRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.PostDictionaryDeviceModelRequest)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .keyapis.telemetry_control.v1.DictionaryDeviceModel data = 1 [(.google.api.field_behavior) = REQUIRED];
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.data_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void PostDictionaryDeviceModelRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PostDictionaryDeviceModelRequest*>(
      &from));
}

void PostDictionaryDeviceModelRequest::MergeFrom(const PostDictionaryDeviceModelRequest& from) {
  PostDictionaryDeviceModelRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.telemetry_control.v1.PostDictionaryDeviceModelRequest)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_internal_mutable_data()->::keyapis::telemetry_control::v1::DictionaryDeviceModel::MergeFrom(
        from._internal_data());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void PostDictionaryDeviceModelRequest::CopyFrom(const PostDictionaryDeviceModelRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.telemetry_control.v1.PostDictionaryDeviceModelRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PostDictionaryDeviceModelRequest::IsInitialized() const {
  return true;
}

void PostDictionaryDeviceModelRequest::InternalSwap(PostDictionaryDeviceModelRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  swap(_impl_.data_, other->_impl_.data_);
}

std::string PostDictionaryDeviceModelRequest::GetTypeName() const {
  return "keyapis.telemetry_control.v1.PostDictionaryDeviceModelRequest";
}

// ===================================================================

class PostDictionaryDeviceModelResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::telemetry_control::v1::PostDictionaryDeviceModelResponse, _impl_._oneof_case_);
  static const ::keyapis::telemetry_control::v1::DictionaryDeviceModel& data(const PostDictionaryDeviceModelResponse* msg);
};

const ::keyapis::telemetry_control::v1::DictionaryDeviceModel&
PostDictionaryDeviceModelResponse::_Internal::data(const PostDictionaryDeviceModelResponse* msg) {
  return *msg->_impl_.type_.data_;
}
void PostDictionaryDeviceModelResponse::set_allocated_data(::keyapis::telemetry_control::v1::DictionaryDeviceModel* data) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (data) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(data);
    if (message_arena != submessage_arena) {
      data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, data, submessage_arena);
    }
    set_has_data();
    _impl_.type_.data_ = data;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.telemetry_control.v1.PostDictionaryDeviceModelResponse.data)
}
PostDictionaryDeviceModelResponse::PostDictionaryDeviceModelResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.PostDictionaryDeviceModelResponse)
}
PostDictionaryDeviceModelResponse::PostDictionaryDeviceModelResponse(const PostDictionaryDeviceModelResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostDictionaryDeviceModelResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_type();
  switch (from.type_case()) {
    case kData: {
      _this->_internal_mutable_data()->::keyapis::telemetry_control::v1::DictionaryDeviceModel::MergeFrom(
          from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.PostDictionaryDeviceModelResponse)
}

inline void PostDictionaryDeviceModelResponse::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_type();
}

PostDictionaryDeviceModelResponse::~PostDictionaryDeviceModelResponse() {
  // @@protoc_insertion_point(destructor:keyapis.telemetry_control.v1.PostDictionaryDeviceModelResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void PostDictionaryDeviceModelResponse::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_type()) {
    clear_type();
  }
}

void PostDictionaryDeviceModelResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void PostDictionaryDeviceModelResponse::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.telemetry_control.v1.PostDictionaryDeviceModelResponse)
  switch (type_case()) {
    case kData: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.type_.data_;
      }
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}


void PostDictionaryDeviceModelResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.PostDictionaryDeviceModelResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_type();
  _internal_metadata_.Clear<std::string>();
}

const char* PostDictionaryDeviceModelResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.telemetry_control.v1.DictionaryDeviceModel data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_data(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* PostDictionaryDeviceModelResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.PostDictionaryDeviceModelResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.telemetry_control.v1.DictionaryDeviceModel data = 1;
  if (type_case() == kData) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::data(this),
        _Internal::data(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.PostDictionaryDeviceModelResponse)
  return target;
}

::size_t PostDictionaryDeviceModelResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.PostDictionaryDeviceModelResponse)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (type_case()) {
    // .keyapis.telemetry_control.v1.DictionaryDeviceModel data = 1;
    case kData: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.data_);
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void PostDictionaryDeviceModelResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PostDictionaryDeviceModelResponse*>(
      &from));
}

void PostDictionaryDeviceModelResponse::MergeFrom(const PostDictionaryDeviceModelResponse& from) {
  PostDictionaryDeviceModelResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.telemetry_control.v1.PostDictionaryDeviceModelResponse)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.type_case()) {
    case kData: {
      _this->_internal_mutable_data()->::keyapis::telemetry_control::v1::DictionaryDeviceModel::MergeFrom(
          from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void PostDictionaryDeviceModelResponse::CopyFrom(const PostDictionaryDeviceModelResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.telemetry_control.v1.PostDictionaryDeviceModelResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PostDictionaryDeviceModelResponse::IsInitialized() const {
  return true;
}

void PostDictionaryDeviceModelResponse::InternalSwap(PostDictionaryDeviceModelResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.type_, other->_impl_.type_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string PostDictionaryDeviceModelResponse::GetTypeName() const {
  return "keyapis.telemetry_control.v1.PostDictionaryDeviceModelResponse";
}

// ===================================================================

class DeleteDictionaryDeviceModelRequest::_Internal {
 public:
};

DeleteDictionaryDeviceModelRequest::DeleteDictionaryDeviceModelRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.DeleteDictionaryDeviceModelRequest)
}
DeleteDictionaryDeviceModelRequest::DeleteDictionaryDeviceModelRequest(const DeleteDictionaryDeviceModelRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.DeleteDictionaryDeviceModelRequest)
}

inline void DeleteDictionaryDeviceModelRequest::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.id_) { 0 }

    , /*decltype(_impl_._cached_size_)*/{}
  };
}

DeleteDictionaryDeviceModelRequest::~DeleteDictionaryDeviceModelRequest() {
  // @@protoc_insertion_point(destructor:keyapis.telemetry_control.v1.DeleteDictionaryDeviceModelRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void DeleteDictionaryDeviceModelRequest::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
}

void DeleteDictionaryDeviceModelRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void DeleteDictionaryDeviceModelRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.DeleteDictionaryDeviceModelRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.id_ = 0;
  _internal_metadata_.Clear<std::string>();
}

const char* DeleteDictionaryDeviceModelRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int32 id = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* DeleteDictionaryDeviceModelRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.DeleteDictionaryDeviceModelRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        1, this->_internal_id(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.DeleteDictionaryDeviceModelRequest)
  return target;
}

::size_t DeleteDictionaryDeviceModelRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.DeleteDictionaryDeviceModelRequest)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // int32 id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_id() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_id());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void DeleteDictionaryDeviceModelRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const DeleteDictionaryDeviceModelRequest*>(
      &from));
}

void DeleteDictionaryDeviceModelRequest::MergeFrom(const DeleteDictionaryDeviceModelRequest& from) {
  DeleteDictionaryDeviceModelRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.telemetry_control.v1.DeleteDictionaryDeviceModelRequest)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_id() != 0) {
    _this->_internal_set_id(from._internal_id());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void DeleteDictionaryDeviceModelRequest::CopyFrom(const DeleteDictionaryDeviceModelRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.telemetry_control.v1.DeleteDictionaryDeviceModelRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DeleteDictionaryDeviceModelRequest::IsInitialized() const {
  return true;
}

void DeleteDictionaryDeviceModelRequest::InternalSwap(DeleteDictionaryDeviceModelRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);

  swap(_impl_.id_, other->_impl_.id_);
}

std::string DeleteDictionaryDeviceModelRequest::GetTypeName() const {
  return "keyapis.telemetry_control.v1.DeleteDictionaryDeviceModelRequest";
}

// ===================================================================

class DeleteDictionaryDeviceModelResponse::_Internal {
 public:
};

DeleteDictionaryDeviceModelResponse::DeleteDictionaryDeviceModelResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.DeleteDictionaryDeviceModelResponse)
}
DeleteDictionaryDeviceModelResponse::DeleteDictionaryDeviceModelResponse(const DeleteDictionaryDeviceModelResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.DeleteDictionaryDeviceModelResponse)
}

inline void DeleteDictionaryDeviceModelResponse::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

DeleteDictionaryDeviceModelResponse::~DeleteDictionaryDeviceModelResponse() {
  // @@protoc_insertion_point(destructor:keyapis.telemetry_control.v1.DeleteDictionaryDeviceModelResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void DeleteDictionaryDeviceModelResponse::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
}

void DeleteDictionaryDeviceModelResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void DeleteDictionaryDeviceModelResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.DeleteDictionaryDeviceModelResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* DeleteDictionaryDeviceModelResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* DeleteDictionaryDeviceModelResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.DeleteDictionaryDeviceModelResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.DeleteDictionaryDeviceModelResponse)
  return target;
}

::size_t DeleteDictionaryDeviceModelResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.DeleteDictionaryDeviceModelResponse)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void DeleteDictionaryDeviceModelResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const DeleteDictionaryDeviceModelResponse*>(
      &from));
}

void DeleteDictionaryDeviceModelResponse::MergeFrom(const DeleteDictionaryDeviceModelResponse& from) {
  DeleteDictionaryDeviceModelResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.telemetry_control.v1.DeleteDictionaryDeviceModelResponse)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void DeleteDictionaryDeviceModelResponse::CopyFrom(const DeleteDictionaryDeviceModelResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.telemetry_control.v1.DeleteDictionaryDeviceModelResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DeleteDictionaryDeviceModelResponse::IsInitialized() const {
  return true;
}

void DeleteDictionaryDeviceModelResponse::InternalSwap(DeleteDictionaryDeviceModelResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string DeleteDictionaryDeviceModelResponse::GetTypeName() const {
  return "keyapis.telemetry_control.v1.DeleteDictionaryDeviceModelResponse";
}

// ===================================================================

class GetDictionaryDeviceModelRequest::_Internal {
 public:
};

GetDictionaryDeviceModelRequest::GetDictionaryDeviceModelRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.GetDictionaryDeviceModelRequest)
}
GetDictionaryDeviceModelRequest::GetDictionaryDeviceModelRequest(const GetDictionaryDeviceModelRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.GetDictionaryDeviceModelRequest)
}

inline void GetDictionaryDeviceModelRequest::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.id_) { 0 }

    , /*decltype(_impl_._cached_size_)*/{}
  };
}

GetDictionaryDeviceModelRequest::~GetDictionaryDeviceModelRequest() {
  // @@protoc_insertion_point(destructor:keyapis.telemetry_control.v1.GetDictionaryDeviceModelRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void GetDictionaryDeviceModelRequest::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
}

void GetDictionaryDeviceModelRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void GetDictionaryDeviceModelRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.id_ = 0;
  _internal_metadata_.Clear<std::string>();
}

const char* GetDictionaryDeviceModelRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int32 id = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* GetDictionaryDeviceModelRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        1, this->_internal_id(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.GetDictionaryDeviceModelRequest)
  return target;
}

::size_t GetDictionaryDeviceModelRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelRequest)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // int32 id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_id() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_id());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GetDictionaryDeviceModelRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetDictionaryDeviceModelRequest*>(
      &from));
}

void GetDictionaryDeviceModelRequest::MergeFrom(const GetDictionaryDeviceModelRequest& from) {
  GetDictionaryDeviceModelRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelRequest)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_id() != 0) {
    _this->_internal_set_id(from._internal_id());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetDictionaryDeviceModelRequest::CopyFrom(const GetDictionaryDeviceModelRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetDictionaryDeviceModelRequest::IsInitialized() const {
  return true;
}

void GetDictionaryDeviceModelRequest::InternalSwap(GetDictionaryDeviceModelRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);

  swap(_impl_.id_, other->_impl_.id_);
}

std::string GetDictionaryDeviceModelRequest::GetTypeName() const {
  return "keyapis.telemetry_control.v1.GetDictionaryDeviceModelRequest";
}

// ===================================================================

class GetDictionaryDeviceModelResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::telemetry_control::v1::GetDictionaryDeviceModelResponse, _impl_._oneof_case_);
  static const ::keyapis::telemetry_control::v1::DictionaryDeviceModel& data(const GetDictionaryDeviceModelResponse* msg);
};

const ::keyapis::telemetry_control::v1::DictionaryDeviceModel&
GetDictionaryDeviceModelResponse::_Internal::data(const GetDictionaryDeviceModelResponse* msg) {
  return *msg->_impl_.type_.data_;
}
void GetDictionaryDeviceModelResponse::set_allocated_data(::keyapis::telemetry_control::v1::DictionaryDeviceModel* data) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (data) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(data);
    if (message_arena != submessage_arena) {
      data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, data, submessage_arena);
    }
    set_has_data();
    _impl_.type_.data_ = data;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.telemetry_control.v1.GetDictionaryDeviceModelResponse.data)
}
GetDictionaryDeviceModelResponse::GetDictionaryDeviceModelResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.GetDictionaryDeviceModelResponse)
}
GetDictionaryDeviceModelResponse::GetDictionaryDeviceModelResponse(const GetDictionaryDeviceModelResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetDictionaryDeviceModelResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_type();
  switch (from.type_case()) {
    case kData: {
      _this->_internal_mutable_data()->::keyapis::telemetry_control::v1::DictionaryDeviceModel::MergeFrom(
          from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.GetDictionaryDeviceModelResponse)
}

inline void GetDictionaryDeviceModelResponse::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_type();
}

GetDictionaryDeviceModelResponse::~GetDictionaryDeviceModelResponse() {
  // @@protoc_insertion_point(destructor:keyapis.telemetry_control.v1.GetDictionaryDeviceModelResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void GetDictionaryDeviceModelResponse::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_type()) {
    clear_type();
  }
}

void GetDictionaryDeviceModelResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void GetDictionaryDeviceModelResponse::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelResponse)
  switch (type_case()) {
    case kData: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.type_.data_;
      }
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}


void GetDictionaryDeviceModelResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_type();
  _internal_metadata_.Clear<std::string>();
}

const char* GetDictionaryDeviceModelResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.telemetry_control.v1.DictionaryDeviceModel data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_data(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* GetDictionaryDeviceModelResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.telemetry_control.v1.DictionaryDeviceModel data = 1;
  if (type_case() == kData) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::data(this),
        _Internal::data(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.GetDictionaryDeviceModelResponse)
  return target;
}

::size_t GetDictionaryDeviceModelResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelResponse)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (type_case()) {
    // .keyapis.telemetry_control.v1.DictionaryDeviceModel data = 1;
    case kData: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.data_);
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GetDictionaryDeviceModelResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetDictionaryDeviceModelResponse*>(
      &from));
}

void GetDictionaryDeviceModelResponse::MergeFrom(const GetDictionaryDeviceModelResponse& from) {
  GetDictionaryDeviceModelResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelResponse)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.type_case()) {
    case kData: {
      _this->_internal_mutable_data()->::keyapis::telemetry_control::v1::DictionaryDeviceModel::MergeFrom(
          from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetDictionaryDeviceModelResponse::CopyFrom(const GetDictionaryDeviceModelResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetDictionaryDeviceModelResponse::IsInitialized() const {
  return true;
}

void GetDictionaryDeviceModelResponse::InternalSwap(GetDictionaryDeviceModelResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.type_, other->_impl_.type_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string GetDictionaryDeviceModelResponse::GetTypeName() const {
  return "keyapis.telemetry_control.v1.GetDictionaryDeviceModelResponse";
}

// ===================================================================

class GetDictionaryDeviceModelListRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<GetDictionaryDeviceModelListRequest>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(GetDictionaryDeviceModelListRequest, _impl_._has_bits_);
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::telemetry_control::v1::GetDictionaryDeviceModelListRequest, _impl_._oneof_case_);
  static const ::keyapis::telemetry_control::v1::DictionaryDeviceModelFilter& filter(const GetDictionaryDeviceModelListRequest* msg);
  static void set_has_filter(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::keyapis::telemetry_control::v1::DictionaryDeviceModelPaging& paging(const GetDictionaryDeviceModelListRequest* msg);
};

const ::keyapis::telemetry_control::v1::DictionaryDeviceModelFilter&
GetDictionaryDeviceModelListRequest::_Internal::filter(const GetDictionaryDeviceModelListRequest* msg) {
  return *msg->_impl_.filter_;
}
const ::keyapis::telemetry_control::v1::DictionaryDeviceModelPaging&
GetDictionaryDeviceModelListRequest::_Internal::paging(const GetDictionaryDeviceModelListRequest* msg) {
  return *msg->_impl_.pagination_.paging_;
}
void GetDictionaryDeviceModelListRequest::set_allocated_paging(::keyapis::telemetry_control::v1::DictionaryDeviceModelPaging* paging) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_pagination();
  if (paging) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(paging);
    if (message_arena != submessage_arena) {
      paging = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, paging, submessage_arena);
    }
    set_has_paging();
    _impl_.pagination_.paging_ = paging;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.telemetry_control.v1.GetDictionaryDeviceModelListRequest.paging)
}
GetDictionaryDeviceModelListRequest::GetDictionaryDeviceModelListRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.GetDictionaryDeviceModelListRequest)
}
GetDictionaryDeviceModelListRequest::GetDictionaryDeviceModelListRequest(const GetDictionaryDeviceModelListRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetDictionaryDeviceModelListRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.filter_){nullptr}
    , decltype(_impl_.pagination_){}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.filter_ = new ::keyapis::telemetry_control::v1::DictionaryDeviceModelFilter(*from._impl_.filter_);
  }
  clear_has_pagination();
  switch (from.pagination_case()) {
    case kPaging: {
      _this->_internal_mutable_paging()->::keyapis::telemetry_control::v1::DictionaryDeviceModelPaging::MergeFrom(
          from._internal_paging());
      break;
    }
    case PAGINATION_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.GetDictionaryDeviceModelListRequest)
}

inline void GetDictionaryDeviceModelListRequest::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.filter_){nullptr}
    , decltype(_impl_.pagination_){}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_pagination();
}

GetDictionaryDeviceModelListRequest::~GetDictionaryDeviceModelListRequest() {
  // @@protoc_insertion_point(destructor:keyapis.telemetry_control.v1.GetDictionaryDeviceModelListRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void GetDictionaryDeviceModelListRequest::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.filter_;
  if (has_pagination()) {
    clear_pagination();
  }
}

void GetDictionaryDeviceModelListRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void GetDictionaryDeviceModelListRequest::clear_pagination() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelListRequest)
  switch (pagination_case()) {
    case kPaging: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.pagination_.paging_;
      }
      break;
    }
    case PAGINATION_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = PAGINATION_NOT_SET;
}


void GetDictionaryDeviceModelListRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelListRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    ABSL_DCHECK(_impl_.filter_ != nullptr);
    _impl_.filter_->Clear();
  }
  clear_pagination();
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* GetDictionaryDeviceModelListRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.telemetry_control.v1.DictionaryDeviceModelFilter filter = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_filter(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.telemetry_control.v1.DictionaryDeviceModelPaging paging = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_paging(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* GetDictionaryDeviceModelListRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelListRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.telemetry_control.v1.DictionaryDeviceModelFilter filter = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::filter(this),
        _Internal::filter(this).GetCachedSize(), target, stream);
  }

  // .keyapis.telemetry_control.v1.DictionaryDeviceModelPaging paging = 2;
  if (pagination_case() == kPaging) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::paging(this),
        _Internal::paging(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.GetDictionaryDeviceModelListRequest)
  return target;
}

::size_t GetDictionaryDeviceModelListRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelListRequest)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .keyapis.telemetry_control.v1.DictionaryDeviceModelFilter filter = 1;
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.filter_);
  }

  switch (pagination_case()) {
    // .keyapis.telemetry_control.v1.DictionaryDeviceModelPaging paging = 2;
    case kPaging: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.pagination_.paging_);
      break;
    }
    case PAGINATION_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GetDictionaryDeviceModelListRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetDictionaryDeviceModelListRequest*>(
      &from));
}

void GetDictionaryDeviceModelListRequest::MergeFrom(const GetDictionaryDeviceModelListRequest& from) {
  GetDictionaryDeviceModelListRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelListRequest)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_internal_mutable_filter()->::keyapis::telemetry_control::v1::DictionaryDeviceModelFilter::MergeFrom(
        from._internal_filter());
  }
  switch (from.pagination_case()) {
    case kPaging: {
      _this->_internal_mutable_paging()->::keyapis::telemetry_control::v1::DictionaryDeviceModelPaging::MergeFrom(
          from._internal_paging());
      break;
    }
    case PAGINATION_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetDictionaryDeviceModelListRequest::CopyFrom(const GetDictionaryDeviceModelListRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelListRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetDictionaryDeviceModelListRequest::IsInitialized() const {
  return true;
}

void GetDictionaryDeviceModelListRequest::InternalSwap(GetDictionaryDeviceModelListRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  swap(_impl_.filter_, other->_impl_.filter_);
  swap(_impl_.pagination_, other->_impl_.pagination_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string GetDictionaryDeviceModelListRequest::GetTypeName() const {
  return "keyapis.telemetry_control.v1.GetDictionaryDeviceModelListRequest";
}

// ===================================================================

class GetDictionaryMrfListRequest::_Internal {
 public:
};

GetDictionaryMrfListRequest::GetDictionaryMrfListRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.GetDictionaryMrfListRequest)
}
GetDictionaryMrfListRequest::GetDictionaryMrfListRequest(const GetDictionaryMrfListRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.GetDictionaryMrfListRequest)
}

inline void GetDictionaryMrfListRequest::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

GetDictionaryMrfListRequest::~GetDictionaryMrfListRequest() {
  // @@protoc_insertion_point(destructor:keyapis.telemetry_control.v1.GetDictionaryMrfListRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void GetDictionaryMrfListRequest::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
}

void GetDictionaryMrfListRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void GetDictionaryMrfListRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.GetDictionaryMrfListRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* GetDictionaryMrfListRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* GetDictionaryMrfListRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.GetDictionaryMrfListRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.GetDictionaryMrfListRequest)
  return target;
}

::size_t GetDictionaryMrfListRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.GetDictionaryMrfListRequest)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GetDictionaryMrfListRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetDictionaryMrfListRequest*>(
      &from));
}

void GetDictionaryMrfListRequest::MergeFrom(const GetDictionaryMrfListRequest& from) {
  GetDictionaryMrfListRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.telemetry_control.v1.GetDictionaryMrfListRequest)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetDictionaryMrfListRequest::CopyFrom(const GetDictionaryMrfListRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.telemetry_control.v1.GetDictionaryMrfListRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetDictionaryMrfListRequest::IsInitialized() const {
  return true;
}

void GetDictionaryMrfListRequest::InternalSwap(GetDictionaryMrfListRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string GetDictionaryMrfListRequest::GetTypeName() const {
  return "keyapis.telemetry_control.v1.GetDictionaryMrfListRequest";
}

// ===================================================================

class GetDictionaryRfListRequest::_Internal {
 public:
};

GetDictionaryRfListRequest::GetDictionaryRfListRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.GetDictionaryRfListRequest)
}
GetDictionaryRfListRequest::GetDictionaryRfListRequest(const GetDictionaryRfListRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.GetDictionaryRfListRequest)
}

inline void GetDictionaryRfListRequest::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

GetDictionaryRfListRequest::~GetDictionaryRfListRequest() {
  // @@protoc_insertion_point(destructor:keyapis.telemetry_control.v1.GetDictionaryRfListRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void GetDictionaryRfListRequest::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
}

void GetDictionaryRfListRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void GetDictionaryRfListRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.GetDictionaryRfListRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* GetDictionaryRfListRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* GetDictionaryRfListRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.GetDictionaryRfListRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.GetDictionaryRfListRequest)
  return target;
}

::size_t GetDictionaryRfListRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.GetDictionaryRfListRequest)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GetDictionaryRfListRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetDictionaryRfListRequest*>(
      &from));
}

void GetDictionaryRfListRequest::MergeFrom(const GetDictionaryRfListRequest& from) {
  GetDictionaryRfListRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.telemetry_control.v1.GetDictionaryRfListRequest)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetDictionaryRfListRequest::CopyFrom(const GetDictionaryRfListRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.telemetry_control.v1.GetDictionaryRfListRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetDictionaryRfListRequest::IsInitialized() const {
  return true;
}

void GetDictionaryRfListRequest::InternalSwap(GetDictionaryRfListRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string GetDictionaryRfListRequest::GetTypeName() const {
  return "keyapis.telemetry_control.v1.GetDictionaryRfListRequest";
}

// ===================================================================

class DictionaryDeviceModelPaging::_Internal {
 public:
};

DictionaryDeviceModelPaging::DictionaryDeviceModelPaging(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.DictionaryDeviceModelPaging)
}
DictionaryDeviceModelPaging::DictionaryDeviceModelPaging(const DictionaryDeviceModelPaging& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.DictionaryDeviceModelPaging)
}

inline void DictionaryDeviceModelPaging::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.order_by_type_) { 0 }

    , decltype(_impl_.direction_type_) { 0 }

    , decltype(_impl_.limit_) { 0 }

    , decltype(_impl_.offset_) { 0 }

    , /*decltype(_impl_._cached_size_)*/{}
  };
}

DictionaryDeviceModelPaging::~DictionaryDeviceModelPaging() {
  // @@protoc_insertion_point(destructor:keyapis.telemetry_control.v1.DictionaryDeviceModelPaging)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void DictionaryDeviceModelPaging::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
}

void DictionaryDeviceModelPaging::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void DictionaryDeviceModelPaging::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.DictionaryDeviceModelPaging)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&_impl_.order_by_type_, 0, static_cast<::size_t>(
      reinterpret_cast<char*>(&_impl_.offset_) -
      reinterpret_cast<char*>(&_impl_.order_by_type_)) + sizeof(_impl_.offset_));
  _internal_metadata_.Clear<std::string>();
}

const char* DictionaryDeviceModelPaging::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.telemetry_control.v1.DictionaryDeviceModelPaging.OrderByType order_by_type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_order_by_type(static_cast<::keyapis::telemetry_control::v1::DictionaryDeviceModelPaging_OrderByType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.telemetry_control.v1.DictionaryDeviceModelPaging.DirectionType direction_type = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_direction_type(static_cast<::keyapis::telemetry_control::v1::DictionaryDeviceModelPaging_DirectionType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 limit = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
          _impl_.limit_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 offset = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
          _impl_.offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* DictionaryDeviceModelPaging::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.DictionaryDeviceModelPaging)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.telemetry_control.v1.DictionaryDeviceModelPaging.OrderByType order_by_type = 1;
  if (this->_internal_order_by_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        1, this->_internal_order_by_type(), target);
  }

  // .keyapis.telemetry_control.v1.DictionaryDeviceModelPaging.DirectionType direction_type = 2;
  if (this->_internal_direction_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        2, this->_internal_direction_type(), target);
  }

  // int32 limit = 3;
  if (this->_internal_limit() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        3, this->_internal_limit(), target);
  }

  // int32 offset = 4;
  if (this->_internal_offset() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        4, this->_internal_offset(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.DictionaryDeviceModelPaging)
  return target;
}

::size_t DictionaryDeviceModelPaging::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.DictionaryDeviceModelPaging)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .keyapis.telemetry_control.v1.DictionaryDeviceModelPaging.OrderByType order_by_type = 1;
  if (this->_internal_order_by_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_order_by_type());
  }

  // .keyapis.telemetry_control.v1.DictionaryDeviceModelPaging.DirectionType direction_type = 2;
  if (this->_internal_direction_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_direction_type());
  }

  // int32 limit = 3;
  if (this->_internal_limit() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_limit());
  }

  // int32 offset = 4;
  if (this->_internal_offset() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_offset());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void DictionaryDeviceModelPaging::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const DictionaryDeviceModelPaging*>(
      &from));
}

void DictionaryDeviceModelPaging::MergeFrom(const DictionaryDeviceModelPaging& from) {
  DictionaryDeviceModelPaging* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.telemetry_control.v1.DictionaryDeviceModelPaging)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_order_by_type() != 0) {
    _this->_internal_set_order_by_type(from._internal_order_by_type());
  }
  if (from._internal_direction_type() != 0) {
    _this->_internal_set_direction_type(from._internal_direction_type());
  }
  if (from._internal_limit() != 0) {
    _this->_internal_set_limit(from._internal_limit());
  }
  if (from._internal_offset() != 0) {
    _this->_internal_set_offset(from._internal_offset());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void DictionaryDeviceModelPaging::CopyFrom(const DictionaryDeviceModelPaging& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.telemetry_control.v1.DictionaryDeviceModelPaging)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DictionaryDeviceModelPaging::IsInitialized() const {
  return true;
}

void DictionaryDeviceModelPaging::InternalSwap(DictionaryDeviceModelPaging* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(DictionaryDeviceModelPaging, _impl_.offset_)
      + sizeof(DictionaryDeviceModelPaging::_impl_.offset_)
      - PROTOBUF_FIELD_OFFSET(DictionaryDeviceModelPaging, _impl_.order_by_type_)>(
          reinterpret_cast<char*>(&_impl_.order_by_type_),
          reinterpret_cast<char*>(&other->_impl_.order_by_type_));
}

std::string DictionaryDeviceModelPaging::GetTypeName() const {
  return "keyapis.telemetry_control.v1.DictionaryDeviceModelPaging";
}

// ===================================================================

class DictionaryDeviceModelFilter::_Internal {
 public:
};

DictionaryDeviceModelFilter::DictionaryDeviceModelFilter(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.DictionaryDeviceModelFilter)
}
DictionaryDeviceModelFilter::DictionaryDeviceModelFilter(const DictionaryDeviceModelFilter& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  DictionaryDeviceModelFilter* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.titles_){from._impl_.titles_}
    , decltype(_impl_.model_kinds_){from._impl_.model_kinds_}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.DictionaryDeviceModelFilter)
}

inline void DictionaryDeviceModelFilter::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.titles_){arena}
    , decltype(_impl_.model_kinds_){arena}
    , /*decltype(_impl_._cached_size_)*/{}
  };
}

DictionaryDeviceModelFilter::~DictionaryDeviceModelFilter() {
  // @@protoc_insertion_point(destructor:keyapis.telemetry_control.v1.DictionaryDeviceModelFilter)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void DictionaryDeviceModelFilter::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _internal_mutable_titles()->~RepeatedPtrField();
  _internal_mutable_model_kinds()->~RepeatedPtrField();
}

void DictionaryDeviceModelFilter::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void DictionaryDeviceModelFilter::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.DictionaryDeviceModelFilter)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_mutable_titles()->Clear();
  _internal_mutable_model_kinds()->Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* DictionaryDeviceModelFilter::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated string titles = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_titles();
            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(ptr);
            CHK_(::_pbi::VerifyUTF8(str, nullptr));
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // repeated string model_kinds = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_model_kinds();
            ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
            CHK_(ptr);
            CHK_(::_pbi::VerifyUTF8(str, nullptr));
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* DictionaryDeviceModelFilter::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.DictionaryDeviceModelFilter)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated string titles = 1;
  for (int i = 0, n = this->_internal_titles_size(); i < n; ++i) {
    const auto& s = this->_internal_titles(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        s.data(), static_cast<int>(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.telemetry_control.v1.DictionaryDeviceModelFilter.titles");
    target = stream->WriteString(1, s, target);
  }

  // repeated string model_kinds = 2;
  for (int i = 0, n = this->_internal_model_kinds_size(); i < n; ++i) {
    const auto& s = this->_internal_model_kinds(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        s.data(), static_cast<int>(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.telemetry_control.v1.DictionaryDeviceModelFilter.model_kinds");
    target = stream->WriteString(2, s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.DictionaryDeviceModelFilter)
  return target;
}

::size_t DictionaryDeviceModelFilter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.DictionaryDeviceModelFilter)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated string titles = 1;
  total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_internal_titles().size());
  for (int i = 0, n = _internal_titles().size(); i < n; ++i) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        _internal_titles().Get(i));
  }

  // repeated string model_kinds = 2;
  total_size += 1 * ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_internal_model_kinds().size());
  for (int i = 0, n = _internal_model_kinds().size(); i < n; ++i) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        _internal_model_kinds().Get(i));
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void DictionaryDeviceModelFilter::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const DictionaryDeviceModelFilter*>(
      &from));
}

void DictionaryDeviceModelFilter::MergeFrom(const DictionaryDeviceModelFilter& from) {
  DictionaryDeviceModelFilter* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.telemetry_control.v1.DictionaryDeviceModelFilter)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_mutable_titles()->MergeFrom(from._internal_titles());
  _this->_internal_mutable_model_kinds()->MergeFrom(from._internal_model_kinds());
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void DictionaryDeviceModelFilter::CopyFrom(const DictionaryDeviceModelFilter& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.telemetry_control.v1.DictionaryDeviceModelFilter)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DictionaryDeviceModelFilter::IsInitialized() const {
  return true;
}

void DictionaryDeviceModelFilter::InternalSwap(DictionaryDeviceModelFilter* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _internal_mutable_titles()->InternalSwap(
      other->_internal_mutable_titles());
  _internal_mutable_model_kinds()->InternalSwap(
      other->_internal_mutable_model_kinds());
}

std::string DictionaryDeviceModelFilter::GetTypeName() const {
  return "keyapis.telemetry_control.v1.DictionaryDeviceModelFilter";
}

// ===================================================================

class GetDictionaryDeviceModelListResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::telemetry_control::v1::GetDictionaryDeviceModelListResponse, _impl_._oneof_case_);
  static const ::keyapis::telemetry_control::v1::DictionaryDeviceModel& data(const GetDictionaryDeviceModelListResponse* msg);
};

const ::keyapis::telemetry_control::v1::DictionaryDeviceModel&
GetDictionaryDeviceModelListResponse::_Internal::data(const GetDictionaryDeviceModelListResponse* msg) {
  return *msg->_impl_.type_.data_;
}
void GetDictionaryDeviceModelListResponse::set_allocated_data(::keyapis::telemetry_control::v1::DictionaryDeviceModel* data) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (data) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(data);
    if (message_arena != submessage_arena) {
      data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, data, submessage_arena);
    }
    set_has_data();
    _impl_.type_.data_ = data;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.telemetry_control.v1.GetDictionaryDeviceModelListResponse.data)
}
GetDictionaryDeviceModelListResponse::GetDictionaryDeviceModelListResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.GetDictionaryDeviceModelListResponse)
}
GetDictionaryDeviceModelListResponse::GetDictionaryDeviceModelListResponse(const GetDictionaryDeviceModelListResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetDictionaryDeviceModelListResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_type();
  switch (from.type_case()) {
    case kData: {
      _this->_internal_mutable_data()->::keyapis::telemetry_control::v1::DictionaryDeviceModel::MergeFrom(
          from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.GetDictionaryDeviceModelListResponse)
}

inline void GetDictionaryDeviceModelListResponse::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_type();
}

GetDictionaryDeviceModelListResponse::~GetDictionaryDeviceModelListResponse() {
  // @@protoc_insertion_point(destructor:keyapis.telemetry_control.v1.GetDictionaryDeviceModelListResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void GetDictionaryDeviceModelListResponse::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_type()) {
    clear_type();
  }
}

void GetDictionaryDeviceModelListResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void GetDictionaryDeviceModelListResponse::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelListResponse)
  switch (type_case()) {
    case kData: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.type_.data_;
      }
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}


void GetDictionaryDeviceModelListResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelListResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_type();
  _internal_metadata_.Clear<std::string>();
}

const char* GetDictionaryDeviceModelListResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.telemetry_control.v1.DictionaryDeviceModel data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_data(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* GetDictionaryDeviceModelListResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelListResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.telemetry_control.v1.DictionaryDeviceModel data = 1;
  if (type_case() == kData) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::data(this),
        _Internal::data(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.GetDictionaryDeviceModelListResponse)
  return target;
}

::size_t GetDictionaryDeviceModelListResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelListResponse)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (type_case()) {
    // .keyapis.telemetry_control.v1.DictionaryDeviceModel data = 1;
    case kData: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.data_);
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GetDictionaryDeviceModelListResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetDictionaryDeviceModelListResponse*>(
      &from));
}

void GetDictionaryDeviceModelListResponse::MergeFrom(const GetDictionaryDeviceModelListResponse& from) {
  GetDictionaryDeviceModelListResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelListResponse)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.type_case()) {
    case kData: {
      _this->_internal_mutable_data()->::keyapis::telemetry_control::v1::DictionaryDeviceModel::MergeFrom(
          from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetDictionaryDeviceModelListResponse::CopyFrom(const GetDictionaryDeviceModelListResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelListResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetDictionaryDeviceModelListResponse::IsInitialized() const {
  return true;
}

void GetDictionaryDeviceModelListResponse::InternalSwap(GetDictionaryDeviceModelListResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.type_, other->_impl_.type_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string GetDictionaryDeviceModelListResponse::GetTypeName() const {
  return "keyapis.telemetry_control.v1.GetDictionaryDeviceModelListResponse";
}

// ===================================================================

class GetDictionaryMrfListResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::telemetry_control::v1::GetDictionaryMrfListResponse, _impl_._oneof_case_);
  static const ::keyapis::telemetry_control::v1::DictionaryMrf& data(const GetDictionaryMrfListResponse* msg);
};

const ::keyapis::telemetry_control::v1::DictionaryMrf&
GetDictionaryMrfListResponse::_Internal::data(const GetDictionaryMrfListResponse* msg) {
  return *msg->_impl_.type_.data_;
}
void GetDictionaryMrfListResponse::set_allocated_data(::keyapis::telemetry_control::v1::DictionaryMrf* data) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (data) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(data);
    if (message_arena != submessage_arena) {
      data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, data, submessage_arena);
    }
    set_has_data();
    _impl_.type_.data_ = data;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.telemetry_control.v1.GetDictionaryMrfListResponse.data)
}
GetDictionaryMrfListResponse::GetDictionaryMrfListResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.GetDictionaryMrfListResponse)
}
GetDictionaryMrfListResponse::GetDictionaryMrfListResponse(const GetDictionaryMrfListResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetDictionaryMrfListResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_type();
  switch (from.type_case()) {
    case kData: {
      _this->_internal_mutable_data()->::keyapis::telemetry_control::v1::DictionaryMrf::MergeFrom(
          from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.GetDictionaryMrfListResponse)
}

inline void GetDictionaryMrfListResponse::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_type();
}

GetDictionaryMrfListResponse::~GetDictionaryMrfListResponse() {
  // @@protoc_insertion_point(destructor:keyapis.telemetry_control.v1.GetDictionaryMrfListResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void GetDictionaryMrfListResponse::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_type()) {
    clear_type();
  }
}

void GetDictionaryMrfListResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void GetDictionaryMrfListResponse::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.telemetry_control.v1.GetDictionaryMrfListResponse)
  switch (type_case()) {
    case kData: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.type_.data_;
      }
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}


void GetDictionaryMrfListResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.GetDictionaryMrfListResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_type();
  _internal_metadata_.Clear<std::string>();
}

const char* GetDictionaryMrfListResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.telemetry_control.v1.DictionaryMrf data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_data(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* GetDictionaryMrfListResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.GetDictionaryMrfListResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.telemetry_control.v1.DictionaryMrf data = 1;
  if (type_case() == kData) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::data(this),
        _Internal::data(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.GetDictionaryMrfListResponse)
  return target;
}

::size_t GetDictionaryMrfListResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.GetDictionaryMrfListResponse)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (type_case()) {
    // .keyapis.telemetry_control.v1.DictionaryMrf data = 1;
    case kData: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.data_);
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GetDictionaryMrfListResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetDictionaryMrfListResponse*>(
      &from));
}

void GetDictionaryMrfListResponse::MergeFrom(const GetDictionaryMrfListResponse& from) {
  GetDictionaryMrfListResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.telemetry_control.v1.GetDictionaryMrfListResponse)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.type_case()) {
    case kData: {
      _this->_internal_mutable_data()->::keyapis::telemetry_control::v1::DictionaryMrf::MergeFrom(
          from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetDictionaryMrfListResponse::CopyFrom(const GetDictionaryMrfListResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.telemetry_control.v1.GetDictionaryMrfListResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetDictionaryMrfListResponse::IsInitialized() const {
  return true;
}

void GetDictionaryMrfListResponse::InternalSwap(GetDictionaryMrfListResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.type_, other->_impl_.type_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string GetDictionaryMrfListResponse::GetTypeName() const {
  return "keyapis.telemetry_control.v1.GetDictionaryMrfListResponse";
}

// ===================================================================

class DictionaryMrf::_Internal {
 public:
  using HasBits = decltype(std::declval<DictionaryMrf>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(DictionaryMrf, _impl_._has_bits_);
  static const ::PROTOBUF_NAMESPACE_ID::Timestamp& created_at(const DictionaryMrf* msg);
  static void set_has_created_at(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Timestamp& changed_at(const DictionaryMrf* msg);
  static void set_has_changed_at(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::StringValue& title(const DictionaryMrf* msg);
  static void set_has_title(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::StringValue& code(const DictionaryMrf* msg);
  static void set_has_code(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
};

const ::PROTOBUF_NAMESPACE_ID::Timestamp&
DictionaryMrf::_Internal::created_at(const DictionaryMrf* msg) {
  return *msg->_impl_.created_at_;
}
const ::PROTOBUF_NAMESPACE_ID::Timestamp&
DictionaryMrf::_Internal::changed_at(const DictionaryMrf* msg) {
  return *msg->_impl_.changed_at_;
}
const ::PROTOBUF_NAMESPACE_ID::StringValue&
DictionaryMrf::_Internal::title(const DictionaryMrf* msg) {
  return *msg->_impl_.title_;
}
const ::PROTOBUF_NAMESPACE_ID::StringValue&
DictionaryMrf::_Internal::code(const DictionaryMrf* msg) {
  return *msg->_impl_.code_;
}
void DictionaryMrf::clear_created_at() {
  if (_impl_.created_at_ != nullptr) _impl_.created_at_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
void DictionaryMrf::clear_changed_at() {
  if (_impl_.changed_at_ != nullptr) _impl_.changed_at_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
void DictionaryMrf::clear_title() {
  if (_impl_.title_ != nullptr) _impl_.title_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
void DictionaryMrf::clear_code() {
  if (_impl_.code_ != nullptr) _impl_.code_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
DictionaryMrf::DictionaryMrf(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.DictionaryMrf)
}
DictionaryMrf::DictionaryMrf(const DictionaryMrf& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  DictionaryMrf* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.created_at_){nullptr}
    , decltype(_impl_.changed_at_){nullptr}
    , decltype(_impl_.title_){nullptr}
    , decltype(_impl_.code_){nullptr}
    , decltype(_impl_.id_) {}
  };

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.created_at_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.created_at_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) {
    _this->_impl_.changed_at_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.changed_at_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000004u) != 0) {
    _this->_impl_.title_ = new ::PROTOBUF_NAMESPACE_ID::StringValue(*from._impl_.title_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000008u) != 0) {
    _this->_impl_.code_ = new ::PROTOBUF_NAMESPACE_ID::StringValue(*from._impl_.code_);
  }
  _this->_impl_.id_ = from._impl_.id_;
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.DictionaryMrf)
}

inline void DictionaryMrf::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.created_at_){nullptr}
    , decltype(_impl_.changed_at_){nullptr}
    , decltype(_impl_.title_){nullptr}
    , decltype(_impl_.code_){nullptr}
    , decltype(_impl_.id_) { 0 }

  };
}

DictionaryMrf::~DictionaryMrf() {
  // @@protoc_insertion_point(destructor:keyapis.telemetry_control.v1.DictionaryMrf)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void DictionaryMrf::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.created_at_;
  if (this != internal_default_instance()) delete _impl_.changed_at_;
  if (this != internal_default_instance()) delete _impl_.title_;
  if (this != internal_default_instance()) delete _impl_.code_;
}

void DictionaryMrf::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void DictionaryMrf::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.DictionaryMrf)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(_impl_.created_at_ != nullptr);
      _impl_.created_at_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      ABSL_DCHECK(_impl_.changed_at_ != nullptr);
      _impl_.changed_at_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      ABSL_DCHECK(_impl_.title_ != nullptr);
      _impl_.title_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      ABSL_DCHECK(_impl_.code_ != nullptr);
      _impl_.code_->Clear();
    }
  }
  _impl_.id_ = 0;
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* DictionaryMrf::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int32 id = 1 [(.google.api.field_behavior) = OUTPUT_ONLY];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Timestamp created_at = 2 [(.google.api.field_behavior) = OUTPUT_ONLY];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_created_at(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Timestamp changed_at = 3 [(.google.api.field_behavior) = OUTPUT_ONLY];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_changed_at(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.StringValue title = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_title(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.StringValue code = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_code(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* DictionaryMrf::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.DictionaryMrf)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 id = 1 [(.google.api.field_behavior) = OUTPUT_ONLY];
  if (this->_internal_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        1, this->_internal_id(), target);
  }

  cached_has_bits = _impl_._has_bits_[0];
  // .google.protobuf.Timestamp created_at = 2 [(.google.api.field_behavior) = OUTPUT_ONLY];
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::created_at(this),
        _Internal::created_at(this).GetCachedSize(), target, stream);
  }

  // .google.protobuf.Timestamp changed_at = 3 [(.google.api.field_behavior) = OUTPUT_ONLY];
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, _Internal::changed_at(this),
        _Internal::changed_at(this).GetCachedSize(), target, stream);
  }

  // .google.protobuf.StringValue title = 4;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, _Internal::title(this),
        _Internal::title(this).GetCachedSize(), target, stream);
  }

  // .google.protobuf.StringValue code = 5;
  if (cached_has_bits & 0x00000008u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, _Internal::code(this),
        _Internal::code(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.DictionaryMrf)
  return target;
}

::size_t DictionaryMrf::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.DictionaryMrf)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    // .google.protobuf.Timestamp created_at = 2 [(.google.api.field_behavior) = OUTPUT_ONLY];
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.created_at_);
    }

    // .google.protobuf.Timestamp changed_at = 3 [(.google.api.field_behavior) = OUTPUT_ONLY];
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.changed_at_);
    }

    // .google.protobuf.StringValue title = 4;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.title_);
    }

    // .google.protobuf.StringValue code = 5;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.code_);
    }

  }
  // int32 id = 1 [(.google.api.field_behavior) = OUTPUT_ONLY];
  if (this->_internal_id() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_id());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void DictionaryMrf::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const DictionaryMrf*>(
      &from));
}

void DictionaryMrf::MergeFrom(const DictionaryMrf& from) {
  DictionaryMrf* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.telemetry_control.v1.DictionaryMrf)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_mutable_created_at()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
          from._internal_created_at());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_internal_mutable_changed_at()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
          from._internal_changed_at());
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_internal_mutable_title()->::PROTOBUF_NAMESPACE_ID::StringValue::MergeFrom(
          from._internal_title());
    }
    if (cached_has_bits & 0x00000008u) {
      _this->_internal_mutable_code()->::PROTOBUF_NAMESPACE_ID::StringValue::MergeFrom(
          from._internal_code());
    }
  }
  if (from._internal_id() != 0) {
    _this->_internal_set_id(from._internal_id());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void DictionaryMrf::CopyFrom(const DictionaryMrf& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.telemetry_control.v1.DictionaryMrf)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DictionaryMrf::IsInitialized() const {
  return true;
}

void DictionaryMrf::InternalSwap(DictionaryMrf* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(DictionaryMrf, _impl_.id_)
      + sizeof(DictionaryMrf::_impl_.id_)
      - PROTOBUF_FIELD_OFFSET(DictionaryMrf, _impl_.created_at_)>(
          reinterpret_cast<char*>(&_impl_.created_at_),
          reinterpret_cast<char*>(&other->_impl_.created_at_));
}

std::string DictionaryMrf::GetTypeName() const {
  return "keyapis.telemetry_control.v1.DictionaryMrf";
}

// ===================================================================

class GetDictionaryRfListResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::telemetry_control::v1::GetDictionaryRfListResponse, _impl_._oneof_case_);
  static const ::keyapis::telemetry_control::v1::DictionaryRf& data(const GetDictionaryRfListResponse* msg);
};

const ::keyapis::telemetry_control::v1::DictionaryRf&
GetDictionaryRfListResponse::_Internal::data(const GetDictionaryRfListResponse* msg) {
  return *msg->_impl_.type_.data_;
}
void GetDictionaryRfListResponse::set_allocated_data(::keyapis::telemetry_control::v1::DictionaryRf* data) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (data) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(data);
    if (message_arena != submessage_arena) {
      data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, data, submessage_arena);
    }
    set_has_data();
    _impl_.type_.data_ = data;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.telemetry_control.v1.GetDictionaryRfListResponse.data)
}
GetDictionaryRfListResponse::GetDictionaryRfListResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.GetDictionaryRfListResponse)
}
GetDictionaryRfListResponse::GetDictionaryRfListResponse(const GetDictionaryRfListResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetDictionaryRfListResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_type();
  switch (from.type_case()) {
    case kData: {
      _this->_internal_mutable_data()->::keyapis::telemetry_control::v1::DictionaryRf::MergeFrom(
          from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.GetDictionaryRfListResponse)
}

inline void GetDictionaryRfListResponse::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_type();
}

GetDictionaryRfListResponse::~GetDictionaryRfListResponse() {
  // @@protoc_insertion_point(destructor:keyapis.telemetry_control.v1.GetDictionaryRfListResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void GetDictionaryRfListResponse::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_type()) {
    clear_type();
  }
}

void GetDictionaryRfListResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void GetDictionaryRfListResponse::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.telemetry_control.v1.GetDictionaryRfListResponse)
  switch (type_case()) {
    case kData: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.type_.data_;
      }
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}


void GetDictionaryRfListResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.GetDictionaryRfListResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_type();
  _internal_metadata_.Clear<std::string>();
}

const char* GetDictionaryRfListResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.telemetry_control.v1.DictionaryRf data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_data(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* GetDictionaryRfListResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.GetDictionaryRfListResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.telemetry_control.v1.DictionaryRf data = 1;
  if (type_case() == kData) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::data(this),
        _Internal::data(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.GetDictionaryRfListResponse)
  return target;
}

::size_t GetDictionaryRfListResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.GetDictionaryRfListResponse)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (type_case()) {
    // .keyapis.telemetry_control.v1.DictionaryRf data = 1;
    case kData: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.data_);
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GetDictionaryRfListResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetDictionaryRfListResponse*>(
      &from));
}

void GetDictionaryRfListResponse::MergeFrom(const GetDictionaryRfListResponse& from) {
  GetDictionaryRfListResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.telemetry_control.v1.GetDictionaryRfListResponse)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.type_case()) {
    case kData: {
      _this->_internal_mutable_data()->::keyapis::telemetry_control::v1::DictionaryRf::MergeFrom(
          from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetDictionaryRfListResponse::CopyFrom(const GetDictionaryRfListResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.telemetry_control.v1.GetDictionaryRfListResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetDictionaryRfListResponse::IsInitialized() const {
  return true;
}

void GetDictionaryRfListResponse::InternalSwap(GetDictionaryRfListResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.type_, other->_impl_.type_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string GetDictionaryRfListResponse::GetTypeName() const {
  return "keyapis.telemetry_control.v1.GetDictionaryRfListResponse";
}

// ===================================================================

class DictionaryPermission::_Internal {
 public:
};

DictionaryPermission::DictionaryPermission(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.DictionaryPermission)
}
DictionaryPermission::DictionaryPermission(const DictionaryPermission& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.DictionaryPermission)
}

inline void DictionaryPermission::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.permission_type_) { 0 }

    , /*decltype(_impl_._cached_size_)*/{}
  };
}

DictionaryPermission::~DictionaryPermission() {
  // @@protoc_insertion_point(destructor:keyapis.telemetry_control.v1.DictionaryPermission)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void DictionaryPermission::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
}

void DictionaryPermission::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void DictionaryPermission::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.DictionaryPermission)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.permission_type_ = 0;
  _internal_metadata_.Clear<std::string>();
}

const char* DictionaryPermission::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.telemetry_control.v1.DictionaryPermission.PermissionType permission_type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_permission_type(static_cast<::keyapis::telemetry_control::v1::DictionaryPermission_PermissionType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* DictionaryPermission::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.DictionaryPermission)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.telemetry_control.v1.DictionaryPermission.PermissionType permission_type = 1;
  if (this->_internal_permission_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        1, this->_internal_permission_type(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.DictionaryPermission)
  return target;
}

::size_t DictionaryPermission::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.DictionaryPermission)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .keyapis.telemetry_control.v1.DictionaryPermission.PermissionType permission_type = 1;
  if (this->_internal_permission_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_permission_type());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void DictionaryPermission::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const DictionaryPermission*>(
      &from));
}

void DictionaryPermission::MergeFrom(const DictionaryPermission& from) {
  DictionaryPermission* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.telemetry_control.v1.DictionaryPermission)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_permission_type() != 0) {
    _this->_internal_set_permission_type(from._internal_permission_type());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void DictionaryPermission::CopyFrom(const DictionaryPermission& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.telemetry_control.v1.DictionaryPermission)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DictionaryPermission::IsInitialized() const {
  return true;
}

void DictionaryPermission::InternalSwap(DictionaryPermission* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.permission_type_, other->_impl_.permission_type_);
}

std::string DictionaryPermission::GetTypeName() const {
  return "keyapis.telemetry_control.v1.DictionaryPermission";
}

// ===================================================================

class DictionaryRf::_Internal {
 public:
  using HasBits = decltype(std::declval<DictionaryRf>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(DictionaryRf, _impl_._has_bits_);
  static const ::PROTOBUF_NAMESPACE_ID::Timestamp& created_at(const DictionaryRf* msg);
  static void set_has_created_at(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Timestamp& changed_at(const DictionaryRf* msg);
  static void set_has_changed_at(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::StringValue& title(const DictionaryRf* msg);
  static void set_has_title(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::StringValue& code(const DictionaryRf* msg);
  static void set_has_code(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
};

const ::PROTOBUF_NAMESPACE_ID::Timestamp&
DictionaryRf::_Internal::created_at(const DictionaryRf* msg) {
  return *msg->_impl_.created_at_;
}
const ::PROTOBUF_NAMESPACE_ID::Timestamp&
DictionaryRf::_Internal::changed_at(const DictionaryRf* msg) {
  return *msg->_impl_.changed_at_;
}
const ::PROTOBUF_NAMESPACE_ID::StringValue&
DictionaryRf::_Internal::title(const DictionaryRf* msg) {
  return *msg->_impl_.title_;
}
const ::PROTOBUF_NAMESPACE_ID::StringValue&
DictionaryRf::_Internal::code(const DictionaryRf* msg) {
  return *msg->_impl_.code_;
}
void DictionaryRf::clear_created_at() {
  if (_impl_.created_at_ != nullptr) _impl_.created_at_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
void DictionaryRf::clear_changed_at() {
  if (_impl_.changed_at_ != nullptr) _impl_.changed_at_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
void DictionaryRf::clear_title() {
  if (_impl_.title_ != nullptr) _impl_.title_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
void DictionaryRf::clear_code() {
  if (_impl_.code_ != nullptr) _impl_.code_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
DictionaryRf::DictionaryRf(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.DictionaryRf)
}
DictionaryRf::DictionaryRf(const DictionaryRf& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  DictionaryRf* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.created_at_){nullptr}
    , decltype(_impl_.changed_at_){nullptr}
    , decltype(_impl_.title_){nullptr}
    , decltype(_impl_.code_){nullptr}
    , decltype(_impl_.id_) {}

    , decltype(_impl_.mrf_id_) {}
  };

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.created_at_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.created_at_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) {
    _this->_impl_.changed_at_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.changed_at_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000004u) != 0) {
    _this->_impl_.title_ = new ::PROTOBUF_NAMESPACE_ID::StringValue(*from._impl_.title_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000008u) != 0) {
    _this->_impl_.code_ = new ::PROTOBUF_NAMESPACE_ID::StringValue(*from._impl_.code_);
  }
  ::memcpy(&_impl_.id_, &from._impl_.id_,
    static_cast<::size_t>(reinterpret_cast<char*>(&_impl_.mrf_id_) -
    reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.mrf_id_));
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.DictionaryRf)
}

inline void DictionaryRf::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.created_at_){nullptr}
    , decltype(_impl_.changed_at_){nullptr}
    , decltype(_impl_.title_){nullptr}
    , decltype(_impl_.code_){nullptr}
    , decltype(_impl_.id_) { 0 }

    , decltype(_impl_.mrf_id_) { 0 }

  };
}

DictionaryRf::~DictionaryRf() {
  // @@protoc_insertion_point(destructor:keyapis.telemetry_control.v1.DictionaryRf)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void DictionaryRf::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.created_at_;
  if (this != internal_default_instance()) delete _impl_.changed_at_;
  if (this != internal_default_instance()) delete _impl_.title_;
  if (this != internal_default_instance()) delete _impl_.code_;
}

void DictionaryRf::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void DictionaryRf::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.DictionaryRf)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(_impl_.created_at_ != nullptr);
      _impl_.created_at_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      ABSL_DCHECK(_impl_.changed_at_ != nullptr);
      _impl_.changed_at_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      ABSL_DCHECK(_impl_.title_ != nullptr);
      _impl_.title_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      ABSL_DCHECK(_impl_.code_ != nullptr);
      _impl_.code_->Clear();
    }
  }
  ::memset(&_impl_.id_, 0, static_cast<::size_t>(
      reinterpret_cast<char*>(&_impl_.mrf_id_) -
      reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.mrf_id_));
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* DictionaryRf::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int32 id = 1 [(.google.api.field_behavior) = OUTPUT_ONLY];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Timestamp created_at = 2 [(.google.api.field_behavior) = OUTPUT_ONLY];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_created_at(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Timestamp changed_at = 3 [(.google.api.field_behavior) = OUTPUT_ONLY];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_changed_at(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.StringValue title = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_title(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.StringValue code = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_code(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 mrf_id = 6 [(.google.api.field_behavior) = REQUIRED];
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
          _impl_.mrf_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* DictionaryRf::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.DictionaryRf)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 id = 1 [(.google.api.field_behavior) = OUTPUT_ONLY];
  if (this->_internal_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        1, this->_internal_id(), target);
  }

  cached_has_bits = _impl_._has_bits_[0];
  // .google.protobuf.Timestamp created_at = 2 [(.google.api.field_behavior) = OUTPUT_ONLY];
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::created_at(this),
        _Internal::created_at(this).GetCachedSize(), target, stream);
  }

  // .google.protobuf.Timestamp changed_at = 3 [(.google.api.field_behavior) = OUTPUT_ONLY];
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, _Internal::changed_at(this),
        _Internal::changed_at(this).GetCachedSize(), target, stream);
  }

  // .google.protobuf.StringValue title = 4;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, _Internal::title(this),
        _Internal::title(this).GetCachedSize(), target, stream);
  }

  // .google.protobuf.StringValue code = 5;
  if (cached_has_bits & 0x00000008u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, _Internal::code(this),
        _Internal::code(this).GetCachedSize(), target, stream);
  }

  // int32 mrf_id = 6 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_mrf_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        6, this->_internal_mrf_id(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.DictionaryRf)
  return target;
}

::size_t DictionaryRf::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.DictionaryRf)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    // .google.protobuf.Timestamp created_at = 2 [(.google.api.field_behavior) = OUTPUT_ONLY];
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.created_at_);
    }

    // .google.protobuf.Timestamp changed_at = 3 [(.google.api.field_behavior) = OUTPUT_ONLY];
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.changed_at_);
    }

    // .google.protobuf.StringValue title = 4;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.title_);
    }

    // .google.protobuf.StringValue code = 5;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.code_);
    }

  }
  // int32 id = 1 [(.google.api.field_behavior) = OUTPUT_ONLY];
  if (this->_internal_id() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_id());
  }

  // int32 mrf_id = 6 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_mrf_id() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_mrf_id());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void DictionaryRf::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const DictionaryRf*>(
      &from));
}

void DictionaryRf::MergeFrom(const DictionaryRf& from) {
  DictionaryRf* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.telemetry_control.v1.DictionaryRf)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_mutable_created_at()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
          from._internal_created_at());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_internal_mutable_changed_at()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
          from._internal_changed_at());
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_internal_mutable_title()->::PROTOBUF_NAMESPACE_ID::StringValue::MergeFrom(
          from._internal_title());
    }
    if (cached_has_bits & 0x00000008u) {
      _this->_internal_mutable_code()->::PROTOBUF_NAMESPACE_ID::StringValue::MergeFrom(
          from._internal_code());
    }
  }
  if (from._internal_id() != 0) {
    _this->_internal_set_id(from._internal_id());
  }
  if (from._internal_mrf_id() != 0) {
    _this->_internal_set_mrf_id(from._internal_mrf_id());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void DictionaryRf::CopyFrom(const DictionaryRf& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.telemetry_control.v1.DictionaryRf)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DictionaryRf::IsInitialized() const {
  return true;
}

void DictionaryRf::InternalSwap(DictionaryRf* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(DictionaryRf, _impl_.mrf_id_)
      + sizeof(DictionaryRf::_impl_.mrf_id_)
      - PROTOBUF_FIELD_OFFSET(DictionaryRf, _impl_.created_at_)>(
          reinterpret_cast<char*>(&_impl_.created_at_),
          reinterpret_cast<char*>(&other->_impl_.created_at_));
}

std::string DictionaryRf::GetTypeName() const {
  return "keyapis.telemetry_control.v1.DictionaryRf";
}

// ===================================================================

class GetDictionaryDeviceModelCountRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<GetDictionaryDeviceModelCountRequest>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(GetDictionaryDeviceModelCountRequest, _impl_._has_bits_);
  static const ::keyapis::telemetry_control::v1::DictionaryDeviceModelFilter& filter(const GetDictionaryDeviceModelCountRequest* msg);
  static void set_has_filter(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::keyapis::telemetry_control::v1::DictionaryDeviceModelFilter&
GetDictionaryDeviceModelCountRequest::_Internal::filter(const GetDictionaryDeviceModelCountRequest* msg) {
  return *msg->_impl_.filter_;
}
GetDictionaryDeviceModelCountRequest::GetDictionaryDeviceModelCountRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.GetDictionaryDeviceModelCountRequest)
}
GetDictionaryDeviceModelCountRequest::GetDictionaryDeviceModelCountRequest(const GetDictionaryDeviceModelCountRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetDictionaryDeviceModelCountRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.filter_){nullptr}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.filter_ = new ::keyapis::telemetry_control::v1::DictionaryDeviceModelFilter(*from._impl_.filter_);
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.GetDictionaryDeviceModelCountRequest)
}

inline void GetDictionaryDeviceModelCountRequest::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.filter_){nullptr}
  };
}

GetDictionaryDeviceModelCountRequest::~GetDictionaryDeviceModelCountRequest() {
  // @@protoc_insertion_point(destructor:keyapis.telemetry_control.v1.GetDictionaryDeviceModelCountRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void GetDictionaryDeviceModelCountRequest::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.filter_;
}

void GetDictionaryDeviceModelCountRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void GetDictionaryDeviceModelCountRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelCountRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    ABSL_DCHECK(_impl_.filter_ != nullptr);
    _impl_.filter_->Clear();
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* GetDictionaryDeviceModelCountRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.telemetry_control.v1.DictionaryDeviceModelFilter filter = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_filter(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* GetDictionaryDeviceModelCountRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelCountRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.telemetry_control.v1.DictionaryDeviceModelFilter filter = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::filter(this),
        _Internal::filter(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.GetDictionaryDeviceModelCountRequest)
  return target;
}

::size_t GetDictionaryDeviceModelCountRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelCountRequest)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // .keyapis.telemetry_control.v1.DictionaryDeviceModelFilter filter = 1;
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.filter_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GetDictionaryDeviceModelCountRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetDictionaryDeviceModelCountRequest*>(
      &from));
}

void GetDictionaryDeviceModelCountRequest::MergeFrom(const GetDictionaryDeviceModelCountRequest& from) {
  GetDictionaryDeviceModelCountRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelCountRequest)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_internal_mutable_filter()->::keyapis::telemetry_control::v1::DictionaryDeviceModelFilter::MergeFrom(
        from._internal_filter());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetDictionaryDeviceModelCountRequest::CopyFrom(const GetDictionaryDeviceModelCountRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelCountRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetDictionaryDeviceModelCountRequest::IsInitialized() const {
  return true;
}

void GetDictionaryDeviceModelCountRequest::InternalSwap(GetDictionaryDeviceModelCountRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  swap(_impl_.filter_, other->_impl_.filter_);
}

std::string GetDictionaryDeviceModelCountRequest::GetTypeName() const {
  return "keyapis.telemetry_control.v1.GetDictionaryDeviceModelCountRequest";
}

// ===================================================================

class GetDictionaryDeviceModelCountResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::telemetry_control::v1::GetDictionaryDeviceModelCountResponse, _impl_._oneof_case_);
};

GetDictionaryDeviceModelCountResponse::GetDictionaryDeviceModelCountResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.GetDictionaryDeviceModelCountResponse)
}
GetDictionaryDeviceModelCountResponse::GetDictionaryDeviceModelCountResponse(const GetDictionaryDeviceModelCountResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetDictionaryDeviceModelCountResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_type();
  switch (from.type_case()) {
    case kData: {
      _this->_internal_set_data(from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.GetDictionaryDeviceModelCountResponse)
}

inline void GetDictionaryDeviceModelCountResponse::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_type();
}

GetDictionaryDeviceModelCountResponse::~GetDictionaryDeviceModelCountResponse() {
  // @@protoc_insertion_point(destructor:keyapis.telemetry_control.v1.GetDictionaryDeviceModelCountResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void GetDictionaryDeviceModelCountResponse::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_type()) {
    clear_type();
  }
}

void GetDictionaryDeviceModelCountResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void GetDictionaryDeviceModelCountResponse::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelCountResponse)
  switch (type_case()) {
    case kData: {
      // No need to clear
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}


void GetDictionaryDeviceModelCountResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelCountResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_type();
  _internal_metadata_.Clear<std::string>();
}

const char* GetDictionaryDeviceModelCountResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int32 data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _internal_set_data(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* GetDictionaryDeviceModelCountResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelCountResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 data = 1;
  if (type_case() == kData) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        1, this->_internal_data(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.GetDictionaryDeviceModelCountResponse)
  return target;
}

::size_t GetDictionaryDeviceModelCountResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelCountResponse)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (type_case()) {
    // int32 data = 1;
    case kData: {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this->_internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GetDictionaryDeviceModelCountResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetDictionaryDeviceModelCountResponse*>(
      &from));
}

void GetDictionaryDeviceModelCountResponse::MergeFrom(const GetDictionaryDeviceModelCountResponse& from) {
  GetDictionaryDeviceModelCountResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelCountResponse)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.type_case()) {
    case kData: {
      _this->_internal_set_data(from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetDictionaryDeviceModelCountResponse::CopyFrom(const GetDictionaryDeviceModelCountResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.telemetry_control.v1.GetDictionaryDeviceModelCountResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetDictionaryDeviceModelCountResponse::IsInitialized() const {
  return true;
}

void GetDictionaryDeviceModelCountResponse::InternalSwap(GetDictionaryDeviceModelCountResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.type_, other->_impl_.type_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string GetDictionaryDeviceModelCountResponse::GetTypeName() const {
  return "keyapis.telemetry_control.v1.GetDictionaryDeviceModelCountResponse";
}

// ===================================================================

class GetDictionaryMrfCountRequest::_Internal {
 public:
};

GetDictionaryMrfCountRequest::GetDictionaryMrfCountRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.GetDictionaryMrfCountRequest)
}
GetDictionaryMrfCountRequest::GetDictionaryMrfCountRequest(const GetDictionaryMrfCountRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.GetDictionaryMrfCountRequest)
}

inline void GetDictionaryMrfCountRequest::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

GetDictionaryMrfCountRequest::~GetDictionaryMrfCountRequest() {
  // @@protoc_insertion_point(destructor:keyapis.telemetry_control.v1.GetDictionaryMrfCountRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void GetDictionaryMrfCountRequest::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
}

void GetDictionaryMrfCountRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void GetDictionaryMrfCountRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.GetDictionaryMrfCountRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* GetDictionaryMrfCountRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* GetDictionaryMrfCountRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.GetDictionaryMrfCountRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.GetDictionaryMrfCountRequest)
  return target;
}

::size_t GetDictionaryMrfCountRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.GetDictionaryMrfCountRequest)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GetDictionaryMrfCountRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetDictionaryMrfCountRequest*>(
      &from));
}

void GetDictionaryMrfCountRequest::MergeFrom(const GetDictionaryMrfCountRequest& from) {
  GetDictionaryMrfCountRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.telemetry_control.v1.GetDictionaryMrfCountRequest)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetDictionaryMrfCountRequest::CopyFrom(const GetDictionaryMrfCountRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.telemetry_control.v1.GetDictionaryMrfCountRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetDictionaryMrfCountRequest::IsInitialized() const {
  return true;
}

void GetDictionaryMrfCountRequest::InternalSwap(GetDictionaryMrfCountRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string GetDictionaryMrfCountRequest::GetTypeName() const {
  return "keyapis.telemetry_control.v1.GetDictionaryMrfCountRequest";
}

// ===================================================================

class GetDictionaryMrfCountResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::telemetry_control::v1::GetDictionaryMrfCountResponse, _impl_._oneof_case_);
};

GetDictionaryMrfCountResponse::GetDictionaryMrfCountResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.GetDictionaryMrfCountResponse)
}
GetDictionaryMrfCountResponse::GetDictionaryMrfCountResponse(const GetDictionaryMrfCountResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetDictionaryMrfCountResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_type();
  switch (from.type_case()) {
    case kData: {
      _this->_internal_set_data(from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.GetDictionaryMrfCountResponse)
}

inline void GetDictionaryMrfCountResponse::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_type();
}

GetDictionaryMrfCountResponse::~GetDictionaryMrfCountResponse() {
  // @@protoc_insertion_point(destructor:keyapis.telemetry_control.v1.GetDictionaryMrfCountResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void GetDictionaryMrfCountResponse::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_type()) {
    clear_type();
  }
}

void GetDictionaryMrfCountResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void GetDictionaryMrfCountResponse::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.telemetry_control.v1.GetDictionaryMrfCountResponse)
  switch (type_case()) {
    case kData: {
      // No need to clear
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}


void GetDictionaryMrfCountResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.GetDictionaryMrfCountResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_type();
  _internal_metadata_.Clear<std::string>();
}

const char* GetDictionaryMrfCountResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int32 data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _internal_set_data(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* GetDictionaryMrfCountResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.GetDictionaryMrfCountResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 data = 1;
  if (type_case() == kData) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        1, this->_internal_data(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.GetDictionaryMrfCountResponse)
  return target;
}

::size_t GetDictionaryMrfCountResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.GetDictionaryMrfCountResponse)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (type_case()) {
    // int32 data = 1;
    case kData: {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this->_internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GetDictionaryMrfCountResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetDictionaryMrfCountResponse*>(
      &from));
}

void GetDictionaryMrfCountResponse::MergeFrom(const GetDictionaryMrfCountResponse& from) {
  GetDictionaryMrfCountResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.telemetry_control.v1.GetDictionaryMrfCountResponse)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.type_case()) {
    case kData: {
      _this->_internal_set_data(from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetDictionaryMrfCountResponse::CopyFrom(const GetDictionaryMrfCountResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.telemetry_control.v1.GetDictionaryMrfCountResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetDictionaryMrfCountResponse::IsInitialized() const {
  return true;
}

void GetDictionaryMrfCountResponse::InternalSwap(GetDictionaryMrfCountResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.type_, other->_impl_.type_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string GetDictionaryMrfCountResponse::GetTypeName() const {
  return "keyapis.telemetry_control.v1.GetDictionaryMrfCountResponse";
}

// ===================================================================

class GetDictionaryRfCountRequest::_Internal {
 public:
};

GetDictionaryRfCountRequest::GetDictionaryRfCountRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.GetDictionaryRfCountRequest)
}
GetDictionaryRfCountRequest::GetDictionaryRfCountRequest(const GetDictionaryRfCountRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(), _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.GetDictionaryRfCountRequest)
}

inline void GetDictionaryRfCountRequest::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      /*decltype(_impl_._cached_size_)*/{}
  };
}

GetDictionaryRfCountRequest::~GetDictionaryRfCountRequest() {
  // @@protoc_insertion_point(destructor:keyapis.telemetry_control.v1.GetDictionaryRfCountRequest)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void GetDictionaryRfCountRequest::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
}

void GetDictionaryRfCountRequest::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void GetDictionaryRfCountRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.GetDictionaryRfCountRequest)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _internal_metadata_.Clear<std::string>();
}

const char* GetDictionaryRfCountRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* GetDictionaryRfCountRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.GetDictionaryRfCountRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.GetDictionaryRfCountRequest)
  return target;
}

::size_t GetDictionaryRfCountRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.GetDictionaryRfCountRequest)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GetDictionaryRfCountRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetDictionaryRfCountRequest*>(
      &from));
}

void GetDictionaryRfCountRequest::MergeFrom(const GetDictionaryRfCountRequest& from) {
  GetDictionaryRfCountRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.telemetry_control.v1.GetDictionaryRfCountRequest)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetDictionaryRfCountRequest::CopyFrom(const GetDictionaryRfCountRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.telemetry_control.v1.GetDictionaryRfCountRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetDictionaryRfCountRequest::IsInitialized() const {
  return true;
}

void GetDictionaryRfCountRequest::InternalSwap(GetDictionaryRfCountRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
}

std::string GetDictionaryRfCountRequest::GetTypeName() const {
  return "keyapis.telemetry_control.v1.GetDictionaryRfCountRequest";
}

// ===================================================================

class GetDictionaryRfCountResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::telemetry_control::v1::GetDictionaryRfCountResponse, _impl_._oneof_case_);
};

GetDictionaryRfCountResponse::GetDictionaryRfCountResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.GetDictionaryRfCountResponse)
}
GetDictionaryRfCountResponse::GetDictionaryRfCountResponse(const GetDictionaryRfCountResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetDictionaryRfCountResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_type();
  switch (from.type_case()) {
    case kData: {
      _this->_internal_set_data(from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.GetDictionaryRfCountResponse)
}

inline void GetDictionaryRfCountResponse::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_type();
}

GetDictionaryRfCountResponse::~GetDictionaryRfCountResponse() {
  // @@protoc_insertion_point(destructor:keyapis.telemetry_control.v1.GetDictionaryRfCountResponse)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void GetDictionaryRfCountResponse::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_type()) {
    clear_type();
  }
}

void GetDictionaryRfCountResponse::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void GetDictionaryRfCountResponse::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.telemetry_control.v1.GetDictionaryRfCountResponse)
  switch (type_case()) {
    case kData: {
      // No need to clear
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}


void GetDictionaryRfCountResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.GetDictionaryRfCountResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_type();
  _internal_metadata_.Clear<std::string>();
}

const char* GetDictionaryRfCountResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int32 data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _internal_set_data(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* GetDictionaryRfCountResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.GetDictionaryRfCountResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 data = 1;
  if (type_case() == kData) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        1, this->_internal_data(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.GetDictionaryRfCountResponse)
  return target;
}

::size_t GetDictionaryRfCountResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.GetDictionaryRfCountResponse)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  switch (type_case()) {
    // int32 data = 1;
    case kData: {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this->_internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void GetDictionaryRfCountResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetDictionaryRfCountResponse*>(
      &from));
}

void GetDictionaryRfCountResponse::MergeFrom(const GetDictionaryRfCountResponse& from) {
  GetDictionaryRfCountResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.telemetry_control.v1.GetDictionaryRfCountResponse)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.type_case()) {
    case kData: {
      _this->_internal_set_data(from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetDictionaryRfCountResponse::CopyFrom(const GetDictionaryRfCountResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.telemetry_control.v1.GetDictionaryRfCountResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GetDictionaryRfCountResponse::IsInitialized() const {
  return true;
}

void GetDictionaryRfCountResponse::InternalSwap(GetDictionaryRfCountResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.type_, other->_impl_.type_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string GetDictionaryRfCountResponse::GetTypeName() const {
  return "keyapis.telemetry_control.v1.GetDictionaryRfCountResponse";
}

// ===================================================================

class DictionaryDeviceModel::_Internal {
 public:
  using HasBits = decltype(std::declval<DictionaryDeviceModel>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(DictionaryDeviceModel, _impl_._has_bits_);
  static const ::PROTOBUF_NAMESPACE_ID::Timestamp& created_at(const DictionaryDeviceModel* msg);
  static void set_has_created_at(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Timestamp& changed_at(const DictionaryDeviceModel* msg);
  static void set_has_changed_at(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::StringValue& title(const DictionaryDeviceModel* msg);
  static void set_has_title(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::StringValue& protocol(const DictionaryDeviceModel* msg);
  static void set_has_protocol(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::StringValue& model_kind(const DictionaryDeviceModel* msg);
  static void set_has_model_kind(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
};

const ::PROTOBUF_NAMESPACE_ID::Timestamp&
DictionaryDeviceModel::_Internal::created_at(const DictionaryDeviceModel* msg) {
  return *msg->_impl_.created_at_;
}
const ::PROTOBUF_NAMESPACE_ID::Timestamp&
DictionaryDeviceModel::_Internal::changed_at(const DictionaryDeviceModel* msg) {
  return *msg->_impl_.changed_at_;
}
const ::PROTOBUF_NAMESPACE_ID::StringValue&
DictionaryDeviceModel::_Internal::title(const DictionaryDeviceModel* msg) {
  return *msg->_impl_.title_;
}
const ::PROTOBUF_NAMESPACE_ID::StringValue&
DictionaryDeviceModel::_Internal::protocol(const DictionaryDeviceModel* msg) {
  return *msg->_impl_.protocol_;
}
const ::PROTOBUF_NAMESPACE_ID::StringValue&
DictionaryDeviceModel::_Internal::model_kind(const DictionaryDeviceModel* msg) {
  return *msg->_impl_.model_kind_;
}
void DictionaryDeviceModel::clear_created_at() {
  if (_impl_.created_at_ != nullptr) _impl_.created_at_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
void DictionaryDeviceModel::clear_changed_at() {
  if (_impl_.changed_at_ != nullptr) _impl_.changed_at_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
void DictionaryDeviceModel::clear_title() {
  if (_impl_.title_ != nullptr) _impl_.title_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
void DictionaryDeviceModel::clear_protocol() {
  if (_impl_.protocol_ != nullptr) _impl_.protocol_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
void DictionaryDeviceModel::clear_model_kind() {
  if (_impl_.model_kind_ != nullptr) _impl_.model_kind_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
DictionaryDeviceModel::DictionaryDeviceModel(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.telemetry_control.v1.DictionaryDeviceModel)
}
DictionaryDeviceModel::DictionaryDeviceModel(const DictionaryDeviceModel& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  DictionaryDeviceModel* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.created_at_){nullptr}
    , decltype(_impl_.changed_at_){nullptr}
    , decltype(_impl_.title_){nullptr}
    , decltype(_impl_.protocol_){nullptr}
    , decltype(_impl_.model_kind_){nullptr}
    , decltype(_impl_.id_) {}
  };

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.created_at_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.created_at_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) {
    _this->_impl_.changed_at_ = new ::PROTOBUF_NAMESPACE_ID::Timestamp(*from._impl_.changed_at_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000004u) != 0) {
    _this->_impl_.title_ = new ::PROTOBUF_NAMESPACE_ID::StringValue(*from._impl_.title_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000008u) != 0) {
    _this->_impl_.protocol_ = new ::PROTOBUF_NAMESPACE_ID::StringValue(*from._impl_.protocol_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000010u) != 0) {
    _this->_impl_.model_kind_ = new ::PROTOBUF_NAMESPACE_ID::StringValue(*from._impl_.model_kind_);
  }
  _this->_impl_.id_ = from._impl_.id_;
  // @@protoc_insertion_point(copy_constructor:keyapis.telemetry_control.v1.DictionaryDeviceModel)
}

inline void DictionaryDeviceModel::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.created_at_){nullptr}
    , decltype(_impl_.changed_at_){nullptr}
    , decltype(_impl_.title_){nullptr}
    , decltype(_impl_.protocol_){nullptr}
    , decltype(_impl_.model_kind_){nullptr}
    , decltype(_impl_.id_) { 0 }

  };
}

DictionaryDeviceModel::~DictionaryDeviceModel() {
  // @@protoc_insertion_point(destructor:keyapis.telemetry_control.v1.DictionaryDeviceModel)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void DictionaryDeviceModel::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete _impl_.created_at_;
  if (this != internal_default_instance()) delete _impl_.changed_at_;
  if (this != internal_default_instance()) delete _impl_.title_;
  if (this != internal_default_instance()) delete _impl_.protocol_;
  if (this != internal_default_instance()) delete _impl_.model_kind_;
}

void DictionaryDeviceModel::SetCachedSize(int size) const {
  _impl_._cached_size_.Set(size);
}

void DictionaryDeviceModel::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.telemetry_control.v1.DictionaryDeviceModel)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(_impl_.created_at_ != nullptr);
      _impl_.created_at_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      ABSL_DCHECK(_impl_.changed_at_ != nullptr);
      _impl_.changed_at_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      ABSL_DCHECK(_impl_.title_ != nullptr);
      _impl_.title_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      ABSL_DCHECK(_impl_.protocol_ != nullptr);
      _impl_.protocol_->Clear();
    }
    if (cached_has_bits & 0x00000010u) {
      ABSL_DCHECK(_impl_.model_kind_ != nullptr);
      _impl_.model_kind_->Clear();
    }
  }
  _impl_.id_ = 0;
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* DictionaryDeviceModel::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int32 id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Timestamp created_at = 2 [(.google.api.field_behavior) = OUTPUT_ONLY];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_created_at(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.Timestamp changed_at = 3 [(.google.api.field_behavior) = OUTPUT_ONLY];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_changed_at(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.StringValue title = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_title(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.StringValue protocol = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_protocol(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.StringValue model_kind = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_model_kind(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

::uint8_t* DictionaryDeviceModel::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.telemetry_control.v1.DictionaryDeviceModel)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 id = 1;
  if (this->_internal_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        1, this->_internal_id(), target);
  }

  cached_has_bits = _impl_._has_bits_[0];
  // .google.protobuf.Timestamp created_at = 2 [(.google.api.field_behavior) = OUTPUT_ONLY];
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::created_at(this),
        _Internal::created_at(this).GetCachedSize(), target, stream);
  }

  // .google.protobuf.Timestamp changed_at = 3 [(.google.api.field_behavior) = OUTPUT_ONLY];
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, _Internal::changed_at(this),
        _Internal::changed_at(this).GetCachedSize(), target, stream);
  }

  // .google.protobuf.StringValue title = 4;
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, _Internal::title(this),
        _Internal::title(this).GetCachedSize(), target, stream);
  }

  // .google.protobuf.StringValue protocol = 5;
  if (cached_has_bits & 0x00000008u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, _Internal::protocol(this),
        _Internal::protocol(this).GetCachedSize(), target, stream);
  }

  // .google.protobuf.StringValue model_kind = 6;
  if (cached_has_bits & 0x00000010u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(6, _Internal::model_kind(this),
        _Internal::model_kind(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:keyapis.telemetry_control.v1.DictionaryDeviceModel)
  return target;
}

::size_t DictionaryDeviceModel::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.telemetry_control.v1.DictionaryDeviceModel)
  ::size_t total_size = 0;

  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    // .google.protobuf.Timestamp created_at = 2 [(.google.api.field_behavior) = OUTPUT_ONLY];
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.created_at_);
    }

    // .google.protobuf.Timestamp changed_at = 3 [(.google.api.field_behavior) = OUTPUT_ONLY];
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.changed_at_);
    }

    // .google.protobuf.StringValue title = 4;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.title_);
    }

    // .google.protobuf.StringValue protocol = 5;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.protocol_);
    }

    // .google.protobuf.StringValue model_kind = 6;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.model_kind_);
    }

  }
  // int32 id = 1;
  if (this->_internal_id() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_id());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void DictionaryDeviceModel::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const DictionaryDeviceModel*>(
      &from));
}

void DictionaryDeviceModel::MergeFrom(const DictionaryDeviceModel& from) {
  DictionaryDeviceModel* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:keyapis.telemetry_control.v1.DictionaryDeviceModel)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_mutable_created_at()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
          from._internal_created_at());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_internal_mutable_changed_at()->::PROTOBUF_NAMESPACE_ID::Timestamp::MergeFrom(
          from._internal_changed_at());
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_internal_mutable_title()->::PROTOBUF_NAMESPACE_ID::StringValue::MergeFrom(
          from._internal_title());
    }
    if (cached_has_bits & 0x00000008u) {
      _this->_internal_mutable_protocol()->::PROTOBUF_NAMESPACE_ID::StringValue::MergeFrom(
          from._internal_protocol());
    }
    if (cached_has_bits & 0x00000010u) {
      _this->_internal_mutable_model_kind()->::PROTOBUF_NAMESPACE_ID::StringValue::MergeFrom(
          from._internal_model_kind());
    }
  }
  if (from._internal_id() != 0) {
    _this->_internal_set_id(from._internal_id());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void DictionaryDeviceModel::CopyFrom(const DictionaryDeviceModel& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:keyapis.telemetry_control.v1.DictionaryDeviceModel)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DictionaryDeviceModel::IsInitialized() const {
  return true;
}

void DictionaryDeviceModel::InternalSwap(DictionaryDeviceModel* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(DictionaryDeviceModel, _impl_.id_)
      + sizeof(DictionaryDeviceModel::_impl_.id_)
      - PROTOBUF_FIELD_OFFSET(DictionaryDeviceModel, _impl_.created_at_)>(
          reinterpret_cast<char*>(&_impl_.created_at_),
          reinterpret_cast<char*>(&other->_impl_.created_at_));
}

std::string DictionaryDeviceModel::GetTypeName() const {
  return "keyapis.telemetry_control.v1.DictionaryDeviceModel";
}

// @@protoc_insertion_point(namespace_scope)
}  // namespace v1
}  // namespace telemetry_control
}  // namespace keyapis
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::PostDictionaryDeviceModelRequest*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::PostDictionaryDeviceModelRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::PostDictionaryDeviceModelRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::PostDictionaryDeviceModelResponse*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::PostDictionaryDeviceModelResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::PostDictionaryDeviceModelResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::DeleteDictionaryDeviceModelRequest*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::DeleteDictionaryDeviceModelRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::DeleteDictionaryDeviceModelRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::DeleteDictionaryDeviceModelResponse*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::DeleteDictionaryDeviceModelResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::DeleteDictionaryDeviceModelResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetDictionaryDeviceModelRequest*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetDictionaryDeviceModelRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetDictionaryDeviceModelRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetDictionaryDeviceModelResponse*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetDictionaryDeviceModelResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetDictionaryDeviceModelResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetDictionaryDeviceModelListRequest*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetDictionaryDeviceModelListRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetDictionaryDeviceModelListRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetDictionaryMrfListRequest*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetDictionaryMrfListRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetDictionaryMrfListRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetDictionaryRfListRequest*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetDictionaryRfListRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetDictionaryRfListRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::DictionaryDeviceModelPaging*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::DictionaryDeviceModelPaging >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::DictionaryDeviceModelPaging >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::DictionaryDeviceModelFilter*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::DictionaryDeviceModelFilter >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::DictionaryDeviceModelFilter >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetDictionaryDeviceModelListResponse*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetDictionaryDeviceModelListResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetDictionaryDeviceModelListResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetDictionaryMrfListResponse*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetDictionaryMrfListResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetDictionaryMrfListResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::DictionaryMrf*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::DictionaryMrf >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::DictionaryMrf >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetDictionaryRfListResponse*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetDictionaryRfListResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetDictionaryRfListResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::DictionaryPermission*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::DictionaryPermission >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::DictionaryPermission >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::DictionaryRf*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::DictionaryRf >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::DictionaryRf >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetDictionaryDeviceModelCountRequest*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetDictionaryDeviceModelCountRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetDictionaryDeviceModelCountRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetDictionaryDeviceModelCountResponse*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetDictionaryDeviceModelCountResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetDictionaryDeviceModelCountResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetDictionaryMrfCountRequest*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetDictionaryMrfCountRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetDictionaryMrfCountRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetDictionaryMrfCountResponse*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetDictionaryMrfCountResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetDictionaryMrfCountResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetDictionaryRfCountRequest*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetDictionaryRfCountRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetDictionaryRfCountRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::GetDictionaryRfCountResponse*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::GetDictionaryRfCountResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::GetDictionaryRfCountResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::telemetry_control::v1::DictionaryDeviceModel*
Arena::CreateMaybeMessage< ::keyapis::telemetry_control::v1::DictionaryDeviceModel >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::telemetry_control::v1::DictionaryDeviceModel >(arena);
}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"