// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: deviceapis/device/v1/deviceapis_device_sip_v1.proto

#include "deviceapis/device/v1/deviceapis_device_sip_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 deviceapis {
namespace device {
namespace v1 {
template <typename>
PROTOBUF_CONSTEXPR GetSipAccountListRequest::GetSipAccountListRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct GetSipAccountListRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetSipAccountListRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetSipAccountListRequestDefaultTypeInternal() {}
  union {
    GetSipAccountListRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetSipAccountListRequestDefaultTypeInternal _GetSipAccountListRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetSipAccountListResponse::GetSipAccountListResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.data_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct GetSipAccountListResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetSipAccountListResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetSipAccountListResponseDefaultTypeInternal() {}
  union {
    GetSipAccountListResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetSipAccountListResponseDefaultTypeInternal _GetSipAccountListResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR EditSipAccountRequest::EditSipAccountRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.data_)*/nullptr
  , /*decltype(_impl_.update_mask_)*/nullptr} {}
struct EditSipAccountRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR EditSipAccountRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~EditSipAccountRequestDefaultTypeInternal() {}
  union {
    EditSipAccountRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EditSipAccountRequestDefaultTypeInternal _EditSipAccountRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SipAccount::SipAccount(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.account_id_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

  , /*decltype(_impl_.name_)*/nullptr
  , /*decltype(_impl_.number_)*/nullptr
  , /*decltype(_impl_.user_)*/nullptr
  , /*decltype(_impl_.password_)*/nullptr
  , /*decltype(_impl_.reg_server_address_)*/nullptr
  , /*decltype(_impl_.sip_server_address_)*/nullptr
  , /*decltype(_impl_.sip_proxy_address_)*/nullptr} {}
struct SipAccountDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SipAccountDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SipAccountDefaultTypeInternal() {}
  union {
    SipAccount _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SipAccountDefaultTypeInternal _SipAccount_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR EditSipTimeoutSettingsRequest::EditSipTimeoutSettingsRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.data_)*/nullptr
  , /*decltype(_impl_.update_mask_)*/nullptr} {}
struct EditSipTimeoutSettingsRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR EditSipTimeoutSettingsRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~EditSipTimeoutSettingsRequestDefaultTypeInternal() {}
  union {
    EditSipTimeoutSettingsRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EditSipTimeoutSettingsRequestDefaultTypeInternal _EditSipTimeoutSettingsRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetSipTimeoutSettingsRequest::GetSipTimeoutSettingsRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct GetSipTimeoutSettingsRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetSipTimeoutSettingsRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetSipTimeoutSettingsRequestDefaultTypeInternal() {}
  union {
    GetSipTimeoutSettingsRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetSipTimeoutSettingsRequestDefaultTypeInternal _GetSipTimeoutSettingsRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetSipTimeoutSettingsResponse::GetSipTimeoutSettingsResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetSipTimeoutSettingsResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetSipTimeoutSettingsResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetSipTimeoutSettingsResponseDefaultTypeInternal() {}
  union {
    GetSipTimeoutSettingsResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetSipTimeoutSettingsResponseDefaultTypeInternal _GetSipTimeoutSettingsResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR EditSipAccountResponse_Error::EditSipAccountResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct EditSipAccountResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR EditSipAccountResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~EditSipAccountResponse_ErrorDefaultTypeInternal() {}
  union {
    EditSipAccountResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EditSipAccountResponse_ErrorDefaultTypeInternal _EditSipAccountResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR EditSipAccountResponse::EditSipAccountResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct EditSipAccountResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR EditSipAccountResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~EditSipAccountResponseDefaultTypeInternal() {}
  union {
    EditSipAccountResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EditSipAccountResponseDefaultTypeInternal _EditSipAccountResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SipTimeoutSettings::SipTimeoutSettings(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.call_timeout_)*/ 0

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SipTimeoutSettingsDefaultTypeInternal _SipTimeoutSettings_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR EditSipTimeoutSettingsResponse_Error::EditSipTimeoutSettingsResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct EditSipTimeoutSettingsResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR EditSipTimeoutSettingsResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~EditSipTimeoutSettingsResponse_ErrorDefaultTypeInternal() {}
  union {
    EditSipTimeoutSettingsResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EditSipTimeoutSettingsResponse_ErrorDefaultTypeInternal _EditSipTimeoutSettingsResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR EditSipTimeoutSettingsResponse::EditSipTimeoutSettingsResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct EditSipTimeoutSettingsResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR EditSipTimeoutSettingsResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~EditSipTimeoutSettingsResponseDefaultTypeInternal() {}
  union {
    EditSipTimeoutSettingsResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EditSipTimeoutSettingsResponseDefaultTypeInternal _EditSipTimeoutSettingsResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetSipAccountStatusListRequest::GetSipAccountStatusListRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct GetSipAccountStatusListRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetSipAccountStatusListRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetSipAccountStatusListRequestDefaultTypeInternal() {}
  union {
    GetSipAccountStatusListRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetSipAccountStatusListRequestDefaultTypeInternal _GetSipAccountStatusListRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetSipAccountStatusListResponse_SipStatus::GetSipAccountStatusListResponse_SipStatus(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.sip_account_id_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetSipAccountStatusListResponse_SipStatusDefaultTypeInternal _GetSipAccountStatusListResponse_SipStatus_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetSipAccountStatusListResponse::GetSipAccountStatusListResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.data_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct GetSipAccountStatusListResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetSipAccountStatusListResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetSipAccountStatusListResponseDefaultTypeInternal() {}
  union {
    GetSipAccountStatusListResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetSipAccountStatusListResponseDefaultTypeInternal _GetSipAccountStatusListResponse_default_instance_;
}  // namespace v1
}  // namespace device
}  // namespace deviceapis
namespace deviceapis {
namespace device {
namespace v1 {
bool GetSipAccountStatusListResponse_SipStatus_StateType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
      return true;
    default:
      return false;
  }
}
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string>
    GetSipAccountStatusListResponse_SipStatus_StateType_strings[7] = {};

static const char GetSipAccountStatusListResponse_SipStatus_StateType_names[] = {
    "DISABLED"
    "REGISTERED"
    "REGISTERING"
    "REGISTRATION_FAILED"
    "STATE_TYPE_UNKNOWN"
    "TIMEOUT"
    "UNREGISTERED"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry GetSipAccountStatusListResponse_SipStatus_StateType_entries[] =
    {
        {{&GetSipAccountStatusListResponse_SipStatus_StateType_names[0], 8}, 6},
        {{&GetSipAccountStatusListResponse_SipStatus_StateType_names[8], 10}, 2},
        {{&GetSipAccountStatusListResponse_SipStatus_StateType_names[18], 11}, 1},
        {{&GetSipAccountStatusListResponse_SipStatus_StateType_names[29], 19}, 4},
        {{&GetSipAccountStatusListResponse_SipStatus_StateType_names[48], 18}, 0},
        {{&GetSipAccountStatusListResponse_SipStatus_StateType_names[66], 7}, 5},
        {{&GetSipAccountStatusListResponse_SipStatus_StateType_names[73], 12}, 3},
};

static const int GetSipAccountStatusListResponse_SipStatus_StateType_entries_by_number[] = {
    4,  // 0 -> STATE_TYPE_UNKNOWN
    2,  // 1 -> REGISTERING
    1,  // 2 -> REGISTERED
    6,  // 3 -> UNREGISTERED
    3,  // 4 -> REGISTRATION_FAILED
    5,  // 5 -> TIMEOUT
    0,  // 6 -> DISABLED
};

const std::string& GetSipAccountStatusListResponse_SipStatus_StateType_Name(GetSipAccountStatusListResponse_SipStatus_StateType value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          GetSipAccountStatusListResponse_SipStatus_StateType_entries, GetSipAccountStatusListResponse_SipStatus_StateType_entries_by_number,
          7, GetSipAccountStatusListResponse_SipStatus_StateType_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      GetSipAccountStatusListResponse_SipStatus_StateType_entries, GetSipAccountStatusListResponse_SipStatus_StateType_entries_by_number, 7,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : GetSipAccountStatusListResponse_SipStatus_StateType_strings[idx].get();
}

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

constexpr GetSipAccountStatusListResponse_SipStatus_StateType GetSipAccountStatusListResponse_SipStatus::STATE_TYPE_UNKNOWN;
constexpr GetSipAccountStatusListResponse_SipStatus_StateType GetSipAccountStatusListResponse_SipStatus::REGISTERING;
constexpr GetSipAccountStatusListResponse_SipStatus_StateType GetSipAccountStatusListResponse_SipStatus::REGISTERED;
constexpr GetSipAccountStatusListResponse_SipStatus_StateType GetSipAccountStatusListResponse_SipStatus::UNREGISTERED;
constexpr GetSipAccountStatusListResponse_SipStatus_StateType GetSipAccountStatusListResponse_SipStatus::REGISTRATION_FAILED;
constexpr GetSipAccountStatusListResponse_SipStatus_StateType GetSipAccountStatusListResponse_SipStatus::TIMEOUT;
constexpr GetSipAccountStatusListResponse_SipStatus_StateType GetSipAccountStatusListResponse_SipStatus::DISABLED;
constexpr GetSipAccountStatusListResponse_SipStatus_StateType GetSipAccountStatusListResponse_SipStatus::StateType_MIN;
constexpr GetSipAccountStatusListResponse_SipStatus_StateType GetSipAccountStatusListResponse_SipStatus::StateType_MAX;
constexpr int GetSipAccountStatusListResponse_SipStatus::StateType_ARRAYSIZE;

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

class GetSipAccountListRequest::_Internal {
 public:
};

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

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

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

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

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

void GetSipAccountListRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.GetSipAccountListRequest)
  ::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* GetSipAccountListRequest::_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* GetSipAccountListRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.GetSipAccountListRequest)
  ::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:deviceapis.device.v1.GetSipAccountListRequest)
  return target;
}

::size_t GetSipAccountListRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.GetSipAccountListRequest)
  ::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 GetSipAccountListRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetSipAccountListRequest*>(
      &from));
}

void GetSipAccountListRequest::MergeFrom(const GetSipAccountListRequest& from) {
  GetSipAccountListRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:deviceapis.device.v1.GetSipAccountListRequest)
  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 GetSipAccountListRequest::CopyFrom(const GetSipAccountListRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.GetSipAccountListRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

std::string GetSipAccountListRequest::GetTypeName() const {
  return "deviceapis.device.v1.GetSipAccountListRequest";
}

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

class GetSipAccountListResponse::_Internal {
 public:
};

GetSipAccountListResponse::GetSipAccountListResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.GetSipAccountListResponse)
}
GetSipAccountListResponse::GetSipAccountListResponse(const GetSipAccountListResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetSipAccountListResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.data_){from._impl_.data_}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.GetSipAccountListResponse)
}

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

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

inline void GetSipAccountListResponse::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _internal_mutable_data()->~RepeatedPtrField();
}

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

void GetSipAccountListResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.GetSipAccountListResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

const char* GetSipAccountListResponse::_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 .deviceapis.device.v1.SipAccount data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_data(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(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* GetSipAccountListResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.GetSipAccountListResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .deviceapis.device.v1.SipAccount data = 1;
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_data_size()); i < n; i++) {
    const auto& repfield = this->_internal_data(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, repfield, repfield.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:deviceapis.device.v1.GetSipAccountListResponse)
  return target;
}

::size_t GetSipAccountListResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.GetSipAccountListResponse)
  ::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 .deviceapis.device.v1.SipAccount data = 1;
  total_size += 1UL * this->_internal_data_size();
  for (const auto& msg : this->_internal_data()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  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 GetSipAccountListResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetSipAccountListResponse*>(
      &from));
}

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

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

void GetSipAccountListResponse::CopyFrom(const GetSipAccountListResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.GetSipAccountListResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

std::string GetSipAccountListResponse::GetTypeName() const {
  return "deviceapis.device.v1.GetSipAccountListResponse";
}

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

class EditSipAccountRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<EditSipAccountRequest>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(EditSipAccountRequest, _impl_._has_bits_);
  static const ::deviceapis::device::v1::SipAccount& data(const EditSipAccountRequest* msg);
  static void set_has_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::FieldMask& update_mask(const EditSipAccountRequest* msg);
  static void set_has_update_mask(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::deviceapis::device::v1::SipAccount&
EditSipAccountRequest::_Internal::data(const EditSipAccountRequest* msg) {
  return *msg->_impl_.data_;
}
const ::PROTOBUF_NAMESPACE_ID::FieldMask&
EditSipAccountRequest::_Internal::update_mask(const EditSipAccountRequest* msg) {
  return *msg->_impl_.update_mask_;
}
void EditSipAccountRequest::clear_update_mask() {
  if (_impl_.update_mask_ != nullptr) _impl_.update_mask_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
EditSipAccountRequest::EditSipAccountRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.EditSipAccountRequest)
}
EditSipAccountRequest::EditSipAccountRequest(const EditSipAccountRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  EditSipAccountRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.data_){nullptr}
    , decltype(_impl_.update_mask_){nullptr}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.data_ = new ::deviceapis::device::v1::SipAccount(*from._impl_.data_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) {
    _this->_impl_.update_mask_ = new ::PROTOBUF_NAMESPACE_ID::FieldMask(*from._impl_.update_mask_);
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.EditSipAccountRequest)
}

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

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

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

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

void EditSipAccountRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.EditSipAccountRequest)
  ::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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(_impl_.data_ != nullptr);
      _impl_.data_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      ABSL_DCHECK(_impl_.update_mask_ != nullptr);
      _impl_.update_mask_->Clear();
    }
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* EditSipAccountRequest::_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) {
      // .deviceapis.device.v1.SipAccount 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;
      // .google.protobuf.FieldMask update_mask = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_update_mask(), 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* EditSipAccountRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.EditSipAccountRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // .deviceapis.device.v1.SipAccount 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);
  }

  // .google.protobuf.FieldMask update_mask = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::update_mask(this),
        _Internal::update_mask(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:deviceapis.device.v1.EditSipAccountRequest)
  return target;
}

::size_t EditSipAccountRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.EditSipAccountRequest)
  ::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 & 0x00000003u) {
    // .deviceapis.device.v1.SipAccount data = 1 [(.google.api.field_behavior) = REQUIRED];
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.data_);
    }

    // .google.protobuf.FieldMask update_mask = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.update_mask_);
    }

  }
  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 EditSipAccountRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const EditSipAccountRequest*>(
      &from));
}

void EditSipAccountRequest::MergeFrom(const EditSipAccountRequest& from) {
  EditSipAccountRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:deviceapis.device.v1.EditSipAccountRequest)
  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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_mutable_data()->::deviceapis::device::v1::SipAccount::MergeFrom(
          from._internal_data());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_internal_mutable_update_mask()->::PROTOBUF_NAMESPACE_ID::FieldMask::MergeFrom(
          from._internal_update_mask());
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void EditSipAccountRequest::CopyFrom(const EditSipAccountRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.EditSipAccountRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void EditSipAccountRequest::InternalSwap(EditSipAccountRequest* 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(EditSipAccountRequest, _impl_.update_mask_)
      + sizeof(EditSipAccountRequest::_impl_.update_mask_)
      - PROTOBUF_FIELD_OFFSET(EditSipAccountRequest, _impl_.data_)>(
          reinterpret_cast<char*>(&_impl_.data_),
          reinterpret_cast<char*>(&other->_impl_.data_));
}

std::string EditSipAccountRequest::GetTypeName() const {
  return "deviceapis.device.v1.EditSipAccountRequest";
}

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

class SipAccount::_Internal {
 public:
  using HasBits = decltype(std::declval<SipAccount>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(SipAccount, _impl_._has_bits_);
  static const ::PROTOBUF_NAMESPACE_ID::StringValue& name(const SipAccount* msg);
  static void set_has_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::StringValue& number(const SipAccount* msg);
  static void set_has_number(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::StringValue& user(const SipAccount* msg);
  static void set_has_user(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::StringValue& password(const SipAccount* msg);
  static void set_has_password(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::StringValue& reg_server_address(const SipAccount* msg);
  static void set_has_reg_server_address(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::StringValue& sip_server_address(const SipAccount* msg);
  static void set_has_sip_server_address(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::StringValue& sip_proxy_address(const SipAccount* msg);
  static void set_has_sip_proxy_address(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
};

const ::PROTOBUF_NAMESPACE_ID::StringValue&
SipAccount::_Internal::name(const SipAccount* msg) {
  return *msg->_impl_.name_;
}
const ::PROTOBUF_NAMESPACE_ID::StringValue&
SipAccount::_Internal::number(const SipAccount* msg) {
  return *msg->_impl_.number_;
}
const ::PROTOBUF_NAMESPACE_ID::StringValue&
SipAccount::_Internal::user(const SipAccount* msg) {
  return *msg->_impl_.user_;
}
const ::PROTOBUF_NAMESPACE_ID::StringValue&
SipAccount::_Internal::password(const SipAccount* msg) {
  return *msg->_impl_.password_;
}
const ::PROTOBUF_NAMESPACE_ID::StringValue&
SipAccount::_Internal::reg_server_address(const SipAccount* msg) {
  return *msg->_impl_.reg_server_address_;
}
const ::PROTOBUF_NAMESPACE_ID::StringValue&
SipAccount::_Internal::sip_server_address(const SipAccount* msg) {
  return *msg->_impl_.sip_server_address_;
}
const ::PROTOBUF_NAMESPACE_ID::StringValue&
SipAccount::_Internal::sip_proxy_address(const SipAccount* msg) {
  return *msg->_impl_.sip_proxy_address_;
}
void SipAccount::clear_name() {
  if (_impl_.name_ != nullptr) _impl_.name_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
void SipAccount::clear_number() {
  if (_impl_.number_ != nullptr) _impl_.number_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
void SipAccount::clear_user() {
  if (_impl_.user_ != nullptr) _impl_.user_->Clear();
  _impl_._has_bits_[0] &= ~0x00000004u;
}
void SipAccount::clear_password() {
  if (_impl_.password_ != nullptr) _impl_.password_->Clear();
  _impl_._has_bits_[0] &= ~0x00000008u;
}
void SipAccount::clear_reg_server_address() {
  if (_impl_.reg_server_address_ != nullptr) _impl_.reg_server_address_->Clear();
  _impl_._has_bits_[0] &= ~0x00000010u;
}
void SipAccount::clear_sip_server_address() {
  if (_impl_.sip_server_address_ != nullptr) _impl_.sip_server_address_->Clear();
  _impl_._has_bits_[0] &= ~0x00000020u;
}
void SipAccount::clear_sip_proxy_address() {
  if (_impl_.sip_proxy_address_ != nullptr) _impl_.sip_proxy_address_->Clear();
  _impl_._has_bits_[0] &= ~0x00000040u;
}
SipAccount::SipAccount(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.SipAccount)
}
SipAccount::SipAccount(const SipAccount& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  SipAccount* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.account_id_) {}

    , decltype(_impl_.name_){nullptr}
    , decltype(_impl_.number_){nullptr}
    , decltype(_impl_.user_){nullptr}
    , decltype(_impl_.password_){nullptr}
    , decltype(_impl_.reg_server_address_){nullptr}
    , decltype(_impl_.sip_server_address_){nullptr}
    , decltype(_impl_.sip_proxy_address_){nullptr}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.account_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.account_id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_account_id().empty()) {
    _this->_impl_.account_id_.Set(from._internal_account_id(), _this->GetArenaForAllocation());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.name_ = new ::PROTOBUF_NAMESPACE_ID::StringValue(*from._impl_.name_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) {
    _this->_impl_.number_ = new ::PROTOBUF_NAMESPACE_ID::StringValue(*from._impl_.number_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000004u) != 0) {
    _this->_impl_.user_ = new ::PROTOBUF_NAMESPACE_ID::StringValue(*from._impl_.user_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000008u) != 0) {
    _this->_impl_.password_ = new ::PROTOBUF_NAMESPACE_ID::StringValue(*from._impl_.password_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000010u) != 0) {
    _this->_impl_.reg_server_address_ = new ::PROTOBUF_NAMESPACE_ID::StringValue(*from._impl_.reg_server_address_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000020u) != 0) {
    _this->_impl_.sip_server_address_ = new ::PROTOBUF_NAMESPACE_ID::StringValue(*from._impl_.sip_server_address_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000040u) != 0) {
    _this->_impl_.sip_proxy_address_ = new ::PROTOBUF_NAMESPACE_ID::StringValue(*from._impl_.sip_proxy_address_);
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.SipAccount)
}

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

    , decltype(_impl_.name_){nullptr}
    , decltype(_impl_.number_){nullptr}
    , decltype(_impl_.user_){nullptr}
    , decltype(_impl_.password_){nullptr}
    , decltype(_impl_.reg_server_address_){nullptr}
    , decltype(_impl_.sip_server_address_){nullptr}
    , decltype(_impl_.sip_proxy_address_){nullptr}
  };
  _impl_.account_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.account_id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

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

inline void SipAccount::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.account_id_.Destroy();
  if (this != internal_default_instance()) delete _impl_.name_;
  if (this != internal_default_instance()) delete _impl_.number_;
  if (this != internal_default_instance()) delete _impl_.user_;
  if (this != internal_default_instance()) delete _impl_.password_;
  if (this != internal_default_instance()) delete _impl_.reg_server_address_;
  if (this != internal_default_instance()) delete _impl_.sip_server_address_;
  if (this != internal_default_instance()) delete _impl_.sip_proxy_address_;
}

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

void SipAccount::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.SipAccount)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.account_id_.ClearToEmpty();
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x0000007fu) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(_impl_.name_ != nullptr);
      _impl_.name_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      ABSL_DCHECK(_impl_.number_ != nullptr);
      _impl_.number_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      ABSL_DCHECK(_impl_.user_ != nullptr);
      _impl_.user_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      ABSL_DCHECK(_impl_.password_ != nullptr);
      _impl_.password_->Clear();
    }
    if (cached_has_bits & 0x00000010u) {
      ABSL_DCHECK(_impl_.reg_server_address_ != nullptr);
      _impl_.reg_server_address_->Clear();
    }
    if (cached_has_bits & 0x00000020u) {
      ABSL_DCHECK(_impl_.sip_server_address_ != nullptr);
      _impl_.sip_server_address_->Clear();
    }
    if (cached_has_bits & 0x00000040u) {
      ABSL_DCHECK(_impl_.sip_proxy_address_ != nullptr);
      _impl_.sip_proxy_address_->Clear();
    }
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* SipAccount::_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) {
      // string account_id = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_account_id();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.StringValue name = 2 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_name(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.StringValue number = 3 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_number(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.StringValue user = 4 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_user(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.StringValue password = 5 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_password(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.StringValue reg_server_address = 6 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_reg_server_address(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.StringValue sip_server_address = 7 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_sip_server_address(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .google.protobuf.StringValue sip_proxy_address = 8 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_sip_proxy_address(), 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* SipAccount::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.SipAccount)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string account_id = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (!this->_internal_account_id().empty()) {
    const std::string& _s = this->_internal_account_id();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "deviceapis.device.v1.SipAccount.account_id");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  cached_has_bits = _impl_._has_bits_[0];
  // .google.protobuf.StringValue name = 2 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::name(this),
        _Internal::name(this).GetCachedSize(), target, stream);
  }

  // .google.protobuf.StringValue number = 3 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, _Internal::number(this),
        _Internal::number(this).GetCachedSize(), target, stream);
  }

  // .google.protobuf.StringValue user = 4 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (cached_has_bits & 0x00000004u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, _Internal::user(this),
        _Internal::user(this).GetCachedSize(), target, stream);
  }

  // .google.protobuf.StringValue password = 5 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (cached_has_bits & 0x00000008u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, _Internal::password(this),
        _Internal::password(this).GetCachedSize(), target, stream);
  }

  // .google.protobuf.StringValue reg_server_address = 6 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (cached_has_bits & 0x00000010u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(6, _Internal::reg_server_address(this),
        _Internal::reg_server_address(this).GetCachedSize(), target, stream);
  }

  // .google.protobuf.StringValue sip_server_address = 7 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (cached_has_bits & 0x00000020u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(7, _Internal::sip_server_address(this),
        _Internal::sip_server_address(this).GetCachedSize(), target, stream);
  }

  // .google.protobuf.StringValue sip_proxy_address = 8 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (cached_has_bits & 0x00000040u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(8, _Internal::sip_proxy_address(this),
        _Internal::sip_proxy_address(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:deviceapis.device.v1.SipAccount)
  return target;
}

::size_t SipAccount::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.SipAccount)
  ::size_t total_size = 0;

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

  // string account_id = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (!this->_internal_account_id().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_account_id());
  }

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x0000007fu) {
    // .google.protobuf.StringValue name = 2 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.name_);
    }

    // .google.protobuf.StringValue number = 3 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.number_);
    }

    // .google.protobuf.StringValue user = 4 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.user_);
    }

    // .google.protobuf.StringValue password = 5 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.password_);
    }

    // .google.protobuf.StringValue reg_server_address = 6 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reg_server_address_);
    }

    // .google.protobuf.StringValue sip_server_address = 7 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.sip_server_address_);
    }

    // .google.protobuf.StringValue sip_proxy_address = 8 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.sip_proxy_address_);
    }

  }
  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 SipAccount::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const SipAccount*>(
      &from));
}

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

  if (!from._internal_account_id().empty()) {
    _this->_internal_set_account_id(from._internal_account_id());
  }
  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x0000007fu) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_mutable_name()->::PROTOBUF_NAMESPACE_ID::StringValue::MergeFrom(
          from._internal_name());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_internal_mutable_number()->::PROTOBUF_NAMESPACE_ID::StringValue::MergeFrom(
          from._internal_number());
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_internal_mutable_user()->::PROTOBUF_NAMESPACE_ID::StringValue::MergeFrom(
          from._internal_user());
    }
    if (cached_has_bits & 0x00000008u) {
      _this->_internal_mutable_password()->::PROTOBUF_NAMESPACE_ID::StringValue::MergeFrom(
          from._internal_password());
    }
    if (cached_has_bits & 0x00000010u) {
      _this->_internal_mutable_reg_server_address()->::PROTOBUF_NAMESPACE_ID::StringValue::MergeFrom(
          from._internal_reg_server_address());
    }
    if (cached_has_bits & 0x00000020u) {
      _this->_internal_mutable_sip_server_address()->::PROTOBUF_NAMESPACE_ID::StringValue::MergeFrom(
          from._internal_sip_server_address());
    }
    if (cached_has_bits & 0x00000040u) {
      _this->_internal_mutable_sip_proxy_address()->::PROTOBUF_NAMESPACE_ID::StringValue::MergeFrom(
          from._internal_sip_proxy_address());
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void SipAccount::CopyFrom(const SipAccount& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.SipAccount)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void SipAccount::InternalSwap(SipAccount* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.account_id_, lhs_arena,
                                       &other->_impl_.account_id_, rhs_arena);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(SipAccount, _impl_.sip_proxy_address_)
      + sizeof(SipAccount::_impl_.sip_proxy_address_)
      - PROTOBUF_FIELD_OFFSET(SipAccount, _impl_.name_)>(
          reinterpret_cast<char*>(&_impl_.name_),
          reinterpret_cast<char*>(&other->_impl_.name_));
}

std::string SipAccount::GetTypeName() const {
  return "deviceapis.device.v1.SipAccount";
}

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

class EditSipTimeoutSettingsRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<EditSipTimeoutSettingsRequest>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(EditSipTimeoutSettingsRequest, _impl_._has_bits_);
  static const ::deviceapis::device::v1::SipTimeoutSettings& data(const EditSipTimeoutSettingsRequest* msg);
  static void set_has_data(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::PROTOBUF_NAMESPACE_ID::FieldMask& update_mask(const EditSipTimeoutSettingsRequest* msg);
  static void set_has_update_mask(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::deviceapis::device::v1::SipTimeoutSettings&
EditSipTimeoutSettingsRequest::_Internal::data(const EditSipTimeoutSettingsRequest* msg) {
  return *msg->_impl_.data_;
}
const ::PROTOBUF_NAMESPACE_ID::FieldMask&
EditSipTimeoutSettingsRequest::_Internal::update_mask(const EditSipTimeoutSettingsRequest* msg) {
  return *msg->_impl_.update_mask_;
}
void EditSipTimeoutSettingsRequest::clear_update_mask() {
  if (_impl_.update_mask_ != nullptr) _impl_.update_mask_->Clear();
  _impl_._has_bits_[0] &= ~0x00000002u;
}
EditSipTimeoutSettingsRequest::EditSipTimeoutSettingsRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.EditSipTimeoutSettingsRequest)
}
EditSipTimeoutSettingsRequest::EditSipTimeoutSettingsRequest(const EditSipTimeoutSettingsRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  EditSipTimeoutSettingsRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.data_){nullptr}
    , decltype(_impl_.update_mask_){nullptr}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.data_ = new ::deviceapis::device::v1::SipTimeoutSettings(*from._impl_.data_);
  }
  if ((from._impl_._has_bits_[0] & 0x00000002u) != 0) {
    _this->_impl_.update_mask_ = new ::PROTOBUF_NAMESPACE_ID::FieldMask(*from._impl_.update_mask_);
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.EditSipTimeoutSettingsRequest)
}

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

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

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

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

void EditSipTimeoutSettingsRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.EditSipTimeoutSettingsRequest)
  ::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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(_impl_.data_ != nullptr);
      _impl_.data_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      ABSL_DCHECK(_impl_.update_mask_ != nullptr);
      _impl_.update_mask_->Clear();
    }
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* EditSipTimeoutSettingsRequest::_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) {
      // .deviceapis.device.v1.SipTimeoutSettings 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;
      // .google.protobuf.FieldMask update_mask = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_update_mask(), 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* EditSipTimeoutSettingsRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.EditSipTimeoutSettingsRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // .deviceapis.device.v1.SipTimeoutSettings 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);
  }

  // .google.protobuf.FieldMask update_mask = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::update_mask(this),
        _Internal::update_mask(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:deviceapis.device.v1.EditSipTimeoutSettingsRequest)
  return target;
}

::size_t EditSipTimeoutSettingsRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.EditSipTimeoutSettingsRequest)
  ::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 & 0x00000003u) {
    // .deviceapis.device.v1.SipTimeoutSettings data = 1 [(.google.api.field_behavior) = REQUIRED];
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.data_);
    }

    // .google.protobuf.FieldMask update_mask = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.update_mask_);
    }

  }
  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 EditSipTimeoutSettingsRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const EditSipTimeoutSettingsRequest*>(
      &from));
}

void EditSipTimeoutSettingsRequest::MergeFrom(const EditSipTimeoutSettingsRequest& from) {
  EditSipTimeoutSettingsRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:deviceapis.device.v1.EditSipTimeoutSettingsRequest)
  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 & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_mutable_data()->::deviceapis::device::v1::SipTimeoutSettings::MergeFrom(
          from._internal_data());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_internal_mutable_update_mask()->::PROTOBUF_NAMESPACE_ID::FieldMask::MergeFrom(
          from._internal_update_mask());
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void EditSipTimeoutSettingsRequest::CopyFrom(const EditSipTimeoutSettingsRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.EditSipTimeoutSettingsRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void EditSipTimeoutSettingsRequest::InternalSwap(EditSipTimeoutSettingsRequest* 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(EditSipTimeoutSettingsRequest, _impl_.update_mask_)
      + sizeof(EditSipTimeoutSettingsRequest::_impl_.update_mask_)
      - PROTOBUF_FIELD_OFFSET(EditSipTimeoutSettingsRequest, _impl_.data_)>(
          reinterpret_cast<char*>(&_impl_.data_),
          reinterpret_cast<char*>(&other->_impl_.data_));
}

std::string EditSipTimeoutSettingsRequest::GetTypeName() const {
  return "deviceapis.device.v1.EditSipTimeoutSettingsRequest";
}

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

class GetSipTimeoutSettingsRequest::_Internal {
 public:
};

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

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

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

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

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

void GetSipTimeoutSettingsRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.GetSipTimeoutSettingsRequest)
  ::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* GetSipTimeoutSettingsRequest::_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* GetSipTimeoutSettingsRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.GetSipTimeoutSettingsRequest)
  ::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:deviceapis.device.v1.GetSipTimeoutSettingsRequest)
  return target;
}

::size_t GetSipTimeoutSettingsRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.GetSipTimeoutSettingsRequest)
  ::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 GetSipTimeoutSettingsRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetSipTimeoutSettingsRequest*>(
      &from));
}

void GetSipTimeoutSettingsRequest::MergeFrom(const GetSipTimeoutSettingsRequest& from) {
  GetSipTimeoutSettingsRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:deviceapis.device.v1.GetSipTimeoutSettingsRequest)
  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 GetSipTimeoutSettingsRequest::CopyFrom(const GetSipTimeoutSettingsRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.GetSipTimeoutSettingsRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

std::string GetSipTimeoutSettingsRequest::GetTypeName() const {
  return "deviceapis.device.v1.GetSipTimeoutSettingsRequest";
}

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

class GetSipTimeoutSettingsResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::deviceapis::device::v1::GetSipTimeoutSettingsResponse, _impl_._oneof_case_);
  static const ::deviceapis::device::v1::SipTimeoutSettings& data(const GetSipTimeoutSettingsResponse* msg);
};

const ::deviceapis::device::v1::SipTimeoutSettings&
GetSipTimeoutSettingsResponse::_Internal::data(const GetSipTimeoutSettingsResponse* msg) {
  return *msg->_impl_.type_.data_;
}
void GetSipTimeoutSettingsResponse::set_allocated_data(::deviceapis::device::v1::SipTimeoutSettings* 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:deviceapis.device.v1.GetSipTimeoutSettingsResponse.data)
}
GetSipTimeoutSettingsResponse::GetSipTimeoutSettingsResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.GetSipTimeoutSettingsResponse)
}
GetSipTimeoutSettingsResponse::GetSipTimeoutSettingsResponse(const GetSipTimeoutSettingsResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetSipTimeoutSettingsResponse* 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()->::deviceapis::device::v1::SipTimeoutSettings::MergeFrom(
          from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.GetSipTimeoutSettingsResponse)
}

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

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

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

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

void GetSipTimeoutSettingsResponse::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:deviceapis.device.v1.GetSipTimeoutSettingsResponse)
  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 GetSipTimeoutSettingsResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.GetSipTimeoutSettingsResponse)
  ::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* GetSipTimeoutSettingsResponse::_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) {
      // .deviceapis.device.v1.SipTimeoutSettings 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* GetSipTimeoutSettingsResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.GetSipTimeoutSettingsResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .deviceapis.device.v1.SipTimeoutSettings 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:deviceapis.device.v1.GetSipTimeoutSettingsResponse)
  return target;
}

::size_t GetSipTimeoutSettingsResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.GetSipTimeoutSettingsResponse)
  ::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()) {
    // .deviceapis.device.v1.SipTimeoutSettings 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 GetSipTimeoutSettingsResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetSipTimeoutSettingsResponse*>(
      &from));
}

void GetSipTimeoutSettingsResponse::MergeFrom(const GetSipTimeoutSettingsResponse& from) {
  GetSipTimeoutSettingsResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:deviceapis.device.v1.GetSipTimeoutSettingsResponse)
  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()->::deviceapis::device::v1::SipTimeoutSettings::MergeFrom(
          from._internal_data());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetSipTimeoutSettingsResponse::CopyFrom(const GetSipTimeoutSettingsResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.GetSipTimeoutSettingsResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void GetSipTimeoutSettingsResponse::InternalSwap(GetSipTimeoutSettingsResponse* 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 GetSipTimeoutSettingsResponse::GetTypeName() const {
  return "deviceapis.device.v1.GetSipTimeoutSettingsResponse";
}

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

class EditSipAccountResponse_Error::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::deviceapis::device::v1::EditSipAccountResponse_Error, _impl_._oneof_case_);
  static const ::deviceapis::device::v1::ValidationError& validation(const EditSipAccountResponse_Error* msg);
};

const ::deviceapis::device::v1::ValidationError&
EditSipAccountResponse_Error::_Internal::validation(const EditSipAccountResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void EditSipAccountResponse_Error::set_allocated_validation(::deviceapis::device::v1::ValidationError* validation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (validation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(validation));
    if (message_arena != submessage_arena) {
      validation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, validation, submessage_arena);
    }
    set_has_validation();
    _impl_.reason_.validation_ = validation;
  }
  // @@protoc_insertion_point(field_set_allocated:deviceapis.device.v1.EditSipAccountResponse.Error.validation)
}
void EditSipAccountResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
EditSipAccountResponse_Error::EditSipAccountResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.EditSipAccountResponse.Error)
}
EditSipAccountResponse_Error::EditSipAccountResponse_Error(const EditSipAccountResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  EditSipAccountResponse_Error* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_reason();
  switch (from.reason_case()) {
    case kValidation: {
      _this->_internal_mutable_validation()->::deviceapis::device::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.EditSipAccountResponse.Error)
}

inline void EditSipAccountResponse_Error::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_reason();
}

EditSipAccountResponse_Error::~EditSipAccountResponse_Error() {
  // @@protoc_insertion_point(destructor:deviceapis.device.v1.EditSipAccountResponse.Error)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void EditSipAccountResponse_Error::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_reason()) {
    clear_reason();
  }
}

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

void EditSipAccountResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:deviceapis.device.v1.EditSipAccountResponse.Error)
  switch (reason_case()) {
    case kValidation: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.validation_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void EditSipAccountResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.EditSipAccountResponse.Error)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

const char* EditSipAccountResponse_Error::_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) {
      // .deviceapis.device.v1.ValidationError validation = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_validation(), 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* EditSipAccountResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.EditSipAccountResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .deviceapis.device.v1.ValidationError validation = 1;
  if (reason_case() == kValidation) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::validation(this),
        _Internal::validation(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:deviceapis.device.v1.EditSipAccountResponse.Error)
  return target;
}

::size_t EditSipAccountResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.EditSipAccountResponse.Error)
  ::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 (reason_case()) {
    // .deviceapis.device.v1.ValidationError validation = 1;
    case kValidation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.validation_);
      break;
    }
    case REASON_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 EditSipAccountResponse_Error::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const EditSipAccountResponse_Error*>(
      &from));
}

void EditSipAccountResponse_Error::MergeFrom(const EditSipAccountResponse_Error& from) {
  EditSipAccountResponse_Error* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:deviceapis.device.v1.EditSipAccountResponse.Error)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.reason_case()) {
    case kValidation: {
      _this->_internal_mutable_validation()->::deviceapis::device::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void EditSipAccountResponse_Error::CopyFrom(const EditSipAccountResponse_Error& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.EditSipAccountResponse.Error)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

std::string EditSipAccountResponse_Error::GetTypeName() const {
  return "deviceapis.device.v1.EditSipAccountResponse.Error";
}

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

class EditSipAccountResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::deviceapis::device::v1::EditSipAccountResponse, _impl_._oneof_case_);
  static const ::deviceapis::device::v1::EditSipAccountResponse_Error& error(const EditSipAccountResponse* msg);
};

const ::deviceapis::device::v1::EditSipAccountResponse_Error&
EditSipAccountResponse::_Internal::error(const EditSipAccountResponse* msg) {
  return *msg->_impl_.type_.error_;
}
void EditSipAccountResponse::set_allocated_error(::deviceapis::device::v1::EditSipAccountResponse_Error* error) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (error) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(error);
    if (message_arena != submessage_arena) {
      error = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, error, submessage_arena);
    }
    set_has_error();
    _impl_.type_.error_ = error;
  }
  // @@protoc_insertion_point(field_set_allocated:deviceapis.device.v1.EditSipAccountResponse.error)
}
EditSipAccountResponse::EditSipAccountResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.EditSipAccountResponse)
}
EditSipAccountResponse::EditSipAccountResponse(const EditSipAccountResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  EditSipAccountResponse* 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 kError: {
      _this->_internal_mutable_error()->::deviceapis::device::v1::EditSipAccountResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.EditSipAccountResponse)
}

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

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

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

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

void EditSipAccountResponse::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:deviceapis.device.v1.EditSipAccountResponse)
  switch (type_case()) {
    case kError: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.type_.error_;
      }
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}


void EditSipAccountResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.EditSipAccountResponse)
  ::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* EditSipAccountResponse::_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) {
      // .deviceapis.device.v1.EditSipAccountResponse.Error error = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_error(), 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* EditSipAccountResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.EditSipAccountResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .deviceapis.device.v1.EditSipAccountResponse.Error error = 1;
  if (type_case() == kError) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::error(this),
        _Internal::error(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:deviceapis.device.v1.EditSipAccountResponse)
  return target;
}

::size_t EditSipAccountResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.EditSipAccountResponse)
  ::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()) {
    // .deviceapis.device.v1.EditSipAccountResponse.Error error = 1;
    case kError: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.error_);
      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 EditSipAccountResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const EditSipAccountResponse*>(
      &from));
}

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

  switch (from.type_case()) {
    case kError: {
      _this->_internal_mutable_error()->::deviceapis::device::v1::EditSipAccountResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void EditSipAccountResponse::CopyFrom(const EditSipAccountResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.EditSipAccountResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void EditSipAccountResponse::InternalSwap(EditSipAccountResponse* 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 EditSipAccountResponse::GetTypeName() const {
  return "deviceapis.device.v1.EditSipAccountResponse";
}

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

class SipTimeoutSettings::_Internal {
 public:
};

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

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

    , decltype(_impl_.talk_timeout_) { 0 }

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

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

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

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

void SipTimeoutSettings::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.SipTimeoutSettings)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

const char* SipTimeoutSettings::_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 call_timeout = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _impl_.call_timeout_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 talk_timeout = 2 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
          _impl_.talk_timeout_ = ::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* SipTimeoutSettings::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.SipTimeoutSettings)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // int32 call_timeout = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (this->_internal_call_timeout() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        1, this->_internal_call_timeout(), target);
  }

  // int32 talk_timeout = 2 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (this->_internal_talk_timeout() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        2, this->_internal_talk_timeout(), 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:deviceapis.device.v1.SipTimeoutSettings)
  return target;
}

::size_t SipTimeoutSettings::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.SipTimeoutSettings)
  ::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 call_timeout = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (this->_internal_call_timeout() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_call_timeout());
  }

  // int32 talk_timeout = 2 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (this->_internal_talk_timeout() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_talk_timeout());
  }

  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 SipTimeoutSettings::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const SipTimeoutSettings*>(
      &from));
}

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

  if (from._internal_call_timeout() != 0) {
    _this->_internal_set_call_timeout(from._internal_call_timeout());
  }
  if (from._internal_talk_timeout() != 0) {
    _this->_internal_set_talk_timeout(from._internal_talk_timeout());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void SipTimeoutSettings::CopyFrom(const SipTimeoutSettings& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.SipTimeoutSettings)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

std::string SipTimeoutSettings::GetTypeName() const {
  return "deviceapis.device.v1.SipTimeoutSettings";
}

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

class EditSipTimeoutSettingsResponse_Error::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::deviceapis::device::v1::EditSipTimeoutSettingsResponse_Error, _impl_._oneof_case_);
  static const ::deviceapis::device::v1::ValidationError& validation(const EditSipTimeoutSettingsResponse_Error* msg);
};

const ::deviceapis::device::v1::ValidationError&
EditSipTimeoutSettingsResponse_Error::_Internal::validation(const EditSipTimeoutSettingsResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
void EditSipTimeoutSettingsResponse_Error::set_allocated_validation(::deviceapis::device::v1::ValidationError* validation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (validation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(validation));
    if (message_arena != submessage_arena) {
      validation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, validation, submessage_arena);
    }
    set_has_validation();
    _impl_.reason_.validation_ = validation;
  }
  // @@protoc_insertion_point(field_set_allocated:deviceapis.device.v1.EditSipTimeoutSettingsResponse.Error.validation)
}
void EditSipTimeoutSettingsResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
EditSipTimeoutSettingsResponse_Error::EditSipTimeoutSettingsResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.EditSipTimeoutSettingsResponse.Error)
}
EditSipTimeoutSettingsResponse_Error::EditSipTimeoutSettingsResponse_Error(const EditSipTimeoutSettingsResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  EditSipTimeoutSettingsResponse_Error* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_reason();
  switch (from.reason_case()) {
    case kValidation: {
      _this->_internal_mutable_validation()->::deviceapis::device::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.EditSipTimeoutSettingsResponse.Error)
}

inline void EditSipTimeoutSettingsResponse_Error::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.reason_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  clear_has_reason();
}

EditSipTimeoutSettingsResponse_Error::~EditSipTimeoutSettingsResponse_Error() {
  // @@protoc_insertion_point(destructor:deviceapis.device.v1.EditSipTimeoutSettingsResponse.Error)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void EditSipTimeoutSettingsResponse_Error::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  if (has_reason()) {
    clear_reason();
  }
}

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

void EditSipTimeoutSettingsResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:deviceapis.device.v1.EditSipTimeoutSettingsResponse.Error)
  switch (reason_case()) {
    case kValidation: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.validation_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void EditSipTimeoutSettingsResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.EditSipTimeoutSettingsResponse.Error)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

const char* EditSipTimeoutSettingsResponse_Error::_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) {
      // .deviceapis.device.v1.ValidationError validation = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_validation(), 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* EditSipTimeoutSettingsResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.EditSipTimeoutSettingsResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .deviceapis.device.v1.ValidationError validation = 1;
  if (reason_case() == kValidation) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::validation(this),
        _Internal::validation(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:deviceapis.device.v1.EditSipTimeoutSettingsResponse.Error)
  return target;
}

::size_t EditSipTimeoutSettingsResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.EditSipTimeoutSettingsResponse.Error)
  ::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 (reason_case()) {
    // .deviceapis.device.v1.ValidationError validation = 1;
    case kValidation: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.validation_);
      break;
    }
    case REASON_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 EditSipTimeoutSettingsResponse_Error::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const EditSipTimeoutSettingsResponse_Error*>(
      &from));
}

void EditSipTimeoutSettingsResponse_Error::MergeFrom(const EditSipTimeoutSettingsResponse_Error& from) {
  EditSipTimeoutSettingsResponse_Error* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:deviceapis.device.v1.EditSipTimeoutSettingsResponse.Error)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.reason_case()) {
    case kValidation: {
      _this->_internal_mutable_validation()->::deviceapis::device::v1::ValidationError::MergeFrom(
          from._internal_validation());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void EditSipTimeoutSettingsResponse_Error::CopyFrom(const EditSipTimeoutSettingsResponse_Error& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.EditSipTimeoutSettingsResponse.Error)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

std::string EditSipTimeoutSettingsResponse_Error::GetTypeName() const {
  return "deviceapis.device.v1.EditSipTimeoutSettingsResponse.Error";
}

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

class EditSipTimeoutSettingsResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::deviceapis::device::v1::EditSipTimeoutSettingsResponse, _impl_._oneof_case_);
  static const ::deviceapis::device::v1::EditSipTimeoutSettingsResponse_Error& error(const EditSipTimeoutSettingsResponse* msg);
};

const ::deviceapis::device::v1::EditSipTimeoutSettingsResponse_Error&
EditSipTimeoutSettingsResponse::_Internal::error(const EditSipTimeoutSettingsResponse* msg) {
  return *msg->_impl_.type_.error_;
}
void EditSipTimeoutSettingsResponse::set_allocated_error(::deviceapis::device::v1::EditSipTimeoutSettingsResponse_Error* error) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_type();
  if (error) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(error);
    if (message_arena != submessage_arena) {
      error = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, error, submessage_arena);
    }
    set_has_error();
    _impl_.type_.error_ = error;
  }
  // @@protoc_insertion_point(field_set_allocated:deviceapis.device.v1.EditSipTimeoutSettingsResponse.error)
}
EditSipTimeoutSettingsResponse::EditSipTimeoutSettingsResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.EditSipTimeoutSettingsResponse)
}
EditSipTimeoutSettingsResponse::EditSipTimeoutSettingsResponse(const EditSipTimeoutSettingsResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  EditSipTimeoutSettingsResponse* 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 kError: {
      _this->_internal_mutable_error()->::deviceapis::device::v1::EditSipTimeoutSettingsResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.EditSipTimeoutSettingsResponse)
}

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

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

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

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

void EditSipTimeoutSettingsResponse::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:deviceapis.device.v1.EditSipTimeoutSettingsResponse)
  switch (type_case()) {
    case kError: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.type_.error_;
      }
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}


void EditSipTimeoutSettingsResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.EditSipTimeoutSettingsResponse)
  ::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* EditSipTimeoutSettingsResponse::_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) {
      // .deviceapis.device.v1.EditSipTimeoutSettingsResponse.Error error = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_error(), 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* EditSipTimeoutSettingsResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.EditSipTimeoutSettingsResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .deviceapis.device.v1.EditSipTimeoutSettingsResponse.Error error = 1;
  if (type_case() == kError) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::error(this),
        _Internal::error(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:deviceapis.device.v1.EditSipTimeoutSettingsResponse)
  return target;
}

::size_t EditSipTimeoutSettingsResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.EditSipTimeoutSettingsResponse)
  ::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()) {
    // .deviceapis.device.v1.EditSipTimeoutSettingsResponse.Error error = 1;
    case kError: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.error_);
      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 EditSipTimeoutSettingsResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const EditSipTimeoutSettingsResponse*>(
      &from));
}

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

  switch (from.type_case()) {
    case kError: {
      _this->_internal_mutable_error()->::deviceapis::device::v1::EditSipTimeoutSettingsResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void EditSipTimeoutSettingsResponse::CopyFrom(const EditSipTimeoutSettingsResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.EditSipTimeoutSettingsResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void EditSipTimeoutSettingsResponse::InternalSwap(EditSipTimeoutSettingsResponse* 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 EditSipTimeoutSettingsResponse::GetTypeName() const {
  return "deviceapis.device.v1.EditSipTimeoutSettingsResponse";
}

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

class GetSipAccountStatusListRequest::_Internal {
 public:
};

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

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

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

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

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

void GetSipAccountStatusListRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.GetSipAccountStatusListRequest)
  ::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* GetSipAccountStatusListRequest::_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* GetSipAccountStatusListRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.GetSipAccountStatusListRequest)
  ::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:deviceapis.device.v1.GetSipAccountStatusListRequest)
  return target;
}

::size_t GetSipAccountStatusListRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.GetSipAccountStatusListRequest)
  ::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 GetSipAccountStatusListRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetSipAccountStatusListRequest*>(
      &from));
}

void GetSipAccountStatusListRequest::MergeFrom(const GetSipAccountStatusListRequest& from) {
  GetSipAccountStatusListRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:deviceapis.device.v1.GetSipAccountStatusListRequest)
  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 GetSipAccountStatusListRequest::CopyFrom(const GetSipAccountStatusListRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.GetSipAccountStatusListRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

std::string GetSipAccountStatusListRequest::GetTypeName() const {
  return "deviceapis.device.v1.GetSipAccountStatusListRequest";
}

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

class GetSipAccountStatusListResponse_SipStatus::_Internal {
 public:
};

GetSipAccountStatusListResponse_SipStatus::GetSipAccountStatusListResponse_SipStatus(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.GetSipAccountStatusListResponse.SipStatus)
}
GetSipAccountStatusListResponse_SipStatus::GetSipAccountStatusListResponse_SipStatus(const GetSipAccountStatusListResponse_SipStatus& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetSipAccountStatusListResponse_SipStatus* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.sip_account_id_) {}

    , decltype(_impl_.state_type_) {}

    , decltype(_impl_.last_attempt_register_at_) {}

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.sip_account_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.sip_account_id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_sip_account_id().empty()) {
    _this->_impl_.sip_account_id_.Set(from._internal_sip_account_id(), _this->GetArenaForAllocation());
  }
  ::memcpy(&_impl_.state_type_, &from._impl_.state_type_,
    static_cast<::size_t>(reinterpret_cast<char*>(&_impl_.last_attempt_register_at_) -
    reinterpret_cast<char*>(&_impl_.state_type_)) + sizeof(_impl_.last_attempt_register_at_));
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.GetSipAccountStatusListResponse.SipStatus)
}

inline void GetSipAccountStatusListResponse_SipStatus::SharedCtor(::_pb::Arena* arena) {
  (void)arena;
  new (&_impl_) Impl_{
      decltype(_impl_.sip_account_id_) {}

    , decltype(_impl_.state_type_) { 0 }

    , decltype(_impl_.last_attempt_register_at_) { 0 }

    , /*decltype(_impl_._cached_size_)*/{}
  };
  _impl_.sip_account_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.sip_account_id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
}

GetSipAccountStatusListResponse_SipStatus::~GetSipAccountStatusListResponse_SipStatus() {
  // @@protoc_insertion_point(destructor:deviceapis.device.v1.GetSipAccountStatusListResponse.SipStatus)
  if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
  (void)arena;
    return;
  }
  SharedDtor();
}

inline void GetSipAccountStatusListResponse_SipStatus::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.sip_account_id_.Destroy();
}

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

void GetSipAccountStatusListResponse_SipStatus::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.GetSipAccountStatusListResponse.SipStatus)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

const char* GetSipAccountStatusListResponse_SipStatus::_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) {
      // string sip_account_id = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_sip_account_id();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .deviceapis.device.v1.GetSipAccountStatusListResponse.SipStatus.StateType state_type = 2 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      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_state_type(static_cast<::deviceapis::device::v1::GetSipAccountStatusListResponse_SipStatus_StateType>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 last_attempt_register_at = 3 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
          _impl_.last_attempt_register_at_ = ::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* GetSipAccountStatusListResponse_SipStatus::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.GetSipAccountStatusListResponse.SipStatus)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string sip_account_id = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (!this->_internal_sip_account_id().empty()) {
    const std::string& _s = this->_internal_sip_account_id();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "deviceapis.device.v1.GetSipAccountStatusListResponse.SipStatus.sip_account_id");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  // .deviceapis.device.v1.GetSipAccountStatusListResponse.SipStatus.StateType state_type = 2 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (this->_internal_state_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        2, this->_internal_state_type(), target);
  }

  // int32 last_attempt_register_at = 3 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (this->_internal_last_attempt_register_at() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt32ToArray(
        3, this->_internal_last_attempt_register_at(), 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:deviceapis.device.v1.GetSipAccountStatusListResponse.SipStatus)
  return target;
}

::size_t GetSipAccountStatusListResponse_SipStatus::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.GetSipAccountStatusListResponse.SipStatus)
  ::size_t total_size = 0;

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

  // string sip_account_id = 1 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (!this->_internal_sip_account_id().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_sip_account_id());
  }

  // .deviceapis.device.v1.GetSipAccountStatusListResponse.SipStatus.StateType state_type = 2 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (this->_internal_state_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_state_type());
  }

  // int32 last_attempt_register_at = 3 [(.grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field) = {
  if (this->_internal_last_attempt_register_at() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_last_attempt_register_at());
  }

  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 GetSipAccountStatusListResponse_SipStatus::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetSipAccountStatusListResponse_SipStatus*>(
      &from));
}

void GetSipAccountStatusListResponse_SipStatus::MergeFrom(const GetSipAccountStatusListResponse_SipStatus& from) {
  GetSipAccountStatusListResponse_SipStatus* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:deviceapis.device.v1.GetSipAccountStatusListResponse.SipStatus)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_sip_account_id().empty()) {
    _this->_internal_set_sip_account_id(from._internal_sip_account_id());
  }
  if (from._internal_state_type() != 0) {
    _this->_internal_set_state_type(from._internal_state_type());
  }
  if (from._internal_last_attempt_register_at() != 0) {
    _this->_internal_set_last_attempt_register_at(from._internal_last_attempt_register_at());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

void GetSipAccountStatusListResponse_SipStatus::CopyFrom(const GetSipAccountStatusListResponse_SipStatus& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.GetSipAccountStatusListResponse.SipStatus)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

void GetSipAccountStatusListResponse_SipStatus::InternalSwap(GetSipAccountStatusListResponse_SipStatus* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.sip_account_id_, lhs_arena,
                                       &other->_impl_.sip_account_id_, rhs_arena);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(GetSipAccountStatusListResponse_SipStatus, _impl_.last_attempt_register_at_)
      + sizeof(GetSipAccountStatusListResponse_SipStatus::_impl_.last_attempt_register_at_)
      - PROTOBUF_FIELD_OFFSET(GetSipAccountStatusListResponse_SipStatus, _impl_.state_type_)>(
          reinterpret_cast<char*>(&_impl_.state_type_),
          reinterpret_cast<char*>(&other->_impl_.state_type_));
}

std::string GetSipAccountStatusListResponse_SipStatus::GetTypeName() const {
  return "deviceapis.device.v1.GetSipAccountStatusListResponse.SipStatus";
}

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

class GetSipAccountStatusListResponse::_Internal {
 public:
};

GetSipAccountStatusListResponse::GetSipAccountStatusListResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.GetSipAccountStatusListResponse)
}
GetSipAccountStatusListResponse::GetSipAccountStatusListResponse(const GetSipAccountStatusListResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetSipAccountStatusListResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.data_){from._impl_.data_}
    , /*decltype(_impl_._cached_size_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.GetSipAccountStatusListResponse)
}

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

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

inline void GetSipAccountStatusListResponse::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _internal_mutable_data()->~RepeatedPtrField();
}

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

void GetSipAccountStatusListResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.GetSipAccountStatusListResponse)
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

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

const char* GetSipAccountStatusListResponse::_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 .deviceapis.device.v1.GetSipAccountStatusListResponse.SipStatus data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_data(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(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* GetSipAccountStatusListResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.GetSipAccountStatusListResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .deviceapis.device.v1.GetSipAccountStatusListResponse.SipStatus data = 1;
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_data_size()); i < n; i++) {
    const auto& repfield = this->_internal_data(i);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, repfield, repfield.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:deviceapis.device.v1.GetSipAccountStatusListResponse)
  return target;
}

::size_t GetSipAccountStatusListResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.GetSipAccountStatusListResponse)
  ::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 .deviceapis.device.v1.GetSipAccountStatusListResponse.SipStatus data = 1;
  total_size += 1UL * this->_internal_data_size();
  for (const auto& msg : this->_internal_data()) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  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 GetSipAccountStatusListResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetSipAccountStatusListResponse*>(
      &from));
}

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

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

void GetSipAccountStatusListResponse::CopyFrom(const GetSipAccountStatusListResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:deviceapis.device.v1.GetSipAccountStatusListResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

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

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

std::string GetSipAccountStatusListResponse::GetTypeName() const {
  return "deviceapis.device.v1.GetSipAccountStatusListResponse";
}

// @@protoc_insertion_point(namespace_scope)
}  // namespace v1
}  // namespace device
}  // namespace deviceapis
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::GetSipAccountListRequest*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::GetSipAccountListRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::GetSipAccountListRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::GetSipAccountListResponse*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::GetSipAccountListResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::GetSipAccountListResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::EditSipAccountRequest*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::EditSipAccountRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::EditSipAccountRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::SipAccount*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::SipAccount >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::SipAccount >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::EditSipTimeoutSettingsRequest*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::EditSipTimeoutSettingsRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::EditSipTimeoutSettingsRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::GetSipTimeoutSettingsRequest*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::GetSipTimeoutSettingsRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::GetSipTimeoutSettingsRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::GetSipTimeoutSettingsResponse*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::GetSipTimeoutSettingsResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::GetSipTimeoutSettingsResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::EditSipAccountResponse_Error*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::EditSipAccountResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::EditSipAccountResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::EditSipAccountResponse*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::EditSipAccountResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::EditSipAccountResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::SipTimeoutSettings*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::SipTimeoutSettings >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::SipTimeoutSettings >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::EditSipTimeoutSettingsResponse_Error*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::EditSipTimeoutSettingsResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::EditSipTimeoutSettingsResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::EditSipTimeoutSettingsResponse*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::EditSipTimeoutSettingsResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::EditSipTimeoutSettingsResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::GetSipAccountStatusListRequest*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::GetSipAccountStatusListRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::GetSipAccountStatusListRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::GetSipAccountStatusListResponse_SipStatus*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::GetSipAccountStatusListResponse_SipStatus >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::GetSipAccountStatusListResponse_SipStatus >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::GetSipAccountStatusListResponse*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::GetSipAccountStatusListResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::GetSipAccountStatusListResponse >(arena);
}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"