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

#include "deviceapis/device/v1/deviceapis_device_encryption_profile_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 DeleteEncryptionProfileListRequest::DeleteEncryptionProfileListRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct DeleteEncryptionProfileListRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR DeleteEncryptionProfileListRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~DeleteEncryptionProfileListRequestDefaultTypeInternal() {}
  union {
    DeleteEncryptionProfileListRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeleteEncryptionProfileListRequestDefaultTypeInternal _DeleteEncryptionProfileListRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR DeleteEncryptionProfileListResponse_Error::DeleteEncryptionProfileListResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct DeleteEncryptionProfileListResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR DeleteEncryptionProfileListResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~DeleteEncryptionProfileListResponse_ErrorDefaultTypeInternal() {}
  union {
    DeleteEncryptionProfileListResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeleteEncryptionProfileListResponse_ErrorDefaultTypeInternal _DeleteEncryptionProfileListResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR DeleteEncryptionProfileListResponse::DeleteEncryptionProfileListResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct DeleteEncryptionProfileListResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR DeleteEncryptionProfileListResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~DeleteEncryptionProfileListResponseDefaultTypeInternal() {}
  union {
    DeleteEncryptionProfileListResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeleteEncryptionProfileListResponseDefaultTypeInternal _DeleteEncryptionProfileListResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR DeleteEncryptionProfileRequest::DeleteEncryptionProfileRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.id_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeleteEncryptionProfileRequestDefaultTypeInternal _DeleteEncryptionProfileRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR DeleteEncryptionProfileResponse_Error::DeleteEncryptionProfileResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct DeleteEncryptionProfileResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR DeleteEncryptionProfileResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~DeleteEncryptionProfileResponse_ErrorDefaultTypeInternal() {}
  union {
    DeleteEncryptionProfileResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeleteEncryptionProfileResponse_ErrorDefaultTypeInternal _DeleteEncryptionProfileResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR DeleteEncryptionProfileResponse::DeleteEncryptionProfileResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct DeleteEncryptionProfileResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR DeleteEncryptionProfileResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~DeleteEncryptionProfileResponseDefaultTypeInternal() {}
  union {
    DeleteEncryptionProfileResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DeleteEncryptionProfileResponseDefaultTypeInternal _DeleteEncryptionProfileResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR EncryptionProfile_DeletingError_EncryptionProfileInUse::EncryptionProfile_DeletingError_EncryptionProfileInUse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct EncryptionProfile_DeletingError_EncryptionProfileInUseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR EncryptionProfile_DeletingError_EncryptionProfileInUseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~EncryptionProfile_DeletingError_EncryptionProfileInUseDefaultTypeInternal() {}
  union {
    EncryptionProfile_DeletingError_EncryptionProfileInUse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EncryptionProfile_DeletingError_EncryptionProfileInUseDefaultTypeInternal _EncryptionProfile_DeletingError_EncryptionProfileInUse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR EncryptionProfile_DeletingError::EncryptionProfile_DeletingError(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.id_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

  , /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct EncryptionProfile_DeletingErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR EncryptionProfile_DeletingErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~EncryptionProfile_DeletingErrorDefaultTypeInternal() {}
  union {
    EncryptionProfile_DeletingError _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EncryptionProfile_DeletingErrorDefaultTypeInternal _EncryptionProfile_DeletingError_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR EncryptionProfile_SavingError_DuplicateName::EncryptionProfile_SavingError_DuplicateName(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct EncryptionProfile_SavingError_DuplicateNameDefaultTypeInternal {
  PROTOBUF_CONSTEXPR EncryptionProfile_SavingError_DuplicateNameDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~EncryptionProfile_SavingError_DuplicateNameDefaultTypeInternal() {}
  union {
    EncryptionProfile_SavingError_DuplicateName _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EncryptionProfile_SavingError_DuplicateNameDefaultTypeInternal _EncryptionProfile_SavingError_DuplicateName_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR EncryptionProfile_SavingError_TooMuchEncryptionProfiles::EncryptionProfile_SavingError_TooMuchEncryptionProfiles(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._cached_size_)*/{}} {}
struct EncryptionProfile_SavingError_TooMuchEncryptionProfilesDefaultTypeInternal {
  PROTOBUF_CONSTEXPR EncryptionProfile_SavingError_TooMuchEncryptionProfilesDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~EncryptionProfile_SavingError_TooMuchEncryptionProfilesDefaultTypeInternal() {}
  union {
    EncryptionProfile_SavingError_TooMuchEncryptionProfiles _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EncryptionProfile_SavingError_TooMuchEncryptionProfilesDefaultTypeInternal _EncryptionProfile_SavingError_TooMuchEncryptionProfiles_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR EncryptionProfile_SavingError::EncryptionProfile_SavingError(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct EncryptionProfile_SavingErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR EncryptionProfile_SavingErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~EncryptionProfile_SavingErrorDefaultTypeInternal() {}
  union {
    EncryptionProfile_SavingError _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EncryptionProfile_SavingErrorDefaultTypeInternal _EncryptionProfile_SavingError_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR EncryptionProfile::EncryptionProfile(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.id_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

  , /*decltype(_impl_.title_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

  , /*decltype(_impl_.password_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

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

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

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

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EncryptionProfileDefaultTypeInternal _EncryptionProfile_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR EncryptionProfileFilter::EncryptionProfileFilter(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.text_)*/nullptr} {}
struct EncryptionProfileFilterDefaultTypeInternal {
  PROTOBUF_CONSTEXPR EncryptionProfileFilterDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~EncryptionProfileFilterDefaultTypeInternal() {}
  union {
    EncryptionProfileFilter _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EncryptionProfileFilterDefaultTypeInternal _EncryptionProfileFilter_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetEncryptionProfileListRequest::GetEncryptionProfileListRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.filter_)*/nullptr} {}
struct GetEncryptionProfileListRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetEncryptionProfileListRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetEncryptionProfileListRequestDefaultTypeInternal() {}
  union {
    GetEncryptionProfileListRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetEncryptionProfileListRequestDefaultTypeInternal _GetEncryptionProfileListRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetEncryptionProfileListResponse::GetEncryptionProfileListResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.data_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}} {}
struct GetEncryptionProfileListResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetEncryptionProfileListResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetEncryptionProfileListResponseDefaultTypeInternal() {}
  union {
    GetEncryptionProfileListResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetEncryptionProfileListResponseDefaultTypeInternal _GetEncryptionProfileListResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetEncryptionProfileRequest::GetEncryptionProfileRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.id_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetEncryptionProfileRequestDefaultTypeInternal _GetEncryptionProfileRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetEncryptionProfileResponse::GetEncryptionProfileResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetEncryptionProfileResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetEncryptionProfileResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetEncryptionProfileResponseDefaultTypeInternal() {}
  union {
    GetEncryptionProfileResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetEncryptionProfileResponseDefaultTypeInternal _GetEncryptionProfileResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SaveEncryptionProfileRequest::SaveEncryptionProfileRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.data_)*/nullptr} {}
struct SaveEncryptionProfileRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SaveEncryptionProfileRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SaveEncryptionProfileRequestDefaultTypeInternal() {}
  union {
    SaveEncryptionProfileRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SaveEncryptionProfileRequestDefaultTypeInternal _SaveEncryptionProfileRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SaveEncryptionProfileResponse_Error::SaveEncryptionProfileResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct SaveEncryptionProfileResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SaveEncryptionProfileResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SaveEncryptionProfileResponse_ErrorDefaultTypeInternal() {}
  union {
    SaveEncryptionProfileResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SaveEncryptionProfileResponse_ErrorDefaultTypeInternal _SaveEncryptionProfileResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR SaveEncryptionProfileResponse::SaveEncryptionProfileResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct SaveEncryptionProfileResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SaveEncryptionProfileResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SaveEncryptionProfileResponseDefaultTypeInternal() {}
  union {
    SaveEncryptionProfileResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SaveEncryptionProfileResponseDefaultTypeInternal _SaveEncryptionProfileResponse_default_instance_;
}  // namespace v1
}  // namespace device
}  // namespace deviceapis
namespace deviceapis {
namespace device {
namespace v1 {
bool EncryptionProfile_Type_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}
static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string>
    EncryptionProfile_Type_strings[3] = {};

static const char EncryptionProfile_Type_names[] = {
    "SL1"
    "SL3"
    "TYPE_UNKNOWN"
};

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry EncryptionProfile_Type_entries[] =
    {
        {{&EncryptionProfile_Type_names[0], 3}, 2},
        {{&EncryptionProfile_Type_names[3], 3}, 1},
        {{&EncryptionProfile_Type_names[6], 12}, 0},
};

static const int EncryptionProfile_Type_entries_by_number[] = {
    2,  // 0 -> TYPE_UNKNOWN
    1,  // 1 -> SL3
    0,  // 2 -> SL1
};

const std::string& EncryptionProfile_Type_Name(EncryptionProfile_Type value) {
  static const bool kDummy =
      ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
          EncryptionProfile_Type_entries, EncryptionProfile_Type_entries_by_number,
          3, EncryptionProfile_Type_strings);
  (void)kDummy;

  int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
      EncryptionProfile_Type_entries, EncryptionProfile_Type_entries_by_number, 3,
      value);
  return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString()
                   : EncryptionProfile_Type_strings[idx].get();
}

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

constexpr EncryptionProfile_Type EncryptionProfile::TYPE_UNKNOWN;
constexpr EncryptionProfile_Type EncryptionProfile::SL3;
constexpr EncryptionProfile_Type EncryptionProfile::SL1;
constexpr EncryptionProfile_Type EncryptionProfile::Type_MIN;
constexpr EncryptionProfile_Type EncryptionProfile::Type_MAX;
constexpr int EncryptionProfile::Type_ARRAYSIZE;

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

class DeleteEncryptionProfileListRequest::_Internal {
 public:
};

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

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

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

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

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

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

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

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

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

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

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

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

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

const ::deviceapis::device::v1::ValidationError&
DeleteEncryptionProfileListResponse_Error::_Internal::validation(const DeleteEncryptionProfileListResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
const ::deviceapis::device::v1::EncryptionProfile_DeletingError&
DeleteEncryptionProfileListResponse_Error::_Internal::deleting(const DeleteEncryptionProfileListResponse_Error* msg) {
  return *msg->_impl_.reason_.deleting_;
}
void DeleteEncryptionProfileListResponse_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.DeleteEncryptionProfileListResponse.Error.validation)
}
void DeleteEncryptionProfileListResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
void DeleteEncryptionProfileListResponse_Error::set_allocated_deleting(::deviceapis::device::v1::EncryptionProfile_DeletingError* deleting) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (deleting) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(deleting);
    if (message_arena != submessage_arena) {
      deleting = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, deleting, submessage_arena);
    }
    set_has_deleting();
    _impl_.reason_.deleting_ = deleting;
  }
  // @@protoc_insertion_point(field_set_allocated:deviceapis.device.v1.DeleteEncryptionProfileListResponse.Error.deleting)
}
DeleteEncryptionProfileListResponse_Error::DeleteEncryptionProfileListResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.DeleteEncryptionProfileListResponse.Error)
}
DeleteEncryptionProfileListResponse_Error::DeleteEncryptionProfileListResponse_Error(const DeleteEncryptionProfileListResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  DeleteEncryptionProfileListResponse_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 kDeleting: {
      _this->_internal_mutable_deleting()->::deviceapis::device::v1::EncryptionProfile_DeletingError::MergeFrom(
          from._internal_deleting());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.DeleteEncryptionProfileListResponse.Error)
}

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

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

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

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

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


void DeleteEncryptionProfileListResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.DeleteEncryptionProfileListResponse.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* DeleteEncryptionProfileListResponse_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;
      // .deviceapis.device.v1.EncryptionProfile.DeletingError deleting = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_deleting(), 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* DeleteEncryptionProfileListResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.DeleteEncryptionProfileListResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (reason_case()) {
    case kValidation: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::validation(this),
          _Internal::validation(this).GetCachedSize(), target, stream);
      break;
    }
    case kDeleting: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::deleting(this),
          _Internal::deleting(this).GetCachedSize(), target, stream);
      break;
    }
    default: ;
  }
  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.DeleteEncryptionProfileListResponse.Error)
  return target;
}

::size_t DeleteEncryptionProfileListResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.DeleteEncryptionProfileListResponse.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;
    }
    // .deviceapis.device.v1.EncryptionProfile.DeletingError deleting = 2;
    case kDeleting: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.deleting_);
      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 DeleteEncryptionProfileListResponse_Error::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const DeleteEncryptionProfileListResponse_Error*>(
      &from));
}

void DeleteEncryptionProfileListResponse_Error::MergeFrom(const DeleteEncryptionProfileListResponse_Error& from) {
  DeleteEncryptionProfileListResponse_Error* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:deviceapis.device.v1.DeleteEncryptionProfileListResponse.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 kDeleting: {
      _this->_internal_mutable_deleting()->::deviceapis::device::v1::EncryptionProfile_DeletingError::MergeFrom(
          from._internal_deleting());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

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

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

const ::deviceapis::device::v1::DeleteEncryptionProfileListResponse_Error&
DeleteEncryptionProfileListResponse::_Internal::error(const DeleteEncryptionProfileListResponse* msg) {
  return *msg->_impl_.type_.error_;
}
void DeleteEncryptionProfileListResponse::set_allocated_error(::deviceapis::device::v1::DeleteEncryptionProfileListResponse_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.DeleteEncryptionProfileListResponse.error)
}
DeleteEncryptionProfileListResponse::DeleteEncryptionProfileListResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.DeleteEncryptionProfileListResponse)
}
DeleteEncryptionProfileListResponse::DeleteEncryptionProfileListResponse(const DeleteEncryptionProfileListResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  DeleteEncryptionProfileListResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_type();
  switch (from.type_case()) {
    case kData: {
      _this->_internal_set_data(from._internal_data());
      break;
    }
    case kError: {
      _this->_internal_mutable_error()->::deviceapis::device::v1::DeleteEncryptionProfileListResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.DeleteEncryptionProfileListResponse)
}

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

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

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

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

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


void DeleteEncryptionProfileListResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.DeleteEncryptionProfileListResponse)
  ::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* DeleteEncryptionProfileListResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int32 data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _internal_set_data(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .deviceapis.device.v1.DeleteEncryptionProfileListResponse.Error error = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          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* DeleteEncryptionProfileListResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.DeleteEncryptionProfileListResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (type_case()) {
    case kData: {
      target = stream->EnsureSpace(target);
      target = ::_pbi::WireFormatLite::WriteInt32ToArray(
          1, this->_internal_data(), target);
      break;
    }
    case kError: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::error(this),
          _Internal::error(this).GetCachedSize(), target, stream);
      break;
    }
    default: ;
  }
  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.DeleteEncryptionProfileListResponse)
  return target;
}

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

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

  switch (type_case()) {
    // int32 data = 1;
    case kData: {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this->_internal_data());
      break;
    }
    // .deviceapis.device.v1.DeleteEncryptionProfileListResponse.Error error = 2;
    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 DeleteEncryptionProfileListResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const DeleteEncryptionProfileListResponse*>(
      &from));
}

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

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

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

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

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

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

class DeleteEncryptionProfileRequest::_Internal {
 public:
};

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

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_id().empty()) {
    _this->_impl_.id_.Set(from._internal_id(), _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.DeleteEncryptionProfileRequest)
}

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

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

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

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

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

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

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

const char* DeleteEncryptionProfileRequest::_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 id = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_id();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } 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* DeleteEncryptionProfileRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.DeleteEncryptionProfileRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_id().empty()) {
    const std::string& _s = this->_internal_id();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "deviceapis.device.v1.DeleteEncryptionProfileRequest.id");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

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

::size_t DeleteEncryptionProfileRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.DeleteEncryptionProfileRequest)
  ::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 id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_id().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_id());
  }

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

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

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

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

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

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

void DeleteEncryptionProfileRequest::InternalSwap(DeleteEncryptionProfileRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.id_, lhs_arena,
                                       &other->_impl_.id_, rhs_arena);
}

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

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

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

const ::deviceapis::device::v1::ValidationError&
DeleteEncryptionProfileResponse_Error::_Internal::validation(const DeleteEncryptionProfileResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
const ::deviceapis::device::v1::EncryptionProfile_DeletingError&
DeleteEncryptionProfileResponse_Error::_Internal::deleting(const DeleteEncryptionProfileResponse_Error* msg) {
  return *msg->_impl_.reason_.deleting_;
}
void DeleteEncryptionProfileResponse_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.DeleteEncryptionProfileResponse.Error.validation)
}
void DeleteEncryptionProfileResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
void DeleteEncryptionProfileResponse_Error::set_allocated_deleting(::deviceapis::device::v1::EncryptionProfile_DeletingError* deleting) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (deleting) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(deleting);
    if (message_arena != submessage_arena) {
      deleting = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, deleting, submessage_arena);
    }
    set_has_deleting();
    _impl_.reason_.deleting_ = deleting;
  }
  // @@protoc_insertion_point(field_set_allocated:deviceapis.device.v1.DeleteEncryptionProfileResponse.Error.deleting)
}
DeleteEncryptionProfileResponse_Error::DeleteEncryptionProfileResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.DeleteEncryptionProfileResponse.Error)
}
DeleteEncryptionProfileResponse_Error::DeleteEncryptionProfileResponse_Error(const DeleteEncryptionProfileResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  DeleteEncryptionProfileResponse_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 kDeleting: {
      _this->_internal_mutable_deleting()->::deviceapis::device::v1::EncryptionProfile_DeletingError::MergeFrom(
          from._internal_deleting());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.DeleteEncryptionProfileResponse.Error)
}

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

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

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

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

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


void DeleteEncryptionProfileResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.DeleteEncryptionProfileResponse.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* DeleteEncryptionProfileResponse_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;
      // .deviceapis.device.v1.EncryptionProfile.DeletingError deleting = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_deleting(), 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* DeleteEncryptionProfileResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.DeleteEncryptionProfileResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (reason_case()) {
    case kValidation: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::validation(this),
          _Internal::validation(this).GetCachedSize(), target, stream);
      break;
    }
    case kDeleting: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::deleting(this),
          _Internal::deleting(this).GetCachedSize(), target, stream);
      break;
    }
    default: ;
  }
  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.DeleteEncryptionProfileResponse.Error)
  return target;
}

::size_t DeleteEncryptionProfileResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.DeleteEncryptionProfileResponse.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;
    }
    // .deviceapis.device.v1.EncryptionProfile.DeletingError deleting = 2;
    case kDeleting: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.deleting_);
      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 DeleteEncryptionProfileResponse_Error::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const DeleteEncryptionProfileResponse_Error*>(
      &from));
}

void DeleteEncryptionProfileResponse_Error::MergeFrom(const DeleteEncryptionProfileResponse_Error& from) {
  DeleteEncryptionProfileResponse_Error* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:deviceapis.device.v1.DeleteEncryptionProfileResponse.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 kDeleting: {
      _this->_internal_mutable_deleting()->::deviceapis::device::v1::EncryptionProfile_DeletingError::MergeFrom(
          from._internal_deleting());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

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

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

const ::deviceapis::device::v1::DeleteEncryptionProfileResponse_Error&
DeleteEncryptionProfileResponse::_Internal::error(const DeleteEncryptionProfileResponse* msg) {
  return *msg->_impl_.type_.error_;
}
void DeleteEncryptionProfileResponse::set_allocated_error(::deviceapis::device::v1::DeleteEncryptionProfileResponse_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.DeleteEncryptionProfileResponse.error)
}
DeleteEncryptionProfileResponse::DeleteEncryptionProfileResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.DeleteEncryptionProfileResponse)
}
DeleteEncryptionProfileResponse::DeleteEncryptionProfileResponse(const DeleteEncryptionProfileResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  DeleteEncryptionProfileResponse* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.type_){}
    , /*decltype(_impl_._cached_size_)*/{}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_type();
  switch (from.type_case()) {
    case kData: {
      _this->_internal_set_data(from._internal_data());
      break;
    }
    case kError: {
      _this->_internal_mutable_error()->::deviceapis::device::v1::DeleteEncryptionProfileResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.DeleteEncryptionProfileResponse)
}

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

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

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

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

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


void DeleteEncryptionProfileResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.DeleteEncryptionProfileResponse)
  ::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* DeleteEncryptionProfileResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // int32 data = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
          _internal_set_data(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .deviceapis.device.v1.DeleteEncryptionProfileResponse.Error error = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          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* DeleteEncryptionProfileResponse::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.DeleteEncryptionProfileResponse)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (type_case()) {
    case kData: {
      target = stream->EnsureSpace(target);
      target = ::_pbi::WireFormatLite::WriteInt32ToArray(
          1, this->_internal_data(), target);
      break;
    }
    case kError: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::error(this),
          _Internal::error(this).GetCachedSize(), target, stream);
      break;
    }
    default: ;
  }
  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.DeleteEncryptionProfileResponse)
  return target;
}

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

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

  switch (type_case()) {
    // int32 data = 1;
    case kData: {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this->_internal_data());
      break;
    }
    // .deviceapis.device.v1.DeleteEncryptionProfileResponse.Error error = 2;
    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 DeleteEncryptionProfileResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const DeleteEncryptionProfileResponse*>(
      &from));
}

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

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

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

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

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

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

class EncryptionProfile_DeletingError_EncryptionProfileInUse::_Internal {
 public:
};

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

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

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

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

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

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

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

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

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

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

std::string EncryptionProfile_DeletingError_EncryptionProfileInUse::GetTypeName() const {
  return "deviceapis.device.v1.EncryptionProfile.DeletingError.EncryptionProfileInUse";
}

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

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

const ::deviceapis::device::v1::EncryptionProfile_DeletingError_EncryptionProfileInUse&
EncryptionProfile_DeletingError::_Internal::encryption_profile_in_use(const EncryptionProfile_DeletingError* msg) {
  return *msg->_impl_.reason_.encryption_profile_in_use_;
}
void EncryptionProfile_DeletingError::set_allocated_encryption_profile_in_use(::deviceapis::device::v1::EncryptionProfile_DeletingError_EncryptionProfileInUse* encryption_profile_in_use) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (encryption_profile_in_use) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(encryption_profile_in_use);
    if (message_arena != submessage_arena) {
      encryption_profile_in_use = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, encryption_profile_in_use, submessage_arena);
    }
    set_has_encryption_profile_in_use();
    _impl_.reason_.encryption_profile_in_use_ = encryption_profile_in_use;
  }
  // @@protoc_insertion_point(field_set_allocated:deviceapis.device.v1.EncryptionProfile.DeletingError.encryption_profile_in_use)
}
EncryptionProfile_DeletingError::EncryptionProfile_DeletingError(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.EncryptionProfile.DeletingError)
}
EncryptionProfile_DeletingError::EncryptionProfile_DeletingError(const EncryptionProfile_DeletingError& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  EncryptionProfile_DeletingError* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.id_) {}

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_id().empty()) {
    _this->_impl_.id_.Set(from._internal_id(), _this->GetArenaForAllocation());
  }
  clear_has_reason();
  switch (from.reason_case()) {
    case kEncryptionProfileInUse: {
      _this->_internal_mutable_encryption_profile_in_use()->::deviceapis::device::v1::EncryptionProfile_DeletingError_EncryptionProfileInUse::MergeFrom(
          from._internal_encryption_profile_in_use());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.EncryptionProfile.DeletingError)
}

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

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

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

inline void EncryptionProfile_DeletingError::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.id_.Destroy();
  if (has_reason()) {
    clear_reason();
  }
}

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

void EncryptionProfile_DeletingError::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:deviceapis.device.v1.EncryptionProfile.DeletingError)
  switch (reason_case()) {
    case kEncryptionProfileInUse: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.encryption_profile_in_use_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


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

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

const char* EncryptionProfile_DeletingError::_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 id = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_id();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .deviceapis.device.v1.EncryptionProfile.DeletingError.EncryptionProfileInUse encryption_profile_in_use = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_encryption_profile_in_use(), 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* EncryptionProfile_DeletingError::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.EncryptionProfile.DeletingError)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_id().empty()) {
    const std::string& _s = this->_internal_id();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "deviceapis.device.v1.EncryptionProfile.DeletingError.id");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  // .deviceapis.device.v1.EncryptionProfile.DeletingError.EncryptionProfileInUse encryption_profile_in_use = 2;
  if (reason_case() == kEncryptionProfileInUse) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(2, _Internal::encryption_profile_in_use(this),
        _Internal::encryption_profile_in_use(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.EncryptionProfile.DeletingError)
  return target;
}

::size_t EncryptionProfile_DeletingError::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.EncryptionProfile.DeletingError)
  ::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 id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_id().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_id());
  }

  switch (reason_case()) {
    // .deviceapis.device.v1.EncryptionProfile.DeletingError.EncryptionProfileInUse encryption_profile_in_use = 2;
    case kEncryptionProfileInUse: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.encryption_profile_in_use_);
      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 EncryptionProfile_DeletingError::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const EncryptionProfile_DeletingError*>(
      &from));
}

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

  if (!from._internal_id().empty()) {
    _this->_internal_set_id(from._internal_id());
  }
  switch (from.reason_case()) {
    case kEncryptionProfileInUse: {
      _this->_internal_mutable_encryption_profile_in_use()->::deviceapis::device::v1::EncryptionProfile_DeletingError_EncryptionProfileInUse::MergeFrom(
          from._internal_encryption_profile_in_use());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void EncryptionProfile_DeletingError::InternalSwap(EncryptionProfile_DeletingError* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.id_, lhs_arena,
                                       &other->_impl_.id_, rhs_arena);
  swap(_impl_.reason_, other->_impl_.reason_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

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

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

class EncryptionProfile_SavingError_DuplicateName::_Internal {
 public:
};

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

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

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

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

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

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

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

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

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

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

std::string EncryptionProfile_SavingError_DuplicateName::GetTypeName() const {
  return "deviceapis.device.v1.EncryptionProfile.SavingError.DuplicateName";
}

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

class EncryptionProfile_SavingError_TooMuchEncryptionProfiles::_Internal {
 public:
};

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

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

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

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

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

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

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

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

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

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

std::string EncryptionProfile_SavingError_TooMuchEncryptionProfiles::GetTypeName() const {
  return "deviceapis.device.v1.EncryptionProfile.SavingError.TooMuchEncryptionProfiles";
}

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

class EncryptionProfile_SavingError::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::deviceapis::device::v1::EncryptionProfile_SavingError, _impl_._oneof_case_);
  static const ::deviceapis::device::v1::EncryptionProfile_SavingError_DuplicateName& duplicate_name(const EncryptionProfile_SavingError* msg);
  static const ::deviceapis::device::v1::EncryptionProfile_SavingError_TooMuchEncryptionProfiles& too_much_encryption_profiles(const EncryptionProfile_SavingError* msg);
};

const ::deviceapis::device::v1::EncryptionProfile_SavingError_DuplicateName&
EncryptionProfile_SavingError::_Internal::duplicate_name(const EncryptionProfile_SavingError* msg) {
  return *msg->_impl_.reason_.duplicate_name_;
}
const ::deviceapis::device::v1::EncryptionProfile_SavingError_TooMuchEncryptionProfiles&
EncryptionProfile_SavingError::_Internal::too_much_encryption_profiles(const EncryptionProfile_SavingError* msg) {
  return *msg->_impl_.reason_.too_much_encryption_profiles_;
}
void EncryptionProfile_SavingError::set_allocated_duplicate_name(::deviceapis::device::v1::EncryptionProfile_SavingError_DuplicateName* duplicate_name) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (duplicate_name) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(duplicate_name);
    if (message_arena != submessage_arena) {
      duplicate_name = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, duplicate_name, submessage_arena);
    }
    set_has_duplicate_name();
    _impl_.reason_.duplicate_name_ = duplicate_name;
  }
  // @@protoc_insertion_point(field_set_allocated:deviceapis.device.v1.EncryptionProfile.SavingError.duplicate_name)
}
void EncryptionProfile_SavingError::set_allocated_too_much_encryption_profiles(::deviceapis::device::v1::EncryptionProfile_SavingError_TooMuchEncryptionProfiles* too_much_encryption_profiles) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (too_much_encryption_profiles) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(too_much_encryption_profiles);
    if (message_arena != submessage_arena) {
      too_much_encryption_profiles = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, too_much_encryption_profiles, submessage_arena);
    }
    set_has_too_much_encryption_profiles();
    _impl_.reason_.too_much_encryption_profiles_ = too_much_encryption_profiles;
  }
  // @@protoc_insertion_point(field_set_allocated:deviceapis.device.v1.EncryptionProfile.SavingError.too_much_encryption_profiles)
}
EncryptionProfile_SavingError::EncryptionProfile_SavingError(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.EncryptionProfile.SavingError)
}
EncryptionProfile_SavingError::EncryptionProfile_SavingError(const EncryptionProfile_SavingError& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  EncryptionProfile_SavingError* 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 kDuplicateName: {
      _this->_internal_mutable_duplicate_name()->::deviceapis::device::v1::EncryptionProfile_SavingError_DuplicateName::MergeFrom(
          from._internal_duplicate_name());
      break;
    }
    case kTooMuchEncryptionProfiles: {
      _this->_internal_mutable_too_much_encryption_profiles()->::deviceapis::device::v1::EncryptionProfile_SavingError_TooMuchEncryptionProfiles::MergeFrom(
          from._internal_too_much_encryption_profiles());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.EncryptionProfile.SavingError)
}

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

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

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

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

void EncryptionProfile_SavingError::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:deviceapis.device.v1.EncryptionProfile.SavingError)
  switch (reason_case()) {
    case kDuplicateName: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.duplicate_name_;
      }
      break;
    }
    case kTooMuchEncryptionProfiles: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.too_much_encryption_profiles_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void EncryptionProfile_SavingError::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.EncryptionProfile.SavingError)
  ::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* EncryptionProfile_SavingError::_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.EncryptionProfile.SavingError.DuplicateName duplicate_name = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_duplicate_name(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .deviceapis.device.v1.EncryptionProfile.SavingError.TooMuchEncryptionProfiles too_much_encryption_profiles = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_too_much_encryption_profiles(), 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* EncryptionProfile_SavingError::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.EncryptionProfile.SavingError)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (reason_case()) {
    case kDuplicateName: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::duplicate_name(this),
          _Internal::duplicate_name(this).GetCachedSize(), target, stream);
      break;
    }
    case kTooMuchEncryptionProfiles: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::too_much_encryption_profiles(this),
          _Internal::too_much_encryption_profiles(this).GetCachedSize(), target, stream);
      break;
    }
    default: ;
  }
  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.EncryptionProfile.SavingError)
  return target;
}

::size_t EncryptionProfile_SavingError::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.EncryptionProfile.SavingError)
  ::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.EncryptionProfile.SavingError.DuplicateName duplicate_name = 1;
    case kDuplicateName: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.duplicate_name_);
      break;
    }
    // .deviceapis.device.v1.EncryptionProfile.SavingError.TooMuchEncryptionProfiles too_much_encryption_profiles = 2;
    case kTooMuchEncryptionProfiles: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.too_much_encryption_profiles_);
      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 EncryptionProfile_SavingError::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const EncryptionProfile_SavingError*>(
      &from));
}

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

  switch (from.reason_case()) {
    case kDuplicateName: {
      _this->_internal_mutable_duplicate_name()->::deviceapis::device::v1::EncryptionProfile_SavingError_DuplicateName::MergeFrom(
          from._internal_duplicate_name());
      break;
    }
    case kTooMuchEncryptionProfiles: {
      _this->_internal_mutable_too_much_encryption_profiles()->::deviceapis::device::v1::EncryptionProfile_SavingError_TooMuchEncryptionProfiles::MergeFrom(
          from._internal_too_much_encryption_profiles());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

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

class EncryptionProfile::_Internal {
 public:
};

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

    , decltype(_impl_.title_) {}

    , decltype(_impl_.password_) {}

    , decltype(_impl_.type_) {}

    , decltype(_impl_.sector_number_) {}

    , decltype(_impl_.block_number_) {}

    , decltype(_impl_.start_index_) {}

    , decltype(_impl_.end_index_) {}

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_id().empty()) {
    _this->_impl_.id_.Set(from._internal_id(), _this->GetArenaForAllocation());
  }
  _impl_.title_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.title_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_title().empty()) {
    _this->_impl_.title_.Set(from._internal_title(), _this->GetArenaForAllocation());
  }
  _impl_.password_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.password_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_password().empty()) {
    _this->_impl_.password_.Set(from._internal_password(), _this->GetArenaForAllocation());
  }
  ::memcpy(&_impl_.type_, &from._impl_.type_,
    static_cast<::size_t>(reinterpret_cast<char*>(&_impl_.end_index_) -
    reinterpret_cast<char*>(&_impl_.type_)) + sizeof(_impl_.end_index_));
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.EncryptionProfile)
}

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

    , decltype(_impl_.title_) {}

    , decltype(_impl_.password_) {}

    , decltype(_impl_.type_) { 0 }

    , decltype(_impl_.sector_number_) { 0 }

    , decltype(_impl_.block_number_) { 0 }

    , decltype(_impl_.start_index_) { 0 }

    , decltype(_impl_.end_index_) { 0 }

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

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

inline void EncryptionProfile::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.id_.Destroy();
  _impl_.title_.Destroy();
  _impl_.password_.Destroy();
}

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

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

  _impl_.id_.ClearToEmpty();
  _impl_.title_.ClearToEmpty();
  _impl_.password_.ClearToEmpty();
  ::memset(&_impl_.type_, 0, static_cast<::size_t>(
      reinterpret_cast<char*>(&_impl_.end_index_) -
      reinterpret_cast<char*>(&_impl_.type_)) + sizeof(_impl_.end_index_));
  _internal_metadata_.Clear<std::string>();
}

const char* EncryptionProfile::_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 id = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_id();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string title = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_title();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .deviceapis.device.v1.EncryptionProfile.Type type = 3 [(.google.api.field_behavior) = REQUIRED];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
          ::int32_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
          _internal_set_type(static_cast<::deviceapis::device::v1::EncryptionProfile_Type>(val));
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 sector_number = 4 [(.google.api.field_behavior) = REQUIRED];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
          _impl_.sector_number_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 block_number = 5 [(.google.api.field_behavior) = REQUIRED];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
          _impl_.block_number_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 start_index = 6 [(.google.api.field_behavior) = REQUIRED];
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
          _impl_.start_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // int32 end_index = 7 [(.google.api.field_behavior) = REQUIRED];
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
          _impl_.end_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // string password = 8 [(.google.api.field_behavior) = INPUT_ONLY];
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 66)) {
          auto str = _internal_mutable_password();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } 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* EncryptionProfile::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.EncryptionProfile)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string id = 1;
  if (!this->_internal_id().empty()) {
    const std::string& _s = this->_internal_id();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "deviceapis.device.v1.EncryptionProfile.id");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  // string title = 2 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_title().empty()) {
    const std::string& _s = this->_internal_title();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "deviceapis.device.v1.EncryptionProfile.title");
    target = stream->WriteStringMaybeAliased(2, _s, target);
  }

  // .deviceapis.device.v1.EncryptionProfile.Type type = 3 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        3, this->_internal_type(), target);
  }

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

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

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

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

  // string password = 8 [(.google.api.field_behavior) = INPUT_ONLY];
  if (!this->_internal_password().empty()) {
    const std::string& _s = this->_internal_password();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "deviceapis.device.v1.EncryptionProfile.password");
    target = stream->WriteStringMaybeAliased(8, _s, target);
  }

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

::size_t EncryptionProfile::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.EncryptionProfile)
  ::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 id = 1;
  if (!this->_internal_id().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_id());
  }

  // string title = 2 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_title().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_title());
  }

  // string password = 8 [(.google.api.field_behavior) = INPUT_ONLY];
  if (!this->_internal_password().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_password());
  }

  // .deviceapis.device.v1.EncryptionProfile.Type type = 3 [(.google.api.field_behavior) = REQUIRED];
  if (this->_internal_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
  }

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

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

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

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

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

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

  if (!from._internal_id().empty()) {
    _this->_internal_set_id(from._internal_id());
  }
  if (!from._internal_title().empty()) {
    _this->_internal_set_title(from._internal_title());
  }
  if (!from._internal_password().empty()) {
    _this->_internal_set_password(from._internal_password());
  }
  if (from._internal_type() != 0) {
    _this->_internal_set_type(from._internal_type());
  }
  if (from._internal_sector_number() != 0) {
    _this->_internal_set_sector_number(from._internal_sector_number());
  }
  if (from._internal_block_number() != 0) {
    _this->_internal_set_block_number(from._internal_block_number());
  }
  if (from._internal_start_index() != 0) {
    _this->_internal_set_start_index(from._internal_start_index());
  }
  if (from._internal_end_index() != 0) {
    _this->_internal_set_end_index(from._internal_end_index());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void EncryptionProfile::InternalSwap(EncryptionProfile* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.id_, lhs_arena,
                                       &other->_impl_.id_, rhs_arena);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.title_, lhs_arena,
                                       &other->_impl_.title_, rhs_arena);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.password_, lhs_arena,
                                       &other->_impl_.password_, rhs_arena);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(EncryptionProfile, _impl_.end_index_)
      + sizeof(EncryptionProfile::_impl_.end_index_)
      - PROTOBUF_FIELD_OFFSET(EncryptionProfile, _impl_.type_)>(
          reinterpret_cast<char*>(&_impl_.type_),
          reinterpret_cast<char*>(&other->_impl_.type_));
}

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

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

class EncryptionProfileFilter::_Internal {
 public:
  using HasBits = decltype(std::declval<EncryptionProfileFilter>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(EncryptionProfileFilter, _impl_._has_bits_);
  static const ::PROTOBUF_NAMESPACE_ID::StringValue& text(const EncryptionProfileFilter* msg);
  static void set_has_text(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::PROTOBUF_NAMESPACE_ID::StringValue&
EncryptionProfileFilter::_Internal::text(const EncryptionProfileFilter* msg) {
  return *msg->_impl_.text_;
}
void EncryptionProfileFilter::clear_text() {
  if (_impl_.text_ != nullptr) _impl_.text_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
EncryptionProfileFilter::EncryptionProfileFilter(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.EncryptionProfileFilter)
}
EncryptionProfileFilter::EncryptionProfileFilter(const EncryptionProfileFilter& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  EncryptionProfileFilter* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.text_){nullptr}};

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

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

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

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

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

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

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

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

  cached_has_bits = _impl_._has_bits_[0];
  // .google.protobuf.StringValue text = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::text(this),
        _Internal::text(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.EncryptionProfileFilter)
  return target;
}

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

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

  // .google.protobuf.StringValue text = 1;
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.text_);
  }

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

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

  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_internal_mutable_text()->::PROTOBUF_NAMESPACE_ID::StringValue::MergeFrom(
        from._internal_text());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const char* GetEncryptionProfileListRequest::_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.EncryptionProfileFilter filter = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_filter(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class GetEncryptionProfileListResponse::_Internal {
 public:
};

GetEncryptionProfileListResponse::GetEncryptionProfileListResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.GetEncryptionProfileListResponse)
}
GetEncryptionProfileListResponse::GetEncryptionProfileListResponse(const GetEncryptionProfileListResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetEncryptionProfileListResponse* 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.GetEncryptionProfileListResponse)
}

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

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

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

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

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

  // repeated .deviceapis.device.v1.EncryptionProfile 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.GetEncryptionProfileListResponse)
  return target;
}

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

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

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

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

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

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

class GetEncryptionProfileRequest::_Internal {
 public:
};

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

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_id().empty()) {
    _this->_impl_.id_.Set(from._internal_id(), _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.GetEncryptionProfileRequest)
}

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

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

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

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

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

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

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

const char* GetEncryptionProfileRequest::_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 id = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_id();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } 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* GetEncryptionProfileRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.GetEncryptionProfileRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_id().empty()) {
    const std::string& _s = this->_internal_id();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "deviceapis.device.v1.GetEncryptionProfileRequest.id");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

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

::size_t GetEncryptionProfileRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.GetEncryptionProfileRequest)
  ::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 id = 1 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_id().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_id());
  }

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

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

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

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

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

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

void GetEncryptionProfileRequest::InternalSwap(GetEncryptionProfileRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.id_, lhs_arena,
                                       &other->_impl_.id_, rhs_arena);
}

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

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

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

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

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

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

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

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

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

  // .deviceapis.device.v1.EncryptionProfile 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.GetEncryptionProfileResponse)
  return target;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const char* SaveEncryptionProfileRequest::_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.EncryptionProfile data = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_data(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const ::deviceapis::device::v1::ValidationError&
SaveEncryptionProfileResponse_Error::_Internal::validation(const SaveEncryptionProfileResponse_Error* msg) {
  return *msg->_impl_.reason_.validation_;
}
const ::deviceapis::device::v1::EncryptionProfile_SavingError&
SaveEncryptionProfileResponse_Error::_Internal::saving(const SaveEncryptionProfileResponse_Error* msg) {
  return *msg->_impl_.reason_.saving_;
}
void SaveEncryptionProfileResponse_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.SaveEncryptionProfileResponse.Error.validation)
}
void SaveEncryptionProfileResponse_Error::clear_validation() {
  if (reason_case() == kValidation) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.validation_;
    }
    clear_has_reason();
  }
}
void SaveEncryptionProfileResponse_Error::set_allocated_saving(::deviceapis::device::v1::EncryptionProfile_SavingError* saving) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (saving) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(saving);
    if (message_arena != submessage_arena) {
      saving = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, saving, submessage_arena);
    }
    set_has_saving();
    _impl_.reason_.saving_ = saving;
  }
  // @@protoc_insertion_point(field_set_allocated:deviceapis.device.v1.SaveEncryptionProfileResponse.Error.saving)
}
SaveEncryptionProfileResponse_Error::SaveEncryptionProfileResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.SaveEncryptionProfileResponse.Error)
}
SaveEncryptionProfileResponse_Error::SaveEncryptionProfileResponse_Error(const SaveEncryptionProfileResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  SaveEncryptionProfileResponse_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 kSaving: {
      _this->_internal_mutable_saving()->::deviceapis::device::v1::EncryptionProfile_SavingError::MergeFrom(
          from._internal_saving());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.SaveEncryptionProfileResponse.Error)
}

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

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

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

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

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


void SaveEncryptionProfileResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:deviceapis.device.v1.SaveEncryptionProfileResponse.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* SaveEncryptionProfileResponse_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;
      // .deviceapis.device.v1.EncryptionProfile.SavingError saving = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_saving(), 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* SaveEncryptionProfileResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:deviceapis.device.v1.SaveEncryptionProfileResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (reason_case()) {
    case kValidation: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::validation(this),
          _Internal::validation(this).GetCachedSize(), target, stream);
      break;
    }
    case kSaving: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::saving(this),
          _Internal::saving(this).GetCachedSize(), target, stream);
      break;
    }
    default: ;
  }
  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.SaveEncryptionProfileResponse.Error)
  return target;
}

::size_t SaveEncryptionProfileResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:deviceapis.device.v1.SaveEncryptionProfileResponse.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;
    }
    // .deviceapis.device.v1.EncryptionProfile.SavingError saving = 2;
    case kSaving: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.saving_);
      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 SaveEncryptionProfileResponse_Error::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const SaveEncryptionProfileResponse_Error*>(
      &from));
}

void SaveEncryptionProfileResponse_Error::MergeFrom(const SaveEncryptionProfileResponse_Error& from) {
  SaveEncryptionProfileResponse_Error* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:deviceapis.device.v1.SaveEncryptionProfileResponse.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 kSaving: {
      _this->_internal_mutable_saving()->::deviceapis::device::v1::EncryptionProfile_SavingError::MergeFrom(
          from._internal_saving());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

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

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

const ::deviceapis::device::v1::EncryptionProfile&
SaveEncryptionProfileResponse::_Internal::data(const SaveEncryptionProfileResponse* msg) {
  return *msg->_impl_.type_.data_;
}
const ::deviceapis::device::v1::SaveEncryptionProfileResponse_Error&
SaveEncryptionProfileResponse::_Internal::error(const SaveEncryptionProfileResponse* msg) {
  return *msg->_impl_.type_.error_;
}
void SaveEncryptionProfileResponse::set_allocated_data(::deviceapis::device::v1::EncryptionProfile* 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.SaveEncryptionProfileResponse.data)
}
void SaveEncryptionProfileResponse::set_allocated_error(::deviceapis::device::v1::SaveEncryptionProfileResponse_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.SaveEncryptionProfileResponse.error)
}
SaveEncryptionProfileResponse::SaveEncryptionProfileResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:deviceapis.device.v1.SaveEncryptionProfileResponse)
}
SaveEncryptionProfileResponse::SaveEncryptionProfileResponse(const SaveEncryptionProfileResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  SaveEncryptionProfileResponse* 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::EncryptionProfile::MergeFrom(
          from._internal_data());
      break;
    }
    case kError: {
      _this->_internal_mutable_error()->::deviceapis::device::v1::SaveEncryptionProfileResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:deviceapis.device.v1.SaveEncryptionProfileResponse)
}

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

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

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

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

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


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

  switch (type_case()) {
    case kData: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::data(this),
          _Internal::data(this).GetCachedSize(), target, stream);
      break;
    }
    case kError: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::error(this),
          _Internal::error(this).GetCachedSize(), target, stream);
      break;
    }
    default: ;
  }
  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.SaveEncryptionProfileResponse)
  return target;
}

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

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

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

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

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

// @@protoc_insertion_point(namespace_scope)
}  // namespace v1
}  // namespace device
}  // namespace deviceapis
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::DeleteEncryptionProfileListRequest*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::DeleteEncryptionProfileListRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::DeleteEncryptionProfileListRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::DeleteEncryptionProfileListResponse_Error*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::DeleteEncryptionProfileListResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::DeleteEncryptionProfileListResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::DeleteEncryptionProfileListResponse*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::DeleteEncryptionProfileListResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::DeleteEncryptionProfileListResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::DeleteEncryptionProfileRequest*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::DeleteEncryptionProfileRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::DeleteEncryptionProfileRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::DeleteEncryptionProfileResponse_Error*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::DeleteEncryptionProfileResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::DeleteEncryptionProfileResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::DeleteEncryptionProfileResponse*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::DeleteEncryptionProfileResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::DeleteEncryptionProfileResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::EncryptionProfile_DeletingError_EncryptionProfileInUse*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::EncryptionProfile_DeletingError_EncryptionProfileInUse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::EncryptionProfile_DeletingError_EncryptionProfileInUse >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::EncryptionProfile_DeletingError*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::EncryptionProfile_DeletingError >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::EncryptionProfile_DeletingError >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::EncryptionProfile_SavingError_DuplicateName*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::EncryptionProfile_SavingError_DuplicateName >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::EncryptionProfile_SavingError_DuplicateName >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::EncryptionProfile_SavingError_TooMuchEncryptionProfiles*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::EncryptionProfile_SavingError_TooMuchEncryptionProfiles >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::EncryptionProfile_SavingError_TooMuchEncryptionProfiles >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::EncryptionProfile_SavingError*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::EncryptionProfile_SavingError >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::EncryptionProfile_SavingError >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::EncryptionProfile*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::EncryptionProfile >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::EncryptionProfile >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::EncryptionProfileFilter*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::EncryptionProfileFilter >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::EncryptionProfileFilter >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::GetEncryptionProfileListRequest*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::GetEncryptionProfileListRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::GetEncryptionProfileListRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::GetEncryptionProfileListResponse*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::GetEncryptionProfileListResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::GetEncryptionProfileListResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::GetEncryptionProfileRequest*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::GetEncryptionProfileRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::GetEncryptionProfileRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::GetEncryptionProfileResponse*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::GetEncryptionProfileResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::GetEncryptionProfileResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::SaveEncryptionProfileRequest*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::SaveEncryptionProfileRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::SaveEncryptionProfileRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::SaveEncryptionProfileResponse_Error*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::SaveEncryptionProfileResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::SaveEncryptionProfileResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::deviceapis::device::v1::SaveEncryptionProfileResponse*
Arena::CreateMaybeMessage< ::deviceapis::device::v1::SaveEncryptionProfileResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::deviceapis::device::v1::SaveEncryptionProfileResponse >(arena);
}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"