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

#include "keyapis/identity/v1/keyapis_identity_oauth2_v1.pb.h"

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AuthServiceError_AuthErrorDefaultTypeInternal _AuthServiceError_AuthError_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR AuthServiceError::AuthServiceError(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct AuthServiceErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR AuthServiceErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~AuthServiceErrorDefaultTypeInternal() {}
  union {
    AuthServiceError _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AuthServiceErrorDefaultTypeInternal _AuthServiceError_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostOauth2LoginByCodeRequest::PostOauth2LoginByCodeRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.code_id_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

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

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostOauth2LoginByCodeRequestDefaultTypeInternal _PostOauth2LoginByCodeRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostOauth2LoginByCodeResponse_Error::PostOauth2LoginByCodeResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostOauth2LoginByCodeResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostOauth2LoginByCodeResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostOauth2LoginByCodeResponse_ErrorDefaultTypeInternal() {}
  union {
    PostOauth2LoginByCodeResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostOauth2LoginByCodeResponse_ErrorDefaultTypeInternal _PostOauth2LoginByCodeResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostOauth2LoginByCodeResponse::PostOauth2LoginByCodeResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostOauth2LoginByCodeResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostOauth2LoginByCodeResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostOauth2LoginByCodeResponseDefaultTypeInternal() {}
  union {
    PostOauth2LoginByCodeResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostOauth2LoginByCodeResponseDefaultTypeInternal _PostOauth2LoginByCodeResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostOauth2LoginByPasswordRequest::PostOauth2LoginByPasswordRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_._has_bits_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_.password_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

  , /*decltype(_impl_.captcha_answer_)*/nullptr
  , /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostOauth2LoginByPasswordRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostOauth2LoginByPasswordRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostOauth2LoginByPasswordRequestDefaultTypeInternal() {}
  union {
    PostOauth2LoginByPasswordRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostOauth2LoginByPasswordRequestDefaultTypeInternal _PostOauth2LoginByPasswordRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostOauth2LoginByPasswordResponse_Error::PostOauth2LoginByPasswordResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostOauth2LoginByPasswordResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostOauth2LoginByPasswordResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostOauth2LoginByPasswordResponse_ErrorDefaultTypeInternal() {}
  union {
    PostOauth2LoginByPasswordResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostOauth2LoginByPasswordResponse_ErrorDefaultTypeInternal _PostOauth2LoginByPasswordResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR PostOauth2LoginByPasswordResponse::PostOauth2LoginByPasswordResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct PostOauth2LoginByPasswordResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PostOauth2LoginByPasswordResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PostOauth2LoginByPasswordResponseDefaultTypeInternal() {}
  union {
    PostOauth2LoginByPasswordResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PostOauth2LoginByPasswordResponseDefaultTypeInternal _PostOauth2LoginByPasswordResponse_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetOauth2ConsentRequest::GetOauth2ConsentRequest(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.consent_challenge_)*/ {
    &::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized {}
  }

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

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetOauth2ConsentRequestDefaultTypeInternal _GetOauth2ConsentRequest_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetOauth2ConsentResponse_Error::GetOauth2ConsentResponse_Error(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.reason_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetOauth2ConsentResponse_ErrorDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetOauth2ConsentResponse_ErrorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetOauth2ConsentResponse_ErrorDefaultTypeInternal() {}
  union {
    GetOauth2ConsentResponse_Error _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetOauth2ConsentResponse_ErrorDefaultTypeInternal _GetOauth2ConsentResponse_Error_default_instance_;
template <typename>
PROTOBUF_CONSTEXPR GetOauth2ConsentResponse::GetOauth2ConsentResponse(
    ::_pbi::ConstantInitialized): _impl_{
    /*decltype(_impl_.type_)*/{}
  , /*decltype(_impl_._cached_size_)*/{}
  , /*decltype(_impl_._oneof_case_)*/{}} {}
struct GetOauth2ConsentResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetOauth2ConsentResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetOauth2ConsentResponseDefaultTypeInternal() {}
  union {
    GetOauth2ConsentResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetOauth2ConsentResponseDefaultTypeInternal _GetOauth2ConsentResponse_default_instance_;
}  // namespace v1
}  // namespace identity
}  // namespace keyapis
namespace keyapis {
namespace identity {
namespace v1 {
// ===================================================================

class AuthServiceError_AuthError::_Internal {
 public:
};

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

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

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

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

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

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

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

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

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

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

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

std::string AuthServiceError_AuthError::GetTypeName() const {
  return "keyapis.identity.v1.AuthServiceError.AuthError";
}

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

class AuthServiceError::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::identity::v1::AuthServiceError, _impl_._oneof_case_);
  static const ::keyapis::identity::v1::AuthServiceError_AuthError& auth(const AuthServiceError* msg);
};

const ::keyapis::identity::v1::AuthServiceError_AuthError&
AuthServiceError::_Internal::auth(const AuthServiceError* msg) {
  return *msg->_impl_.reason_.auth_;
}
void AuthServiceError::set_allocated_auth(::keyapis::identity::v1::AuthServiceError_AuthError* auth) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (auth) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(auth);
    if (message_arena != submessage_arena) {
      auth = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, auth, submessage_arena);
    }
    set_has_auth();
    _impl_.reason_.auth_ = auth;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.AuthServiceError.auth)
}
AuthServiceError::AuthServiceError(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.AuthServiceError)
}
AuthServiceError::AuthServiceError(const AuthServiceError& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  AuthServiceError* 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 kAuth: {
      _this->_internal_mutable_auth()->::keyapis::identity::v1::AuthServiceError_AuthError::MergeFrom(
          from._internal_auth());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.AuthServiceError)
}

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

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

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

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

void AuthServiceError::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.identity.v1.AuthServiceError)
  switch (reason_case()) {
    case kAuth: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.auth_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void AuthServiceError::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.AuthServiceError)
  ::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* AuthServiceError::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.identity.v1.AuthServiceError.AuthError auth = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_auth(), 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* AuthServiceError::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.AuthServiceError)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.identity.v1.AuthServiceError.AuthError auth = 1;
  if (reason_case() == kAuth) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::auth(this),
        _Internal::auth(this).GetCachedSize(), target, stream);
  }

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

::size_t AuthServiceError::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.AuthServiceError)
  ::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()) {
    // .keyapis.identity.v1.AuthServiceError.AuthError auth = 1;
    case kAuth: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.auth_);
      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 AuthServiceError::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const AuthServiceError*>(
      &from));
}

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

  switch (from.reason_case()) {
    case kAuth: {
      _this->_internal_mutable_auth()->::keyapis::identity::v1::AuthServiceError_AuthError::MergeFrom(
          from._internal_auth());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void AuthServiceError::InternalSwap(AuthServiceError* 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 AuthServiceError::GetTypeName() const {
  return "keyapis.identity.v1.AuthServiceError";
}

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

class PostOauth2LoginByCodeRequest::_Internal {
 public:
};

PostOauth2LoginByCodeRequest::PostOauth2LoginByCodeRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.PostOauth2LoginByCodeRequest)
}
PostOauth2LoginByCodeRequest::PostOauth2LoginByCodeRequest(const PostOauth2LoginByCodeRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostOauth2LoginByCodeRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.code_id_) {}

    , decltype(_impl_.code_) {}

    , decltype(_impl_.login_challenge_) {}

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.code_id_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.code_id_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_code_id().empty()) {
    _this->_impl_.code_id_.Set(from._internal_code_id(), _this->GetArenaForAllocation());
  }
  _impl_.code_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.code_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_code().empty()) {
    _this->_impl_.code_.Set(from._internal_code(), _this->GetArenaForAllocation());
  }
  _impl_.login_challenge_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.login_challenge_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_login_challenge().empty()) {
    _this->_impl_.login_challenge_.Set(from._internal_login_challenge(), _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.PostOauth2LoginByCodeRequest)
}

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

    , decltype(_impl_.code_) {}

    , decltype(_impl_.login_challenge_) {}

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

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

inline void PostOauth2LoginByCodeRequest::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.code_id_.Destroy();
  _impl_.code_.Destroy();
  _impl_.login_challenge_.Destroy();
}

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

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

  _impl_.code_id_.ClearToEmpty();
  _impl_.code_.ClearToEmpty();
  _impl_.login_challenge_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* PostOauth2LoginByCodeRequest::_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 code_id = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_code_id();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string code = 2 [(.google.api.field_behavior) = REQUIRED];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_code();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string login_challenge = 3 [(.google.api.field_behavior) = REQUIRED];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          auto str = _internal_mutable_login_challenge();
          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* PostOauth2LoginByCodeRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.PostOauth2LoginByCodeRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

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

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

  // string login_challenge = 3 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_login_challenge().empty()) {
    const std::string& _s = this->_internal_login_challenge();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.identity.v1.PostOauth2LoginByCodeRequest.login_challenge");
    target = stream->WriteStringMaybeAliased(3, _s, target);
  }

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

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

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

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

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

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

  if (!from._internal_code_id().empty()) {
    _this->_internal_set_code_id(from._internal_code_id());
  }
  if (!from._internal_code().empty()) {
    _this->_internal_set_code(from._internal_code());
  }
  if (!from._internal_login_challenge().empty()) {
    _this->_internal_set_login_challenge(from._internal_login_challenge());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

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

std::string PostOauth2LoginByCodeRequest::GetTypeName() const {
  return "keyapis.identity.v1.PostOauth2LoginByCodeRequest";
}

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

class PostOauth2LoginByCodeResponse_Error::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::identity::v1::PostOauth2LoginByCodeResponse_Error, _impl_._oneof_case_);
  static const ::keyapis::identity::v1::OtpCode_Error& otp_code(const PostOauth2LoginByCodeResponse_Error* msg);
  static const ::keyapis::identity::v1::SsoError& sso(const PostOauth2LoginByCodeResponse_Error* msg);
  static const ::keyapis::identity::v1::KeyError& key(const PostOauth2LoginByCodeResponse_Error* msg);
  static const ::keyapis::identity::v1::AuthServiceError& auth_service(const PostOauth2LoginByCodeResponse_Error* msg);
};

const ::keyapis::identity::v1::OtpCode_Error&
PostOauth2LoginByCodeResponse_Error::_Internal::otp_code(const PostOauth2LoginByCodeResponse_Error* msg) {
  return *msg->_impl_.reason_.otp_code_;
}
const ::keyapis::identity::v1::SsoError&
PostOauth2LoginByCodeResponse_Error::_Internal::sso(const PostOauth2LoginByCodeResponse_Error* msg) {
  return *msg->_impl_.reason_.sso_;
}
const ::keyapis::identity::v1::KeyError&
PostOauth2LoginByCodeResponse_Error::_Internal::key(const PostOauth2LoginByCodeResponse_Error* msg) {
  return *msg->_impl_.reason_.key_;
}
const ::keyapis::identity::v1::AuthServiceError&
PostOauth2LoginByCodeResponse_Error::_Internal::auth_service(const PostOauth2LoginByCodeResponse_Error* msg) {
  return *msg->_impl_.reason_.auth_service_;
}
void PostOauth2LoginByCodeResponse_Error::set_allocated_otp_code(::keyapis::identity::v1::OtpCode_Error* otp_code) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (otp_code) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(otp_code));
    if (message_arena != submessage_arena) {
      otp_code = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, otp_code, submessage_arena);
    }
    set_has_otp_code();
    _impl_.reason_.otp_code_ = otp_code;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.PostOauth2LoginByCodeResponse.Error.otp_code)
}
void PostOauth2LoginByCodeResponse_Error::clear_otp_code() {
  if (reason_case() == kOtpCode) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.otp_code_;
    }
    clear_has_reason();
  }
}
void PostOauth2LoginByCodeResponse_Error::set_allocated_sso(::keyapis::identity::v1::SsoError* sso) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (sso) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(sso));
    if (message_arena != submessage_arena) {
      sso = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, sso, submessage_arena);
    }
    set_has_sso();
    _impl_.reason_.sso_ = sso;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.PostOauth2LoginByCodeResponse.Error.sso)
}
void PostOauth2LoginByCodeResponse_Error::clear_sso() {
  if (reason_case() == kSso) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.sso_;
    }
    clear_has_reason();
  }
}
void PostOauth2LoginByCodeResponse_Error::set_allocated_key(::keyapis::identity::v1::KeyError* key) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (key) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key));
    if (message_arena != submessage_arena) {
      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, key, submessage_arena);
    }
    set_has_key();
    _impl_.reason_.key_ = key;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.PostOauth2LoginByCodeResponse.Error.key)
}
void PostOauth2LoginByCodeResponse_Error::clear_key() {
  if (reason_case() == kKey) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.key_;
    }
    clear_has_reason();
  }
}
void PostOauth2LoginByCodeResponse_Error::set_allocated_auth_service(::keyapis::identity::v1::AuthServiceError* auth_service) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (auth_service) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(auth_service);
    if (message_arena != submessage_arena) {
      auth_service = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, auth_service, submessage_arena);
    }
    set_has_auth_service();
    _impl_.reason_.auth_service_ = auth_service;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.PostOauth2LoginByCodeResponse.Error.auth_service)
}
PostOauth2LoginByCodeResponse_Error::PostOauth2LoginByCodeResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.PostOauth2LoginByCodeResponse.Error)
}
PostOauth2LoginByCodeResponse_Error::PostOauth2LoginByCodeResponse_Error(const PostOauth2LoginByCodeResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostOauth2LoginByCodeResponse_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 kOtpCode: {
      _this->_internal_mutable_otp_code()->::keyapis::identity::v1::OtpCode_Error::MergeFrom(
          from._internal_otp_code());
      break;
    }
    case kSso: {
      _this->_internal_mutable_sso()->::keyapis::identity::v1::SsoError::MergeFrom(
          from._internal_sso());
      break;
    }
    case kKey: {
      _this->_internal_mutable_key()->::keyapis::identity::v1::KeyError::MergeFrom(
          from._internal_key());
      break;
    }
    case kAuthService: {
      _this->_internal_mutable_auth_service()->::keyapis::identity::v1::AuthServiceError::MergeFrom(
          from._internal_auth_service());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.PostOauth2LoginByCodeResponse.Error)
}

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

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

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

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

void PostOauth2LoginByCodeResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.identity.v1.PostOauth2LoginByCodeResponse.Error)
  switch (reason_case()) {
    case kOtpCode: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.otp_code_;
      }
      break;
    }
    case kSso: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.sso_;
      }
      break;
    }
    case kKey: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.key_;
      }
      break;
    }
    case kAuthService: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.auth_service_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void PostOauth2LoginByCodeResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.PostOauth2LoginByCodeResponse.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* PostOauth2LoginByCodeResponse_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) {
      // .keyapis.identity.v1.OtpCode.Error otp_code = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_otp_code(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.identity.v1.SsoError sso = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_sso(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.identity.v1.KeyError key = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_key(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.identity.v1.AuthServiceError auth_service = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_auth_service(), 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* PostOauth2LoginByCodeResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.PostOauth2LoginByCodeResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (reason_case()) {
    case kOtpCode: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::otp_code(this),
          _Internal::otp_code(this).GetCachedSize(), target, stream);
      break;
    }
    case kSso: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::sso(this),
          _Internal::sso(this).GetCachedSize(), target, stream);
      break;
    }
    case kKey: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(3, _Internal::key(this),
          _Internal::key(this).GetCachedSize(), target, stream);
      break;
    }
    case kAuthService: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(4, _Internal::auth_service(this),
          _Internal::auth_service(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:keyapis.identity.v1.PostOauth2LoginByCodeResponse.Error)
  return target;
}

::size_t PostOauth2LoginByCodeResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.PostOauth2LoginByCodeResponse.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()) {
    // .keyapis.identity.v1.OtpCode.Error otp_code = 1;
    case kOtpCode: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.otp_code_);
      break;
    }
    // .keyapis.identity.v1.SsoError sso = 2;
    case kSso: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.sso_);
      break;
    }
    // .keyapis.identity.v1.KeyError key = 3;
    case kKey: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.key_);
      break;
    }
    // .keyapis.identity.v1.AuthServiceError auth_service = 4;
    case kAuthService: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.auth_service_);
      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 PostOauth2LoginByCodeResponse_Error::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PostOauth2LoginByCodeResponse_Error*>(
      &from));
}

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

  switch (from.reason_case()) {
    case kOtpCode: {
      _this->_internal_mutable_otp_code()->::keyapis::identity::v1::OtpCode_Error::MergeFrom(
          from._internal_otp_code());
      break;
    }
    case kSso: {
      _this->_internal_mutable_sso()->::keyapis::identity::v1::SsoError::MergeFrom(
          from._internal_sso());
      break;
    }
    case kKey: {
      _this->_internal_mutable_key()->::keyapis::identity::v1::KeyError::MergeFrom(
          from._internal_key());
      break;
    }
    case kAuthService: {
      _this->_internal_mutable_auth_service()->::keyapis::identity::v1::AuthServiceError::MergeFrom(
          from._internal_auth_service());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void PostOauth2LoginByCodeResponse_Error::InternalSwap(PostOauth2LoginByCodeResponse_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 PostOauth2LoginByCodeResponse_Error::GetTypeName() const {
  return "keyapis.identity.v1.PostOauth2LoginByCodeResponse.Error";
}

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

class PostOauth2LoginByCodeResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::identity::v1::PostOauth2LoginByCodeResponse, _impl_._oneof_case_);
  static const ::keyapis::identity::v1::PostOauth2LoginByCodeResponse_Error& error(const PostOauth2LoginByCodeResponse* msg);
};

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_type();
  switch (from.type_case()) {
    case kError: {
      _this->_internal_mutable_error()->::keyapis::identity::v1::PostOauth2LoginByCodeResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.PostOauth2LoginByCodeResponse)
}

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

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

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

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

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


void PostOauth2LoginByCodeResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.PostOauth2LoginByCodeResponse)
  ::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* PostOauth2LoginByCodeResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.identity.v1.PostOauth2LoginByCodeResponse.Error error = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_error(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  // .keyapis.identity.v1.PostOauth2LoginByCodeResponse.Error error = 1;
  if (type_case() == kError) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::error(this),
        _Internal::error(this).GetCachedSize(), target, stream);
  }

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

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

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

  switch (type_case()) {
    // .keyapis.identity.v1.PostOauth2LoginByCodeResponse.Error error = 1;
    case kError: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.error_);
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

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

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

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

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

void PostOauth2LoginByCodeResponse::InternalSwap(PostOauth2LoginByCodeResponse* 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 PostOauth2LoginByCodeResponse::GetTypeName() const {
  return "keyapis.identity.v1.PostOauth2LoginByCodeResponse";
}

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

class PostOauth2LoginByPasswordRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<PostOauth2LoginByPasswordRequest>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(PostOauth2LoginByPasswordRequest, _impl_._has_bits_);
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::identity::v1::PostOauth2LoginByPasswordRequest, _impl_._oneof_case_);
  static const ::keyapis::identity::v1::CaptchaAnswer& captcha_answer(const PostOauth2LoginByPasswordRequest* msg);
  static void set_has_captcha_answer(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::keyapis::identity::v1::CaptchaAnswer&
PostOauth2LoginByPasswordRequest::_Internal::captcha_answer(const PostOauth2LoginByPasswordRequest* msg) {
  return *msg->_impl_.captcha_answer_;
}
void PostOauth2LoginByPasswordRequest::clear_captcha_answer() {
  if (_impl_.captcha_answer_ != nullptr) _impl_.captcha_answer_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
PostOauth2LoginByPasswordRequest::PostOauth2LoginByPasswordRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.PostOauth2LoginByPasswordRequest)
}
PostOauth2LoginByPasswordRequest::PostOauth2LoginByPasswordRequest(const PostOauth2LoginByPasswordRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostOauth2LoginByPasswordRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_._has_bits_){from._impl_._has_bits_}
    , /*decltype(_impl_._cached_size_)*/{}
    , decltype(_impl_.password_) {}

    , decltype(_impl_.login_challenge_) {}

    , decltype(_impl_.captcha_answer_){nullptr}
    , decltype(_impl_.type_){}
    , /*decltype(_impl_._oneof_case_)*/{}};

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _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());
  }
  _impl_.login_challenge_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.login_challenge_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_login_challenge().empty()) {
    _this->_impl_.login_challenge_.Set(from._internal_login_challenge(), _this->GetArenaForAllocation());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_impl_.captcha_answer_ = new ::keyapis::identity::v1::CaptchaAnswer(*from._impl_.captcha_answer_);
  }
  clear_has_type();
  switch (from.type_case()) {
    case kPhoneNumber: {
      _this->_internal_set_phone_number(from._internal_phone_number());
      break;
    }
    case kEmail: {
      _this->_internal_set_email(from._internal_email());
      break;
    }
    case kLogin: {
      _this->_internal_set_login(from._internal_login());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.PostOauth2LoginByPasswordRequest)
}

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

    , decltype(_impl_.login_challenge_) {}

    , decltype(_impl_.captcha_answer_){nullptr}
    , decltype(_impl_.type_){}
    , /*decltype(_impl_._oneof_case_)*/{}
  };
  _impl_.password_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.password_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  _impl_.login_challenge_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.login_challenge_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  clear_has_type();
}

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

inline void PostOauth2LoginByPasswordRequest::SharedDtor() {
  ABSL_DCHECK(GetArenaForAllocation() == nullptr);
  _impl_.password_.Destroy();
  _impl_.login_challenge_.Destroy();
  if (this != internal_default_instance()) delete _impl_.captcha_answer_;
  if (has_type()) {
    clear_type();
  }
}

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

void PostOauth2LoginByPasswordRequest::clear_type() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.identity.v1.PostOauth2LoginByPasswordRequest)
  switch (type_case()) {
    case kPhoneNumber: {
      _impl_.type_.phone_number_.Destroy();
      break;
    }
    case kEmail: {
      _impl_.type_.email_.Destroy();
      break;
    }
    case kLogin: {
      _impl_.type_.login_.Destroy();
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = TYPE_NOT_SET;
}


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

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

const char* PostOauth2LoginByPasswordRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // string phone_number = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_phone_number();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string email = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          auto str = _internal_mutable_email();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string login = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          auto str = _internal_mutable_login();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // string password = 4 [(.google.api.field_behavior) = REQUIRED];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          auto str = _internal_mutable_password();
          ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
          CHK_(::_pbi::VerifyUTF8(str, nullptr));
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.identity.v1.CaptchaAnswer captcha_answer = 5 [(.google.api.field_behavior) = OPTIONAL];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_captcha_answer(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // string login_challenge = 6 [(.google.api.field_behavior) = REQUIRED];
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
          auto str = _internal_mutable_login_challenge();
          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:
  _impl_._has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  switch (type_case()) {
    case kPhoneNumber: {
      const std::string& _s = this->_internal_phone_number();
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
          _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.identity.v1.PostOauth2LoginByPasswordRequest.phone_number");
      target = stream->WriteStringMaybeAliased(1, _s, target);
      break;
    }
    case kEmail: {
      const std::string& _s = this->_internal_email();
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
          _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.identity.v1.PostOauth2LoginByPasswordRequest.email");
      target = stream->WriteStringMaybeAliased(2, _s, target);
      break;
    }
    case kLogin: {
      const std::string& _s = this->_internal_login();
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
          _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.identity.v1.PostOauth2LoginByPasswordRequest.login");
      target = stream->WriteStringMaybeAliased(3, _s, target);
      break;
    }
    default: ;
  }
  // string password = 4 [(.google.api.field_behavior) = REQUIRED];
  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, "keyapis.identity.v1.PostOauth2LoginByPasswordRequest.password");
    target = stream->WriteStringMaybeAliased(4, _s, target);
  }

  cached_has_bits = _impl_._has_bits_[0];
  // .keyapis.identity.v1.CaptchaAnswer captcha_answer = 5 [(.google.api.field_behavior) = OPTIONAL];
  if (cached_has_bits & 0x00000001u) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, _Internal::captcha_answer(this),
        _Internal::captcha_answer(this).GetCachedSize(), target, stream);
  }

  // string login_challenge = 6 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_login_challenge().empty()) {
    const std::string& _s = this->_internal_login_challenge();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.identity.v1.PostOauth2LoginByPasswordRequest.login_challenge");
    target = stream->WriteStringMaybeAliased(6, _s, target);
  }

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

::size_t PostOauth2LoginByPasswordRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.PostOauth2LoginByPasswordRequest)
  ::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 password = 4 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_password().empty()) {
    total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                    this->_internal_password());
  }

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

  // .keyapis.identity.v1.CaptchaAnswer captcha_answer = 5 [(.google.api.field_behavior) = OPTIONAL];
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *_impl_.captcha_answer_);
  }

  switch (type_case()) {
    // string phone_number = 1;
    case kPhoneNumber: {
      total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                      this->_internal_phone_number());
      break;
    }
    // string email = 2;
    case kEmail: {
      total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                      this->_internal_email());
      break;
    }
    // string login = 3;
    case kLogin: {
      total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
                                      this->_internal_login());
      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 PostOauth2LoginByPasswordRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PostOauth2LoginByPasswordRequest*>(
      &from));
}

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

  if (!from._internal_password().empty()) {
    _this->_internal_set_password(from._internal_password());
  }
  if (!from._internal_login_challenge().empty()) {
    _this->_internal_set_login_challenge(from._internal_login_challenge());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_internal_mutable_captcha_answer()->::keyapis::identity::v1::CaptchaAnswer::MergeFrom(
        from._internal_captcha_answer());
  }
  switch (from.type_case()) {
    case kPhoneNumber: {
      _this->_internal_set_phone_number(from._internal_phone_number());
      break;
    }
    case kEmail: {
      _this->_internal_set_email(from._internal_email());
      break;
    }
    case kLogin: {
      _this->_internal_set_login(from._internal_login());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void PostOauth2LoginByPasswordRequest::InternalSwap(PostOauth2LoginByPasswordRequest* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.password_, lhs_arena,
                                       &other->_impl_.password_, rhs_arena);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.login_challenge_, lhs_arena,
                                       &other->_impl_.login_challenge_, rhs_arena);
  swap(_impl_.captcha_answer_, other->_impl_.captcha_answer_);
  swap(_impl_.type_, other->_impl_.type_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string PostOauth2LoginByPasswordRequest::GetTypeName() const {
  return "keyapis.identity.v1.PostOauth2LoginByPasswordRequest";
}

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

class PostOauth2LoginByPasswordResponse_Error::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::identity::v1::PostOauth2LoginByPasswordResponse_Error, _impl_._oneof_case_);
  static const ::keyapis::identity::v1::CaptchaAnswer_Error& captcha_answer(const PostOauth2LoginByPasswordResponse_Error* msg);
  static const ::keyapis::identity::v1::SsoError& sso(const PostOauth2LoginByPasswordResponse_Error* msg);
  static const ::keyapis::identity::v1::KeyError& key(const PostOauth2LoginByPasswordResponse_Error* msg);
  static const ::keyapis::identity::v1::AuthServiceError& auth_service(const PostOauth2LoginByPasswordResponse_Error* msg);
};

const ::keyapis::identity::v1::CaptchaAnswer_Error&
PostOauth2LoginByPasswordResponse_Error::_Internal::captcha_answer(const PostOauth2LoginByPasswordResponse_Error* msg) {
  return *msg->_impl_.reason_.captcha_answer_;
}
const ::keyapis::identity::v1::SsoError&
PostOauth2LoginByPasswordResponse_Error::_Internal::sso(const PostOauth2LoginByPasswordResponse_Error* msg) {
  return *msg->_impl_.reason_.sso_;
}
const ::keyapis::identity::v1::KeyError&
PostOauth2LoginByPasswordResponse_Error::_Internal::key(const PostOauth2LoginByPasswordResponse_Error* msg) {
  return *msg->_impl_.reason_.key_;
}
const ::keyapis::identity::v1::AuthServiceError&
PostOauth2LoginByPasswordResponse_Error::_Internal::auth_service(const PostOauth2LoginByPasswordResponse_Error* msg) {
  return *msg->_impl_.reason_.auth_service_;
}
void PostOauth2LoginByPasswordResponse_Error::set_allocated_captcha_answer(::keyapis::identity::v1::CaptchaAnswer_Error* captcha_answer) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (captcha_answer) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(captcha_answer));
    if (message_arena != submessage_arena) {
      captcha_answer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, captcha_answer, submessage_arena);
    }
    set_has_captcha_answer();
    _impl_.reason_.captcha_answer_ = captcha_answer;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.PostOauth2LoginByPasswordResponse.Error.captcha_answer)
}
void PostOauth2LoginByPasswordResponse_Error::clear_captcha_answer() {
  if (reason_case() == kCaptchaAnswer) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.captcha_answer_;
    }
    clear_has_reason();
  }
}
void PostOauth2LoginByPasswordResponse_Error::set_allocated_sso(::keyapis::identity::v1::SsoError* sso) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (sso) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(sso));
    if (message_arena != submessage_arena) {
      sso = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, sso, submessage_arena);
    }
    set_has_sso();
    _impl_.reason_.sso_ = sso;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.PostOauth2LoginByPasswordResponse.Error.sso)
}
void PostOauth2LoginByPasswordResponse_Error::clear_sso() {
  if (reason_case() == kSso) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.sso_;
    }
    clear_has_reason();
  }
}
void PostOauth2LoginByPasswordResponse_Error::set_allocated_key(::keyapis::identity::v1::KeyError* key) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (key) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key));
    if (message_arena != submessage_arena) {
      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, key, submessage_arena);
    }
    set_has_key();
    _impl_.reason_.key_ = key;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.PostOauth2LoginByPasswordResponse.Error.key)
}
void PostOauth2LoginByPasswordResponse_Error::clear_key() {
  if (reason_case() == kKey) {
    if (GetArenaForAllocation() == nullptr) {
      delete _impl_.reason_.key_;
    }
    clear_has_reason();
  }
}
void PostOauth2LoginByPasswordResponse_Error::set_allocated_auth_service(::keyapis::identity::v1::AuthServiceError* auth_service) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (auth_service) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(auth_service);
    if (message_arena != submessage_arena) {
      auth_service = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, auth_service, submessage_arena);
    }
    set_has_auth_service();
    _impl_.reason_.auth_service_ = auth_service;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.PostOauth2LoginByPasswordResponse.Error.auth_service)
}
PostOauth2LoginByPasswordResponse_Error::PostOauth2LoginByPasswordResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.PostOauth2LoginByPasswordResponse.Error)
}
PostOauth2LoginByPasswordResponse_Error::PostOauth2LoginByPasswordResponse_Error(const PostOauth2LoginByPasswordResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  PostOauth2LoginByPasswordResponse_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 kCaptchaAnswer: {
      _this->_internal_mutable_captcha_answer()->::keyapis::identity::v1::CaptchaAnswer_Error::MergeFrom(
          from._internal_captcha_answer());
      break;
    }
    case kSso: {
      _this->_internal_mutable_sso()->::keyapis::identity::v1::SsoError::MergeFrom(
          from._internal_sso());
      break;
    }
    case kKey: {
      _this->_internal_mutable_key()->::keyapis::identity::v1::KeyError::MergeFrom(
          from._internal_key());
      break;
    }
    case kAuthService: {
      _this->_internal_mutable_auth_service()->::keyapis::identity::v1::AuthServiceError::MergeFrom(
          from._internal_auth_service());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.PostOauth2LoginByPasswordResponse.Error)
}

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

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

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

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

void PostOauth2LoginByPasswordResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.identity.v1.PostOauth2LoginByPasswordResponse.Error)
  switch (reason_case()) {
    case kCaptchaAnswer: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.captcha_answer_;
      }
      break;
    }
    case kSso: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.sso_;
      }
      break;
    }
    case kKey: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.key_;
      }
      break;
    }
    case kAuthService: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.auth_service_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void PostOauth2LoginByPasswordResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.PostOauth2LoginByPasswordResponse.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* PostOauth2LoginByPasswordResponse_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) {
      // .keyapis.identity.v1.CaptchaAnswer.Error captcha_answer = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_captcha_answer(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.identity.v1.SsoError sso = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_sso(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.identity.v1.KeyError key = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_key(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      // .keyapis.identity.v1.AuthServiceError auth_service = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_auth_service(), 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* PostOauth2LoginByPasswordResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.PostOauth2LoginByPasswordResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (reason_case()) {
    case kCaptchaAnswer: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(1, _Internal::captcha_answer(this),
          _Internal::captcha_answer(this).GetCachedSize(), target, stream);
      break;
    }
    case kSso: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(2, _Internal::sso(this),
          _Internal::sso(this).GetCachedSize(), target, stream);
      break;
    }
    case kKey: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(3, _Internal::key(this),
          _Internal::key(this).GetCachedSize(), target, stream);
      break;
    }
    case kAuthService: {
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(4, _Internal::auth_service(this),
          _Internal::auth_service(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:keyapis.identity.v1.PostOauth2LoginByPasswordResponse.Error)
  return target;
}

::size_t PostOauth2LoginByPasswordResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.PostOauth2LoginByPasswordResponse.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()) {
    // .keyapis.identity.v1.CaptchaAnswer.Error captcha_answer = 1;
    case kCaptchaAnswer: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.captcha_answer_);
      break;
    }
    // .keyapis.identity.v1.SsoError sso = 2;
    case kSso: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.sso_);
      break;
    }
    // .keyapis.identity.v1.KeyError key = 3;
    case kKey: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.key_);
      break;
    }
    // .keyapis.identity.v1.AuthServiceError auth_service = 4;
    case kAuthService: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.auth_service_);
      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 PostOauth2LoginByPasswordResponse_Error::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PostOauth2LoginByPasswordResponse_Error*>(
      &from));
}

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

  switch (from.reason_case()) {
    case kCaptchaAnswer: {
      _this->_internal_mutable_captcha_answer()->::keyapis::identity::v1::CaptchaAnswer_Error::MergeFrom(
          from._internal_captcha_answer());
      break;
    }
    case kSso: {
      _this->_internal_mutable_sso()->::keyapis::identity::v1::SsoError::MergeFrom(
          from._internal_sso());
      break;
    }
    case kKey: {
      _this->_internal_mutable_key()->::keyapis::identity::v1::KeyError::MergeFrom(
          from._internal_key());
      break;
    }
    case kAuthService: {
      _this->_internal_mutable_auth_service()->::keyapis::identity::v1::AuthServiceError::MergeFrom(
          from._internal_auth_service());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void PostOauth2LoginByPasswordResponse_Error::InternalSwap(PostOauth2LoginByPasswordResponse_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 PostOauth2LoginByPasswordResponse_Error::GetTypeName() const {
  return "keyapis.identity.v1.PostOauth2LoginByPasswordResponse.Error";
}

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

class PostOauth2LoginByPasswordResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::identity::v1::PostOauth2LoginByPasswordResponse, _impl_._oneof_case_);
  static const ::keyapis::identity::v1::PostOauth2LoginByPasswordResponse_Error& error(const PostOauth2LoginByPasswordResponse* msg);
};

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_type();
  switch (from.type_case()) {
    case kError: {
      _this->_internal_mutable_error()->::keyapis::identity::v1::PostOauth2LoginByPasswordResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.PostOauth2LoginByPasswordResponse)
}

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

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

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

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

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


void PostOauth2LoginByPasswordResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.PostOauth2LoginByPasswordResponse)
  ::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* PostOauth2LoginByPasswordResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.identity.v1.PostOauth2LoginByPasswordResponse.Error error = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_error(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  // .keyapis.identity.v1.PostOauth2LoginByPasswordResponse.Error error = 1;
  if (type_case() == kError) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::error(this),
        _Internal::error(this).GetCachedSize(), target, stream);
  }

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

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

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

  switch (type_case()) {
    // .keyapis.identity.v1.PostOauth2LoginByPasswordResponse.Error error = 1;
    case kError: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.error_);
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

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

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

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

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

void PostOauth2LoginByPasswordResponse::InternalSwap(PostOauth2LoginByPasswordResponse* 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 PostOauth2LoginByPasswordResponse::GetTypeName() const {
  return "keyapis.identity.v1.PostOauth2LoginByPasswordResponse";
}

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

class GetOauth2ConsentRequest::_Internal {
 public:
};

GetOauth2ConsentRequest::GetOauth2ConsentRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.GetOauth2ConsentRequest)
}
GetOauth2ConsentRequest::GetOauth2ConsentRequest(const GetOauth2ConsentRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetOauth2ConsentRequest* const _this = this; (void)_this;
  new (&_impl_) Impl_{
      decltype(_impl_.consent_challenge_) {}

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  _impl_.consent_challenge_.InitDefault();
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
        _impl_.consent_challenge_.Set("", GetArenaForAllocation());
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (!from._internal_consent_challenge().empty()) {
    _this->_impl_.consent_challenge_.Set(from._internal_consent_challenge(), _this->GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.GetOauth2ConsentRequest)
}

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

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

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

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

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

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

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

const char* GetOauth2ConsentRequest::_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 consent_challenge = 1 [(.google.api.field_behavior) = REQUIRED];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          auto str = _internal_mutable_consent_challenge();
          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* GetOauth2ConsentRequest::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.GetOauth2ConsentRequest)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // string consent_challenge = 1 [(.google.api.field_behavior) = REQUIRED];
  if (!this->_internal_consent_challenge().empty()) {
    const std::string& _s = this->_internal_consent_challenge();
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "keyapis.identity.v1.GetOauth2ConsentRequest.consent_challenge");
    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:keyapis.identity.v1.GetOauth2ConsentRequest)
  return target;
}

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

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

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

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

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

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

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

std::string GetOauth2ConsentRequest::GetTypeName() const {
  return "keyapis.identity.v1.GetOauth2ConsentRequest";
}

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

class GetOauth2ConsentResponse_Error::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::identity::v1::GetOauth2ConsentResponse_Error, _impl_._oneof_case_);
  static const ::keyapis::identity::v1::AuthServiceError& auth_service(const GetOauth2ConsentResponse_Error* msg);
};

const ::keyapis::identity::v1::AuthServiceError&
GetOauth2ConsentResponse_Error::_Internal::auth_service(const GetOauth2ConsentResponse_Error* msg) {
  return *msg->_impl_.reason_.auth_service_;
}
void GetOauth2ConsentResponse_Error::set_allocated_auth_service(::keyapis::identity::v1::AuthServiceError* auth_service) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_reason();
  if (auth_service) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(auth_service);
    if (message_arena != submessage_arena) {
      auth_service = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, auth_service, submessage_arena);
    }
    set_has_auth_service();
    _impl_.reason_.auth_service_ = auth_service;
  }
  // @@protoc_insertion_point(field_set_allocated:keyapis.identity.v1.GetOauth2ConsentResponse.Error.auth_service)
}
GetOauth2ConsentResponse_Error::GetOauth2ConsentResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyapis.identity.v1.GetOauth2ConsentResponse.Error)
}
GetOauth2ConsentResponse_Error::GetOauth2ConsentResponse_Error(const GetOauth2ConsentResponse_Error& from)
  : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
  GetOauth2ConsentResponse_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 kAuthService: {
      _this->_internal_mutable_auth_service()->::keyapis::identity::v1::AuthServiceError::MergeFrom(
          from._internal_auth_service());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.GetOauth2ConsentResponse.Error)
}

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

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

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

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

void GetOauth2ConsentResponse_Error::clear_reason() {
// @@protoc_insertion_point(one_of_clear_start:keyapis.identity.v1.GetOauth2ConsentResponse.Error)
  switch (reason_case()) {
    case kAuthService: {
      if (GetArenaForAllocation() == nullptr) {
        delete _impl_.reason_.auth_service_;
      }
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = REASON_NOT_SET;
}


void GetOauth2ConsentResponse_Error::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.GetOauth2ConsentResponse.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* GetOauth2ConsentResponse_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) {
      // .keyapis.identity.v1.AuthServiceError auth_service = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_auth_service(), 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* GetOauth2ConsentResponse_Error::_InternalSerialize(
    ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:keyapis.identity.v1.GetOauth2ConsentResponse.Error)
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  // .keyapis.identity.v1.AuthServiceError auth_service = 1;
  if (reason_case() == kAuthService) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::auth_service(this),
        _Internal::auth_service(this).GetCachedSize(), target, stream);
  }

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

::size_t GetOauth2ConsentResponse_Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyapis.identity.v1.GetOauth2ConsentResponse.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()) {
    // .keyapis.identity.v1.AuthServiceError auth_service = 1;
    case kAuthService: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.reason_.auth_service_);
      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 GetOauth2ConsentResponse_Error::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetOauth2ConsentResponse_Error*>(
      &from));
}

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

  switch (from.reason_case()) {
    case kAuthService: {
      _this->_internal_mutable_auth_service()->::keyapis::identity::v1::AuthServiceError::MergeFrom(
          from._internal_auth_service());
      break;
    }
    case REASON_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

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

void GetOauth2ConsentResponse_Error::InternalSwap(GetOauth2ConsentResponse_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 GetOauth2ConsentResponse_Error::GetTypeName() const {
  return "keyapis.identity.v1.GetOauth2ConsentResponse.Error";
}

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

class GetOauth2ConsentResponse::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::keyapis::identity::v1::GetOauth2ConsentResponse, _impl_._oneof_case_);
  static const ::keyapis::identity::v1::GetOauth2ConsentResponse_Error& error(const GetOauth2ConsentResponse* msg);
};

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

  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  clear_has_type();
  switch (from.type_case()) {
    case kError: {
      _this->_internal_mutable_error()->::keyapis::identity::v1::GetOauth2ConsentResponse_Error::MergeFrom(
          from._internal_error());
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyapis.identity.v1.GetOauth2ConsentResponse)
}

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

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

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

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

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


void GetOauth2ConsentResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:keyapis.identity.v1.GetOauth2ConsentResponse)
  ::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* GetOauth2ConsentResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::uint32_t tag;
    ptr = ::_pbi::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // .keyapis.identity.v1.GetOauth2ConsentResponse.Error error = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_error(), ptr);
          CHK_(ptr);
        } else {
          goto handle_unusual;
        }
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<std::string>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}

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

  // .keyapis.identity.v1.GetOauth2ConsentResponse.Error error = 1;
  if (type_case() == kError) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, _Internal::error(this),
        _Internal::error(this).GetCachedSize(), target, stream);
  }

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

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

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

  switch (type_case()) {
    // .keyapis.identity.v1.GetOauth2ConsentResponse.Error error = 1;
    case kError: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *_impl_.type_.error_);
      break;
    }
    case TYPE_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  }
  int cached_size = ::_pbi::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

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

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

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

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

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

void GetOauth2ConsentResponse::InternalSwap(GetOauth2ConsentResponse* 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 GetOauth2ConsentResponse::GetTypeName() const {
  return "keyapis.identity.v1.GetOauth2ConsentResponse";
}

// @@protoc_insertion_point(namespace_scope)
}  // namespace v1
}  // namespace identity
}  // namespace keyapis
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::AuthServiceError_AuthError*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::AuthServiceError_AuthError >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::AuthServiceError_AuthError >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::AuthServiceError*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::AuthServiceError >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::AuthServiceError >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::PostOauth2LoginByCodeRequest*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::PostOauth2LoginByCodeRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::PostOauth2LoginByCodeRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::PostOauth2LoginByCodeResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::PostOauth2LoginByCodeResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::PostOauth2LoginByCodeResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::PostOauth2LoginByCodeResponse*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::PostOauth2LoginByCodeResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::PostOauth2LoginByCodeResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::PostOauth2LoginByPasswordRequest*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::PostOauth2LoginByPasswordRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::PostOauth2LoginByPasswordRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::PostOauth2LoginByPasswordResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::PostOauth2LoginByPasswordResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::PostOauth2LoginByPasswordResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::PostOauth2LoginByPasswordResponse*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::PostOauth2LoginByPasswordResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::PostOauth2LoginByPasswordResponse >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::GetOauth2ConsentRequest*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::GetOauth2ConsentRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::GetOauth2ConsentRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::GetOauth2ConsentResponse_Error*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::GetOauth2ConsentResponse_Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::GetOauth2ConsentResponse_Error >(arena);
}
template<> PROTOBUF_NOINLINE ::keyapis::identity::v1::GetOauth2ConsentResponse*
Arena::CreateMaybeMessage< ::keyapis::identity::v1::GetOauth2ConsentResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyapis::identity::v1::GetOauth2ConsentResponse >(arena);
}
PROTOBUF_NAMESPACE_CLOSE
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"